From 9d2abbb85197d253e78b03329a458e43f16c3279 Mon Sep 17 00:00:00 2001 From: mj221 Date: Tue, 31 Jan 2023 00:46:38 +1000 Subject: [PATCH 01/36] added domain content (website) resolver for Solana and Ethereum --- .../app-extension/src/background/index.ts | 32 +++++ .../IpfsGatewayCustom.tsx | 87 ++++++++++++++ .../IpfsGatewaySwitch.tsx | 86 +++++++++++++ .../DomainContentResolver/index.tsx | 25 ++++ .../Unlocked/Settings/Preferences/index.tsx | 3 + .../Settings/SettingsNavStackDrawer.tsx | 17 +++ packages/app-extension/src/manifest.json | 2 +- packages/app-extension/src/redirect.html | 113 ++++++++++++++++++ packages/app-extension/src/redirect404.html | 38 ++++++ .../src/redirects/ResolveDomainName.tsx | 37 ++++++ .../app-extension/src/redirects/constants.tsx | 40 +++++++ .../app-extension/src/redirects/index.tsx | 71 +++++++++++ .../src/redirects/ipfsBuilder.tsx | 111 +++++++++++++++++ .../Ethereum/index.tsx | 36 ++++++ .../supportedNetworkDomains/Solana/index.tsx | 93 ++++++++++++++ .../supportedNetworkDomains/index.tsx | 2 + packages/app-extension/webpack.config.js | 1 + packages/background/src/backend/core.ts | 31 ++++- packages/background/src/frontend/server-ui.ts | 24 +++- packages/common/src/constants.ts | 6 + packages/common/src/preferences.ts | 4 + packages/common/src/types.ts | 1 + .../recoil/src/atoms/preferences/index.tsx | 8 ++ packages/recoil/src/context/Notifications.tsx | 20 +++- .../recoil/src/hooks/preferences/index.tsx | 4 + 25 files changed, 888 insertions(+), 4 deletions(-) create mode 100644 packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewayCustom.tsx create mode 100644 packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewaySwitch.tsx create mode 100644 packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/index.tsx create mode 100644 packages/app-extension/src/redirect.html create mode 100644 packages/app-extension/src/redirect404.html create mode 100644 packages/app-extension/src/redirects/ResolveDomainName.tsx create mode 100644 packages/app-extension/src/redirects/constants.tsx create mode 100644 packages/app-extension/src/redirects/index.tsx create mode 100644 packages/app-extension/src/redirects/ipfsBuilder.tsx create mode 100644 packages/app-extension/src/redirects/supportedNetworkDomains/Ethereum/index.tsx create mode 100644 packages/app-extension/src/redirects/supportedNetworkDomains/Solana/index.tsx create mode 100644 packages/app-extension/src/redirects/supportedNetworkDomains/index.tsx diff --git a/packages/app-extension/src/background/index.ts b/packages/app-extension/src/background/index.ts index cdcc6df0d..255400f22 100644 --- a/packages/app-extension/src/background/index.ts +++ b/packages/app-extension/src/background/index.ts @@ -1,5 +1,37 @@ import { start } from "@coral-xyz/background"; +import { supportedDomains, urlPatterns } from "../redirects/constants"; +import { redirect } from "../redirects/ResolveDomainName"; + start({ isMobile: false, }); + +chrome.webNavigation.onBeforeNavigate.addListener( + async (details) => { + await redirect(details.url); + }, + { + url: supportedDomains.map((domain) => { + return { urlMatches: `^[^:]+://[^/]+.${domain}/.*$` }; + }), + } +); + +chrome.webNavigation.onBeforeNavigate.addListener( + async (details) => { + const domainUrl = new URL(details.url).searchParams.get("q"); + if (domainUrl) await redirect(domainUrl); + }, + { + url: supportedDomains.flatMap((param) => + urlPatterns.map((pattern) => { + return { + urlMatches: pattern.includes("duckduckgo") + ? `${pattern}\\.${param}$` + : `${pattern}\\.${param}&.*$`, + }; + }) + ), + } +); diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewayCustom.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewayCustom.tsx new file mode 100644 index 000000000..ca8a0c150 --- /dev/null +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewayCustom.tsx @@ -0,0 +1,87 @@ +import { useEffect, useState } from "react"; +import { setIPFSGateway } from "@coral-xyz/app-extension/src/redirects/ipfsBuilder"; +import { UI_RPC_METHOD_SETTINGS_DOMAIN_CONTENT_IPFS_GATEWAY_UPDATE } from "@coral-xyz/common"; +import { InputListItem, Inputs, PrimaryButton } from "@coral-xyz/react-common"; +import { useBackgroundClient } from "@coral-xyz/recoil"; +import { styles } from "@coral-xyz/themes"; + +import { useNavStack } from "../../../../common/Layout/NavStack"; + +const useStyles = styles((theme) => ({ + textFieldRoot: { + color: theme.custom.colors.secondary, + "& .MuiOutlinedInput-root": { + "& fieldset": { + border: "none", + color: theme.custom.colors.secondary, + }, + }, + }, + listParent: { + border: `2px solid black`, + "&:hover": { + border: `2px solid red !important`, + }, + "&:focussed": { + border: `2px solid yellow !important`, + }, + borderRadius: "10px", + }, +})); + +export function PreferencesCustomIpfsGateway() { + const nav = useNavStack(); + const background = useBackgroundClient(); + + const [gatewayUrl, setGatewayUrl] = useState(""); + const changeIpfsGateway = async () => { + try { + background + .request({ + method: UI_RPC_METHOD_SETTINGS_DOMAIN_CONTENT_IPFS_GATEWAY_UPDATE, + params: [gatewayUrl], + }) + .catch(console.error); + + await setIPFSGateway(gatewayUrl); + } catch (err) { + console.error(err); + } + }; + + useEffect(() => { + const title = nav.title; + nav.setTitle("Change IPFS Gateway"); + return () => { + nav.setTitle(title); + }; + }, []); + + return ( +
+
+
+ + { + setGatewayUrl(e.target.value); + }} + /> + +
+
+ +
+
+
+ ); +} diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewaySwitch.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewaySwitch.tsx new file mode 100644 index 000000000..0a3f40e42 --- /dev/null +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewaySwitch.tsx @@ -0,0 +1,86 @@ +import { useEffect } from "react"; +import { UI_RPC_METHOD_SETTINGS_DOMAIN_CONTENT_IPFS_GATEWAY_UPDATE } from "@coral-xyz/common"; +import { PushDetail } from "@coral-xyz/react-common"; +import { useBackgroundClient, useIpfsGateway } from "@coral-xyz/recoil"; +import { useCustomTheme } from "@coral-xyz/themes"; +import { Check } from "@mui/icons-material"; + +import { IPFSGateways } from "../../../../../redirects/constants"; +import { useNavStack } from "../../../../common/Layout/NavStack"; +import { SettingsList } from "../../../../common/Settings/List"; + +interface MenuItems { + [key: string]: { + onClick: () => void; + detail?: React.ReactNode; + style?: React.CSSProperties; + classes?: any; + button?: boolean; + icon?: React.ReactNode; + label?: string; + }; +} +import { setIPFSGateway } from "@coral-xyz/app-extension/src/redirects/ipfsBuilder"; +export function PreferencesIpfsGateway() { + const nav = useNavStack(); + const background = useBackgroundClient(); + + const currentIpfsGatewayUrl = useIpfsGateway(); + const changeIpfsGateway = async (url: string) => { + console.log("IT's triggering!: ", url.toString()); + try { + background + .request({ + method: UI_RPC_METHOD_SETTINGS_DOMAIN_CONTENT_IPFS_GATEWAY_UPDATE, + params: [url], + }) + .catch(console.error); + + await setIPFSGateway(url); + } catch (err) { + console.error(err); + } + console.log("CURRENT GATEWAY: ", currentIpfsGatewayUrl.toString()); + }; + + useEffect(() => { + nav.setTitle("IPFS Gateway"); + }, [nav]); + + const menuItems = IPFSGateways.reduce((acc, gateway) => { + (acc as MenuItems)[gateway] = { + onClick: () => changeIpfsGateway(gateway), + detail: currentIpfsGatewayUrl === gateway ? : <>, + }; + return acc; + }, {}); + const customMenu: MenuItems = { + Custom: { + onClick: () => { + nav.push("preferences-edit-ipfs-gateway-custom"); + }, + detail: !IPFSGateways.includes(currentIpfsGatewayUrl) ? ( + <> + + + + ) : ( + + ), + }, + }; + Object.assign(menuItems, customMenu); + + return ; +} + +export function Checkmark() { + const theme = useCustomTheme(); + return ( + + ); +} diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/index.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/index.tsx new file mode 100644 index 000000000..45d0e3df6 --- /dev/null +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/index.tsx @@ -0,0 +1,25 @@ +import { useEffect } from "react"; + +import { useNavStack } from "../../../../common/Layout/NavStack"; +import { SettingsList } from "../../../../common/Settings/List"; +export const PreferencesDomainContent: React.FC = () => { + return ( +
+ <_PreferencesDomainResolverContent /> +
+ ); +}; + +export const _PreferencesDomainResolverContent: React.FC = () => { + const nav = useNavStack(); + const resolverMenuItems = { + "IPFS Gateways": { + onClick: () => nav.push("preferences-ipfs-gateway"), + }, + }; + useEffect(() => { + nav.setTitle("Domain Content Resolver"); + }, [nav]); + + return ; +}; diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/index.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/index.tsx index ef5b13b88..c402f3f87 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/index.tsx @@ -60,6 +60,9 @@ export function Preferences() { "Trusted Sites": { onClick: () => nav.push("preferences-trusted-sites"), }, + "Domain Content Resolver": { + onClick: () => nav.push("preferences-domain-content-resolver"), + }, }; if (BACKPACK_FEATURE_LIGHT_MODE) { diff --git a/packages/app-extension/src/components/Unlocked/Settings/SettingsNavStackDrawer.tsx b/packages/app-extension/src/components/Unlocked/Settings/SettingsNavStackDrawer.tsx index 1521c0c1f..341533844 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/SettingsNavStackDrawer.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/SettingsNavStackDrawer.tsx @@ -15,6 +15,9 @@ import { Requests } from "../Messages/Requests"; import { ImportSecretKey } from "./AddConnectWallet/ImportSecretKey"; import { PreferencesAutoLock } from "./Preferences/AutoLock"; +import { PreferencesDomainContent } from "./Preferences/DomainContentResolver"; +import { PreferencesCustomIpfsGateway } from "./Preferences/DomainContentResolver/IpfsGatewayCustom"; +import { PreferencesIpfsGateway } from "./Preferences/DomainContentResolver/IpfsGatewaySwitch"; import { PreferencesEthereum } from "./Preferences/Ethereum"; import { PreferencesEthereumConnection } from "./Preferences/Ethereum/Connection"; import { PreferenceEthereumCustomRpcUrl } from "./Preferences/Ethereum/CustomRpcUrl"; @@ -87,6 +90,20 @@ export function SettingsNavStackDrawer({ name={"preferences-trusted-sites"} component={(props: any) => } /> + } + /> + } + /> + ( + + )} + /> } diff --git a/packages/app-extension/src/manifest.json b/packages/app-extension/src/manifest.json index 93ae16833..57a0071b0 100644 --- a/packages/app-extension/src/manifest.json +++ b/packages/app-extension/src/manifest.json @@ -26,5 +26,5 @@ "192": "anchor.png", "512": "anchor.png" }, - "permissions": ["storage"] + "permissions": ["webNavigation", "storage", "tabs"] } diff --git a/packages/app-extension/src/redirect.html b/packages/app-extension/src/redirect.html new file mode 100644 index 000000000..52be3ff23 --- /dev/null +++ b/packages/app-extension/src/redirect.html @@ -0,0 +1,113 @@ + + + + + + Backpack Domain Resolver + + + + + + +
+ Redirecting to + +
+
+ + + + +
+ + +
+ + + + diff --git a/packages/app-extension/src/redirect404.html b/packages/app-extension/src/redirect404.html new file mode 100644 index 000000000..79e9eda60 --- /dev/null +++ b/packages/app-extension/src/redirect404.html @@ -0,0 +1,38 @@ +
+
+ Redirect error +

404

+ page not found +
+
+ diff --git a/packages/app-extension/src/redirects/ResolveDomainName.tsx b/packages/app-extension/src/redirects/ResolveDomainName.tsx new file mode 100644 index 000000000..d864771f8 --- /dev/null +++ b/packages/app-extension/src/redirects/ResolveDomainName.tsx @@ -0,0 +1,37 @@ +export const redirect = async (urlString: string) => { + const tab: chrome.tabs.Tab = await getCurrentTab(); + + if (tab !== undefined && urlString !== undefined) { + chrome.tabs.update(tab.id || chrome.tabs.TAB_ID_NONE, { + url: `./redirect.html?domainUrl=${urlString}`, + }); + } +}; + +export const getCurrentTab = (): Promise => { + return new Promise((resolve, reject) => { + try { + chrome.tabs.query( + { active: true, windowId: chrome.windows.WINDOW_ID_CURRENT }, + function (tabs) { + resolve(tabs[0]); + } + ); + } catch (e) { + reject(e); + } + }); +}; + +/** + * Append the `https://` scheme to the beginning of a url if it does not have it. + * + * @param {string} url to add the scheme to + * @returns {string} url with a scheme + */ +export const addHttps = (url: string): string => { + if (!url.match(/^(?:f|ht)tps?:\/\//)) { + url = "https://" + url; + } + return url; +}; diff --git a/packages/app-extension/src/redirects/constants.tsx b/packages/app-extension/src/redirects/constants.tsx new file mode 100644 index 000000000..93e629810 --- /dev/null +++ b/packages/app-extension/src/redirects/constants.tsx @@ -0,0 +1,40 @@ +// TLD constants +export const ETH_TLD = "eth"; +export const SOL_TLD = "sol"; + +// IPFS and IPNS prefix constants to be queried in the domain content +export const ipnsOrIpfsPrefix = ["ipns=", "ipfs=", "ipfs://", "ipns://"]; + +export const ipAddressRegex = + /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/; + +/** + * Some public IPFS Gateway URLs (https://ipfs.github.io/public-gateway-checker/) + */ +export const IPFSGateways: string[] = [ + "4everland.io", + "dweb.link", + "infura-ipfs.io", + "cf-ipfs.com", + "astyanax.io", + "ipfs.io", + "cloudflare-ipfs.com", + "gateway.pinata.cloud", +]; + +export enum PREFIX { + IPFS = "/ipfs/", + IPNS = "/ipns/", +} +export const DEFAULT_GATEWAY: string = IPFSGateways[0]; + +export const supportedDomains: string[] = ["sol", "eth"]; + +// Url regex patterns for most popular search engines: Google, Bing and DuckDuckGo. +export const urlPatterns: string[] = [ + "^[^:]+://www\\.google(\\.[a-z]{2,3}){1,2}/search\\?q=.*", + "^[^:]+://www\\.bing\\.com/search\\?q=.*", + "^[^:]+://duckduckgo\\.com/\\?q=.*", +]; + +export { DEFAULT_SOLANA_CLUSTER } from "@coral-xyz/common/src/solana/cluster"; diff --git a/packages/app-extension/src/redirects/index.tsx b/packages/app-extension/src/redirects/index.tsx new file mode 100644 index 000000000..4e3d76fc7 --- /dev/null +++ b/packages/app-extension/src/redirects/index.tsx @@ -0,0 +1,71 @@ +import { ETH_TLD, SOL_TLD } from "./constants"; +import { addHttps } from "./ResolveDomainName"; +import * as dnsResolver from "./supportedNetworkDomains"; + +async function main() { + // Extract the domainUrl search parameter + const domain = new URL(window.location.href).searchParams.get("domainUrl"); + if (!domain) { + return; + } + + // Add HTTPS to the domainUrl value + const domainUrl = addHttps(domain); + const urlParsed = new URL(domainUrl); + + // Split the hostname into an array of parts + const hostNameArray = urlParsed.hostname.split("."); + + let domainFull = ""; + + // Iterate through the array, concatenating each item until we reach the last two + for (let i = 0; i < hostNameArray.length - 2; i++) { + domainFull += hostNameArray[i] + "."; + } + + // Extract the name service domain and TLD + const nameServiceDomain = hostNameArray[hostNameArray.length - 2]; + const currentTLD = hostNameArray[hostNameArray.length - 1]; + + // Concatenate the name service domain and TLD to form the full domain + domainFull += nameServiceDomain + "." + currentTLD; + + //---------------------------------------------------------------- + + // Concatenate the name service path and search values + const nameServicePathAndSearch = urlParsed.pathname + urlParsed.search; + + // Update the domain display text + const displayText = document.getElementById("domainDisplay"); + if (displayText) displayText.textContent = domainFull; + + try { + // Handle the domain based on the TLD + switch (currentTLD) { + case SOL_TLD: + await dnsResolver.handleDomainSOL( + nameServiceDomain, + hostNameArray, + nameServicePathAndSearch, + domainFull + ); + break; + case ETH_TLD: + await dnsResolver.handleDomainETH( + nameServiceDomain, + hostNameArray, + nameServicePathAndSearch, + domainFull + ); + break; + default: + throw new Error("invalid TLD"); + } + } catch (err) { + console.log(err); + // Redirect to error page if something fails;; + window.location.href = "./redirect404.html"; + } +} + +main(); diff --git a/packages/app-extension/src/redirects/ipfsBuilder.tsx b/packages/app-extension/src/redirects/ipfsBuilder.tsx new file mode 100644 index 000000000..647aa9d9b --- /dev/null +++ b/packages/app-extension/src/redirects/ipfsBuilder.tsx @@ -0,0 +1,111 @@ +// Modified implementation from https://github.com/zhvng/sns-resolver. Thank @zhvng! + +import { + DEFAULT_GATEWAY, + ipAddressRegex, + ipnsOrIpfsPrefix, + PREFIX, +} from "./constants"; +import { addHttps } from "./ResolveDomainName"; + +/** + * Build IPFS url from cid and path + * + * @param {string} cid IPFS cid to access with url + * @param {string} path path of the url (containing any search params) + * @param {PREFIX} prefix prefix of the url + */ +export async function build_IPFS_OR_IPNS_Url( + cid: string, + path: string, + prefix: PREFIX +) { + const gatewayUrl = await getIPFSGateway(); + return addHttps(gatewayUrl + prefix + cid + path); +} + +interface GatewayData { + IPFSGateway?: string; +} +/** + * Retreive user preferred IPFS gateway from local storage + * + * @returns {Promise} Stored IPFS gateway url + */ + +export async function getIPFSGateway() { + const data: GatewayData = await new Promise((resolve, reject) => { + chrome.storage.local.get("IPFSGateway", (data) => + data ? resolve(data) : reject() + ); + }); + + if ("IPFSGateway" in data) { + return data["IPFSGateway"]; + } else { + await setIPFSGateway(DEFAULT_GATEWAY); + return DEFAULT_GATEWAY; + } +} + +/** + * Set user's preferred IPFS gateway to a new gateway url. + * Retreive url from the `IPFSGateways` object or use a custom url if needed + * + * @param {string} gateway New IPFS Gateway url + */ +export async function setIPFSGateway(gateway: string) { + await new Promise((resolve) => { + chrome.storage.local.set({ IPFSGateway: gateway }, () => resolve()); + }); +} + +/** + * Checks if URL prefix starts with IPFS or IPNS + * @param data Domain content + * @param prefixes Defaults to specified IPFS and IPNS + * @returns Returns the prefix it starts with else null + */ +export const checkUrlPrefix = ( + data: string, + prefixes: string[] = ipnsOrIpfsPrefix +) => { + for (let prefix of prefixes) { + if (data.startsWith(prefix)) { + return prefix; + } + } + return null; +}; + +/** + * Constructs a url depending on the type of url and prefix + * @param data Domain content + * @param nameServicePathAndSearch Path of the url + */ +const redirectToIpfs = async ( + data: string, + nameServicePathAndSearch: string +) => { + const urlPrefix = checkUrlPrefix(data); + let url: string; + if (urlPrefix) { + const cid = data.slice(urlPrefix.length); + url = await build_IPFS_OR_IPNS_Url( + cid, + nameServicePathAndSearch, + urlPrefix.includes("ipfs") ? PREFIX.IPFS : PREFIX.IPNS + ); + } else if (data.match(ipAddressRegex)) { + url = "http://" + data + nameServicePathAndSearch; + } else { + url = addHttps(data + nameServicePathAndSearch); + } + let response = await fetch(url); + if (response.status != 200) { + throw new Error("invalid url"); + } + window.location.href = url; +}; + +export default redirectToIpfs; diff --git a/packages/app-extension/src/redirects/supportedNetworkDomains/Ethereum/index.tsx b/packages/app-extension/src/redirects/supportedNetworkDomains/Ethereum/index.tsx new file mode 100644 index 000000000..a5939822b --- /dev/null +++ b/packages/app-extension/src/redirects/supportedNetworkDomains/Ethereum/index.tsx @@ -0,0 +1,36 @@ +import { ethers } from "ethers"; + +import redirectToIpfs from "../../ipfsBuilder"; + +const getContentFromAccount = async ( + nameServiceDomain: string +): Promise => { + const provider = ethers.getDefaultProvider(); + const resolver = await provider.getResolver(nameServiceDomain); + + const data = await resolver?.getContentHash(); + if (!data) { + return; + } + return data; +}; + +/** + * Resolves Ethereum Domain + * @param nameServiceDomain User's TLD + * @param hostNameArray Array of domains which includes Domains and Subdomains + * @param nameServicePathAndSearch Path of the url + * @param domainFull Full concatenated domain + */ +export const handleDomainETH = async ( + nameServiceDomain: string, + hostNameArray: string[], + nameServicePathAndSearch: string, + domainFull: string +) => { + const data = await getContentFromAccount(domainFull); + if (!data) { + throw new Error("invalid domain content"); + } + await redirectToIpfs(data, nameServicePathAndSearch); +}; diff --git a/packages/app-extension/src/redirects/supportedNetworkDomains/Solana/index.tsx b/packages/app-extension/src/redirects/supportedNetworkDomains/Solana/index.tsx new file mode 100644 index 000000000..d9e04c5db --- /dev/null +++ b/packages/app-extension/src/redirects/supportedNetworkDomains/Solana/index.tsx @@ -0,0 +1,93 @@ +import { getHashedName, getNameAccountKey } from "@bonfida/spl-name-service"; +import * as web3 from "@solana/web3.js"; + +import { DEFAULT_SOLANA_CLUSTER } from "../../constants"; +import redirectToIpfs from "../../ipfsBuilder"; +/** + * Compute the key for the account pointing to the domain. + * See https://github.com/Bonfida/solana-name-service-guide + * + * @param {string} name The .sol domain name + * @returns {Promise} Public key of the domain's account in the sns + */ +export const getDomainKey = async (name: string): Promise => { + const SOL_TLD_AUTHORITY = new web3.PublicKey( + "58PwtjSDuFHuUkYjH9BYnnQKHfwo9reZhC2zMJv9JPkx" + ); + const hashedName = await getHashedName(name); + const domainKey = await getNameAccountKey( + hashedName, + undefined, + SOL_TLD_AUTHORITY + ); + return domainKey; +}; + +/** + * Compute the key for the account pointing to a given subdomain. + * See https://github.com/Bonfida/solana-name-service-guide + * + * @param {web3.PublicKey} parentDomainKey The parent .sol domain name + * @param {string} subdomain The subdomain to compute the key for + * @returns {Promise} Public key of the subdomain's account in the sns + */ +async function getSubdomainKey( + parentDomainKey: web3.PublicKey, + subdomain: string +) { + const hashedName = await getHashedName("\0".concat(subdomain)); + const subdomainAccount = await getNameAccountKey( + hashedName, + undefined, + parentDomainKey + ); + return subdomainAccount; +} + +/** + * Retreive the data stored in a given account + * + * @param {web3.PublicKey} publicKey key pointing to the account + * @returns {Promise} Promise resolving to the stringified content of the account + * @throws {Error} + */ +async function getContentFromAccount( + publicKey: web3.PublicKey, + apiUrl = DEFAULT_SOLANA_CLUSTER +) { + const connection = new web3.Connection(apiUrl); + const nameAccount = await connection.getAccountInfo(publicKey, "processed"); + const data = nameAccount?.data.toString("ascii").slice(96).replace(/\0/g, ""); + return data; +} + +/** + * Resolves Solana Domain + * @param nameServiceDomain User's TLD + * @param hostNameArray Array of domains which includes Domains and Subdomains + * @param nameServicePathAndSearch Path of the url + * @param domainFull Full concatenated domain + */ +export const handleDomainSOL = async ( + nameServiceDomain: string, + hostNameArray: string[], + nameServicePathAndSearch: string, + domainFull?: string +) => { + const domainKey = await getDomainKey(nameServiceDomain); + + let accountKey: web3.PublicKey = domainKey; + // check for subdomains + if (hostNameArray.length === 3) { + accountKey = await getSubdomainKey(domainKey, hostNameArray[0]); + } else if (hostNameArray.length > 3) { + throw new Error("Multiple nested subdomains not supported"); + } + + const data = await getContentFromAccount(accountKey); + + if (!data) { + throw new Error("Invalid domain content"); + } + await redirectToIpfs(data, nameServicePathAndSearch); +}; diff --git a/packages/app-extension/src/redirects/supportedNetworkDomains/index.tsx b/packages/app-extension/src/redirects/supportedNetworkDomains/index.tsx new file mode 100644 index 000000000..757d6fe52 --- /dev/null +++ b/packages/app-extension/src/redirects/supportedNetworkDomains/index.tsx @@ -0,0 +1,2 @@ +export { handleDomainETH } from "./Ethereum"; +export { handleDomainSOL } from "./Solana"; diff --git a/packages/app-extension/webpack.config.js b/packages/app-extension/webpack.config.js index e029372f4..4041665b4 100644 --- a/packages/app-extension/webpack.config.js +++ b/packages/app-extension/webpack.config.js @@ -68,6 +68,7 @@ const options = { options: "./src/options/index.tsx", permissions: "./src/permissions/index.tsx", popup: "./src/index.tsx", + redirects: "./src/redirects/index.tsx", contentScript: "./src/contentScript/index.ts", // injected: "../provider-injection/dist/browser/index.js", }, diff --git a/packages/background/src/backend/core.ts b/packages/background/src/backend/core.ts index b44c91cbf..88fb7a6a7 100644 --- a/packages/background/src/backend/core.ts +++ b/packages/background/src/backend/core.ts @@ -14,6 +14,7 @@ import { BACKEND_EVENT, Blockchain, DEFAULT_DARK_MODE, + DEFAULT_GATEWAY, defaultPreferences, DerivationPath, deserializeTransaction, @@ -21,7 +22,6 @@ import { EthereumExplorer, getAddMessage, LOAD_PUBLIC_KEY_AMOUNT, - NOTIFICATION_KEY_IS_COLD_UPDATE, NOTIFICATION_ACTIVE_BLOCKCHAIN_UPDATED, NOTIFICATION_AGGREGATE_WALLETS_UPDATED, NOTIFICATION_APPROVED_ORIGINS_UPDATE, @@ -30,11 +30,13 @@ import { NOTIFICATION_BLOCKCHAIN_KEYRING_DELETED, NOTIFICATION_DARK_MODE_UPDATED, NOTIFICATION_DEVELOPER_MODE_UPDATED, + NOTIFICATION_DOMAIN_CONTENT_IPFS_GATEWAY_UPDATED, NOTIFICATION_ETHEREUM_ACTIVE_WALLET_UPDATED, NOTIFICATION_ETHEREUM_CHAIN_ID_UPDATED, NOTIFICATION_ETHEREUM_CONNECTION_URL_UPDATED, NOTIFICATION_ETHEREUM_EXPLORER_UPDATED, NOTIFICATION_FEATURE_GATES_UPDATED, + NOTIFICATION_KEY_IS_COLD_UPDATE, NOTIFICATION_KEYNAME_UPDATE, NOTIFICATION_KEYRING_DERIVED_WALLET, NOTIFICATION_KEYRING_IMPORTED_SECRET_KEY, @@ -1483,6 +1485,33 @@ export class Backend { return SUCCESS_RESPONSE; } + async domainContentIPFSGatewayRead(uuid: string): Promise { + const data = await store.getWalletDataForUser(uuid); + return data.ipfsGateway ?? DEFAULT_GATEWAY; + } + + async domainContentIPFSGatewayUpdate(ipfsGateway: string): Promise { + const uuid = this.keyringStore.activeUserKeyring.uuid; + const data = await store.getWalletDataForUser(uuid); + + if (data.ipfsGateway === ipfsGateway) { + return false; + } + + await store.setWalletDataForUser(uuid, { + ...data, + ipfsGateway, + }); + this.events.emit(BACKEND_EVENT, { + name: NOTIFICATION_DOMAIN_CONTENT_IPFS_GATEWAY_UPDATED, + data: { + ipfsGateway, + }, + }); + + return true; + } + async isApprovedOrigin(origin: string): Promise { const { uuid } = await this.userRead(); const data = await store.getWalletDataForUser(uuid); diff --git a/packages/background/src/frontend/server-ui.ts b/packages/background/src/frontend/server-ui.ts index 3b1c155cb..9d5c66e09 100644 --- a/packages/background/src/frontend/server-ui.ts +++ b/packages/background/src/frontend/server-ui.ts @@ -20,7 +20,6 @@ import { ChannelAppUi, getLogger, TAB_XNFT, - UI_RPC_METHOD_KEY_IS_COLD_UPDATE, UI_RPC_METHOD_ACTIVE_USER_UPDATE, UI_RPC_METHOD_ALL_USERS_READ, UI_RPC_METHOD_APPROVED_ORIGINS_DELETE, @@ -39,6 +38,7 @@ import { UI_RPC_METHOD_ETHEREUM_SIGN_TRANSACTION, UI_RPC_METHOD_GET_FEATURE_GATES, UI_RPC_METHOD_GET_XNFT_PREFERENCES, + UI_RPC_METHOD_KEY_IS_COLD_UPDATE, UI_RPC_METHOD_KEYNAME_READ, UI_RPC_METHOD_KEYNAME_UPDATE, UI_RPC_METHOD_KEYRING_ACTIVE_WALLET_UPDATE, @@ -83,6 +83,8 @@ import { UI_RPC_METHOD_SETTINGS_DARK_MODE_UPDATE, UI_RPC_METHOD_SETTINGS_DEVELOPER_MODE_READ, UI_RPC_METHOD_SETTINGS_DEVELOPER_MODE_UPDATE, + UI_RPC_METHOD_SETTINGS_DOMAIN_CONTENT_IPFS_GATEWAY_READ, + UI_RPC_METHOD_SETTINGS_DOMAIN_CONTENT_IPFS_GATEWAY_UPDATE, UI_RPC_METHOD_SIGN_MESSAGE_FOR_PUBLIC_KEY, UI_RPC_METHOD_SOLANA_COMMITMENT_READ, UI_RPC_METHOD_SOLANA_COMMITMENT_UPDATE, @@ -287,6 +289,10 @@ async function handle( return await handleDeveloperModeRead(ctx, params[0]); case UI_RPC_METHOD_SETTINGS_DEVELOPER_MODE_UPDATE: return await handleDeveloperModeUpdate(ctx, params[0]); + case UI_RPC_METHOD_SETTINGS_DOMAIN_CONTENT_IPFS_GATEWAY_READ: + return await handleDomainContentIPFSGatewayRead(ctx, params[0]); + case UI_RPC_METHOD_SETTINGS_DOMAIN_CONTENT_IPFS_GATEWAY_UPDATE: + return await handleDomainContentIPFSGatewayUpdate(ctx, params[0]); case UI_RPC_METHOD_SETTINGS_AGGREGATE_WALLETS_UPDATE: return await handleAggregateWalletsUpdate(ctx, params[0]); case UI_RPC_METHOD_APPROVED_ORIGINS_READ: @@ -835,6 +841,22 @@ async function handleDeveloperModeUpdate( return [resp]; } +async function handleDomainContentIPFSGatewayRead( + ctx: Context, + uuid: string +): Promise> { + const resp = await ctx.backend.domainContentIPFSGatewayRead(uuid); + return [resp]; +} + +async function handleDomainContentIPFSGatewayUpdate( + ctx: Context, + uuid: string +): Promise> { + const resp = await ctx.backend.domainContentIPFSGatewayUpdate(uuid); + return [resp]; +} + async function handleAggregateWalletsUpdate( ctx: Context, aggregateWallets: boolean diff --git a/packages/common/src/constants.ts b/packages/common/src/constants.ts index 879bad49f..d59909a04 100644 --- a/packages/common/src/constants.ts +++ b/packages/common/src/constants.ts @@ -189,6 +189,10 @@ export const UI_RPC_METHOD_SETTINGS_DEVELOPER_MODE_READ = "ui-rpc-method-settings-developer-mode-read"; export const UI_RPC_METHOD_SETTINGS_DEVELOPER_MODE_UPDATE = "ui-rpc-method-settings-developer-mode-update"; +export const UI_RPC_METHOD_SETTINGS_DOMAIN_CONTENT_IPFS_GATEWAY_READ = + "ui-rpc-method-settings-domain-content-ipfs-gateway-read"; +export const UI_RPC_METHOD_SETTINGS_DOMAIN_CONTENT_IPFS_GATEWAY_UPDATE = + "ui-rpc-method-settings-domain-content-ipfs-gateway-update"; export const UI_RPC_METHOD_SETTINGS_AGGREGATE_WALLETS_UPDATE = "ui-rpc-method-settings-aggregate-wallet-update"; export const UI_RPC_METHOD_SIGN_MESSAGE_FOR_PUBLIC_KEY = @@ -274,6 +278,8 @@ export const NOTIFICATION_AGGREGATE_WALLETS_UPDATED = export const NOTIFICATION_DARK_MODE_UPDATED = "notification-dark-mode-updated"; export const NOTIFICATION_DEVELOPER_MODE_UPDATED = "notification-developer-mode-updated"; +export const NOTIFICATION_DOMAIN_CONTENT_IPFS_GATEWAY_UPDATED = + "notification-domain-content-ipfs-gateway-updated"; export const NOTIFICATION_FEATURE_GATES_UPDATED = "notification-feature-gates-updated"; export const NOTIFICATION_KEYNAME_UPDATE = "notification-keyname-update"; diff --git a/packages/common/src/preferences.ts b/packages/common/src/preferences.ts index 612c668bf..f3e9236c7 100644 --- a/packages/common/src/preferences.ts +++ b/packages/common/src/preferences.ts @@ -1,3 +1,5 @@ +import { DEFAULT_GATEWAY } from "@coral-xyz/app-extension/src/redirects/constants"; + import { EthereumConnectionUrl, EthereumExplorer } from "./ethereum"; import { SolanaCluster, SolanaExplorer } from "./solana"; import type { Blockchain, Preferences } from "./types"; @@ -6,6 +8,7 @@ export const DEFAULT_DARK_MODE = false; export const DEFAULT_DEVELOPER_MODE = false; export const DEFAULT_AGGREGATE_WALLETS = false; export const DEFAULT_AUTO_LOCK_INTERVAL_SECS = 15 * 60; +export { DEFAULT_GATEWAY }; export function defaultPreferences(): Preferences { return { @@ -16,6 +19,7 @@ export function defaultPreferences(): Preferences { approvedOrigins: [], darkMode: DEFAULT_DARK_MODE, developerMode: DEFAULT_DEVELOPER_MODE, + ipfsGateway: DEFAULT_GATEWAY, aggregateWallets: DEFAULT_AGGREGATE_WALLETS, solana: { explorer: SolanaExplorer.DEFAULT, diff --git a/packages/common/src/types.ts b/packages/common/src/types.ts index 93dc6c8fb..487817c95 100644 --- a/packages/common/src/types.ts +++ b/packages/common/src/types.ts @@ -156,6 +156,7 @@ export type Preferences = { approvedOrigins: string[]; darkMode: boolean; developerMode: boolean; + ipfsGateway: string; aggregateWallets: boolean; solana: SolanaData; ethereum: EthereumData; diff --git a/packages/recoil/src/atoms/preferences/index.tsx b/packages/recoil/src/atoms/preferences/index.tsx index df205074e..05aaefc79 100644 --- a/packages/recoil/src/atoms/preferences/index.tsx +++ b/packages/recoil/src/atoms/preferences/index.tsx @@ -70,6 +70,14 @@ export const isDeveloperMode = selector({ }, }); +export const domainContentIpfsGateway = selector({ + key: "domainContentIpfsGateway", + get: async ({ get }) => { + const p = get(preferences); + return p.ipfsGateway; + }, +}); + export const autoLockSettings = selector({ key: "autoLockSettings", get: async ({ get }) => { diff --git a/packages/recoil/src/context/Notifications.tsx b/packages/recoil/src/context/Notifications.tsx index 0eafa4520..42ddc2099 100644 --- a/packages/recoil/src/context/Notifications.tsx +++ b/packages/recoil/src/context/Notifications.tsx @@ -10,7 +10,6 @@ import { CHANNEL_POPUP_NOTIFICATIONS, ChannelAppUi, getLogger, - NOTIFICATION_KEY_IS_COLD_UPDATE, NOTIFICATION_ACTIVE_BLOCKCHAIN_UPDATED, NOTIFICATION_AGGREGATE_WALLETS_UPDATED, NOTIFICATION_APPROVED_ORIGINS_UPDATE, @@ -19,12 +18,14 @@ import { NOTIFICATION_BLOCKCHAIN_KEYRING_DELETED, NOTIFICATION_DARK_MODE_UPDATED, NOTIFICATION_DEVELOPER_MODE_UPDATED, + NOTIFICATION_DOMAIN_CONTENT_IPFS_GATEWAY_UPDATED, NOTIFICATION_ETHEREUM_ACTIVE_WALLET_UPDATED, NOTIFICATION_ETHEREUM_CHAIN_ID_UPDATED, NOTIFICATION_ETHEREUM_CONNECTION_URL_UPDATED, NOTIFICATION_ETHEREUM_FEE_DATA_DID_UPDATE, NOTIFICATION_ETHEREUM_TOKENS_DID_UPDATE, NOTIFICATION_FEATURE_GATES_UPDATED, + NOTIFICATION_KEY_IS_COLD_UPDATE, NOTIFICATION_KEYNAME_UPDATE, NOTIFICATION_KEYRING_DERIVED_WALLET, NOTIFICATION_KEYRING_IMPORTED_SECRET_KEY, @@ -126,6 +127,16 @@ export function NotificationsProvider(props: any) { }; }); }; + + const setDomainContentIPFSGateway = (ipfsGateway: string) => { + setPreferences((current) => { + return { + ...current, + ipfsGateway, + }; + }); + }; + const setIsAggregateWallets = (aggregateWallets: boolean) => { setPreferences((current) => { return { @@ -270,6 +281,9 @@ export function NotificationsProvider(props: any) { case NOTIFICATION_DEVELOPER_MODE_UPDATED: handleIsDeveloperModeUpdated(notif); break; + case NOTIFICATION_DOMAIN_CONTENT_IPFS_GATEWAY_UPDATED: + handleDomainContentIPFSGatewayUpdated(notif); + break; case NOTIFICATION_AGGREGATE_WALLETS_UPDATED: handleAggregateWalletsUpdated(notif); break; @@ -523,6 +537,10 @@ export function NotificationsProvider(props: any) { setIsDeveloperMode(notif.data.developerMode); }; + const handleDomainContentIPFSGatewayUpdated = (notif: Notification) => { + setDomainContentIPFSGateway(notif.data.ipfsGateway); + }; + const handleAggregateWalletsUpdated = (notif: Notification) => { setIsAggregateWallets(notif.data.aggregateWallets); }; diff --git a/packages/recoil/src/hooks/preferences/index.tsx b/packages/recoil/src/hooks/preferences/index.tsx index ac590ca86..01530cf9f 100644 --- a/packages/recoil/src/hooks/preferences/index.tsx +++ b/packages/recoil/src/hooks/preferences/index.tsx @@ -36,6 +36,10 @@ export function useDeveloperMode(): boolean { return useRecoilValue(atoms.isDeveloperMode)!; } +export function useIpfsGateway(): string { + return useRecoilValue(atoms.domainContentIpfsGateway)!; +} + export function useIsAggregateWallets(): boolean { return useRecoilValue(atoms.isAggregateWallets); } From e7a6f8d5ee49de60aa2bf4f8545520119d22776c Mon Sep 17 00:00:00 2001 From: mj221 Date: Tue, 31 Jan 2023 00:48:03 +1000 Subject: [PATCH 02/36] removed console log --- .../Preferences/DomainContentResolver/IpfsGatewaySwitch.tsx | 2 -- 1 file changed, 2 deletions(-) diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewaySwitch.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewaySwitch.tsx index 0a3f40e42..61bb26fbb 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewaySwitch.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewaySwitch.tsx @@ -27,7 +27,6 @@ export function PreferencesIpfsGateway() { const currentIpfsGatewayUrl = useIpfsGateway(); const changeIpfsGateway = async (url: string) => { - console.log("IT's triggering!: ", url.toString()); try { background .request({ @@ -40,7 +39,6 @@ export function PreferencesIpfsGateway() { } catch (err) { console.error(err); } - console.log("CURRENT GATEWAY: ", currentIpfsGatewayUrl.toString()); }; useEffect(() => { From 4db41f0d7c34b615d5ba9c92422cf21ffe71bad4 Mon Sep 17 00:00:00 2001 From: mj221 Date: Tue, 31 Jan 2023 21:39:43 +1000 Subject: [PATCH 03/36] fix: :bug: resolved cicular dependency issue --- .../IpfsGatewaySwitch.tsx | 10 +++++---- .../app-extension/src/redirects/constants.tsx | 21 +++++-------------- packages/common/src/preferences.ts | 16 +++++++++++--- 3 files changed, 24 insertions(+), 23 deletions(-) diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewaySwitch.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewaySwitch.tsx index 61bb26fbb..3f4c2c1dc 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewaySwitch.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewaySwitch.tsx @@ -1,11 +1,13 @@ import { useEffect } from "react"; -import { UI_RPC_METHOD_SETTINGS_DOMAIN_CONTENT_IPFS_GATEWAY_UPDATE } from "@coral-xyz/common"; +import { + DEFAULT_IPFS_GATEWAYS, + UI_RPC_METHOD_SETTINGS_DOMAIN_CONTENT_IPFS_GATEWAY_UPDATE, +} from "@coral-xyz/common"; import { PushDetail } from "@coral-xyz/react-common"; import { useBackgroundClient, useIpfsGateway } from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; import { Check } from "@mui/icons-material"; -import { IPFSGateways } from "../../../../../redirects/constants"; import { useNavStack } from "../../../../common/Layout/NavStack"; import { SettingsList } from "../../../../common/Settings/List"; @@ -45,7 +47,7 @@ export function PreferencesIpfsGateway() { nav.setTitle("IPFS Gateway"); }, [nav]); - const menuItems = IPFSGateways.reduce((acc, gateway) => { + const menuItems = DEFAULT_IPFS_GATEWAYS.reduce((acc, gateway) => { (acc as MenuItems)[gateway] = { onClick: () => changeIpfsGateway(gateway), detail: currentIpfsGatewayUrl === gateway ? : <>, @@ -57,7 +59,7 @@ export function PreferencesIpfsGateway() { onClick: () => { nav.push("preferences-edit-ipfs-gateway-custom"); }, - detail: !IPFSGateways.includes(currentIpfsGatewayUrl) ? ( + detail: !DEFAULT_IPFS_GATEWAYS.includes(currentIpfsGatewayUrl) ? ( <> diff --git a/packages/app-extension/src/redirects/constants.tsx b/packages/app-extension/src/redirects/constants.tsx index 93e629810..dfa7e3341 100644 --- a/packages/app-extension/src/redirects/constants.tsx +++ b/packages/app-extension/src/redirects/constants.tsx @@ -8,25 +8,10 @@ export const ipnsOrIpfsPrefix = ["ipns=", "ipfs=", "ipfs://", "ipns://"]; export const ipAddressRegex = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/; -/** - * Some public IPFS Gateway URLs (https://ipfs.github.io/public-gateway-checker/) - */ -export const IPFSGateways: string[] = [ - "4everland.io", - "dweb.link", - "infura-ipfs.io", - "cf-ipfs.com", - "astyanax.io", - "ipfs.io", - "cloudflare-ipfs.com", - "gateway.pinata.cloud", -]; - export enum PREFIX { IPFS = "/ipfs/", IPNS = "/ipns/", } -export const DEFAULT_GATEWAY: string = IPFSGateways[0]; export const supportedDomains: string[] = ["sol", "eth"]; @@ -37,4 +22,8 @@ export const urlPatterns: string[] = [ "^[^:]+://duckduckgo\\.com/\\?q=.*", ]; -export { DEFAULT_SOLANA_CLUSTER } from "@coral-xyz/common/src/solana/cluster"; +export { + DEFAULT_GATEWAY, + DEFAULT_IPFS_GATEWAYS, + DEFAULT_SOLANA_CLUSTER, +} from "@coral-xyz/common"; diff --git a/packages/common/src/preferences.ts b/packages/common/src/preferences.ts index f3e9236c7..7ca9033d8 100644 --- a/packages/common/src/preferences.ts +++ b/packages/common/src/preferences.ts @@ -1,5 +1,3 @@ -import { DEFAULT_GATEWAY } from "@coral-xyz/app-extension/src/redirects/constants"; - import { EthereumConnectionUrl, EthereumExplorer } from "./ethereum"; import { SolanaCluster, SolanaExplorer } from "./solana"; import type { Blockchain, Preferences } from "./types"; @@ -8,7 +6,19 @@ export const DEFAULT_DARK_MODE = false; export const DEFAULT_DEVELOPER_MODE = false; export const DEFAULT_AGGREGATE_WALLETS = false; export const DEFAULT_AUTO_LOCK_INTERVAL_SECS = 15 * 60; -export { DEFAULT_GATEWAY }; + +export const DEFAULT_IPFS_GATEWAYS: string[] = [ + "4everland.io", + "dweb.link", + "infura-ipfs.io", + "cf-ipfs.com", + "astyanax.io", + "ipfs.io", + "cloudflare-ipfs.com", + "gateway.pinata.cloud", +]; + +export const DEFAULT_GATEWAY = DEFAULT_IPFS_GATEWAYS[0]; export function defaultPreferences(): Preferences { return { From 923e8c1e7945f58f44944915bc40508eec097829 Mon Sep 17 00:00:00 2001 From: mj221 Date: Tue, 31 Jan 2023 21:47:23 +1000 Subject: [PATCH 04/36] refactor: :art: moved default gateways to constants --- packages/common/src/constants.ts | 11 +++++++++++ packages/common/src/preferences.ts | 13 +------------ 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/packages/common/src/constants.ts b/packages/common/src/constants.ts index d59909a04..a65d4a258 100644 --- a/packages/common/src/constants.ts +++ b/packages/common/src/constants.ts @@ -580,6 +580,17 @@ export const MESSAGING_COMMUNICATION_FETCH_RESPONSE = export const UNKNOWN_NFT_ICON_SRC = "data:image/png;base64,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"; +export const DEFAULT_IPFS_GATEWAYS: string[] = [ + "4everland.io", + "dweb.link", + "infura-ipfs.io", + "cf-ipfs.com", + "astyanax.io", + "ipfs.io", + "cloudflare-ipfs.com", + "gateway.pinata.cloud", +]; + export const DEFAULT_GROUP_CHATS: { id: string; name: string; diff --git a/packages/common/src/preferences.ts b/packages/common/src/preferences.ts index 7ca9033d8..2547bfa2a 100644 --- a/packages/common/src/preferences.ts +++ b/packages/common/src/preferences.ts @@ -1,3 +1,4 @@ +import { DEFAULT_IPFS_GATEWAYS } from "./constants"; import { EthereumConnectionUrl, EthereumExplorer } from "./ethereum"; import { SolanaCluster, SolanaExplorer } from "./solana"; import type { Blockchain, Preferences } from "./types"; @@ -6,18 +7,6 @@ export const DEFAULT_DARK_MODE = false; export const DEFAULT_DEVELOPER_MODE = false; export const DEFAULT_AGGREGATE_WALLETS = false; export const DEFAULT_AUTO_LOCK_INTERVAL_SECS = 15 * 60; - -export const DEFAULT_IPFS_GATEWAYS: string[] = [ - "4everland.io", - "dweb.link", - "infura-ipfs.io", - "cf-ipfs.com", - "astyanax.io", - "ipfs.io", - "cloudflare-ipfs.com", - "gateway.pinata.cloud", -]; - export const DEFAULT_GATEWAY = DEFAULT_IPFS_GATEWAYS[0]; export function defaultPreferences(): Preferences { From 88cd6aaf02632759991ad388a051df2596c8e155 Mon Sep 17 00:00:00 2001 From: mj221 Date: Fri, 3 Feb 2023 13:40:16 +1000 Subject: [PATCH 05/36] WIP Merge branch 'master' of https://github.com/mjLabrys/backpack into mj/domain-content-resolver-revised --- .../tables/auth_notification_cursor.yaml | 25 +++++++++++++++++++ .../default/tables/auth_notifications.yaml | 1 + .../default/tables/auth_twitter_users.yaml | 6 +++++ .../default/tables/auth_user_nfts.yaml | 21 ++++++++++++++++ .../databases/default/tables/auth_users.yaml | 1 + .../default/tables/auth_waolist_tokens.yaml | 3 ++- .../databases/default/tables/tables.yaml | 1 + .../down.sql | 1 + .../up.sql | 1 + .../down.sql | 1 + .../up.sql | 2 ++ backend/workers/feature-gates/.eslintrc.js | 8 ++++++ 12 files changed, 70 insertions(+), 1 deletion(-) create mode 100644 backend/reef/hasura/metadata/databases/default/tables/auth_notification_cursor.yaml create mode 100644 backend/reef/hasura/migrations/default/1675247983228_create_table_auth_notification_cursor/down.sql create mode 100644 backend/reef/hasura/migrations/default/1675247983228_create_table_auth_notification_cursor/up.sql create mode 100644 backend/reef/hasura/migrations/default/1675373311788_create_index_users_referrer_id_key/down.sql create mode 100644 backend/reef/hasura/migrations/default/1675373311788_create_index_users_referrer_id_key/up.sql create mode 100644 backend/workers/feature-gates/.eslintrc.js diff --git a/backend/reef/hasura/metadata/databases/default/tables/auth_notification_cursor.yaml b/backend/reef/hasura/metadata/databases/default/tables/auth_notification_cursor.yaml new file mode 100644 index 000000000..8ad827739 --- /dev/null +++ b/backend/reef/hasura/metadata/databases/default/tables/auth_notification_cursor.yaml @@ -0,0 +1,25 @@ +table: + name: notification_cursor + schema: auth +insert_permissions: + - role: auth_worker + permission: + check: {} + columns: + - uuid + - last_read_notificaiton +select_permissions: + - role: auth_worker + permission: + columns: + - last_read_notificaiton + - uuid + filter: {} +update_permissions: + - role: auth_worker + permission: + columns: + - last_read_notificaiton + - uuid + filter: {} + check: null diff --git a/backend/reef/hasura/metadata/databases/default/tables/auth_notifications.yaml b/backend/reef/hasura/metadata/databases/default/tables/auth_notifications.yaml index 7b58170b8..061024ac1 100644 --- a/backend/reef/hasura/metadata/databases/default/tables/auth_notifications.yaml +++ b/backend/reef/hasura/metadata/databases/default/tables/auth_notifications.yaml @@ -27,6 +27,7 @@ select_permissions: - xnft_id - timestamp filter: {} + allow_aggregations: true update_permissions: - role: auth_worker permission: diff --git a/backend/reef/hasura/metadata/databases/default/tables/auth_twitter_users.yaml b/backend/reef/hasura/metadata/databases/default/tables/auth_twitter_users.yaml index 8247f4e94..4633ac7e9 100644 --- a/backend/reef/hasura/metadata/databases/default/tables/auth_twitter_users.yaml +++ b/backend/reef/hasura/metadata/databases/default/tables/auth_twitter_users.yaml @@ -27,6 +27,12 @@ select_permissions: - pfp_staked_since - pfp_staked_cumulative filter: {} + - role: public_avatar + permission: + columns: + - backpack_username + - pfp_staked_hash + filter: {} update_permissions: - role: one_xnft permission: diff --git a/backend/reef/hasura/metadata/databases/default/tables/auth_user_nfts.yaml b/backend/reef/hasura/metadata/databases/default/tables/auth_user_nfts.yaml index d3e532ce5..890b23b73 100644 --- a/backend/reef/hasura/metadata/databases/default/tables/auth_user_nfts.yaml +++ b/backend/reef/hasura/metadata/databases/default/tables/auth_user_nfts.yaml @@ -22,6 +22,15 @@ insert_permissions: - collection_id - nft_id - public_key + - role: one_xnft + permission: + check: {} + columns: + - blockchain + - centralized_group + - collection_id + - nft_id + - public_key select_permissions: - role: auth_worker permission: @@ -33,7 +42,19 @@ select_permissions: - public_key filter: {} allow_aggregations: true + - role: one_xnft + permission: + columns: + - nft_id + - public_key + - collection_id + - blockchain + - centralized_group + filter: {} delete_permissions: - role: auth_worker permission: filter: {} + - role: one_xnft + permission: + filter: {} diff --git a/backend/reef/hasura/metadata/databases/default/tables/auth_users.yaml b/backend/reef/hasura/metadata/databases/default/tables/auth_users.yaml index 8cbf24f6d..e5314d3f2 100644 --- a/backend/reef/hasura/metadata/databases/default/tables/auth_users.yaml +++ b/backend/reef/hasura/metadata/databases/default/tables/auth_users.yaml @@ -81,6 +81,7 @@ select_permissions: - role: auth_worker permission: columns: + - created_at - id - username filter: {} diff --git a/backend/reef/hasura/metadata/databases/default/tables/auth_waolist_tokens.yaml b/backend/reef/hasura/metadata/databases/default/tables/auth_waolist_tokens.yaml index 0dac5cdc8..c373db4da 100644 --- a/backend/reef/hasura/metadata/databases/default/tables/auth_waolist_tokens.yaml +++ b/backend/reef/hasura/metadata/databases/default/tables/auth_waolist_tokens.yaml @@ -27,8 +27,9 @@ update_permissions: - role: one_xnft permission: columns: + - username - eligible_count - minted_count - tx_list filter: {} - check: null + check: {} diff --git a/backend/reef/hasura/metadata/databases/default/tables/tables.yaml b/backend/reef/hasura/metadata/databases/default/tables/tables.yaml index 252e76396..eea306602 100644 --- a/backend/reef/hasura/metadata/databases/default/tables/tables.yaml +++ b/backend/reef/hasura/metadata/databases/default/tables/tables.yaml @@ -7,6 +7,7 @@ - "!include auth_mad_feed_media.yaml" - "!include auth_mad_feed_posts.yaml" - "!include auth_mad_feed_votes.yaml" +- "!include auth_notification_cursor.yaml" - "!include auth_notification_subscriptions.yaml" - "!include auth_notifications.yaml" - "!include auth_public_keys.yaml" diff --git a/backend/reef/hasura/migrations/default/1675247983228_create_table_auth_notification_cursor/down.sql b/backend/reef/hasura/migrations/default/1675247983228_create_table_auth_notification_cursor/down.sql new file mode 100644 index 000000000..0bd705d47 --- /dev/null +++ b/backend/reef/hasura/migrations/default/1675247983228_create_table_auth_notification_cursor/down.sql @@ -0,0 +1 @@ +DROP TABLE "auth"."notification_cursor"; diff --git a/backend/reef/hasura/migrations/default/1675247983228_create_table_auth_notification_cursor/up.sql b/backend/reef/hasura/migrations/default/1675247983228_create_table_auth_notification_cursor/up.sql new file mode 100644 index 000000000..f2ded7a50 --- /dev/null +++ b/backend/reef/hasura/migrations/default/1675247983228_create_table_auth_notification_cursor/up.sql @@ -0,0 +1 @@ +CREATE TABLE "auth"."notification_cursor" ("uuid" text NOT NULL, "last_read_notificaiton" integer NOT NULL, PRIMARY KEY ("uuid") , FOREIGN KEY ("last_read_notificaiton") REFERENCES "auth"."notifications"("id") ON UPDATE no action ON DELETE no action); diff --git a/backend/reef/hasura/migrations/default/1675373311788_create_index_users_referrer_id_key/down.sql b/backend/reef/hasura/migrations/default/1675373311788_create_index_users_referrer_id_key/down.sql new file mode 100644 index 000000000..0052c5746 --- /dev/null +++ b/backend/reef/hasura/migrations/default/1675373311788_create_index_users_referrer_id_key/down.sql @@ -0,0 +1 @@ +DROP INDEX IF EXISTS "auth"."users_referrer_id_key"; diff --git a/backend/reef/hasura/migrations/default/1675373311788_create_index_users_referrer_id_key/up.sql b/backend/reef/hasura/migrations/default/1675373311788_create_index_users_referrer_id_key/up.sql new file mode 100644 index 000000000..798dd61b0 --- /dev/null +++ b/backend/reef/hasura/migrations/default/1675373311788_create_index_users_referrer_id_key/up.sql @@ -0,0 +1,2 @@ +CREATE INDEX "users_referrer_id_key" on + "auth"."users" using btree ("referrer_id"); diff --git a/backend/workers/feature-gates/.eslintrc.js b/backend/workers/feature-gates/.eslintrc.js new file mode 100644 index 000000000..70ecc7af4 --- /dev/null +++ b/backend/workers/feature-gates/.eslintrc.js @@ -0,0 +1,8 @@ +module.exports = { + root: true, + extends: ["custom"], + parserOptions: { + tsconfigRootDir: __dirname, + project: ["./tsconfig.json"], + }, +}; From 83dabb51d296e7d5c79dc2abe0b169c040e025fb Mon Sep 17 00:00:00 2001 From: mj221 Date: Fri, 3 Feb 2023 13:41:58 +1000 Subject: [PATCH 06/36] WIP Merge branch 'master' of https://github.com/mjLabrys/backpack into mj/domain-content-resolver-revised --- backend/workers/feature-gates/src/FEATURES.ts | 1 + backend/workers/version/package.json | 17 +++++++++++++++++ backend/workers/version/tsconfig.json | 3 +++ backend/workers/version/wrangler.toml | 7 +++++++ 4 files changed, 28 insertions(+) create mode 100644 backend/workers/version/package.json create mode 100644 backend/workers/version/tsconfig.json create mode 100644 backend/workers/version/wrangler.toml diff --git a/backend/workers/feature-gates/src/FEATURES.ts b/backend/workers/feature-gates/src/FEATURES.ts index 87d0864fd..c7d41e420 100644 --- a/backend/workers/feature-gates/src/FEATURES.ts +++ b/backend/workers/feature-gates/src/FEATURES.ts @@ -3,4 +3,5 @@ export const FEATURE_GATES = { NOTIFICATIONS_ENABLED: true, MESSAGES_ENABLED: true, MESSAGE_IFRAME_ENABLED: false, + OFFLINE_IMAGES: true, }; diff --git a/backend/workers/version/package.json b/backend/workers/version/package.json new file mode 100644 index 000000000..a3cacc08f --- /dev/null +++ b/backend/workers/version/package.json @@ -0,0 +1,17 @@ +{ + "name": "version", + "version": "0.0.0", + "devDependencies": { + "@cloudflare/workers-types": "^3.16.0", + "typescript": "~4.9.3", + "wrangler": "^2.1.6" + }, + "private": true, + "scripts": { + "dev": "wrangler dev --local", + "deploy": "wrangler publish" + }, + "dependencies": { + "hono": "^2.2.1" + } +} diff --git a/backend/workers/version/tsconfig.json b/backend/workers/version/tsconfig.json new file mode 100644 index 000000000..3c43903cf --- /dev/null +++ b/backend/workers/version/tsconfig.json @@ -0,0 +1,3 @@ +{ + "extends": "../tsconfig.json" +} diff --git a/backend/workers/version/wrangler.toml b/backend/workers/version/wrangler.toml new file mode 100644 index 000000000..ea4967ea1 --- /dev/null +++ b/backend/workers/version/wrangler.toml @@ -0,0 +1,7 @@ +name = "version" +main = "src/index.ts" +compatibility_date = "2022-09-22" +node_compat = true + +[env.development.vars] +STRIPE_SECRET = "" From 0db5d7dbdf77cba42aabb1d0e58e51bd4be8624b Mon Sep 17 00:00:00 2001 From: mj221 Date: Fri, 3 Feb 2023 13:48:01 +1000 Subject: [PATCH 07/36] WIP Merge branch 'master' of https://github.com/mjLabrys/backpack into mj/domain-content-resolver-revised --- backend/workers/version/src/index.ts | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 backend/workers/version/src/index.ts diff --git a/backend/workers/version/src/index.ts b/backend/workers/version/src/index.ts new file mode 100644 index 000000000..0257f3d2a --- /dev/null +++ b/backend/workers/version/src/index.ts @@ -0,0 +1,14 @@ +import { Hono } from "hono"; + +const app = new Hono(); + +app.get("/", (c) => { + return c.json( + { + version: 1, + }, + 200 + ); +}); + +export default app; From b68acdd43a5496705f56e5dd5b680c0d59b6ddc0 Mon Sep 17 00:00:00 2001 From: mj221 Date: Fri, 3 Feb 2023 13:48:30 +1000 Subject: [PATCH 08/36] WIP Merge branch 'master' of https://github.com/mjLabrys/backpack into mj/domain-content-resolver-revised --- backend/workers/xnft-wrapper/.eslintrc.cjs | 8 + backend/workers/xnft-wrapper/.eslintrc.js | 4 - backend/workers/xnft-wrapper/src/index.ts | 2 +- backend/workers/xnft-wrapper/tsconfig.json | 3 + .../simple/src/solana/OpenXnftButton.tsx | 4 +- examples/xnft/explorer/.gitignore | 1 + .../Screen Shot 2022-11-16 at 7.04.33 PM.png | Bin 387408 -> 0 bytes .../Screen Shot 2022-11-16 at 7.04.44 PM.png | Bin 456036 -> 0 bytes .../Screen Shot 2022-11-16 at 7.05.46 PM.png | Bin 125328 -> 0 bytes .../Screen Shot 2022-11-16 at 7.05.55 PM.png | Bin 392462 -> 0 bytes .../Screen Shot 2022-11-16 at 7.07.18 PM.png | Bin 168543 -> 0 bytes examples/xnft/explorer/published/icon.png | Bin 19205 -> 0 bytes examples/xnft/explorer/published/index.js | 200847 --------------- examples/xnft/iframe/src/index.tsx | 1 + .../app-extension/src/app/DbRecoilSync.tsx | 20 + packages/app-extension/src/app/Router.tsx | 72 +- .../common/Account/ImportAccounts.tsx | 299 +- .../common/Account/SetupComplete.tsx | 146 +- .../src/components/common/Icon/index.tsx | 36 + .../src/components/common/Layout/Nav.tsx | 4 +- .../src/components/common/Layout/Router.tsx | 23 +- .../src/components/common/Layout/Tab.tsx | 4 +- .../common/NotificationIconWithBadge.tsx | 36 + .../src/components/common/PopoverMenu.tsx | 74 + .../src/components/common/WalletList.tsx | 3 +- 25 files changed, 492 insertions(+), 201095 deletions(-) create mode 100644 backend/workers/xnft-wrapper/.eslintrc.cjs delete mode 100644 backend/workers/xnft-wrapper/.eslintrc.js create mode 100644 backend/workers/xnft-wrapper/tsconfig.json create mode 100644 examples/xnft/explorer/.gitignore delete mode 100644 examples/xnft/explorer/published/Screen Shot 2022-11-16 at 7.04.33 PM.png delete mode 100644 examples/xnft/explorer/published/Screen Shot 2022-11-16 at 7.04.44 PM.png delete mode 100644 examples/xnft/explorer/published/Screen Shot 2022-11-16 at 7.05.46 PM.png delete mode 100644 examples/xnft/explorer/published/Screen Shot 2022-11-16 at 7.05.55 PM.png delete mode 100644 examples/xnft/explorer/published/Screen Shot 2022-11-16 at 7.07.18 PM.png delete mode 100644 examples/xnft/explorer/published/icon.png delete mode 100644 examples/xnft/explorer/published/index.js create mode 100644 packages/app-extension/src/components/common/NotificationIconWithBadge.tsx create mode 100644 packages/app-extension/src/components/common/PopoverMenu.tsx diff --git a/backend/workers/xnft-wrapper/.eslintrc.cjs b/backend/workers/xnft-wrapper/.eslintrc.cjs new file mode 100644 index 000000000..70ecc7af4 --- /dev/null +++ b/backend/workers/xnft-wrapper/.eslintrc.cjs @@ -0,0 +1,8 @@ +module.exports = { + root: true, + extends: ["custom"], + parserOptions: { + tsconfigRootDir: __dirname, + project: ["./tsconfig.json"], + }, +}; diff --git a/backend/workers/xnft-wrapper/.eslintrc.js b/backend/workers/xnft-wrapper/.eslintrc.js deleted file mode 100644 index c8df60750..000000000 --- a/backend/workers/xnft-wrapper/.eslintrc.js +++ /dev/null @@ -1,4 +0,0 @@ -module.exports = { - root: true, - extends: ["custom"], -}; diff --git a/backend/workers/xnft-wrapper/src/index.ts b/backend/workers/xnft-wrapper/src/index.ts index 9215b59e8..c3ac04983 100644 --- a/backend/workers/xnft-wrapper/src/index.ts +++ b/backend/workers/xnft-wrapper/src/index.ts @@ -2,7 +2,7 @@ const RPC = "https://api.devnet.solana.com"; //TODO: This should always point to the most recent released renderer code const PROD_RENDERER_URL = - "https://unpkg.com/@coral-xyz/react-xnft-dom-renderer@0.2.0-latest.676/dist/index.js"; + "https://unpkg.com/@coral-xyz/react-xnft-dom-renderer@0.2.0-latest.2586/dist/index.js"; export default { async fetch(request: Request): Promise { diff --git a/backend/workers/xnft-wrapper/tsconfig.json b/backend/workers/xnft-wrapper/tsconfig.json new file mode 100644 index 000000000..3c43903cf --- /dev/null +++ b/backend/workers/xnft-wrapper/tsconfig.json @@ -0,0 +1,3 @@ +{ + "extends": "../tsconfig.json" +} diff --git a/examples/clients/simple/src/solana/OpenXnftButton.tsx b/examples/clients/simple/src/solana/OpenXnftButton.tsx index 0147b1c6b..21d6d3193 100644 --- a/examples/clients/simple/src/solana/OpenXnftButton.tsx +++ b/examples/clients/simple/src/solana/OpenXnftButton.tsx @@ -2,9 +2,7 @@ import { PublicKey } from "@solana/web3.js"; export function OpenXnftButton() { const onClick = () => { - const degodsXnft = new PublicKey( - "AM8TpkQaKnoiofQZrnBWhhbmUfrDo2kWJLLoNm2kybAW" - ); + const degodsXnft = "AM8TpkQaKnoiofQZrnBWhhbmUfrDo2kWJLLoNm2kybAW"; window.backpack.openXnft(degodsXnft); }; return ; diff --git a/examples/xnft/explorer/.gitignore b/examples/xnft/explorer/.gitignore new file mode 100644 index 000000000..ed44c5d13 --- /dev/null +++ b/examples/xnft/explorer/.gitignore @@ -0,0 +1 @@ +./published diff --git a/examples/xnft/explorer/published/Screen Shot 2022-11-16 at 7.04.33 PM.png b/examples/xnft/explorer/published/Screen Shot 2022-11-16 at 7.04.33 PM.png deleted file mode 100644 index 0b2d60a7bddefb8640eb716aeada5127b52493a3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 387408 zcmb5VWmH_twg%cb!6Csl5Ml%mE)BthOM<(*yEMTqXt1EcLvZ)T-QC^YwdHm8KIh&$ z-uv~|7;98@>8hGibAGcrTuDI+7mET5007|1NQ-~cVf z#FS*j#ORcq?9D7~OaTDt@I-YC4b=gXOl_5yH2`FlPxb*}KL9G9ERgctDPKM#_#E~v z+enIpSf^Q|J)|t+tp-vhgBwXth;LMr_v8wy z>q1Ux4P@NirGVHkjXE;u0ITGeV{f-jMR03{!!pEueqjP!(Yu8k8$Er(RA1J8<2DL2 zeH^Z#b>V;&q;lsC?3m#g_ULQ}Q_&5R?l}}fvkvap7va|B4|l zkPR^UackQ65O~$YZHmQ5__?K=j*~?^j4QFF= z(Rd6s=UyX!6vOcwD9Y%A0`Z>syAwxFQH6>qp1^rVFxyu?62-Uv*ebtb3L~*|HeWby zN@y;Rzm*WYS0TWgrvtG0znJ|Pi&5oY(OO?gy86y506;1&f=&RyVC3YbS6*cZnA1=~ zg#}3iE<<}ChP=_T2`=?RHF{={@`k*zcNnTVo`*S$lJ$SPQ+aqh5nGRXPR7v*^4RMf z47}KFe}4qOgU~%?7>d5u8IZ;h;+V!@4*%8-Fv4UHvxuZz7j7V>!7KNx;NOy4Hg=#{ zJ9(yvNgWg#bQHwWSt`?MG@z&)ji##vlunJTp>_VIEh?|ROnVn{s6;;3gX@oSiVUrA z(BEGmuCg&*t}0>kn}jXl_<2x#7KnI`mXDKruWaK-^V_U&mp_kw=qBbtx%(&g5BpoC zu`$>J&?F0gsUnNH5^dh^_=6jfKn!&U1rmxtG?$_6yfQhBmTt_>AM0`LD8WpdA_hn( zxZ@4ekV%_rscOs=sf7MFgW_Xq+8jnu|C zy`eCL(c4Zn-~Pah!n2MB5uw9Gi=)GP6&TL;DAzE`Xn>W1v>TwJgqIZX#ejMqv(BH| zfM*_qqJz+ZC>@Ek!_(hEz|5k+^? z4M@L_{}x8@jsqn%^asOGoNK>X9{NHg)h7k|y*RvWl1spWs2)R>63!QiT4jc5Eb4F$ zWfF>z-e1qhaa=gGf|9Z$C%7!Qny_s}6mv)?jx0zYkx%*n1px;}1t}=K-SZl+k^=IL ziEK!|hI}!Y(V(8i$-4Sdf_>B@yeXa@&FO&A5FmE$kshkpYrYYA?s|{cf@I%QzKMS> z459oc$@Xggx!^OZPed;R*@Bfm7tz@;P`yeI@&2859xeUqkf=2L)PeQ&^Xjmv@W`;E z@SE=E-FTY}M!<0K$u|oLEi!ShSbqDfeb$m)l;Brr`gHi(m+nujeE;Y+ofDR(ILmAG zSoiptxboPnc%bUXw@EJ)KfelAOqJC9wD8%oKqtpVRalkl_pF+|6%|(`e{xfZmXwfu ztE_KsPL5H*<}adBdbQNtDoN9rLB2$c_q1PX)lSqFinqSx7e{`n|C6cIn*SIgnX5Sg zv3OU5ylA9_d-CE$_#}`*cSQMnZm)V;>DS-0*=`ai`TPvDInIu89fY(Zw7Vldxn=-O3=<6X|9Gp4ARtzMvB?yh^5AS?z{0&0U&{c>SKD9i1m zbc+TN9q55m=&fC~q29QAxU7_I_V>18)8nITy$($qBwgHHehkLB1`L%GTDhu{t-VdX ze!ZH#Oy6V3?^4F)edK~(Gs#D%37YS-X+%-=Qb;o8j!ln$>{hdCTBupMu1>AhY|*UL zY+Vp?F6NsOT=B{GjP%S34)4*3BqymQsb_wdBsU~CG?Qe`yr!+G&8Rg}Z&l-ER%$*{ z$x>BT+h#3ReNmfgqiX9sl4LPdGg7B(@4bLm>s&ij^QWfSBxbRB0sCZb$vuiL>YVH) zg|bl2l<3U29i@Gxqw{vvACZ-Q7y&u-EYU}jNV~k-DxWElz-N>%{uZ(oyVOgTsuQMra9QV z*gMhtjcOWsk50GXp6L1cUCN1L_f~FUn)$aq;W2OvRZCT?o0kx!v5+L2*-?trs@bZ} z*~qG{Fiw_Qmb|cTTS1%7n$=pU->#nz*w#-`v##XBEX%Ac=nW_wE(*W1QM{GA4F`On z=xlZZnu$Kj?V#3G=1l%b`#Fe3Dc&g&|XxoxU!|&mmCdd@9^rJezy09LT)(K!zKRl)oC8|chGeAbjEM}hPY)b zI}pX2()Xn?eY>T*t?N%0>X+WAs{uO!g$Jt#LsMC%9_A(e`vcb_CH=?5Rl!F=oIGQn%<@O9Qf-BsP2BF%*ZBl?Rrburpsn-2Jv=X#Jj1Vk%0_+O{UP|sc%Qte zQmZ0kx#v^$V*T z$?wk3$>&LWU|FivarT_Jlw#^Fv(OmO(5$;WDVF&&s@|Yxqa&}&th-YC+DCp$E3#I0 z&QCMB@zg6HWa^t}IMZ2tcl2;nZgak*R6k*1{LrhI7L;aZhqt<{Wcx+8GPoh%VJM;W znf4g07gB1L)=_t9t6v{k=YA5lFrl@jr&>MbuotgY^Hpo9+8RC5ib8Pk5?vVF|S5f}LpNDnB zzOJR16q?_H#m+7R?1z={#wdM}(RWz{S^Gk%j+e?qc}W6=@d~=u-|cLH)NYT%B(|mL+`Wp2{$4~gw^A7tWa;!BU zWChc_ncUs^28O__j${vy{1`pC&b=lmp*%}#O)a(uF^6C{%iYS}ohj`#@c6zT;&H3G zSy-4===0K7^J?bS`l`Od-W|gU1HD`4nL3Qgzayfc5arxU08nEB*gyA?q%P!z4`Ao; zRu2;1D{44O{vhQ69InH?U05N_2dD;PUp*iJkB3`GVL3E64eMEO5?Nu;*`lz+;R0f10T0P26*C?L|mPb}j7+vndDB|Zdzf%rv)cs;U_ z|JxdQKO5!0dDJ3A9Y9o7OhyKgsv0|)n%X&A*t?u*1PCDto;gTsIs*VCjDKGw8I@Ov zPeq!uRMT+LkeA~(wzp+5G_f}_W%00e_&W|j(1Rb5wKa7yr1P+~v2*745TgI51wSJH zx0scl?w=+u)5lj%L~r5Z;=s?! z>hA8&;?Bup?_|!(&d0~c%ErOU!NH7Z!R+j5=VIu=Z0F4I?;!sjN8Hre*vZnt#nRr6 z?(evUM)s~QLiF^1C;Fe~-|sZ_u>9Yd?419zEW`p?|JJawBN+aF#zu4%{9DSeWa(jQ zqbY7_i`X;79K!7Ed>n%Rbol>N{qL0jr>n;QcIEl_@&ESxKQ;gFo?o0zoy6>I5p%i- z|1Z7%)A|2a{->iL>))mSpRM?JpZ_UEY_u?zAnX4SO&BW-KLrOtM=DEkMKwf<;Ih9D z^56X1e^W#rxs5TCASw(15CO=Di>i4b9k)Kq)|YSv3bR^>YLk?v#FEy083#9`lC}rG z(r{NM{G?k1L_=~Xz@(2wgIY@1N{Et(O-Ize|9bQ_@-tD%AO#7rQbpPL`_E{8wb}7^ za35jw(c$GMXj^Ph%XVvD>h=ns^JpsHU8eW$aN|{mfV;_T37_%14UhuEpwy(+Iu3Uy zrpD|j8Pe!{UoYT!c=r}gd-pqXWMTk8jFzo-_jms}s{|v0BMSX~d}t`N);C0#`BDEq z>m0m~38CFmi~_qvNDE3r2ruSbqJUCnBNT~=?wuBr=$K_vl5A8iTjsYIjF)3{E01Bh z*u=W%=UNcYeq4eUW9pAgltSA)G3>wK72ti)2B;I>d;ff^Tw*=!#o~(#sc!wdpnGSN zSvk~w2V`!Z9{5NZy<{IYh<8phGFeZvMu{=+Vr=HF*W_~H_LxN2SpDr zTDp`B$6MEIP4k?+#yeidjOsP3$Q?Vc0HD0=pS_#HnJh()CLeVfn#UVK0hRQ_Oa9y< zjeGbcDV+rQ{1$zDhM<8292+hcN)AiT#a4|1a;F=4L|^c1;z#DsvjX0g1?X1%(Fif_ z*4KPFjs~B~c;AN1wy>qx`f8A}h;G?W#8@e>TVOaZ@>0{5#1gZCL-+T{!9{-WaKs;T z3G5H|9B+@zt309-m{SDFmHLxcEqD?10lL1prF`x7@;a9&8#4m2qZm+BH&M=KaLO%3 zH{z;icnv-k-!GC!pZ^>X!*Vq-=%ytE$-@xTd#y*554F+?_~wb%v=Su~A3Rmu!5eab zoyJ8fT3LIt`zhywEVyNs>cWMD^My%l9~pVrVgT8u2JL;UeT218#0&c-+<#VlC6##0 zQ3ZSkHx@>g%0CCQ!-}lC?#s<9!8W zu=KFBaih$K*;XA9^cX147Oo~EwIk+(%9|Pz1b>LpQ9xP$rI``rivz)h)N>uesC#Rz zzAP^pwY&LE6WtOsy(((5QpwT8B<9?CS?1(a%JCA-@!oTW4|mFMa+2lHV;jTYGvv-Q zIdAJ(e#zugA9_i9IOv53oeD9aGz3k+JK-yYxh@0X4! zxmLsO11X9S42iv%4V2)h$6B$mff&l_R5>lliLy%&EEKP;yM5Kc5u9JpV0m?TD0gL3 z!AaEDj7gsUQVoz#j%+PfNO)O&C2?Z zY9sn9t%M+P2p8I>;_+qxBg@CH1ynrR&lISmaVSfEtcNM!G5OylI0x1=jl|tFn6qx7 zwG7Ups@m{jzZ4bqV9DLji&ZoYf_1@i;KA@`@H8o0k8U!M5#;-Qplmb)tja^#%b;O8 z@8AW3)6@Ad66SH@9fNH@%2WEAZ_B2;2C_~eYZCi8-+D9C&DzKBlbC8ZTP+is)R3UQ zjKzN#$M{0@Sgz|6*_0$=>(Ws_RsV=fh5@fRh#Uv|MD#-Y#PT4uiSQB>f5(!Xi;wmI0V2*!ZxZ?lcixp6e)@v z;D$p+r6slM@?I5d_PAs5E1V&-88Ne^XVhuB8}|J|TDAr4r2Fl%_yJ=r%TG4p&XbxsWe zmSpE%4gS&|6F%qQCCrlRcm{I*fpl!%6X3p8IqiC`LR`3~jgN6}vACpPsy?taa7;D^-!6kRz(^J(c^)5P_ z*7=Mix_-pYvLGOiy=l|#Pu@?xC7qy8o}@kQD>jX`Nm8HsL-DGG<+{p5i_@?;d_!UK z0uoYx<#3)SLiEKQ1Be(F>c;?K1+C?WpR@L6k%4M?={E6?2=-qPf;tox3hsx@#-R%X zqr)dNA-o|05Jx02sm9+%EI$ zFTHx{pTD>iga0e{?V%y?o^ztDn2!T-uBgsnp5_<8x-Lo7m505= z%?6vZqK-fSV-r_-103Kj!sk{l>eCfQ@=5qwiZ}!|LejJ=h5hVlh~Ltc@E?_>KN{0_ zFQz}vKS&1JprnVjcljc;Av4TIkBFLk*}4gxopV{woO_u*h(heA>Tp@*4K7xp4W8ah zzSsUXbhRBp974em3NNn);>W_7pnr~)gw{U-nhhi8;PZrODZD{lu9Z0Pjo;97!02Bw zH$5i2z@Rl{faTm(Oy5w<%GUWnOqV`vF4r6f0aGt%1vAcm4L{FkSMTfnhJ>Tl-X|+& zs!PfAOPcjJO2J_2Wx^klehRboqS_3{3SN2nBnW1 z7g}+p!C3#C`h6|t_xfo!c_233?t2vZ?t9t5ilFGti@wp^T+7qt#)G&RKa<6sU-7g_Ia^Pn!Vzg)~2{eKb1qsx&8tUnqDLHDTUm zK6WU6ebn`Z+IEf1E7yPY^Rr-(y#uK^{j4_7&CEfS>|7qD{e5tOXQ3=49N>$0DyT~f zt_vOtKz4DAiZfv6Jg?#2#diNpVA~szBOleZ&U=-%H;kldly<5n^Bgq#AD+mKHTRiLC=DpP)n4 zN|kyY11g@z;^O+=NM%i_2Rb-T%TTxLZpATGksR-xaU!Z;OaGo9^Dn2hkCh&krcRvZEE_oN|El|%=Xa$wj1yOt!IbiSJ0BjnrmDoAIC8e$0Fkn^pe9 z$<`mr^-A5a>vctp)C2!;3FuHYOMw<18dIok4+U9RA1;7&H{-ug=r-w>JJE54M;mA* ztX7GqQSSLG?F|f!BRs z{cE{Cp4Ct>rx-!l#|##;n^Wwz&gz!z(pJwy=JLhxgaJ7KixQ=tk%LMvWN zrMSO0vhps>amQ_k`v&$_OV$=HYuEWd3P{j^FqM-Hri0j!syT(F4aUANYnHszw6`lT zv9QO%#xyrTqCR>T>~m!K3$%~KO?aDpg4D`@(8IJ%JAX~7?)x-6&yhb<6H?R}b!&#& zyi#rvKgr}>*b~3fv3)lz=qo_Mu0w`OKJIk#Nt1QI*v0aHw{7nSh2PfK=iRlQ`C2}N zs>`L`KS$!f6D?F`(2z99)BjZc?&7M$*emtZhmic6+@dIpn-Hq(K>g+plT0Fwu(9`! zK$R2ZKsm_#YITzpe#4tcH`=v!(Wz+7;Pd-o;&9jE6Y?!O761YGzfk z5&Fo=QKbb1)V!=IrB7TTrdbS zkPWwoKh;ld_Q+1&mA9hT8Qhsx^@6zrM~kv;(%uRjl9gxPw&$*QWUX7)yV-t4>JwG# zA?wcN%C5pmKFNM@De&krqty5dJ1&E+HplGx z9nY!Hq%%J#Dh$_n$CoZ!Eb}9+KI6_;*z<<9`%L827sO;;h09Qb-iz#UJvlewns|*K zbgyYW{Xu)mV^13X8Q@IYQDmt>_+gbKRI~MH+Sw|>I3Uxc^mG51m&1w^W`3JsFwBy( zfO;;j#p=HbMW{1iYWhkt3fS}7XZa@Gcu3mX%>DycC!kV)W%O%su_2z00$#DyoT?T`!G^FvH9gs;10UW^ctQgMS$4??P%XSF>nU%l*nt= z&=VQo)`k_-o+DQX-JEZq{4}!&VMr60h-#_r;1dG{zu25XYN@-zmMt+p@d$4~D5SAj z@#=9-<9`Y3()QPG{>C~kzIaUqQWQD~v;+>PCyS@``L7!X_>GLAN#fVh)daHju(2S` z9BF!g&8-naC0oaQn9_r1b;&&*>BG@Ar%b|uCydJJDt%FwBba3Z0#(;hDG*M!+=FTj zU5=5otB;K>WoE&Gl9NdsgS<-W*d7GP3V+;Lt1y_fnF4z3=;&u+%J4rG%v zK3Z<<6r-AN8~@41wuUcF7AlSJv8|rgx)X(8NBT%4dqjQONJ4s zc1*R{|0#$jN4?~O7$&n-@qoVb0tK3pGcB+_x8(Mxj$_V4880Fh*cFg@>>0{Dva10N!J)De;GoJY*ZQiUdg6X6r(8A9lheig= z`bKBR?q{8_GnqNC%r$=PN%fe1{-5&3MI0OK-YkY{HwtQ|>YAp6^v43EO_4ox<6U)N zBR6AckJ-}0>KL7nwtw)=0-ea5>u>5879WmZK*pM)&CgG(yNd}g^U)99{Fmg^W`7|M z-snZP!Hpl4b1oDhpz~?r1!0bm>vyadm>2Q2v#T`x;YKo)cTs`f=`%m%}bl>srzbDjWn%upjP_N;|Mf1YD%$9$$DvIFM z;83VDxU9i@y)A417tUBSQ>2d6ef{?Yyq_k@#=`pR3QDRdhTl?aKv&hf-d8N6iG4`gJi2yb+D9~x{h*9ATWM1?hCp*C6i zp25TK7xyoB%>QIC6T=aHFjujImZCb&wDY)bc|2(-QzGHjs_~fJ$j>E-KcBhn_8eU+ z4C9oNJ05Z9^3sRLL|)nd#E=}seE0>T!1hl1z?h~opLJLIA3G!WGYy9k*c!EOypVQ}zrydxiV%=i{J-eXyGeK5ychWjBFY zv2DGYN=bU9FFkpR|J+>rP^!RIK{9yP33Xo@N`5`U2-e9NrKjy}grQyS z*6L~QX0Ho)S|>gs_dahmA^e2jh}5ItOOg^nm3ugE_>r5YPgFgm*`NPL)8HrFgZ0P2 zXn^lsQ@5$}V148fO|NX3S1%D`IQa2t?ql1+;}e2*S&~xbLqmg}$cMKeh0uM8EYXL3 zDloi@b~2_6+;$J2Sje?(rmjm++(nZfY=VGY+4f8lqaka{KF*IjAn5zQF16@WV5v?0 ziQ7T(pV_?9`qkbjd6H=XoLVr=7;leJ=6+~k^^Sc0;5;2CZ}2v!h&g=Cmj`?N$W*@V z=njw}YJCsqu|OkA28mp2TKJ=4neqQ-+Zo0{aaVLvhX_SX^kiIuF`4@V4RcXc1`cL42rI=-8bN6;_H{~7^5}(ywTCZZ%cKD zB)%>7e0}H)#>i7uczEh$Xs1TQ-W6_kIeUu;rz(Pe-Y#DK&dvp_;%9kEdcm+W%bly6 z#3;{6yiRtF7~tuO=?T$%ySyKJ051#A;YY4;ZRizC0}NA<6b^6VX<^Cm=)ABa=Q{fi zPc$HKWnbnHb&!a2eXCmby#!sy#BTCMV!17eBe`k#5J{8YXw+C&$$ir`5JY1(u3p}` z5bf`NR^znuxt&j*9tz%~K9i&6KN0IG;WmeNv9MH=Gp2pzM~|!^kA6W}BHh;?yJQnJ zQiNjIUo!EtlIG6lHMuj-cg|l_2Jd1}SAujTCuH2X|6>-}A3kJdxYNj!>iZ}=##{&L z3!GUWB$oTQx;h;pcB$#G>e`>0R-?CJVj|-~j9~e-)^M52#y2tK>kp|;oZ6NsZyz+J zAlrpN8Sm2$z{oD5kTm^K>dQK|kgQAI<}X zuA!~zq`HlOxfAhJkBf|p+sy)=8RUHC;|um~OSbNFUk9+Y3-wejMD|W{oCe}D1)K*6-x%4S^vEXVnaU1wJH-B{ejJFM>}3|D+HQ zw*CE1!iaeAKi+hBaSmKw9?r>cuFy1XK7O!W1r~VRH=cYWd@-Oxf|fwM^`H;C25+Iz zN^>)2iSnF8LbkFXIGp?53-3DNnXc%_*S^;Nr_42t zGiA0lA3K?YX(7D3DH83E{^L8Ca3BntbqWQ=2xX?j9-Ondh8%J)(#<#&IFc^NG2Z#g zF_ZQqjrGOJ*HlK0@k$>UTQ!Q{d9=k{)^?-0y4%-l9$)u+p;7nmcp=I(zq9(3%?^8f zmaTX`IGHc&Pkjup>o(=GFt*HObtI<;Elir;H|?pM|FT8B+%qm%DF7{TOUxQpgbNoW zVQ>5I)$)n5`dz>dIb=JdsP=W>|4 zrmOR5Q_5{m@{7YwoJuIhom91hm&>uZPM%fw3mU@fC8dGmhad0ZEGeRjlTz`qF>fgUEx2`3Ano>Xu9#Rw|+WP%(X58sA%E zcsaK&CQ+iA)KK)@>n+h6X_(LPaMk;>;Z2pBNPU)?%RScqmIiUOeXY$+s^Nr1Bf7N$ z&)ALyx4n-)lLhUq)f)b1ER#pzRTTc#%Z*pdWiqVu^*|CF5jp}1oczj8C4pMMxFAbU!8NM|m}YkgwTnF}fNKUSj@E5lqa z%Js&>^d-=lEzpnMY@Cm60YmBdSDL!>MNe`bDHvf^DNO8t>bnDxWG~_H>+Yqupi|Qk zX=|sEu;_$w?Wc>H^X13*Z08=_*Jorqn$SbeawMek8Da!gsyx&ccnux-pN@&&inaN) zq(g!R#scK^qJWzC(+|^Aa2{~@4m17=T4ClGcy$@cf;ZGy=wJb4p*Q;$i~4;ryw z9l5E_SG|qXdJ^}l4@EY;ZvA50Oa@ejhgs3>Nz}AiZ+LcY-~>ZDx4j(6Ki|4$z=}O@CbkB^cZ|YTM{6&R8YuTbJ zz>7?u_22p5P%=rv(`;boc(W1uUY33`KkAEDKd&^nw_WKTOyg(1z6La2fYkLo`Sgfv zlNv10GXet`SK%lG+0NmSHb}1I*i9V|D04OF94Q+o&y#y1EztVS)!K5>G z0UF)6Xxg5PG?B_URmMVlTgOeao*ouzdpzv9;T{sOk4)|K?nU;HVBU6mf++0g5PM)W zug#rVT2CANKtCW0e4el5FZ?93z}I-XoSsps;UH|^4);VsXo18Ct-w)o7yA2;t8fTdYZ~0Nx;Cp3e_KnU_Bb z^HAVkzdY&g|IkAB`wpO>FA;PuX#qVi1cS6#R|>D{~4On5W0td5zmgVaTZ;xM_dL(|o$ zz{Z3o-L=M_Uh4AHXG{xCZc6%&k2v*NELg0-@@)bU1gurLkJ-QV71iHlw zE`2z9aAd#qw`YN;NKKA&{L|mIY?vQ846-SgNoO`9^N-|enMHYRN?`cFW7h+H7~0SS z1^iD!u1^M0Au*35L;zc#=;p|{FB_2Wql=b2#Fy~hsE>7r{~d+G9nyQAq1#JEqyqH> zBs5aKU`_-^-Ua&%HUM1+lS36198{mOY%AcGhckPH7()A^O3k%xXKkzs$p-Ht((M%C ztgB}|^G-*BZjtSyD_VNjn<(p>>swXuEu!SA5qjS8*4xGF0YyJ76d2LW);A<*b>>a_ z^^<^~zQc~*^T0aWv>s~Z3gM1q@w4Hj4^AQJ^!VK@EN6Y(kxqr}>>@xKBro}r<^u%z zBBK@T2RQd#9^Pbn7-{+4O1-2FzBz|`15YeHviX>y4=AVlij^W3D05x{w={aN4dR20 zGcVHX_L%uCil}YPDBuHZ3a?=E{%LlLB%fz%OMK;rJx3hc2Y-#F_`c%K+911JTVs?T zEXW-V$XBNQ>fzn1T?I?sbQv9c;{A7RZIyE%a(Bm$fmuL?d7Hw{$K=^_;tIf~wd~2w zSoTZq!A)^vdE3&63@`w(5OtDQ*yCdu-IB4N6Ol1XNtGP!P44KFqj{TbHcLZYiI}vB z`PE<;=My>Zo4FE#Vt3%@tMC`u%|@Ob{_haZ25Thdt7znVdy`xe8amf5tj^*h3OsJ{ z{=_2PD#L@u?H%+Pw}0@^U(OZwbk&)pQ2gQ)HuzN(c=3%dgjV=9;q*hIx?VW>>7KD? z1CS*RcILchJ6R8d2GmR`2z;~t0Nua`b<1Xrb#v>?9Y{99)2f|$MBp8@K)EZDO^L(<9aSK*qj4O%4^N1vls150usM;P%w$BuYk^#Q5nuj)CH0?Wg*%*3=#R zMle3Q59cvLFz|FP>pO{yEWf_XVeYCEDlEDiRSo9a`O|@WhuNwJA+L^9wA^xVcG$Sc zvW}dpguc>5(>3__DZC&a?DG&hg+R;Fovc?d2X6oqoeJfiXOB#VZ>RUZHoh@9h|hm? zmD`onl9}D28k>C3U=_lD^0@o?mg~{~;)|VVt;W2z8a8PNGFk0duJ5>GzzSf+RkIOo z#;E)Y6W&YGwmOM20sRPl;(Q#3dlb2@^cywpS2g(8_3_QE>poD%iNOt`#jp31`|o{J zJFgY6++9+E_Ik;d(gTa7rP#$iD!CH1Y~*d1iRF2L_`)C4zA0nlml=L~%o@plTE@*2 zNp!n*-c@SvVcy@Q65^E&C?!4_KuTjnu3%&n{DKGwmXkTj4ss0NehGyL?+{&{)T2zr zSw}2xLoxrk#gL`}uSVd79}FrKl2`A0c?zA!pf-hYYTs$)gQDEEPL_8(?t||N^W4Et zLMSl%(e#BB(fXTOo9ODDt34qxeTX0&Ql5_pizu8pq5Ht0_|j_+cz1I31Cg`vMcEvk z&CV?OzRCS#jIQb&l`RmyAc6Jxnm$mi#;B){Ef7}s>3j(0!*)?!rL7z`zc~aclIl2!HtpxgPNJBfres3$-WaOK%;kBn z9O+qwhpM+8&K&52AGyNP=AVFaa5th2&>JHN-&qStKF06bc+huLxA+Isx_iOKTLYx` z&2(K$Huoxqn5>#rWSncVO1FexC3UQZ`>l&I-Ur~}O0I_mbY7|ZG1PzIdseDdOY{vU z!*)a1AxoFg0cHf6k2TK^Pn%G>L9J(XqMNJ<)aUl;`K0j~D#1(%e~btNC)#k(B-J{xmYdF)~Ji(bLWw9JY>eE>6+@3+2M{NQMaa*Tb# z9r*)Jh_>HH$v(9916E(%jdrPc&9%=<3HEzt&;NcW%lov^vb^xvvRaO}ybI5pxy~Fy zuR$q!E_Crsv2%4kOEk8PSc_I>4R-53DXSO2D9-2F7#Sg|Tkj)JFN%tUE_&UM^FmrL?PG~RB*D&QW5`eIblLZb zSZ09z(bcaHbIwr(e`uug^zUw{`InK#j=Pl^@;f8{IZGG0fY_ zf9~u&OPsbfHQsjDza4I_booim0@k+Abo0@qeGohPmGhA0V|es(jaMMb4v+5Uyd83x z43>-WhMbu^S1!OKvN`gR{6czV1w)SZ?15dB!>Uf!V!wN1LtIqq88h_k z!ku^BUKYqXc^%Gjl*Nu=r2ZR&4Zj11()u;%q325Fz&+Qz*Rodc+U|x^>1brX6AfQxHb7nO@Bq`7A|uZ zHXB;%u041?SNZi@U!mCPdt1hSz42S_OE-2(Z|Lo>9Cn|gqS0*cp`?1L!JBQJud4(P z=@Yx<=qJti}M zyaS~`QwilxFYbCNL1orucUkI_L7QgR9Hb~|#$uFy&;rFTyQ02!GMMalSM<*Zj@{e%M9wB zG1btY-rO6J_`)d zwd8l|pEI;lN`LMIaf$@XCVyS~)7T$tf0v?#^Up!L1cB{6Q}jWun|y3}@N^L?6N3+h z3ZinV#Du0%$kZ=8$$BB;{h4-;H}*Es0fqa|?4n`z+-xc}e`_xS ze|YZ&k;K`yNbqUb!F_)+L$Ja(m88tti)v(+l})(ZUa;Gky)aKM|IJa8fd(05oNe~T zW(LL?yI-Qtzvi2bL)XyizMli}wY~cMw1zmts@f#U<#oTwd$y>O8CVkPKD7M^GukzN z4WS&*Eh|%dCn8MDheE1@Pk88)7AqUY!%CD3Y)vB0` z_yn29`*zf79(pF;2gV%V6Zz0{VV&h*&5O;)qsOaYik?Z)>$5@Quq%FYoKN?S`&Ikh zJ3@p->RUl458+dn`A*LLk2`_@k5)$GBd~l@fjD?~(Rvc-6E#-_gTXa? ziuN&4_jgAKvuR@h8MN;^!LASRm8|RT>)GIiNGoz1G^4}8CU z@H|J88csns#n^z0xv)Ypo}p>UufD-cpVxOIe<1)kA8+H-iNP;>D4SojFCX0sOSa`b zGBwkN-!iwhlQ&SGAuedM(qQq07z}xh1}ZNn!k6an-AxKJByRxp^)i+>hjLzigC|)w z&Zg*{u_x*w!@uiXo&}ecN6GkKiBK642?K(C_TT>#CM<7C+7zQu*QQc7eO~hnI)=Dq zkWKpOEGGZ0lNEtTWiox3&qmvmDTYv+53^%OJlo?SOJGE13pD z3NkDqaJpuX{0rB{SV0DvSh`MM`^1fIk8M!6pzg1-Twqs@Y`$AIV?XMt(-b5$rQ2?n z5ee{nywo%ogO=B6cDsdV4u(d|iowf4U4{n@ThX%GwrGW8k^Ot=oQdV|iJJp#{d=Rw zVe?UWU`J#_DQt!dt2#?`bWRLb(BKE$%XB&5=>@KS0{`xxGX$xxqwS|cKHG5x8sSUS z_k>VRHr&zHn$Uesd$JzWuK=KZHK3m`kmuzN2sdRLTlW%Ec{4t?*TXfVlb}1+Fj(H4 zX0mJd_0PSGP4`WC2M&LE?NfYFmI8^!X`DuD&BUecYoFSW!z&s!KK&Aj*1tYTxv?%+ z-iSNpJ0dWJLa{M9(*-3<@%@)`$dHvE@IU&{_d>ABlc9P|lImxdKm;!PH6*R_?+qv4 zo=7243erF;H))uv|M%s|D7gWNS&ZNNZ*m2+a2}MDW{mb}5B)QOpaUOr;Os0CI`w=I z{HKlNHi!g{Qw-13kXwUMkJMy%3VT6)u4(iheAl4hDPFb#eTArAGrf=8JnZ~T8u;EJ&a zcVM^}|HF2|RA_~|AWAVAh&u~9CAXsXW)Pm~zN$WDOmp>CI)|Cz<`n$WdvBv(?{rVA zkttAbQP48gOltw&u=6sIU$*x34rlhA=G`JP-I;&CHhhbA>vySI80&AA9@*mfV6RA0 z)(P2szs9cZB@}rnr#oR6nS8bUXiM~rH-av-*MliX++oeX;GQWHyEsj6(D%Reg(T)l z>I9C^g?VLPeQlz${i1zk2Xkky8!Z8UuF(-&{Cm^urU7dV@9y`0C#-= zH#fm&oocr!vIT;f&rR6%`uROF-m18#2Th!%3^Ru3zE*gSia+^)Qqn*AiTe7vgRzDP zFABEDAY13>O*DdkuADXkHNaso4A*g~d;8$$`yf476u`3AA!%}t zWzS{IV2pFSmOdQrpNcO%2K!^qh<@CBCd?zW{R>~zHWO8)O)ucgqYo}$nBnCW1#Dqf z8#AkbyRN|H89@(Ne(vjyEj@w18{zb~L;1aQh6Ji9On?G*@x`81j(pB1dEM&DbTu0X zoy97b10$vIl7rKJ*3xUrgXBI_Im`QGaalB!@zshWRvlkYs8h_uHMjnwi6GAh5!Nr5 z%eW6->sD@i2dC`z^(Ed?{PCp~ahKpId}8X$L$NF7!WWN58WX6!h{LTBpWl=o@u!M{ z=jYhldue^Vwp<3kd&Piu!+atbpX_t1ktWXz+duhy0H7f)1_P+YtEMq!{u9Y#ZGO>| z#JrBUo79J~ZvE@e6e8ZMXr5^I1Om(6^^l6!FIq9B6Si@9%_L%exb0C%5FqZuxdP=v z;@{qhCa-mcMwE3Bkq(c3--Dn2Kis`lR2*H~_lZM*V8Pu94#5ddfDqh*L+}t>6SN@& z*Ce>Rgy3$$-6goYyVG=k)yaLo@AIyiHEY(IIhbz_IH9_#tE=|D_GSOy_Brv&;{@#~ zB&vBUp0%EIFy&!;Toq45d4ytE)Ge?LbZ0*XdZfra0bP}US==S!8d0~Y)PldssyTmY6iz`^dg7o_tDC+V(F^umdF?zF$hkg zN|~@d#QMp!Ohzso*NR!|T2g3Lw*nVgDam?1JR;dE`!dahv8H&?$FdA67E`h&7b;hA ziY*bvRBzB)!bcm2-PfGn%6{H0F=6h^!NVUx-H!g$Tpnsd*dI^s#T^GwC!3ZZ?Q2-? zmc>T4kMCR0){RpncPQ8w825z-YWA{ktDjJkM2ojK1w|PCcN3rSyFUrFBH+z^|?n# zKsQuz2gxOJqNJ50S2}dzYON`^Y|RQkf( zl~0bXf8Bsv+#dBPFD^Y0cjh%0xW=|Tm#2=ilhqOV50N(&vK1d0I0Cbfo7qRn^#1l6 za&q>58=BJ1a42lg0oo8d$7OWou~i`4%!2r0&z)p_a=v4nHCq>kS59OFxAOa(UEJ1_ zrs=xbRdNQ-o-z;*qp{OWX?eUu#QMAp15HjuYxJ8fP_UyH;kRKZsz5g zuZoy7X+w;qv=#hjP1@H@I=^8|{HR9**7^~8Ew17-uQ6F5{;0wwbfL5Ic>M9%%>krJ z{9*F)WThGIpxtgzy7U={6lI^x0j#nd3l9|t=GoN?PzHsjX}$5Y_e~QVk-vOgp(zs* zO#5{|4Ty^6hGlWU6Gwb7<51akW{?3f%x- zk@)(bf@C{p=S9Ls`m7)_Zy&cALw9-XrL8P$A~p*kpH)`C+UoVY?J8wj!*kS2MVS+H zH#m^jdN(YWKkB{D0|d`GXCL{0)q2e_5XE^dA}<2#7*1?qhd>tsA@$9+ec6vGSy^~k z_atKuc#xx0A-nwhQVn+FmAtsysK+w90Y?*@bfL7WDbaF>Sh%tX!-YaIIIq3fQ`r-v zYEda*>N?N3Rtal3J-lX(^BsKH&#*biJKN1CDvNYWj)=9Wap1*y9O%jo2*`#R9dJQU zF8Lvouzt)nZKwWs#wGNd94ob>6U#*s7n_M6%(@x|BDP(wB46zwI>3}-Ddt?%!7I`dE=@*-LaT8lr5gvXNVDxwbKij>9 zxY*6Wlp$%A7JAxRi+zvV4W$AhAY4|7BUs1kXs|+MI6c*bA1@~*=-ufJZ#oZ7X%CI_ z#KCLP9W@Xt;|O`<`;MI&jwOAswQ!?v9KUX9_0M9yPJgSL{VlGmcNbgaN_20P#%=++ zc?JF0j$Axh+GM&Qj4b3H4*sQA6mA2wjxL{nT#L^MOv6|kGcTVDP?BN zE2&tyiqkgmx0$a^9TE3k|GxKgYj6@fi;VUp(Cv0{d^-+wA+RUIxlCl25(RSV9Gx`s z5*2+sixOAdeZ+=-KWV5uJAvjOf)q}_ZLI}wbEC_83v)2lAXzVmDT$~a51N)0shSjPJLj0Y021NzfcdmhdgaMTisP0K_z zz0NF)!3npZ!NfVkVS+*&VuMo%Cwx{I$1ICFvg~a!9&3+u!bQ`n%S-)> z^LWFb26tDkCtfT1K1b8~_DWudS5ucO5L4O~e1o}8s;iL8t1=$~eOmiGzsrPHu!W~^ zeB+|$f?eYKLLh_x+;WWbD&bXcdDm93Ucj+fRAk8@6exZA?gbS1WFGL)fUZZddob_Q zoPjuvBy)j3{IZ*_7Uj{7X?Ca=>2}4ep=%3mD08x=(~U>MI0~+%#W%7e_3XnYmGfzF zIUNS7AmdAIDS;)|?_zH+>w87{fz+{y$k&Z1z{v=vxYlC}y-Nn-FLCZ`hnr4bhmFf^ z5>Q4npdJCT&AP2yY0Y}CWf8|wV(me>qz)RLl3UX2(LE4hsg%zGYN`^7$al$-y$vJX zBd^_)QlR%WQ-LFrDo6S4$H|xQM}&MYC9p`EMRquv^!C9@fL1 zD0z{LNbhM;k<*DF#{*E^R=g&Z?{0S>qmo|G^|!(=ye7Q*0eFS)yBFOl8{7szEm*~f zeTi2|id-F4R+2k4wdzJ09*{jrRQpF8u%HOpsoL>nJi3b&T@4)~YPqVf%ZoM)OB z&7Q`d$uM+ZAsbP_APQBkcYHq1&JTPBZY_}%S3fT*12P6_iCE3Yl6MZD9uLaJD61aw z2~Y7et9R_cx8e{w3eVlOJuhuzJ6q+x24hf!xM+8wpaE3#=6-(V)6Ghr9m}J!V>=6* z%beRP-wBIjm%^FCJ-H&=Reg$r9H$ws84+W#?_Cnz1Mt&u< zDGUTi7suXYcGJbI%`Ff;E!55_!qY%WTy@BlwkyWif>Wd&`rzp+9ln=rX~2c^{Bk5PoTox zeVgr2C90Yb{sN=^ErmFH6LeA`o5%zuEebExW^8AzVCCr<=%#Z^EM1rUr2R}VT` z=+-}td#x5{DM?>i(ek0~@U_j^=zbMx4CcNGmpK9EYyFTb!p9p6E=6_(DKSk+AJr;# z+35mRL27^UKM$G+V#RVRO?~YAFAKofKBo^`c$kDjX<^M|6ICaC7s2 zFW5KPo!R-bPVmngP4x(pjh$!apOs=;MTs?y1+mGA&AIg1KI>H<;lRrE4X|qnbm^vf z-fAV=;lwl8YCCMPFWxkq7Vdp9cw!8lU>KZ`cQB6Mh?}o+Qz@iZA)GFpaxAi?qSHgD z|2V4C8oWOUxcse;*Doi`s00L-+z;6CdR%fa(>z(JPG5By!#c;i6Jjse^1it2BLjma zz=oKo^}c_l=iEBU?iq4CNv=LJIgjlO_0RX{9B#-T;uSukr?-3c)fqGAR*bbK{qg($ z3Vf4}H%|1U4P%$V+XCFX5>k$tUDODnG9_19^~{?2#LQGOyKO<^YD()|yw8Ktx|qZi z#D8xsC}g+zj4`!eaduC{TQH?fMM41rN=5dDx<2< ziG?72i^t-gaW9*5amPiF6fN!&E~I5n<6IiB@9CR;?Ym#Ql^M057YKZ&Fn)W0GSu0d zDFV@L{8SO&7V!~M$Q2`eQw?NjjSW&|oEV>yJFu72HpDifdgh25Uf=&FX z^V{J-urX*bw~RX>If?3R?vt#J*KO8VJPzQpxDd@`+w&QNC^(9u3qUclDY|t($R1C4 zZbDZEMe^QQJFGhE-o1u6Y@caUv8+Go8*@}mEj(Dic#27k20`k2;)}P3^D?w0klr%4 zriF>9;(bmg0jPq$0O7NIZB8i85b3{x^k0>}tz+uQ#)*~q#olFX!EtwH=J%j41Qhp% z1h95+7N;;Zw?i&cvgnOW)=oo-w0kx#r5NxCe>h{27vve6c=(}t%EkT5&nG=spacCC zWz@q~$M9ZQ6L_uqXPfsLD$9545h&(Si>ykqvQ#w&>5Fq55aJJJSwfcM@VMg&jEH@U zuj0O{i8RD;TD)D-^hpu65xT^7>31i*?iE8?fJvsAzz$~^M>zDO)=}9zW@cdSCEIjB z!v-E{n;Gp?RVh*;6^000y7~F)dzhhG4W@*}RY+PoqW4?*jR0nIsXQD*z2&D@&(+S$ zx0R6%zRGB#8ziHO+QvSSfw|Hrt)8-9zl#PAr0_y288~!xQucD6NB6yLZa?~2PyETz zj!Rq0Q09#Xe{*JgTd^PJNDPbLyR8^biZ@TQKvluz;wSR^Mr>nZ*-(p%8257;u*z9h zKCaH2TjN679;!#uBcDKiZu#Do03*n`>$%r*$!wc}c+1ke^HQFdvb)R+Qi3f+Oz=Df=SvE+L~@@eKsOkPGh!Xf!% zej^JqTi@tJKW={`Ywu6L>1&u(B^&c-Dl~A;-5D`(rW2gIpcEn^`+z9yKoqACb-9?N zU=N(VOt)hyZTBDj%8{$)qh6Z^wuNw`f(LBg?U(dpjB;SU7cSf6il!SwpVIAkBVT~5 z*I{@Ak|xGV7V!4rjh@8M75ecO?ND<*7JwI_l8;AlelUr7iTjV`X9Be6>1F-0*e)?Z z>^ORM1N7}EJsjO+drp!SE&V#b`QFY4<dD zRX9ZM@e9-+3#K8K&fp5{U71vV$h4eTB1=BG$T1WB*t}&BX2Y4PHzuP}gybGwH$040 zc5*lr>>@aQQH!$w1C7i{ zk8EwwR89SDgWXAXAwZjsyz4tz$BA-Z}a| zS+7^VLYQNyi)F5$L8f$_Sq

zi)(z!y_~ zlytRIz`;tEBQeL%r(?Zvb)*4(Uj$*Y?9H03ge~cbshxD0M}Vx>6taDTFfmCeS(3D# z>)->_h4JJ{DIA6+v4+cRvqW%!r>nSe^mU z36f{3FCdq$34^{bR1sC?e&W2QBda-uV-8?OE6)BPs1q`B8lGUgUVdqC?i?T$!-;nP3iSuU*;LCYRdDJW~nPAEM*rmpK`kpEbDLGs%up`@j6+_+p;Pfd(6N) zD;UnyaNBP7VAiDJT*PArJ3W;q&#|%#L=!;8Df6Y3GhA1A+ObL?-NWiaSzRU^yQ*>g zXYK7>^?&U1LPuwj1IRGg~VdEUbjFy<%>lY zH-$VJII$N37_~5&WW}KZ zlg{i->pLW=pD|5mZb-|ZKlv01#~1ii)kck&#Z|*=kKN#@P%sgI$Ef=+JO=Tfvd1(< z4pi58w=pB?z)n=|mWryc6FNbtCmni*TFb4}yK+>wzyZ{U2PgeeITV`?8*M_(=N}xd z{e1nQzu0mc<4TE&t~_t`vLp<#PC!YEG}$q|H8If(5=2_+a%xJgM{5`$@(l;flgY5PCc`*;~IrWz*6$s!)Eb3Wm zq}c0L?c=15b6RXYyx6qh1QXT(2t>`|=O(Q$jmM1#69OZ~Nsy!BojeTAW}NyW3eY@% zc)cq7%e8L=kWQUluU&Of%zT@7!%^@k?5kPIs=8sO4107`Tv{Ws8H-oD9}@j@M77kv z{^OWo+tZz_QNY|D7$?U5J(yd#QDffcreRMl+FR3ex3no2RrLK1uS+k*r2B$HGy}Ij z>++dImsL$kffFrUQP&GBQmNh`#vcQAU^6A+r?-o_W)B{HR$zI%x$2V3$=z9rm!>+e zTY-_{I%wCbB=ESOe>s@}VS7a5*#ZP3$*yyGHWN<;mi_iMZ!be&;E*FUA{D+}gc`!` z>5!BUdRJSL0buj9FO|V_KdcEPhb5*{YV8m8?EvFEnQpGY6;v+nn!gLGM!TR~1MQy@ zK(r-aKFUOhi`@@+^xWD^dgFrH$cLO{!F&Kz2Wi)3cbl!;Qo^r^Wy3P!i~dVQo>jA7 zj?GBp?mKEjvhSqjd@Y%?1kwVrS#m?gcUa<93Z;IL+x+9gP~HEAVFKE)VAv$Ob}0XEJ7`O0@B6ZQR{#Axa5*>*?Ps8PyvVx?s)x+B9 zS=%Ba>sdvcu%&7$`d2nSy#M0xe1Q&2qX)+mgScdSZj1d8uQOxKFf4FEndMeECSO@E!<+$x%Vr8@RP*d8Wzp^0ud(kwfz9tl} zw|`?O+%NCOLe5aJ`~wP5R6T=}QPc>`aH6>(>K*_UVh;8T5_8Xj5nShs#0&K0di+8_ zU0xIOE-mFUq-LSEOI*jepOiYosO9z_;wydkQ2lfh&H1MAXGa9(^o`$Ed^o3~O&*30`o%INM^Jnk675nVI}8=Ra%hc)}NGdycj4wVWIY zM4RsQzu>0?Q@QAuq8Y!=3Tk!DV-2n71sNR+yJT47`4h$2=P{#vj=oomM1?4o-+J^( z3bilBB5yOwRBgpR5k{FbrQHXjz+7^*N zYN~}!V~ysK-j9&mmJ$^=DS)gbhS4wWdqMoKK@Wz+{qnP~O!&(({PTjY$aBIbnIPmz zd@hV%4lJwqF$iwXTW}zD**IJde>J+d zqMI7x`D0@sADt%;(&C|znLRRBa%YNZ!y$h-tbbR2I>_oR$yq`*SNF!~SKXJ9QE|F@ zG6<=jtBJjEr1?>qUyUC(=VL|KOsSEQo^SHJu0t2J6r5!5RP!&8RplGZGy5SelHu$V zuLBSbHJGko5Iz|4AQ+1WX0pl=qlP@ZBmZ*D@;$&s39ksAyWqSFv6Ia5K%j6@wOgwr z|AOH3YC5d?u6e*%v+9BxQ54k!XZFHEm76$eYA7_1hk8mv^q&zO2tBhS+!EO1+LPK! zS?YCGg=zhxBa{9D%@Q7DQ4;^W9U&Xdgq&VylzpMyYp&#t09iC6@zNCir8$ihv}E$S zx*~aA%ACaX%WS?=%xSClF*MQK&eQ`b+wi^jZNc6e2EGy8hHsaG{>;`pgAeW`a~ZHy zkv`>zOmr+;Zip)GE!E!{tErN<5oZb9(%)$TvRJqioua95 z4}dMKc5$lL85Y?Tdsj^=q^);Ml2r3%R(ye^Ff1QXwJW={+@rv+4TiJeo*RA?FY12~n zUKCaa!ENebg0}nq7Rmc^ZRhEY^x=r_rz{%JhIV#C&tH#8OArps(-_y$UaFW$sFDEd z2`5-({+(OAtIjF`mZm`*E70 zLS+MA;rsnn-Sf$Lt&J$^oEmDhcF(?Gu|gm(=#v~E2J`M=97JFtMBu=R7s8D?n?VWr zXTd7)DGaG_xrRHuoxdN$g%l3xI-IR#9z7F{r=^U$(>!P%s1n$-faz+hW$9+rntJ}a zvP!|HVg$fFM-L$cpSF@Z+a^(6;{LUW)PCnq0e7ePXERe_|4<4YZ_RFTg0fwgHm+qa z;`PAGEk|s3Z{A~9bCZ=uA^67J!PELKMN8i3ZGQ+u>NC?-@?-ilFMcLesFYvq!p~jk zARpWq5E^k)#; z;syLSrEseQk&w}n@QqITILjCBA2fi$vTDh`j6*2I*bXYMI7zs&bwz~Xu&-N0|8H3#q2fmXzrl899?o~IJ0@>ZOi1 z;n|Gn^Z!$PVLr)uO(I)efzp=+%*6{95{FUe+JuA-I88rg5~M_D+44STkvX75o^k!{ zDW?@MT;(stZ&8zE|Afhy+z{6u4Xhk;Ni)EqlXi#G0H&fLJ?rNsv&!BK^s%{MkL=sY zvdsoXd`a=`Ce~CalIo|n!v3qzs@>`fjUmIS-vdE9o*W(xk~Gp{)fD#v`hJmL9xE`C z2(zK%CW-tV(6IpLds=-tm`?;F7>+sUWZ#6G&3Iyf8VbU0iOx_jB{o)#-@fTGR+XEU zJ9_hqdTvtbZ33WO(qW{B)R4Gl6x8wz?pQGez7)uZX_uP4QuErT!}whSmB!#^@rct| zp4kLwV>U2YkjUD+g=v>?&yPN$|Isd)k3M<4=pBY(uXaiP1@&M23&RxvG}POc{8FIL2=4PoJTpiy9kLc>nnn~U?L;cG{Q*;XZ4#r@) z%-RJRo=iHimV|#DtytOln-M8EBIkyfeq&w7Ry=33JvAB3@S-Kz zVll0A%KlvDYy7%76(w$$B4hA1KJAo=4$>KSPdR`Y%dUCZmh3M?Tiv}sho0-FgS(~IR*y4=QtBW@Z7Ka>r7$K?< zwc+9=mEhLZFQA~S#++wLF2!^|8=$l-&euZXL;U%Zfdgo7X9k`MX#P8y^j{jv?$gV- zZEcdmAZT7d$eA2A`(*+*WP+Ma5^(uud9AvPcgeN|O~^Po*dPuA4#^A|bA*1QT5uE^z~-Nim$gc>gZDzI=a{-GIMN zyh2qYpZO5{jVKL-e9pQ+4U!zOn)FXJl20npk&%gjW{6F!W*etq`P@xcc0HuCjJ(!F z_;rN5v{()7qGrLW4i(aS(&NxdZEO7T-OzWiY2unCrXKg}*+#VIn~2ua65vO`eQ#k7 zP6=scbOY-q)SCzQ-1^mVu1F2;-QMB^q*xEWiwKuwpvZn)-R0ZEx*X>GZBf*fzFZh1 z!W$BUEy}Ez@YaB5;9txpESZLihyZe^HTwr~o3=4ZnwfB$JWkyVhZ2Bil2iD93`LOD z+KSqmt7%?|!Ge)sAQV!&B{Drm#cWVKBP)TLzU((%< zs9bqOn?dUrT>q|7xoD^P<_P>(dTJy#cx{sK!nZYKirdVH;kSYVnG9%S`m>2)32b7R zg@OMlPZA8#eWYNIh8vQ}G)vs?^rFXDL#~S|BCk>u82NS^Dk+jynyR%&Swvh3ZOU!D zKtNKpDG_U7uumgYMjzv%N-Hp&zK((JTwgOVf~xDOGN6(#NEIqM?h71nt6%E z_w-NrVg}AT&&B>&31a|r%Wq&K?^bJMFx5p3S+JxMl=br)6fLFlY@g%(iASbY5%jL@ zM|qe(N-aO8#xyVF|b zGjHU#{*^v8qd_Rb2*U89E@od=RajsV$mY;!jyXr@Coiq3^jVp5HO31arP{y!tK-mJ z+zx14O1uTgHSQ0`i~#0*ppu(+854?4?>c$*X3SfDRdY|n-ARn$G@gFP1=6b~!F-s1 z&dv}`_afO{G!`0Ri4@8G6SFP%eQoLs|G#KA%@2RV?~EYYdz1qly?Go+F!~c{@e`WH zH}22qKQQ!U{6w>+QwfvjE~REwwcv&%x4eS+2nZ&VF@vcs26*w zthfl`^k6#rCVYTdQ2J?!yKE-H^RAq?`GxH3wmU?G!%oEQz)*s%f#MbkzJGzOfc+M% zKNrtd82Q0-M!Zq>h_~{b9>(j<_Xb-7`k?OuCcI{ri;E*sY?WZoceA31HV8h1IqGQr z7Sv^f`uLfX6{lw{nf+E-UQ7{xtSDgVE;%oeU7xk!|F`Qj?h?TQSfSQuaT1f+L(Ieg zj5%58N0BhVwv4m`Vvi_T>_KB9Rugb+mVdoH98i$*CCuENNMj?K+%9+qp7sbKQrzr45nThLe05p6JUWn zb&f_TufN+yJ<#$+2#r>7;};?H=dZxk%bx&G-66InhNq)j`~&^WNk7*U#ww8gPni4j z0%88?f7FHn;3;W&AAB#&qcY7bB{tdb{+C+j8usOGx4+l~E)qkEYq-qU+3pQiI4+uw z1k#II6{fcYjzf<5`awAepz8K8@aXoG7#z!})!uLAz68?TjK6}uzx8JrF&X<7Ue=OO zXHPp1coly_4iX7gG%Hxhq5C;XsIc}_A0_*5wOB0fl&Hp5#QYtsTx@OpRO>4~!$z0N zOrb8K+dDN_810iHL_)|ei|u9tvhXuqS^sW#DSj96Utfkz0GlMp8i|x=JFq%#W11(M zS!Oz_kI_3NVgz0Dpk4v54?I79lt+cclfcmE2QPFovfxrhdPXJK97s{f$xwX}H>0DX z@5i^%d-H;U#yIO8p_c`yhqpU>ziwJMlcl}VpHm&p=OBG$%r>j`X`}At$}7=c0g;zvWbHcRaGLyOA6BJ z&w}aZ0byIyCBOw_1W+sDD&pXF?8&$U_KcIg#VSt`s2 zuDoW{kmD|(TwFaV_~rff%M8EqPbhxEylO9qs`NN`cG~8JsyKYVY>NGQb@}ZBshLWU z@vRPN8V^&;^=ap1F&0F8UMqj5t6s(-{%PIl7$O171{||^K33`i^#*l5KN&Cwt^`uy z6^ephNT5FiIHQ0^Gn0c%e(2>uWuW1Z-U|2kKPW6>h6>s4R~X5lLTe3xCS!81Amgij z{aTQ{BdV4Pkgq(2%zPTf%#UZHg*5dJ)B#oE2D^M^`QOiy5G^E8>Qsv3*5fBT&d%eMH@h&&_OagCC7;>`yB%32;? zOlrTvKa4G5tv58AL|T}w@>w7fZNPC6uTRLLWc-`GH(9`XRRs+kv0!IEa$lo}Rk>q10%1^Wu+}E8!<~Yql2F{-ec0&wb zzAj!M*Nyg?uEa93u!&$!AqkAhbZ_H}0{4m@bMHZaT~JuxRK|9XNIl)jcXf`mMU3Qh zA-e9^MxsfU`oCS@eY)FhsL3HT;bO(nfSY>g5uF+i15f>5k**pxWgRPbM4dVKr%+s% zIam_N_ZoN-7Gaz$xsmRm`TzHe(Es1M$#osQs_k>vMJJ}*;?m|1>fOfr!VrwRkUFbB zQFS6tNnvEZ+V&SdKK2}a#dC3;?nZBXY$7i}R3t={=fg>n5SovXMWzE7veiahs{ zyT*VTRfH-=5BEP$@E{O?Bl*vgJfb>l$A6wswvO`uq=rv^+8p*D4*|=G|4~Vf{Oic$ zrPW}>ZhS;5v3Vevoe0_p0g|L*WKT7w!jqEY^Y^$cvQ%AzR!lMWFg7F01+tsYYKy{@~*% zi{$k0^aPQDV-$@n^yhg&<4!|KQqU~WtkkUW9{L(|h^M|_H@;CP=eHT`_<(9NskI_3 zTx=r*kchgqwz|R_5!ju_JyqhfIkjc!^|#>%^iq(`F=*ep52pRvQfH>BJ#+~tCQ4r08Z>n;&Bt2b@=i0-l!mDA1+JIkxr<=D#(wN(`|OlD`I zAC~GTM0SiDcA?=)*#RaRHTk6BQvJ1Zv~c$m2TPXrXl%tgmO zCh|D4@TU56i3E?={X&MNJAuFdXEy+Fn;6AB_^*g|V-&LB47X_*c3d0MiQZa058)W2 zNsxkX9Fl%Bvga(y`Ex`S$1qcxBM`wA*fleCa?8_5C+&Z`8xtae@l)~ueu@=$yiO6^ z+m$dS+q{BbkrT&m8RyXjci{ZF#$EwjjU2pJ~ zr7lyCErR_=Aci!21n{qp)W5tR6I(TQ17h@dK(7P-b_}-G7(Bqs&*GPMdkwp`2i)+nli z^WY-Gx>n*tpg$B)c1iZk+2W_hyjmmRm5f@rLk#oOTX#FV>Vb6;XX6&6BwjYf&ST!WH0{I9d3#aUqZBG%Wvp7HflPRMlaE=gl=nL z0cUR!zsn3HGn*3M{a%^E|NiB&ue$Kz)K17FL19JRigEpdhEeBlUn z|Dv4WG6M9eEwnp#s5Ep!qE}EA@V`?+Av=)KCBQoewnTEnZzJG~`6$!@1=0us=E@Ws z5+>*mD+E>`dJ52IyO&EwZ!spFY!$(I7T7X2S}G~5fOBzVNInI+`1XEqw@yFWrreHL z>?t{8rkDKNT+&W5c9)pqMQ15q3Y$=DKg-v=`QoimtUa%lrZ+tMADW7`wzsX+h12PG zq_tJEF2{{(n?>VU;8F)2X;zkee!nVaZ#Rr1aHcu}I3s37z@EmK+Iepaw+I(Y)cbs@ z6WAT1^U&ddUW_=stayFLx;Hd8|8WVe4}p62?Mp0yi*jCb=hr$v;2b$RwTcKnG$4O0 z#{d8SMOkK;b1xI+L^+ncFNR^gsm6g|@}T~VS-=u&?4$=BtkmivDGe&un+HO1o<2}+ z^Wq16;44Sr3~*zow%RECS*!a*MrJ}}>}O1u0%_=y>+Ra?g?GQ{S9*1*QnX8dDrL` z`FOB{yy6CydCIK|HLGv-*bx6tc|MZ|6%J5-dF`bfKCOo@CdqA^7g@JvgEil;0&G$K zVE0z380`Z}<Vx0%_sBI7P$%az;khhI!+$LM(jX&_j0UCC;=SLURsMtT zSOf9bL3OLPD=!y!TDU%boNV2GeIg6~y=Zs$b(jJg2$n_M=vo2D9GN@gi?=l@i*{cw z&`U{jav+!@C1*0oqFM2>KdYR9;`iv+&pao0N$g~}Cms}RuYt{HcJ^|505s9x_*5!0&ci(U`GZ%-vy4=GaQD-&AI}4w`S~Fex-7KX ztnY0ufQ5+4(-`|P`mlQPxpvj;(X>I6?GP4AN<-3<3EESu!l19W&AdG%ZpcRip)p_X!`WVzTa5NI81e!Gd64YY|c%~&R*EO?6=MU-69J)e> zz(0;#+#CqTa8*gH!d+e{v#s>kfBgy_ZzWCEvZO8=5&k^)E8;j?g{oUd(IX9+Zupl+ z<{g!fPvavMW%!1aVaa|5?KFjo=2HrSin+SEo6_eumR1&=LSqHd>$LgJBlEWjUYqm$ zkcC@^i|EK85#AS>lHbn7eDI05x7=#`?{+}9lb~fo&wh)mlL&jWptA&Kf1lER`^ej} zIk|GKr_cm;4(k_|5$(R;@1u66x@BB>^PwbNdAFFoeCL(QBkGFR!)mNH&j&9obMd>% zyth_XFXP2gUKze#>ur1DtA)Gum8t#|*wesy19R4Y>@bH}UBAz|Z;NKjKd!xlRn?NQ zO%TzYninbn1yn#({C41WI*8485HsU_;m}(|+#9n*djndWdGO?R#>ZRmg#hRR>IS+K zhcet(Mu!ZCwlZFUBKaaQ2PIPvfLks=-L&}ZHx9jraKbkV;%Ai~xi|@^V?S^ZwcAl) zxM*}2QoLzbjrk?!M#U;Gv@9*|e_f)`I-ce^!0Z#X!Dhyf*A%^@F5MIJEf51P>**&w z$B+2VLHBR&Z(m84**9OYk@{P<-nCw}@eb133G0?AOTaT>GN{T;}DswvQU@QN># z5v+cLszxM$oyhpsi&_c_EJAnjSF1FK3ozV#^d(L;OCd_w^D|2~CNp?l(9N!c6I9w8IgW$gTvZGJzsa=ygesYJ0A^XWHI7>KL{uXQS8IK5)%Mqpz=#q^cZBE7Ug$=b3qo zfWIl}?Vbr7(EH!|fKcsmoZC`Xu=ki*KAzr|y0m(hU{`UkanNAj+Yo5-z!d z#C<}zK_IupW$sz2UPdt`_#JNP^;i#q%K@{h7#{(DZ6f*ATyi6U$~P91>fRX-bo3jfqFg+Q{n$GRFqt;NIT|Sh;uW66JRPITwx;w*nw%N z9@J(7+ebp-oE*m^)tve}Izvds5VcHy7dZ_{@2-DRJ0|agW2_w3mO$Mnt5t6tS>P;? zEu;V=o=umZ=`4Z0R-Fc~ik$)&qt^5DU!Zp37JPbp<`zWpn3u29)c}2h5`bM#>M%(et_Oa}$6`)z(UfjL& z4tn1T3Ui#`O#}7!g7cExcE`E*l7?Fq2swFbCN>+6OLZ81%+9pIT5I6Cyp2}N*6P(B zutP6fWnETEru_I=Jj1MKPNxpN3hOSUhWQ!8pn}#z)}>V}PJ0y>{Stb{^xHDuq1Tq5 z-}D?}?@Eq*;%UuIP7+#Hui~U)9My?$L9)!%;6K-NzxUvHn)%lp@Vc)H4(8-W)F}@5 zp^rQt&4aH#o9Qto1CfeZo9o2O^}nOUR**EK)@eHB< zLKd~I;F&{}QK*jO4K_hm5?e)!pk1I6tFk0rshrKZ8`1++$)J`SqY)9@_IE!9rc5}v z2{jg{RP6cW-_b8c*4_|kk>C^>@$x&i?Bl*ctM=~twN$|yx#Fj3&Ve@U3v6hi^mnrN zTFGUwc1AFdo%2Jne4)U!ht7yXhtO4t@RSp3R*YBHO@I0E@H0Wqzu)W{LbAsf(!n=& z5a2Pc&{_-nY(Q=jUeUZ&%3%vwZ5006y})VA+zQvKim4eC`l|GM!V&xQDYn*%7Ww#T>BHV#24%cgm+o0r+qPQvOYP>W9^01K9b^aQ{ z)`IRVa*duDSB+X*O+qsCsvV13uJ&v;*l?23pLUN%=us;ts@SboJu23WzwdKudH)U} zWcbd64trHMY-`}D6LzCX;AYr2j`?@%GWQ+N)CNqD!Theci}xwMGi%VC+8poukt06Nnq_SS9|R@{ZpP{f4k~7|Q>p(hIE` z0t~to&<~om*Py7#PhT{~an)0xOU!rk+bcIy;3o4kcrbj0@!X|GO7Mu{dKq&IL2}SU zd=xak*4fh3Vy;b-57KnRl3Ag?TmT>1~-goJNeIj2C;V11eol@gUN4QN;H{#6aqA!tP zbGroUH1=Zdon-ncKV%-<`J`#M_3`UhUynrrav?Ey-l)`X{YN*bhVQ!sF7+NBGu*+Q z>>S&&u1&yF&t@60((uf~rVBJI*3;n%cHj(6&a4A=hRIy~*7MAHW$MHgyKB5MwVtF) zI*~K(g)Z(j`6}k2?nsC{g9Vy%czAypjxQ1>y(k9G+^27ztm-tK&WQX^hQ-p}*-e5o z?iCL}o$WmS>XAk0B!tA}3%53~_sXq04^AmSP$sj3P$;GoX7bdUnh$gH4Bm#TB~o>w zF*yVRen&<+w1AL9@55TPXnaMMdd{RjLj|r++i9w+G2h2h0{QR7=9(j>F7ch>Cs*wVMIybr%{BY!MgN5-2xn55I|@vNE0N$K$v( zN&*qG3%yfb=Zs?J=*pL_@^_AC_t$?8N#T6(y?t#9E^Rvf9Nwhwps(AVabY1IoOtN& zSQOafXd@0uEA@F$#SJWRsPdUGc#ke&Au%E@=@fvGWZTIixvVp!DBoT4z;4wbfov|w zT&DZ*9`91hoq|~<>&fQ)m~8nE5nRUQI)aA*s%up)rtTKI zNooG9Pv+e-RjqWi$);-P9zIdos~@QQUHe1ykn_H;dW$dJ^C+LwDn>@2@36vtrWyP_ zGLg|DKw}@U2^`>tq;ft?<5>1{+9p)oer&uxVi^D7qzk_cda>R-;T&j{x?J*Ua+?X& zQNBWni>&-f&`x1fh@I1uKn9(!FFMi_Je4al8px0r#bkQk7E6uO5{Epoy-tDZL#w#w zdyJFFf}eHAsOQJ=Lou}n16sp!5V-yAAa)lHDIhzDVRe^^)0u8afNW8h*<@&|W>`b- zCxmw>NE3;vs4o$rWW9l5xsv*mzIReBE2N^XZD{!8dW_SjJUkuHdzGHvLywkh=j3nT8Z;Y!bEqvs{o;3l*WCXi z?>(cM?BabvIw~SfK?FgOB1M8Ay#$mZqJW_Ej)($Mq?Zt?NJomGlmLoIuhJnD>C&W^ z5PF9Y0tqA}&&~UuduGn8HS69lcV^aI^EEr!dFtN(@++z*^Gq~hMPB43Y(#u+_vVK> zQaZQP&dvDT`y*$Etd6yQT+odL8KCx`XXqVi(t;Cn5e{ynZ?#Gr>i%2nlv2Yo+nDvH zWSNyeK9s}7J#v9v-}IyBuj(A)@8l_`mnKe_M5Bw950n&z9K5pNf*@@5GD2 zx*n#TM(?5dbOJV-HFx!){9i@FV-8!s7uUj4Ey)>R{~BLTYJk?nb7gy+HKsx;ipMaBh+Cv}1XPu161 zha07S8!g%kJ#eSKJNxf1b>udOna%wZvq#$*b6+_dbgI7)U(Qk_Pp0hikXrVCqsin9 z+L-@S3*i5OQ-0SjzePW+eeMwYrQ4&j^4bdgtePCuA4s2-yLbqrH-ly!o1Y1hmjhx^ zBt!c0?U;C)q5EIyhT%?!0%7ml^L@E08W^6IY26w=y3J`F+FTW9pj~RZx|!>kK(VgY z#MIRHs^fN{p0M8sn!6}2#)jCZ?A-71sbP+fLyl}J{(m|Q3bRo2WwB_)D-WIy8k?|S zZ_B|3Pf^u_;%EX_Jm5YObiLB=6O~0@x2fbf*-FK&VBV-~kAwiwDEgBT-uBd6M`@zQ zD?3;j2cQ!J8qUXX0=m-xDKFm(Rhj|_^D`I6sD)gqTV?wtd1Zln5Ai`a-D780=)J!t zX{VPL^Zp0;Ns*H04=>PErD}J1M+hyYK0(-%vCo8=EneQR#!c6aG-9b{X{6juh?ZE_ z-M5yS4vC|^Kb9f&i!_br#XsbN`roZZZ%T!~j=51%G%Py(NBWk%#x0;dxp#t`s{cK& z@ncbW@qix9VRcb`{0CO=*Wp70Eun`Z$Zx?8N2l_u74-A#LN{y*bg6s;co1(o&4~h6$;Rt^ELQsbhFB2~ zmjO=c`{vH)gQ1IDaQOOF4o$Y2M7Rs8u}F0!qwCad$SHeR77hoC8ZUlmUFYbeFIC4A zAH_8`V#z}777V)I$B$fYpSQbm0`r#wPB2$!PJX|;R&0?3`Q$pj-PYaBYp43hizYZ@5YR|sR(GW zPh=#YwJ+kv&l%2s)q6@|+6F#pj?e%1Ih>2>6qb40dn=$1wzcgqOsT5n(MU6Hm@@1H zr+Cn0?q)e@88p`2fNLU=A3Zc5V6Yq13m-p$yLmh>80huoOO7i!vM_SMqgu8Ug^^wAt#zIFAAnYDn>x<nK5#%XR3A6CyzdAwJpMYoyXx=+s zE+tj`^0#K$IVJgTE%PDkoL=JG036`S3@tZ}_vH!{hVx&l$r5_k;U7k1aDUxY@aito zaD?<7uLW(&|AZfZBxCz1EWmJ}?&Dw^?bd`E6^RUn?@YOTonPWxh&`T7^>gS)#+j#w zd`6c!n8qNGY`&6d8z%fm7k-U~H*9MQ@q>@2T;~-+cI?(QFKHz&rBAnp5g^rp>%XR( zrmX_M&D#?8o3niv^UPb^0oQtj&nMrQDwaNPZTluz*aqvTtIJ|Zl$)*=f((UN@xOG} z9x!McMAWF#Wi@+z5p%&JgD~+2WWbhe#`@>IdcAs^`FAnQxj#XjX-T(-5e-j;C(~tu zzPs~Z491kzHwnQ4WJJvykc)^qA0)SdC2lIy%|}lKV{rhG3)jB&h`RaL{#4~UHvo@1 zc;MhBD@NTz3;U8^LyqB9dm~qRf9DY3u7QDW-yH04XxPDbsjy zO!?#wLjkGi=Oot&(hb(yWN4f@Nm?l8|U`;WzNp9;_k64sujC;rvB5Zcwt*w&~yWpjjeDtn{MbaBgWF35k@A@ z$ML+%xu1TtU}Nmjb9kg;5iqM0M}A5@L_KGZD%V%Z;T7+QnlWf2D(2Ln2nVVC(Ors4 zz}qvC$r8VRcCof!jW``o-inTon`D*lT=UZsOb>|3m4=heM3^_Fd_d+FVYgyZ-zzKl zx4zKn3uZ0OP&H^hc5KWqX8nWZ4LGhk(5hdY^f-AiRi8STk0ARk&O?IEJP>4x`%rZO zkJx=rf<|DiN!LmC$UEX@7s+r$1!);P8Gmr6RHS4`vU6YS!a&0wbJ4rMgJ6yre?w!g(N**yQ_e zh$Q^A)-Q)C|89Uir#6P+b1M%)#^S@IO*dg;ycn@G zq1(FdhjZ*twb6k*=D}Il=e{f2L|+#-m;FR$j{*ennR)6^3PBoS(TC zLH)EJOx$hG%p91uckxK{e;+i^e&OAgdX>|&DP@;H1v}5R#iY9K$S3cMb&48wx*R*G zCNv~l_1F*mTQ>M8_$R%6k%3U(-jM^1O$;7W5C_36GN{eE))lNz8e8=i<7*J(dbZ}& zqVEu1k9_~4c@Glg&PQ|mPjozM#lGqsniz(z4hYS!*Swic z0!2h}L6 zSdLpkgy96m{h4f^fs2UbNJ7SYsZV=K=rt*Xw`^H8WV^JzZr;Vdq*HOf;gJE@lW+_# zcokk5zI?;a(-JtVMTri{nw|JHp0?1rh%ofi zZ(jMDIiYW&*2|vJ`jp;)2&lRF;7mHG1I{hBHGH=B77o_2cEffu%b(fvZmS%IK5EH+ z|LL;J-{7`veST5jG9SC!L7~>4x8!^(NG_4 zaTVN&V@R-oQ6FT8C><^SiWS zah{`ywz5ydk|aCA%eM@@P_k{}mU#1C@(%k)Kcc%7h8ya-kJp=4p*nWh^1r${tui*} zmsPp+RVA#8ed*$>aG8TO&Ew%q6TE+ziw^rmm21|26zXoCVzTRR^kN1!xS33J*r>JD14_)J6vJ@(-Y+5){xee&JO%I1(;n6FVs0?6r#wZVo)m(`qh+K`%n% z{aWXl<{x2^Q0uMvZ}UBP{!1JMFI!vetVFH8#Qb#H^*y?bZ3koa7!a|bwu!R9b?Igl z!e_A{5UHl)E;5o}RGoU)7r3hH-gxvivs6#wE*OWIv2XJYxOi2rUeSXg4iB8YO$->* z&;5yXm9fsUH;(J*omQDtPV|9nM|vZ6E8q!)`J#C?$Qp!RY`+eXAcXu*ZuAGCn3St; zKxxe!_aNAXR`Y7VJX60b-ock3>-~;7TK$Y~3N4$%uUIVXS7lncUcrtle>&2^rqn-| z%1~UQNZ$-P{D{;3)9)?20B+4r5PoA<;an!=gPruHkluuW2_KG`pX?ru_8sS;;+ zMpSSQaXX?FUW$33N`NQKSN^9~HEpiok3ZVEt1XhxoS=UnX{X#v&wsRD<3h)O^8%g1 zuxQGFma|CSg23vpE&VgGOv--xu+Rj|!1tq}V06l@^@AcmZ{0OVIqGC48tR*yX+>v9 z;wavFTPQ4b@R5M;ze93omp8qnitRx5;MEJ8vZOa{C>RNXjuZFV2+h+hkBx22`<^ z_SZku#f}hb`;&UwTjXX3_ded*$G}K(JT^X}rES*UY>- z_9d`dDqf{M2%=x;<~YJ12Wo~bS3LAMpB>8ka~owocMpu7agExq6V?2F^#quc9o0Le z&^RfC9gQ8d3&b{axwW0xN+YKfBf9ycj~mMMDkU=>(H0YJ3QY5zBNQRb>$b6 z4Dv`?LHTjy1cWc{U!X`B%XSEbkT-vtm}>I#&$O(z{~|=#;~vw~e1&*^P?|nx^8M{E z?VT2CUEMX2ZlX(`dA2zpKEL}@E#qK1+CC0)le3aSmY zF)@}h-OnpB(Y%Wx#2pjHv_yMtMmqeP?dnKG;fRSX`}gN(&J}G_me^J<=3DU3Czpwd z9btdx@3bq6(lr=REl#%u%Ts~qRt*tvg`l;~T$BLj!mBcf>Gkaw6GZ)q?5%*)&Cf4= zec+J8PYdP6T1ZlY;@%8oWmU*4mi@pnz%TD@+l#<%Y1s{e3Jz1~E4%pK5!V?ja6KMt z>MGPi?T&R+S==`(`;%g5P-GPPd%bIv$+d~myPMSXdkTUh!g+^ffdwJG4$jT>%bx81 zH_T1;jybQsGDUWFDsSZE1kD+bTJqMn-%_nt-b#M_nXaDW!XYXfcV67g1)PeNykc$d zB0DsuU$#lNSG;C8R-M<3{g8IL`zOT*#@pUCnc&B}azF^Sj0YDxa;7aXFtNcDF|W=w zLZKQz$BoDIrdC0MwNQK!@BRTC@I~Ax{Vk=f2PZPgpN1TG9ShSMr~V53y*?(b=Ow#Z z@uC8b{_*qGBZ{Xq_Ep5Q+yS(Z;-B8+Z5ho_{QDlxO6uFQy!YtslJ;V07GDYf2l~gD zsG<8gDm9h|Lx%pWvB?aF+`KRZ3<2A=64;w3%>Ngxki-yaQ*=w^&XIABryG=%t$V(X zldi33G~)gj>*LlPvp%!ZdF}W?Ng+OvI1r?0jji_~7COUewwyQ>;)bi?QVlnTUH6*V z<=(I?a1Z{>1{W_rpRujHhcQH0r2PI&~_0 zEUZf=78Q&Nn4tC!=QbVz2c6m?qN)(#P@jtN(Yd6*wy~XDi290_^1y2y(rng(%FOc& z4L2I;hxMQ2$L=Cgn@nl@frAlCm>by{LQVn8?K6SHfX-{ zZD%lz0axXdmLCMpu>JZ<1>KhxobaVADa*w2QQV|kQ2qR29g{0vM+M&!(j)3-lLi45 zRfE9Q;z1psx#povXU*uPqw&DQCA)n%WhiDCL8*hS4{)im$xHzKdGAe(_YzyDDh&$W z?i~55`(+3e{g9Uk-*j!Bmx(GEt??TRu6wo;$uaE>@3f|CAV!fK=XmG6he-=>6J8i! znz(t#pyAo3V!HJ-`jO$&1r@JRN}WpDH@5Z2&ekSbtM1P^$n$c-2{lvWjjJl>;V9H+ z=<(K*d)8E~M_;)-0Wg#3meT7nw^8F6|I2sS5QcRP*WdbuW(Na-8}eBN33u+EO-hOH$LbifizWX zZQha2{{)e}h6a(Og-)_(dTWHD;%*Bta8Nw_=b5*MlkFHt#zv#^YW8*64(Gopxn?+) zXvt$TNY6v&87egL$WV8u4YFOZao}g#avE~a4(dD&ZNjqTg0zRidLDL3TyPwhddA6f z$D0++Bp_z5&8ADKu=Y;zaq@lnb{97Wk;^@mA)ll#jCy)h-V0^kH&@f7OEJ)2vbj|m zr$6X_I~q%QXr**#mhD0<6jbNF5IhZeN#t}FS7UCxs@Bh1df9XGzKFY}a{NW&*nna) zJx@@di|(^`;}E)%)yqEv|C*Sdzs0pbO3cvVd}`%~{W3#8;@PQ;cK(b6Iue`e{W~u| z?hQJ9gs5834Y|4xK3wX$`7Ze}j!4pQy#2G2oh}7~hwgKw`?}q3u;Y@t_uC4im)+Jf zPu>!r*0c17Q@OI7UEz_axEeXe_ zH2yEkV=@r#4Q>%fF^9H7X>Rqv|(i|qYg02^Y!V4H*K!~fU3UzklPE9u-=mNU=b*9M)xARE<7~_EDzg{X-|C}bLg(( z!Sh7kHs70zw(Zsmxx0rJR?>}YS%JnIhd%gy2o=`Yo#SW7aU}N;VHvN%MG+DMG(hIlmdEhz^)ec&^$0RX@L%K$@<%Xq{f-NUG`x9DM9hbPWY@I}CX34O z?yXd3zNh<$Y&;4GJWJ+3=pgnzzicJ&ap{`5^l9}f#&0{(+^vVzcm!aea!YJ+ZdM!y#&Jm>)v*l^2I+fy#I5aqgu1tjQ3kLl4V1?O#4CqyD0i?1g}{B zF2B8%#;We}x?bUp`QSlsSB1gEQ_6XHrH^-@887(UH6Qm#2iUxpp#Fwske%tv^|aPZ zaz|D`=ZRR~M4t+HjG>v}1dvOOMX3ZVj3IcMSJmT6XF`!SBiLv4i?(_`LCgDz*U#TQ zLanKMDPuiF@8jAx-2MPjw;Gm7?m8)#t}9DWwtcuKjXcM`GcFnt3@~&^v1IJ%D2MsC*GIY$|^tTj5c!qAwrsIoi|q zB^`u2+&O19DtBw2x;;j=y}bdZ?Jbj_fV1{KDke5YI)ES_FGS{OQa~G9&!2R29kOl< zJx3uz+`nHn|I7PUP@+M-|M%1H^9K#Rx<;WP zkFliTt!eu9UT+#1ch6AnEb{zjr5!-vfbi&#ZK6aDLHB0FBNbqY@GCF+)nm_*klnx; zYtn~V@K(EnAIGx2>3mmWS@+JVi0CjD=wspCO4y9el_}4k$_E*0Jubg6tq-`AQgFtI z@MXPwWfP(J&tj|-~_Cx+I@%diysN+2tGsq7QT@Wa9R+#1LMD7yQ(5LgAR^! z?t!eH_-2>M*=Z2hy({KgmE)9qg3y1#pkF*{qo2al{AjI?*Dm@soF209+|{Wt-&UYo zfD+0?OCd9)UORI}z3rr|_x(&5KHI_u_gIFA>oz&WFXQOxs8+!`KvtZfg58HFkm@^J z-s|Y?2-Z})8F`S+q-x7oqZN)h!gr&1Oy^re(|!F5_khhH{OY8&#$LzDKau9%XCxZhIJUM4>A`yLor z!;K874r&N+f`SDM@jrSo)VY0=ZJl>l(Fu8pO-9 zHr%e&obg?|k;P+~y;NGy2ByT1on?Tk$?tl#AEe77gT6JdHG^x}LS{(cF(%zzi-1ZX z%of$UY&g+h(4ng>lbRxC()cRMKlNiJzYqcb*pJcfZO4Fs;-7Eo5dyP&@bOLPudnax zvTW9!hHQBR_{93BNM*!AUO*zm!9edQOG+>=`Qtk=Qp^pz^QuO)b@Z+msL61JMf`k* z6#JQ5;v*Q;G5B4`Uh%2eJ(I>-M$BCnTkWY;w?Azfm7d%HyLAIm8(n|1rtj;c%f4|R z>cl#*I@=O@kB@~e0CTC)$?FATerRhW_G*zyxKq$89i!9Qx*K|C*sJt2hShIP!{S-C z`PFmMv-+je=_JevLFj`HEgn=bF*C~j%4rjK%aPbVDCkNcIh1<`FX0M~u;;oR`$%({ z30JLLCP;9(ZuIsKF#itz4i{yu#6`t?NtQ%6EDGEkX592h8c~Ur8bo#u27l3u`~@U} z+07ji){MU7Z#Y9yfunC>f!$2N=*Nz`W`s0&A)31Oo`aH_8Trd?A#DH%AtjSNRQs9;r1%BubPAWi2^72ui?gv zVK$LKuuD`JF+1C_vE*URnS->)}5e6oA| z>F4XZRb&ZsG@WUc zo$o$zq*(t;(SrvvAb5wS6Wr9#)ruiB*l3jaNTc}MuZs^pJQM9%S-}OUOVyzx(;n?N z@csF{OBL98_%}L)YRN?3>2_rQ9Br+12}`Xj|8vK`8wR)3qpBZGl^oY zfNxKcSTo<21M>*Fx6A-~POyFqnKb`nG>T>sQ=vtF({x;F(D758?*3Ke?Xe(iwMSI3 z+IzV&SVUNElV-dZlc>|k$D!4bhci|3l>+9n|=&_w&l!OteQ{c=? zKriQ_RY3c|NiXqGgXS|i!&dT5C0WLBaK+Od*q_S%VXBHs-yg=i#qLw+u%i+u7a{vE zz9=)dqiG+}i9@0NxGIk9j{Veq%&+ukFWuIZx-~X)rBpXB1zhV905A@%I_?j6P@yt< zJvtG*O2;JjvP9WHs$>Vln{7#j7X=B zQ@~7)b<2`eWqeAw0bxEW=I_{-sMXsEkjS^mz&=Qm2}4Y#m1_qR5YZ%EHi zo|Fd&>v89i_5Zj}YbL>oz{)fgEw%CjDs@6KdxzvDVKjlkUC|PCgAUOYh^etRA3m;mM0)R}AfF?LU8* z|CoN&Wh=X~vq_jxzu=Sp&exXcyTAgSf?t46={<3UvlY6YugDrfgTEXzxeUf2e?|9Y zh=eI6+Yu|^XFhxBnupY(*;T$cL&vO$Yj0>94t$Evn%%6TrTQVe47glg$OL_<>F>>S zb>zyT-Il_3L;$Vw9F(DB78)vM%rr~V;!7$F0(VRH?6Q1Ri64J)u9I)|RdmaT`?lhX z$07sw#CI$8vI4ggOE<-|Jb&8(y2i*h>yk}BWu6Z-oRtF6bnwMENFrrI$gh4xo z+k|vcp0p5Kg)dPgC|%$m|G0dTQ>t;FJx{aO#y8%Kna_U%T_y!~ zr5Ao_IISujqY7tggsT!yIfO~xF|r*|#ehisms>X`<91OOaia#WBUrRO&NTu6I=X-E zl?>r90{f;NzKr>EoDJ}$BRlX69h`LIUu zDzj>gnliO_ito@lhWIbxC!lOnc4mS*Ok$URq2gm2Zf z$q5+$v&(&A`MLJ1-zI#PK4(mSXD191Jc0W$p0(gF2i&|@0*<2($XKa$`ZRKT>_z>2 zxk(;(m9=8(>u*Dh2wCxF1==jGCi{l`xO72!??+$Ktpa`#rhFTB;>nv5S<*dUQDI-L zexMz|M<`l)^65U7@6>%9jg5i0dMu-%59)Xmbd|KUgs|PW(GP-7C9IlWG0nctEJ_IM z^-ffJjUFg*3jygfpHx`?5W`-$4_U1)sqChulyOb=UKa^S)7%?$JQvxi2f?RyMo73u zy_^_O=D}`v3S_$psAuvezZpWWESKfq#>RS~&#|IyQ0m{aQVr5V`}g&*zvvNoMwt?{ zPJZCBlJ^;}YIXqjOuVZM+%~v}IX?t9Y`Jh_er_8@B4&oL9AC8lz!}_skaz(#DDBO{ zhSK2Vdv4f$zbB=gQ zwyKFtS|3%k9hu>Vpbc{>85&d1O+3IXC|Q?ck_aeL6dL4!v5!YBx1pLl!a)9{Dr`gp22?WCbo?4u-yvIdOe8*1_URL@G(Fu%7La4RZy~ zlM;tWT?hBcOI{4fdQAHX_uRQiDP4y3Kd(vTl5g@TM67-Ufnbz zSavIZt@f<;w~{Gx$z1i=8PKW><9TPc6nV|((*2JLNABS6Zs%@AZH4FkgkU0t(K~bp zOdY>fC3kJ3kBNU|oFSTW;McTmEUj+7?Mf?jr8Xt`33T=-#@V%Y=dkUx>dwJr!bu`_ zKa|EXyau>Qu-*Fxp0oD4H}$5mt|D+*Td_@q@og=tdlPcQT;ud;Rl?GfSmyV3Hr#BE zoEsD_J9Hl>-<<%Th#8S8nuMoeT8szr%3H3SC)I`)`W5P&du4^U{PTuZEzha6{O5}0 zJ}OPF#cq02GY0C)2oi!pFv^Z2sDht(MaS5)AKv*Y`= zMQ$+btX9l{^~~X#b$KNy6rpy$rHJpKY!%fZv%1 zf0y;|nHbpoarZg*mFZV-YpC||z9M7`cnv>#iUBW-;d!+*l=)iIBb>RQ?sQoawj@~p zxqYwLUxa?|nO_~60}6$#Xw{KdMflV0(6c4`L|`e&})NVLTa9UxP`=~1&H1VbEmG6 z6s_)$oyZ&}GxBa$YCp!JPG>>Qfy|Fh!X$I}t5)oLZ_QY&oIKvK>e3bg1KkzPuvKc6 z+9Gl^ZqI`27O5GKf)m=TeZj4}9J*a65;XEcFu&4wHzoP@+}a03y%AUBZ+iCE^fSp{ z2St8=p+Z$l8Oo%)bvn^M+L2}yFhB0*aez-WT8ylUx<^&?Y*ko1d3_Mdb(nm2K6CRE zugB?an*tb@unyzzGD&3PIsPEc*qvSB`{^NMu3yN9p10+?fW=4XwKL(cRu~y&=nCj% zp{ov-9Im?yzpbb%LE04N&FJLw$JN4NE1i&IKkZa&?q`%uECJ~|pV^L1P)iw_r8`IL z|Fj?FbpHZ3SRLN|VmDV>6UE=*t;yISXTxq`8d$lb zVt6*GS??ARnG}yz2|7u2IQ`Eksl(XpjLh3jdGoG>cTEiLVGQ8*YrWRN+7qrlyKru( z$8v97Lu3!D*ZI|6X~`woblX3uaQX^Rmbb#;n)(IOn`>=9W8p@l{HR3egqZCqv%!( zuOQLu7Hs#_^WWatKP=4w<{LbZ8M~u9@Ahl2jTvsJS0CazxbKQXw%yn`I7P!^yEm@> z2A7A4Q*;b;e1NSyR7MMB2?*QzrrP|CIp`DUMXT>i3AfWUK^Tkw>To?GxV4;U`c6vM zdyzpyE!R#McH&h15|w@SeN@{I`RZu4ygr!#-wwyJ6CuZ4c@|VGw3eiBu4c!afW?D! zpZc!FxyV!2H5HSh^}+XgOSP$+jg#&Cm1)1*SpCfmmQFSYR)%I!;(!#n3Fr=YWx?Xx zK7Qkc{hpRRn;hJ)d=>^h2%xsU?|{E+qzR5&MaL9EVh00C`^vR4#VWA5T0*R^zwYpK zYrPH*;do(BK!qru=v0C@85(D(Fj?6kaSoKjyuk1w{l_&Z7<8_=MNNtGRWTaH{pJby zC3CNc6cH55KtAG8TUsD zwDcgguxZoE#Ia;**Uv2O*<}S71ob_;_wGs-#w(6*7fN|xPO0#0qxGbpWV3r^D{}{m z>>M~9l)I8Fy@HNbGW~#SB4X#~wH2HzC5bnNosjZ-tc5blA7}aE^yh_ zM>x!D$2=U~a#$Kfn(R;W#@-@ybSAh^76rzokv*Saq& zt|as62gA=_s8rpst4~2%jGNZ}6P8-?KQ^H8_xy*6d~O0xFwO`wAkgg?oHJgAgvyXT zPA0V8*VxY-){kt!t`RFu!jCBFTz|w}7CbWO@#lK4{-rJgqWJng7e z&FlO%UG6_i$&}sXqyMDrz6c&SC39-o+-8zJ_rKCK#;--mBBqohbN%g4WC2wcYF4^U zA?^y|&RM6bCO-_40LeRPqF-p$-nnwo3e6)j+%a z(>9joarFH!WI*aQvK4vq%kklgsr#|1YDb0^%y-p#wRwpbbUpmxNCRwa^sGS9zTfZF z`1Y%d!+?U$I!YF3Imi58o4i$!Do4O2>?C znedDuwvEbJO(c{}MM!E$utCEor|Fq5S9A|Nm~FXAFub5z-|^fpw&_ly(q)j|kI7Dp zxzK#}lC)dOhnZ2$)(AkcB`M|_{`awyo~^ehN2wi;*>LdZaw{T=&`phKm7AYeSxI4h zY70k~lUq#*Rq3}u&F4|YS$?)u=oX|^hC9Wp5ua9S9R zu@yk9?sKe_?6c!)tr695uX3r?&7Gh_t-fQ8GJwY!{9NR}$Wtm<}D6c@T zcle*3=3Ybgx1ZK9ncXCj4t$xErx3xL5QKt@zsUNJChGLOeUGcJ&%e4pH}65#G$aOk zRF8#^*6?7cb_;pavpp{TRUz!Xo&SVgu$Ns7ldA7L^<5nzO?`!C0x9$X82E_LtRfd} zPY?19FihZXQBqb`{LWeh{e3)dDY|&%G|&f^bLN zWq}iOOhlBQ5h~y$O&p&t?Xr`2c-l=5o|7wzu5O@9@2`0#{ji1J#A;S_ajsU_bbHlX z`gUVuE%#?yN}X?dk^jwW5S8#GZWvMrw%!tUp&~ zG4S20M?{9u{q5R=A*>t8?H`)zMND7B*$6JzE%@Aljo0N6RNI#EL2dBjGt-e^yIBdL zmPR!4=^mz*gJ3~e?);yrOAKXvP8Pcl9Z)HqO* zx%Z6?ClGp93IX#JR>A!D7dIC;?L<*kY&RMxQ(gZ3nn0GPF&eXx9g606!Sv4RQspCM@0X$=#=;UFf$Oi7eV(woGdPj62I!~{zstaIxY^%TDW!j zx5z_Ps=H~{-IwtA+JbHV7VD0CGN#KPThcwr6BbCN%Rc;H@yGv5&*FbF+2ysO(f`x} z_`knAGE3PN)SLXI>h?cj?j|;)y{W3b8?vO#Xb9bwkaOX%Lz%aW#8@pfbIcv&Fr zxkC0o_uO#elA$LD8PPzR=!_gZWbXc~wr=-;F^e3q^X3jx#vV|_n4Jz4f)s<}QSSpra`63!CAZ}Q(=CoKVsdL_jOa)b#X5CK^8a}x zYSz47pZdcd>B0>D`Szmh4fp?gpdD8KUk=kWh8^%VxN4pk^cnFYr3yTmf%_SC|M36Y zm%CKWCO1%j>9VYtS4S8|^wjE&M^;8qOL9Hywq&fpx4nUv^`__j)VE$Gw0(8{?_d;C z9^X{LuZMO^`;*UTN)&87#b`2C<8AOW#yu%rXAcBt2P`MdSPT4~B6oVL=#^z(EDPbn zRJDJ2dCms&-A>VXa;@}-LWRXYRR3$CrD;k(UL%9%&tc7BO}>c02w~jfIQ(@vB`1Sj z{(Z-XH1a1A;ACcOj3K_=;JEe z%}#H#lgH-ns-)mc2cKRvRPn{`qM267mzNCKF^pwj$um-OsHK51z-^dm#0vbc>4N@PhZO`R^^-(1F<|+P03r*Y@XWr z%IAw@t*yuZRSBSJ!s()+=B!O?(Xguf;&~!yOQVo-sha|9%qameQvrhxG7-o+H0>h=YP(*=5MJ) zInzZ?g2Pi|aKp*5HRY?|(A8kQCfSoLCRoD0l&wQMCvUC4>SKQ{I|~^aW4~dE-A?yG zrYM_V?4*{^)(d#)5k3Cko4V3cU|)LE>lS`xcis6k!jme+t|&Y*8GSyO0WGIh{^BfHK~wd z3il1mp_XT+%RN@&%#Qi-mGy|;{C=4_s;`NUto)zxT2Ih9n*@a^CO!F}RrCBHD+lWeLI+xWF`9{yh)}IJz$Lf z`q6vDp5(NU5|z$KH8ITq;eOol=e&WG7EpY;&&w7Y2>u1E?$`YWa_$v^#f6S6+3gy6 z@pK~3Kf@Ah<{Cl**eT^)uGh}%b9tIHhn0@qh2$kYW*jgKtq3a>2EdmcigWm ziN1=C%?%GdVVDm}$1?2vvbN6HSYEF2K}b^b!_`+!MKQ9difdN4-`%Ecih2z(KY@1p zZ24%Qqn%mzrb>=lbMz5~JmD}3r9JQ$RrXc`Og5^|tBwEN4=<_Tj$Byz0r)tFiSwr} z11h5Hp3D{&!kq$FwBs+#Y{+@_pN9R#TYCL5pmpp2)IYx>09Dz^w8oJugX3=SC7Of} zx{v%6CnB=t7h3Bax0}}Q22V;D+$HJy4U?Y7IzRMm>AA9k`aCeG6xSP=8P#=A`Gvi> zxb8JzlRzWOT}60f^ST9X6O5vYwLd!EcyRVG+IU|!dFt{BvSmh9j&yHB-4I$Rt{H=( zor2z;tIHf!*nSH1^i9G%w>UTI*gHS=F;2D&N4~cv%ESe8JKv;^RnY|qXwlt?(%-Lh zUS$hy3p%905dbS3W|lz8$fEMi@q8o#Bj2QAkT2t!CW*o$SAXJ|(}IUPVcwlUhj0|Bvv;8!skw<| zU`c6W64E@i;!sgOH*4QXD2q^eeG^udlP*D&$c%e4Zs1*27b~W^SPrGV3G>X`7ngCy zU1+iUd7uF@mjvT#$Wn~|`ZqdFMM1b1+zvYOOx5KfgU$Wihq-Nf2z)>jV1o(6&D=g@ ze*cCsMPvhm_B@7Lh2b>)biY&KgK>ows^P5ikidsJVY5lEbjtKUAwkz^8pf#wLP6&5 zK@XcU>bIACfll%iZI_#%S~{Cx_BX;bO|SahCs>2svftFQ;f(mK(VE_mx|L))h2a3i znWWez7xvnZT$<#`nSH;-R_Zcdg-BZ~RG06Sxig8skve>$=0z-f*1EXq(QKB4934OL zWd?^N53eljgX^D$>>+6+xqizoEC1}8c9)pJ-*KP3=*k-~k>o{7-|(o$3xDU0o%5-( zAK4HhM`qwGAT56IWgLA*`U%ip{!i=rR?YibDYg04Mme*qKMmpfXnwhA+9hNh3e@`K zeZM4izwex+gdrjBJ%u7|8F;{yyu^-k^~}(T5GmI2ZROic4jX#|mg>6?YZ*P(yeLxY z%0QR;|AsHQdCl*~TP=E$1aF+kAO8xy34@!xhj@)b6|);>%1r!*`9j~mNy%gc49S(xqBDu%k}y{hsCxGCF1kd1sM?It zRd*R=dSf>6C^;ZgF_XK#I8dIFpd-g;juHPnSAEjAOsmw21C9D&u=Q%PLq{rf9CrGc zX5ufhWWd8A?e`3yh8yI~MCU z(rrC?K1^Gb*cEr@jpL_uobn#L+@37CSv2xQVI9xT1fp$OR~z*4DL%gfXuUp+jVw)k zud90{YTy+6M>0GGl~%2Rd)(lm+z3Lq@KAJ!+83LYeFr`KA+>Xl+4n!m5E z-KGa&EJ5w8b8&0pM_)}uw7SE!P#ReQh9}q)ChOONJEY)tVhypdd8VvuA8|?(i*sC4 z_nf-NiTTzz4@=Ug(zM|;BSY75LZiUx-lKbyGZO6ZfR-cn;M_X*Ln84ZRc@@$Q3~%1 zXvUW`hOJnR1}7#^2W7M~1I6ys^4CKxch7AUUejsthQ^Z9_k(qXQDYze>3Egj3Y$Xt z6w8}dE*;WuK8Gv!lmOQ`O@}Rk514iejrJ{Mv|JEV0fsfH$Dj1r{RWu#S-Chn)?-?jf@QV%Ud zOihSRv(sz^n2$ZL==*ea83<(@2sI4NZSDso<_Z`9_UJABv*;!n^htU3<$nO=KwoK) z)B$)K*CW!XvBcMW5?3I+^)=Q~*wkz(ApjKqT%5lK2TcEi9PFYg#zzHZH5*+4Fp>{v zl#wbFOF4JU|c-f5ApWM;z{SgAj7%!@$(BB`- z$kVACI?-}Bqg-r-BR)L?pMej+(03+Ih1;8JyB{~A=s2q7{BI)#5v_+dFw3)%CS%wM zsWXHS0N(D8(7eSR*UyQ0C;Hh5K|4P8Ykp1e_||9z&MHM7!bDQ%!~0ui|J}+K)AvJ@ zcedXsYF~0vV2?X&hdGq6Y`NqA(^EK1a?xPOR#nKn-p~nj6@FMlk+ML|AWMO&6$rzx z!~rz8#DAf|ClN?l#P?81CPA45s@U#iv`>QLAL%1u*52$aiNfPaog>rddW@(m{C$uO z89pqUh3?~`RXkY#XDJUmjZ(t1D@PyK5qG`C73?s{wGEh#p3ZnAk3^0$%4kQ=tNt%w zIH21+c>z{9!>hY#wL)WcY-}1_v_wKHQ9hP2Nu=d4a~3a@tT~Yx7H}Km5PYAux+^vz<9u0%Gx7}fp5Q}e zBxhC%5A`3aIncsWop)LpDyi?dP|a*#OZj9vb6&<)qSMrcHWs^!(a^x(#vz7qOFgLh z|1%8m|67(hqU9uMlq-qq&y!2Qp6FZEzW~6`As8hQ*DEN_b#c>uKNxM&2Le9SO6o|s z8;id*@0;DAj#p9o6v4wL>raKd-fln&BRL(_c@!v#nnqTA!aAbyAP6g}t zk7z_?@CR|tGUq~Cn@8d=`IbY6NuK?rWlXLaLlpp&Jq(dB#P`Vz|4cPq$n6pTdXg~K zA)M|j<)BoZ9>CgE?)qMQFFiysxidQ8Z6m|#_1+Kn6y_KH0KiuZk%<@HM4 zcl(7tlp3)uXtBKEc%UUnGR8b|0^tA}6M09q#!4)NEh| zitobZ`sTB*uQ?1BWh&)QDR>e&D_Bg5e&*$yLGX2d$L;cX$O~?b#l^7Qh(!?*CTb#9 zGXO|C**R;!#$Cg|jA4J%U>5gxe>{R;y0gR&FOfy6bM8Z)c9@EjfOy=KGIP|y5rAXp zcmVZTE3o6;f_#F6iVn|4H-N{&i6U&%^1)K8uvPX4k0L8jJS;qR!}S2P9Qr0m#Tx(F z@qz7*fg3;JelMQc_TqLl-DaBThV?XVTgG}-aA)NsMSto&lE`L#_jxH`6ZPB`y`h`o zxznZki5r`#@w{YIK!c#)Hb6H?T`vjD&3LE#o3#{f*)qV}Cq<(@5$t4%1mO1(B0E@_ ziZXFaO??P-VCa!2em>ekAkc1o4YHxHr|36!V&k(^i_g?_s6b}4D&9hpdk-*ufoF1W z9fIXU0hJ9`B~0lfS_mtp7cPDJ;Gsd(^yUHPC8+r?FnkufDM=ZP1S!NhUV$c#{jjH4 z+XaKpIdg+qXTPN1uMM3v0#CnO>=O|R4}GPb2!|4L_w(2{mb-)A^g!>G;5|X=(d{5~V z&&Y=^Fqv&y{s6@Hlx|lpGppZyvy8V1M)1Qwynm@|3qGaU9ab^woRE?_&4NEY#$4y=M@&Ji4OXJ4~PF_d>@DS;!G0#h^iKw!JvB#34h8K3m_)9SA^lW_jeH3nNCydeOT+)xa%;7 zuhO2D6*hZ+Y13!ejrEQ7+8-a`6wZMjjkEO-r0TzH1~?QLTO&meCr&~!px#WdH;S(Sz`4VuN zG4;i9-lVU)Ah3Z=!R}K(_YVq{u-a)4&t^05zzwjQc0G^!l&j&vivF!x@!C&6s`O+d zpY`Qc z$P>x|MHS7eaV0p^<&CPUm)yb3L%zCsmH-_yXk#s03z(CF-dNg_73CZ;k8~kXLv% zj;^CJW+hZ;XLa*X6pe2g4~S1y9+4$|6s8SSYCIg33OCU!HT)d z_bu>ZcsPWc_6I^v`uKl+<71fAR ze8jT82lythf~szdPAxy3vrfUD`ykAo&HcN~nvfH=z9bWiraICpAT#;*Un;ue6+Y z-o~77a8V{y&!%k^61Cr=5PasMfE~f-007ID5md{LhUH~`XRdDMtlQxC=I_p2#9?Mw z=N3sv9f^dZ33psYDUudRojn2P_%eFAe zd@YIq;Wh8ldUpS_hsKi{Tv^bkW^*rHzB#N8RgRtSUYVu?!v|VnMosWL_zjppa)%eT z{^FyUAhpt#hpcLmQ#AT7 zm$h4#yo4huGmE#dM-*5&%^r+!?_@T5919y0B1A6}O#}Po$Bwx{id+}dvCh_B?2%hLj zeNN;>-1$q1{;Ji?3s9I^UHA1J&~9PZ*m^wxo~kxl=dr5^KpbD7%Uu+T;!%=wCPh;N zuAKR0&X>ZyJqd5=VigrPBO~dxw|ZrVWj*?xE2DSX|3%uvCnNxeTziAnVqkZ*y*t*_ zUHANwUhgi<#$&{{3pE=yiQti&rlWHv{C4S9D4DyGsYfq;W+Hb6b{rWMS{9YIgQ{d; zdQgL>z2@&V9-w9g&e{d4NaUav0>sMc@8)f*$Ldt1RvSl4Phb?mY4$(mm#ms;zL}ZE z4Qt(Z@d&_X(GN9CO32|Xi5K4xc89*;yKxxKOJ6oYWe?96)r`^G5S_`Vi>Cp!s-KIw zvy<@t0LY`MZuHfj1h~D1_Iba&GKa5^G=gvV;ETUfD>K8y#+NGnOqjUvPalf?|D8tu z|2l#E5`0$=FT2Bs!$7&c=DzFYrHIHYZsX`LZX8=8Fg@^jHQkWkSvi$=XeLd??o#(% z%zudEYPFT&<4KS8Atlh|ge12f+HzupfL+Yp`CGBD|E?*LyP)>|tK@joX2tmZUtDs& zZS?4WmmK}4UfBPuY-l)$_rJTo`5#6){Tm*%f7d9x7LgqP^<5+@-eUf{m>SlAy!o$M ztG972!M}^CSd?F@^#g>@R~iNmZf$5xq7>cNGd+XcnZiDrJ>q$Oen z)Yc3yMyhB&!e2!3zIe2iZ)?vuGu&H`;m?9YDhs~e{k>n@npD^LaZr*ZIzm&AD1XuP z_74F3`D=jVy=UkMCB{l-;nb@5PX(_^`}Avy&za2`_&0Vb{I0i9HtO*f@4pI)RzQsb zbpA;gzL_-&$HLR$%}mV4v-ixXsSP>ulV5;>dIEEft{KQo`U20_@wRrG0fy?EAZ|(afx987s`nPRk zq;0fna0*o)1O;It$2K3q?`|@Zy^hW{hgxFn**uQYw+2N8fOEiamOZu`RGQp!BQggl zBEm`BLV2GkJX89nCfsni93vdSYa;kWeUY`Xm*YgRNM>%c&P#S4voUdbipjz zroC*s^7#H!`6ZRG{e1c?Z|vz<+x94!#sSO6>qGOwW_!^Q8~N#W+EW#4*cQ7U#C74v zLEgubFa{#mkp<;X)k~=FUvX_}S3xa;!wl5Q}izERcJzD>IfY57LGbw6;E z1T#17sq9Y^vrDm)hkF$pf?>b$>>jaGr`d_#leP$Nd2N40z8BAi-`ui}3DOz`q8jk9%aefLp-T@mfpDlw+-c(=& zDM>ajygh7why028UF|2-eq;mkL#BM{e05)HIK_;a80x3#T~%xDq)SoMM&5bp*TS#! zU>fi>@Hp(3vX{u5N>PH@(3>$i$Hz^L7Ua628pEw=U{Ux!`tq(IWwKVn`$u+yechX3 zM(69Ny7bm+x?A;m$2$Ep6ul5z2Pk#s#w^-?cbU{0JyRl|-tlSW!n~{;5R;>l{5&*uIVRz-nteUup!c z^Xqz0n)-=H`cl08ch+Iyu43c$@P?M#B3j$23qp!X`9k}}sOf|_yNKe=?+?#y27E3~ z;g_s@JUw)0L{ou=S=0@@L^n$=S~ng2If6Mwkugk40;per_YzF1&wlh~ZU$N~04gzL@y#SxZXa|pLjDV#Y+SmjchvZ!fGGSxpLXIk z$V1jeB!x=5|0e0oZXpf4n!gbR4{`j7b@W@Ca$EML0zXa#oF}YR9hNxJiqz;^*vsZG z$}#^C)2rUwlwI68x8tcxM~vnf6$zDZht84CWb$E3SPbIbsa6gto%q&`s!(+$j?l6`c4^60At=Rmqnyi&e<9P*4X@Pkn0pCtX)-~UN_uC50oA{4)tlRw#Rf9}z74F^i5 z0^2UD2Y8<@C?ucgjd8H2%5HULc-Tj_2UUF){ z`;K33Kq^h8wRxd_Hyb^FGR9?a;_j;0UZC#~*HMeTp|~qT`>Jx`HA7elvy7)Rh^lo|)>-JW>%2DE5McSvV!fBTsjU3|!QCT{t5&$rfW(o* z$Y}`pJjArs=Zf3wcdhIkaHi!xuY^t9$9l`xy9{%#TG=59U$-M)F?Y;7Pfl2^`7C=% zm>C|wvgeR_8e_3<#8q`u6B7G4y{7eX+*j?ugWhK*k)gJoaKW?e*I!D{zHddYOu$lZ z$6;^aH0Z))W9=@gWRiwL(N%y-U zTTLrBwhilFxP$xm)(^tKzpldhyAScHm(Q=cw*-P_uk$Cst%1X0+NK`TXS(rEnQd>Z zq>oydfAe`vo2&^Y1PgyXN>Ss-w)dX0Wn;lKWM!#RU$rMM`G2&#=_Fxe!wRi&^O=<` zSpIxvM_3-boiVrx7a}kA+%#L_M}G!gW;#n) z=&PP6d>oz&C&e7gjyZ^;K?y4$S8aYtuRXl)#MCV`V-#=hBgme5%?to5NWc`CCIyG0 z5^Pmuub|AW40inzgf%3Ifm2ow|Hg6FZ)_Ixeh~v9l6@po#DEe7TiPiNO)@vR?&S0NuLp zV9te)97j^ss~t@w!WK!M8$T3}?Qw zFEa36cJIwm%cMn-nP9N{+Qe5iMh1D6Xl1LrU=P{d(qZ*B>y=?PqI}Ks)>I|k)r-hU zO@Z9@7^=$6Ly$u?W6q*(2Y zObY`r`*cd*61|TnUukBQ$C4pn+*SA8Zxt6b?P!}E2gVjyJvaNU-aHU1qVM_ep$qnz zl}>upkmze`>Ndy;tD5)?a(MUfR6~qir|0G!PK8%+2FEAu z07gW|-wLr3-Lbp_m)KzK4@Jf$8;Q%NQW^HZslNMfiQm3_iQNEm&+EIGiDm)b8U8kE z1_{2Gb-U5hLr-_;*V30JrPF#6w5*lS+zkrj7GTN_u8Zs!eET6dA8-b79=sx5Rk6}a zwphV-HZ>R&-pctrO5a$BO*f%Lp=R`vH2=@k%!4CdQTvwqP36T;3$9^5?AK?-kTj)GcH9Jt$Bl2wRifA<3)MDipV=O_KRcI| zhII_zleW9h^E&h=WnAwv)+FDm05%~B#t!AfktqW;!1^DO5P{{eUSq8Vbs8-^g`Fq8 zLLNn5d**?`@g;fH`oYv8GeInebnm=eD%8-}H2s-oyJIGyN(-)407rg}`cKA9%C-XU z10G=bW(=!$JUW8jVO!F<;MABP)^aCTI$(Mr`e0)4WFFJWjBpT$eS64g_4jopNv7d* zx4<#nMnaU!@&rGfp-zodobb{O8x#_BrTC!qYiZPejFOSZy?$(%$V?Y`9{o8jry9N- zWs==Nyk1Lx2dh>#VgJcDkUU`F>b(jRxZcbabco zZ~aOJkL7BO?sz`|`p4>+!E{*JZiFKJa`-5Hu%;R=vWTeqH}V8BtVS;KH(7)v$+zSL zivNt2T^Y!b#tBO6hm#!&!lft)_ETrZR=BTq*-!z?JAbej>Rt9I?4U7~aQr=>|KxG7 z8WFFasgYR z2%ot5l!a5bgDd+kWa)19yfrHo;mS<$#=uJzp<)8)6TOM+&g=M=7~pII+XqXmFg?C| zYFYhn4tRFxU4>r<)tp$&zjNE7@bXhRxaD(5sJn=KCyWgtRYVuhMOW1fc4*4G|K=G# zUX&kJ04w$^iSd-bqZT4z(;Nnk(1EF@KC=D~?o&GwbU~KnBh^>wthKnvz-T^j5s(m^ z>at`1d0QM)4HEYd}g-V%7+Y z@Q>vQ1qFwp7{6m-fz7)f?{qeM+*uJ*N0;!^Wn23BMCbwwH%d$`=SOW z(5K@NzfSQO@O%99DH{XiG!I`h_Vx&}of}mH#CCh&arpKvb6fj+UDOkOu!+AM;Eb*H zx*;borES8>l)b^B)lOKo(FU%vE++@X)QL<+ai0q284BH&^08EJM80^-k%?;Bb8!C34?!@CNSL)D_;(nVCyPJnL6&YIIToTJJ+fa zU9BNVv}Bn5DdACX-V@_QGmP^3y*pmojo&uGoIo2O)aC>^e{}ilhdH0{cgEZQ}n`UEGGMj?_OP zXBUdu{*nG;$Q9|A`%im|_dL&t=W~SzOzP94@HN%{W*rZqLSIzz4l1>Qj1oOs7+P_7-GPW=N-Dds84OMI+JTfKunVKZCk!R)J70}@+3 z%O1OhmI`0gGK281)ZrOQzlidH6+gi;rqhbhJ3|*e9LzIDd`Y38Hw+Jo?4wELueCQ$ zQ$kzYO7t*bla$U-)tCsXGwsPJf-hC18^~;}_|9QjY`7b_>o+x2KQl*`g5c0w$OfI#EkDDT!jXr2su+NCNaWAOkPT zhWh$#^5IirpCtFQCp85cV>fR*-coVPm$in1P;^;g^J2&5&1PzJL-bz9G5qk&y?OC? z%3;4RHpaRXuU1iCKb6(0lg(AXNO1i+&&B>V@dLO*sOTM3jV($+2!>P3u={gm(%Wc?}N>?7is0=eZux2mg3~&E&%Z`)o7ZX_P|k zhb2BpHHUptfOOmP`t0#Xqz2Eeb}jSWY1~6UmD<3KejEaN+WgimwEa8l@C^1%;@~i@ zyS@B!w}QqI3yl_9MPQBa?HJwC-^fY2zy7Pd5G!wrkGG$Fc^WW(%U(dMdl+)vnCr`# zw=7Jwl*oO36D!f^VgcGD^bwY53~o=-A|2uV3k3NuvkUy=A-7lN0(F$(MZv?t=w|=C zgH%SS1QakBDdgUD#u#Ha%H!D2PENRs8(`Vtqk*=FJ1(W1n1eg>ly}jKim^gC1x`FZ z6Ml_k|C))Sxkj*#+M}&eS1wV(!B{5c!}ijIs-f}W6ZIC74_~cH1&6LP{#!5rH+f5N z-7NY?l>oMhXJdpe)9t!3+Y;hbB==Uiy=h~#Cd6JGOEpj`FJm}0_IwyG>AP7^^{J&u zT6oI`v6mRTg(3>6r%=JT+o&CpaAsh9=xrJQv9jCiBnKaQ{{$#}8*+6b^+NZYe#2g) z$-hws=DRN0-+kaXKI_x?m?}bWI4HMHH+yb7{1eH5(w90MhdX`!IYvJdonJ;N!GPnt zf7Ca^derlBKH_;x{dekzFs7KH#k~L{=K+I)er*0Lvzp7fT&aeVBGv>ah|}NlD3&`% zyjvTOm1DipQ5!|Ztc;_i za%rS#ou??{Z*y*zbO>PP?2l~D#CyqD-sKsB5_0{`!p)+>BUu4WdQ$PvRnx%kLFb^; z{H02ezUi$|Im6$Wr{gnL`Dji7ApV}f&aKHP4`HD}LRk-6$J{$_Eci2wH)doi;~OK< z25reUG#_l?)!+SzKfYl$?IKmjM`3?M@hNt2);QCE&*EUq-&Mbi<#L4agZ52))1SmB zz)d7HSEwF}5fySm?FQ5T#^#J63il78f=*$2k{7`In=E*>r=dA*7^Cu-UnxZjlj zMqD?!fY{(Riav-+!k8Y@2Y(W9UuOz>K?G)j5ydYyo|t>fPYO%;jm0B+yU_UudB4^Ave^o=;MZYj_cA$~^mO3XECXQzh~Ax6$1toYq)SgrenA9Rl7w z2A{uO#X=`&c1>npR_AB!e@9WFt-t8Gr*X?eLo{ar%UT~uX9yZSC3r-w>LtB9@aEy- zQSTQR*Kp)rE=(G#imYdhzOSm~2P)Ds4Pbt3Ml_`%d5iTaA9fd#Py-r@O9L}Iq4vC+ zA)H{P`MmyDOvM5A6@Pl9(`fo9p#RvnkA4_`TgVe4GCuGZ!bjrKAh+1m0g0xnCrR@J zaj_|0QO3(YFtBb;>`~G|RVmLj8yI^&!w4x@tW*3b$qAYaT~-G)6~fl8KAu2mHF0Cp zvI79JiLgsH8`l#?L_(@&gh=l(IB-=E(FStsAp>sbr;>;o55q0usr_dRZBA0m#v@73 zl?b}xwH0X7)t=)|Y9Is%!ni^%Q>5>dXxMlsTN-ZOkmVuLG@U8Qf1SjT2+HGnT0pGX z!BE_KqPCDOup6nv&3ulrpTno@3|+`oY%ikCR8PYDuSt` zZO*9MewCZ7r`*++RWmk!Z@8dX%A0c=cMiIq-WK>7kqb|d{A*ee0XzZtHss6ke(>Px z#+L_uXBiDo^3l?6{1RR~K9@6op81*DH1Gk6SgcshxG6O_?zA6STJw}tl8Z?>BA$;S z_P_0HIeCaaxcTWNIoX?OC0oN+cTDd$cW$XYD*b@EWKPy? z5LoPP?`F4O!gD&t{@a*?0ezxZ5_u;1?>b4pk7>~g&S*5h7h3srLGOry zSDb2&j4j9jO0-Nk&eLb}KCU4bUil6oMc8MIZn_alw@&7sQdWO|U9y>yWNo7_+`40W z6Bp92)W)hEh-^!cr_+BcIF8weDlLaD-s#Hlzlbl6f(7*uVcI{@APcN9VMFCdmnprf z<0Au75fQoGImaKyd241%H}-NN22}30euX^V7s?XLbFV8~`UR2B?8{zoJcgubSCQs< z$7l5<0zw*+FPkp(H)r%uo}oh;x#BSqFt^07o!&1u`_zWw$xTz>j|sL(_4@HST=HFG zi~CI;rxrxXcNKy#dGX_Ey@#4jr6_10c?RoyM?rj}HF2YO7SE#OBeDn25*3t;E!DRp10TEoa|EJb-|TDdI#eG*B#xRl3$S{#d&rB9v{Im7!0tnyQo=*wB(J{Rl+Ud_G{`xc5F67>Wc1!GQ8X6BFEV#|}2{GL`?7#)hUpD3+!;rGUY;yv_wkN&TdW**OM zdN~C&_BoTSp8VLV$$9*mD@GTc@Wl^8n=02uhn}jAOYxwwTH)vHu+LeaQq?7G9GWcb z`jgOeKmR)ej8Nzy4DIJ4H6KF2cmixKk*bv+A+DaBuMs0?|rDZPaNk4^j&BM~WY*n+>60p(*hhQ6})( z+9OGp%lr1~Q{SY#?e_gI7C<8BwjUfY4M!iXCy%Gc09Q1tF?2(|jBQ}7b02XBWW~l6 z|0}i5h|!QYv$Dm_HlUf>!NETs_N@x)4DazM*>{W(Nlip9mgLZyRDHseoc#*YgW^dE^IRfVk_k8|W8r^@`5iCaYpW97V*~T9A#$QwvDs zo0H6G=l@FH6+m~@|LbK`UaXe)ZN+U}wHgttny?2~q&&^G zK2k;Jz|gd5qcY}2q0bDe<(e?oSy!ebKa3`Rjngq-+BEKh{iv?bz$PGM%l~`#^Pw7x$1I z#R{pyhm3XjGc|a?=j!e!X-#okE8m7#Ba(A*s@qT@#e?HXusuNRDeN3f7HIbRy{{+L zvQ?+pzw&EiMH8~Y2fXh*=$gvHhgn>h$j*usswmtMhDZfeqr<%dUB`5GX~UOmx($&U zc{qOXUe{}#`H;e7k$j9&^C-`Jooosy^os+qYt+hOUG1AqUSN&Pv*`$CdMydKNxoQ{ zlaeq6LNs;p!;+=5!*eld4NG|b@1Nxf-eb4^Kb3TGZVVQ3Xj@z%YN{Y005xT)DgY|! zjGC4Eh#3ft+WrEfFrWtPMLlYpx^ziE11u<~?*eqvqaDzixKvfL=)QrM(K@(MdkN;> z@F(wXpV$~lIJx>K)Z?mT5@#Y4dP@5{*JM$eN-d|99W- zu+NI7g;v3{THzaHgJUHAx}bBN=m@n++2#L~p)7HXzw>Kt11CG{xGsCJcSRRgsBJAQ z>TtGR@O!5GF_NNid(|H+7G?cz_cLNQtr<}}WEby@lJntMBdM@@UENy*^6F3H<8Vs}eCYQkY{gh%kzJ7vNJb~7^`IF~E+EOO#cokZz+0BrzE-|1yzJ}pZ z-T^Wh+bqlN}%vH-L%=i8yO?Qj7wys^S6?9IqL({9}b6SjHSx?J`>aACnKXr ze)G|*Z8iv4>R)a5S1uDTcW$DD0AaRpz!qE+1LGre(Z$Rv>OR4H17tn(;Wl+7ki(r@ z2+XZx8X_Ti<#sC%#XtPe@#`P4 zJ#`KCcKmC2fS}YUv$YfttY2>tqY}2-J532M3xuB$CUIgVGlqm_uj{-t*+y&L(r+Ns z&(d}EX5zC5eW?qPB{@L70cvIL?_IDyKmD38SM8>wZ9n_;6vMI8BjHq+k|ujgHUB<> zA65kSbw%XG^*+J>qycB>Eg66mEJ%+JrdQ+cAYFd&89XxvzY_`@B)t^>__$^2d*#PY z(Rm{A-4ko;nlieT$lz(Nch00GpJ2tbb?u)wf6Z0@2>Th>ZkE93;QLm?YfS5ph39{8 zfOc8hot!EJ&H)GpKvucp8zPQC6a-DUyTD;&eBTr|W*sPV)}~fh06$j~NC(o)^?Ya; z$NItEg7tJumHm_1&F(b(lkJ=qyM6i^?PZ~XfaY`7&0=lZ5Cwz&#W|TQq6n!^rqD}ZN9(??!WmXgzUYndsG^D?YW6S7lIkxi`Dy zou6;;aBjW9`8(ZDzxwy1B-|;T0 z^NUM3@!1Z~agOJ&hz@roEtXUWr4Rx8a9KmYWo$v>S$yH1>*xxa6*cH12~x(}$uKN= zZ{?-uGaW&9-$l2Y+G~dp`MDqY&@LKNGdI=rn;%%);NjL$KLexN)^j)_I;Emr!ySj) z;vI~*%s;=fL$&Pnp6M;+f#Dq)@t;uLgX;qy%3%rOY3`99>`Tb@|NQ(>k+)7tBtD1H zK}KS8AG;8vQ0LOOzH!}Yd)Ohr>!-0mubbW^kzt%byDULXvTGh9Z3pZ+X_T!x%G(k@e^oO8m>^Qc&p`f7nPrWZx8WQYjQEWq(N#tMLx1gddOC~u5fAsr^P<6y-N^mlZp@w2{jQBhPS{e6-bYd0oxzw|{i`B5B@ceCmh++@Mht|4N%NK%C`ICi_zrRZZuZM5r z_$3Efqt)Ht8e+li$=`KS%=(V!SY}T7^sVP+mbOQ35B9D?yV0Ej_aHVdfcws?j`V zT>oIFS`q*Le!KbMW?1SLbE@!bY`-DZK$6l3Y=*?sVl_mi<5{v3%q0>i)=WtqEg+H% z)xrm0M1}$PQN7yz7Cjdc?_qQW?sDoFg)biSwVT9A0k}}E1WzBis@swb$v)2A^tI*M zwja)?k~QXb0m6s=b~KbkpC#Kwle3vhzpku5DSWluIG|HHzlzL_=Hh=3R0|mc4aN!b zU$|NL+#%jn73*N8NZ#<}=f8zK;M^+gW_{|{z)%2u}TOS$~qP^9J<^KW$*)s0rhiqC^pVILM2-T$kGFe-I5o z>B?lcxU{lgm|#Kdc;)?%uDmt<-+1r5^z` zx$N1Jkb4hK7spqTM|ZG7A5;6435uT!6%)S@qr=V&SKo=zWM~mSeW|M?y%a+DKJ!`4 ze~E`*THj1!tSidrFad`d<(l*j9_5q&ZTCNBwcBWBFX@#odt1z!Xsl?~iwX6XN<2dWMtejA1r(G(fl6XKA0ORv&1ScWC_XD6urFv!Vp|6-eK z3A<ar$#SJtY;0CB5hmiO90eQZSP{|tLE3J?t|*O!P5LjUc#4@HQH!I;humKXX@ zX0i`}O4X_?QpMwstBdF%%wUsi#B{x!ViQ)Nep#&$Sa3sR3J;JTH8jbPnhMg=Cxlz$cq)Por2!O5{GgnbJ!GtAI9-ZjvEsCgQYUK(Zunav3A)7iQd zL}oq$%Y81*D%NRc zWbntlw!8Yp-ps&M1|bDAkFf1kl#p+3Ny=kX!GGl5Z~h-i3k*qwwvO-z>&oeFF*0LBkok>_jS(J{~R0l)CISa z@s!ExhjUZIgiiUdDc4uG_+-j|frEzsEX`6B6-op3JvLDt**SBd`d; z=sb2<)K!o%%@Ew)5BWmH{hKKQN#a7EszG0AK{`M%cA_uoywK`Jt8{*C6iLLaBtuMCkBumUf**sZz~&zmum-dR_fRhp*YzcAp)!UHq%Pvb5$?}o(1=t z7rx#7rP4St`qWuW3p>GeQ=#+vs)5$#|KRDXADVoienCJ`Vj?0U4Jr*HNW(}GkuJ$u zv~=ePkuE8vL%K_vfq-Y6@=4>!b8rseGDWUV79T@}jze`IbaP%@tp+o#pL;ss7 zao2v-#5m;{*tw_Rphl9Hps>sZ&kfV_2GZ!iy#+QqCK7c>s!jj1G};9MHNOr`@@;T> z64>@|LZWVWGPJTKukc`7*S2t~pK}$^-$_e;P*-akEXem(?w4rjvyvmN=6_Ew@;pRQ zzNv=cxm#G;cQG1tc$otH_iVi}m$5FuR?gR?0<4=04{WCYanMa_tiAm=_uEo- z7MFthS_6kqyH-rkkMQJO?Y_8=jRq(hk~RAw8tqfE8x9i4LYT)A^D;cku3OO^=K1$( zNDO=vtnen!W9Hdid8=>XU_Z@jDH_2(rjTg0nY4>!VB;-kjAsw?Ei+~#kFT1pRJ?w9%I=T z5}>SsyNw?w8vo|sWD9yV61IDgs&v%uPDm`868Xb1)o|)!=cS7dS!BcH&gdU*#=()? zS4*b(d23eOc|U~>t;X-fm``XJ3|R$)ciIP6B2)8Jv`xP?_+VYzs-_=r~irw>48%u}u#)3(98JfDye5`F$;yvRrLR z8~UExZpqTJqA8}IZOT?22bVL`27_k&RJ1p-q^J1rMP8#gLr;I(l1dlHex$ce&W{ai z=XU#PtI4tzuUd_v{XmzeeDrPM(2a+n$>jN%bwl_xFT9tlo(=?^Fx=-dI|2pJNR$1O z%{$B+gXndjavdWy-u}JOT(SMTdK5Gw*Kt$#^H6YGjp#pKECcEyzmDe;`Z<3AF%~}y zR9*8cpyn(_D!jN;^n{txj{}y+QGib3*~slmAc|xhOQN|`beqHctB!X*{z7}!7S-x- zow%QMA~H{qDfC(X*V*S;5hJC=nVeTYwHXVTVqPpi8*CjleD(3sQG+dCq%fQ*tL$@G z>gpZy3csjt5V~6{p^@ww=_rO&uqV*GEidTve*S#ax46uHp2kX zul#z}AggaahBdvBM*ViSS!NaDEsfja$;1;a_a+pjJ}9X|B)hiAqY+ zGySXsA!}q~N;9aT9D4UX@n)_Zb?+L3yMn|ZHPJ4$cGC_lz_8?8v z==F7(xSKh>qDs9BQ>(I#3Wvhb$qQ5M)cBwOd-@k%z-Cte7VKLKSHb4^J2W;41jw^*i&Fi|rKieb^Ln1|f6$KWqmoopq22O*q>`M+s5pF& z?D2FNtq}W(4bOd+t|>0;1lRKBL+2?Tj(yfJ7M_o!?J@{^KGa8>W1XUxq)w=A#$rLtBVjhs>SS2bkuBlP9g%WQY^AuoLq9P4;qy6k$>nrX!R1LCHh?vC$Luylrbd!>kVbc4sr4MTyZhEGOWC-b?923*o87bF& zf#>WzC`!M&P!J@NajB3spSHo0my+SR*DvQmk6!Dln=14Kl)Q91`JQpZ&o!K{uLQvp z!UO3Q~^U@PLh1I zAN)b%XwTf&dha|wliGT}?HQ|-gMfnU-Aqf23GYbz%a%d0^RC`6c0P}a9Q>x0<7~nl zCcKxeLH=LRVe-Q9gt-S1vG_zp$@05OW-p^{%1Yi9{71uJK%$A~AlmwY|0Q7%%zM{g->9gXFatrSijeAWXZPRb3D_)2VhV=cyYO-d0_GD3@&y7DioAw8 zdhf31vEszPgx;M~@v7@sh!Mv>PJu<^5ByM%5 zUSDlCULA+YZjZa9a$*w9(;vwYZy|nli#_*B&Py(#(i${!Lw{Z~zd2cU@_eV*S;)nq z?f&l-S8NxOwf!Zl$4>4B8Rb2RPjW|Hwj3U{_#iDqh|Q~llyLL27|F`nZk*@1zQ{!MCuF+c^~_nA*aZ)*m}6e6 zJtI{6HmhGKoVF-BO}G%LtV=tQ2~V{4d;6{R&D-)9NF8tPjlVZ2WlR9NIXmS9inwJ3 z5;U2_S*r|MU009fVuf*AXM#H{o^h4-#zOZ^GmK(rZ|<4B7m^msJ-BX%meaGbzENieNE z=Ju~qmpj(oZq=uMRE?&8RrJ3<`%LQpWV-g`v_{vMY znxX2KlO^YBo3+^5cR)m!8c>Y8omsCKx^>~Lv(D;LsnW^R@tqx&aLNJ^UApq z21f4-BGUV!ZPh!t%o6G=?tS3JtgYosaUj;|AS(8Vl8y7ddb0LAT&`bO_)ZAVUoPk- zw5Vydm{^%9{_;OtFtwcuAZyF73Xf`f)Za%0s`?WBOpz;j`FULiHmz<*P!MK1P} zBbx_(CtgE;SQX*G{{KY;EPgkI5MT^EDZ>Zcw3g>rQxok`#B z3%xIf#^Bz92}_=Se5}IH^QZvWSO%#dz!2Qy+48^He-ZYaMXJ#K?1T&_MZ@>p5HkWv zoj)Q}1i^pj7!rAV=0R-g9q{E;b6J}$O|s{$O!c6W+!IZ^ggIlH;C-kJcToXEdOaxQ0l6b1?I5U{fNcRGB>HG9S>K)p9N9 zSwyM;g>;nJq#s43%P7sk1x&qal{ichSL_d};LbATJ+f$NoiQ^d3*7SPSy#9^BrvD8Z6fp7I z0h6rsQ2l`8$?Xrc=(xLiW#|)0vPL`v!jcZy)xvz2&$G}COAJF}P~3UYS*X9d7=X8E zHRopUC#k~!ubu`8Y+ip-#}%nF6;8iyim8BR$a6kouK6vMtJWlaQ`FZ9OcvgDI>I0A?4iTVC?9qBW6s`4)O7N8L)d?FKL3ld+rOIH%CmUk6Xa zsY~TWV<$7YrbS-vkNX=f9T{ zLWy20EwzLvee}QN<==tO+NA4ZGC2*j9F6(d7{k}<5QN(!XZ=- z3s>Pk+ux!w%)wSyW!k>*;m(`?wzaw~;K|>ZE;Wa*;D9dHy-4M6Eim;xIvLbAG}BGt zGphZI`}80iH_SOGLnZr?8SB|9gtsAQE~<){KbL>R9uWHU>nuyAcg0L|!Zl3ZnPMblJwf-2g z=-qs?e5_qUDn>1a%2i8#`I6dZ6Qmn_oPVBu>$Wv^cl9?Pu$3sQ6)V2sBqHV?kKSmd zNfSg*!@sKqywi|5nnpB_1+X#m6ioosDvSmil0Wl}{Jpj~;`jh8IMsbKZp_F8XzW1a z=R=l>IWmuK_SM_usSf0}%Ti4hl46k&A=K<-`@f35A3=m(TN%*w72qX+uXeqd^s0mX z_7bf(G}N~e=6TE%@^{p}@&e8KpNf~>G)Orx=EtAZdsf~tN$lM}TUg^v-YI)>ZY(2g z1Kb&o+d&^~*MB-!Uxfjww6(@}lNrpAb9(ai)n;o42XT9HNKGw3q*L z4<)#MdliD4`qV)b}I@uI>qr!ij z6sm>D$QRk2OrWdNdTQ`-DTzE+aOw&?+Ul8OR7f(>Qt`2T$V6rQ^H-O)~etfJ@W@OJor+CiyrpfI|IO!bIU~Zuy(# zt`uPxXx}1`>jzKLO$x&m4F=o@a6tgH5z`35VrWR7beTi1PtF8*%tma8!fpL!oQ2}V zQ1u`2j;+3(QYnN3FG5q=hyZ)qEt7?$muUiG^PrRdH9Ayu5I0rS!LDo-Uo-QrChZsE zn`|D>j`PgHRG44d?i~v;elue#sl(iD^waUb*N#+JFhFt(E?7=rh7~_jgYZ;&^_ETl zaX*J~u?^p|7!Rq3?Pvm154WFJ+lF{*B8vQdH zkm{(6m6mc?O-O9fgZR%IjpHN!3mjIqa?fgyAH^_;FukN@U!`hlp%Q%a*_YEjZ+M0} zwc`^54|pp^WWeYfxr0WMGo_yAN;5=oZn>>EBY;v0e#;}^>77cdH0DK=e$+9nzO3u{ z>1}u7pEmg#6?Z6`$Mu|ST)4YWL%-~CmLA}n-Fqb8s*~zH0ud(ba|x%7RSMx-fP{-N zc>;!?7ald4ytt~==_x+pyR#dWvO_2B^QCOqfYSVeUt|In*sIOaPteC?qMt#atP5#A z8|=RqEb~Jrp@h~r!)jk3B)p(7rTOtiHF$gA)daYdwVQy+CYf$tR#H*P+q7E9nEQ@T z)R2ed1|s~0)lKtuE(n##ZwqzETljryq>}n6Zh}gZK1A;Prd;0ko`0Vd@i^G+jiDWY zz2vv@KN=Qj_d`Xxj4y+J^C&zuop|*Ro{|A|&^#a~YLUlrwlMl1wm@#U8JsBW{z+rO zHtJIFiU|MimM+}NRR<&sH5_V|&SsDET!--UK~eQZsRd&E{G8bsV6dbpYgQc9A%O;h zckkxFnvQbFbFy#CLANav!B{kn?LS7m24V7Lq`A@j)aP|8Q2;}3xAq^gll~X?kUv%! z{=ov9{3BCLY$RbEb~xUVrCR53P(>)|&LA7@-KTT=K=u(Uz1!axbMA{3_xPrk`&exi z(>{1TBdXS$lj=#{K5TZ)n|R|`?C0T-ub(_GClv0Qc-s>p&;-BPo-+hWGXiGlEt);Y z_auDA`<}cCh?F2#hi5Yw*}%!~A2cV%3;ImtkdA)n1Kp|-)FXX^n$S!>fVNThvR5#O z>zYF!tF{Fuu@?kNwW-2ESp?R>i=wlD_?OLvJZlbGL`WuLP2Zb1JLlJue}2NTThd<# z$$~?j#!`nQ9Um2MyW-x-(ql7T3*UAot3n=SwLCLINn`WyyHgfb=@S%8iiE?_@nG4V8~8gH563IE+bcCU!lAKj)ibCYkz><^KQYYGlEgsfoy6eU;wHXhh0 z_wCGvH(N+Vj^+uDdr2AQEI6yaC)kMgW^C1xKY|iK7wGEYFA2WD>CN?1lfU_WFty_4 zk(E}OHt(84tXo$)m$~@^xrzq$97}vl>{U0R+OfN=klag$&zKR@-jpYjS5*FPQrnda zX5%ZzizD9yl=UtIBN{SVy^2HB1KJwCi#9yeaGEr;r(1ittUkm!L^*_H_Lw<`N0MwX zyjGz*-OUDHM9h}Gvl>qw<%(N5nAq-Yr{cPj+>&)F$aAk{yNr9am{`M3h5X`v8D_dA zXnH;DGAz_r4AnjfCKu#UkvZbxWVahRuNqj@v>Jzr{*#BW1qO%(b(XR%KcVS%BSV?A z0E>B;2_|F-A_$aWx^kX%rBMb*t(QA<%kBrUemm6we?lS;+7K_z*`bCCM8bOQaxL6z}xq>e9O9x(x^1MbA=d6jR ztx>6$o(I*i1Gk>uA6+zo+SO`$#7_H~4IIehL*c_1bTvMbKd3{?pj`AtIO-1} ztkA;v&0-iL-IAbo0tpW%ls%ejebhbvZ4=}g=W=LZi0V>P{@67Ty4<)+NL+BMEZ;~; z+|i+;M2Htt63TNuknd9MTukL}DEmD{0IyTNn-lhVn_9bc{dQ}Y%Z~<=0bdIgi$Ci0z$)9!Vbb~TLM;zUGXRnJ zkyJcQuo~4{>viUC(Z}S;bJYs?kK6?$pWzy{8Oe$u}z}vXZ}DwSM}xO8l1z;*Pp(gy{-2Uw^MALPxCd zyj%V>wwT-}yHoR$++QPk%pXT?5wY^2l?N5)b=^I*ax;9g1t>Ujp?1Vz?SnY6h~M2j zz^}xWA|@mUm&1o}Bx98CV%Uo8(7q~gjka23E@pk@TUGY{e`h38r9A6RkWs%x&f`3o6+#nI$>juMMbajeh^8=lKs~*&|2vmC*fS zrO7y$*Bch0@|q}FHEb13|M6itH0aKrb&-+q5MO~!1W}~6zfMB_{jGyB8==dPh_qK! z-m)L_{bHMzh~+$=-7OTbUw^H3RPfjTr_b}f4;8H#AA%p=n|v_Kv%p0btz-Wx#gWDX z7{f#E$_n76Z#f`B`_rKURbGaDi4`;z_vzUt1vgbQULdW?Q!)Nm6;klon3at@!H5+s z>u63GQ)90fx-TobEyDFeZZ)-00@e;j+ier<*L7hJ(tt;C=hL;rK;-a81Eto&glPikWS` zb?*CbklXK~3}PY+gpQRNO>8`J=1F>CH(QRtoxsk$E_| z)D!>72>dn}-<>Z~T%K9q+r^nsHhQjqljUXvN$xqXTRIL0%nQ0OeNv ze1hYta-J*RsTu%Vdr}?lq8t%v2rFd74(DT@P8323&^5Q<2X=s&Vp)#$`c68O8^!|t z#(KeG{Ld5zK5{&$haFT-foN;EnozXlf#9S@9t?wPl&a`H&>iy0vn$rF4tD*$`0lF| zZSgx>*G+*8ax)VI?QvekF@%M;^cq45U%$^Xf4~}v{;Tyz-_`B5%!~Ya26kw@#jn68 z8SA$@NuUs$+m8(9=^*7y$TC41IUus*$zv(_xXa(EBOS%fnMkDCflP)pYi#ovL7?cP zn#;4?7hl;{X$Q1(bL+Nw`B7cuwzugbv^lT2Owf)9^(sCtMjk9hr~gzL2VqZt9v^yD zKi6m<#$&?&`s@8H_j1+>_Wde4lu<}P{LwCx^#gIDm6A7p9@F%>W+Xi!oVVc4KYkYI z-41Mf|77sDodE8z(Bz%;%sY1^MBLn2Tx+!bRqtY8_dMIn%8ylb&*xUl>-PQfXZ)vV z1986Xmd?2RK|)_fu5tWaxt@6b5h=9MQ4xYo@9Ka0*TwykF0YVy_#v9YClMqEMQcNC zm@1Aic6kg<_E_T%zn`Nyt5dzl^evOsU%+<0?bz**ZP_acC5tI!_G5U<<4w8?iyp&v z#Ed)R@F@DD->8I2pp&CV28XnIpX&!_@b;7Msr=Ppp^{xN zA$sLJ>Fb=H_he$0j_h?8VCb>xe-$7;9jkca3%Fn}qIk`?t9-F`gSy!|7sPd4*NIR3 z4op^g@M~htSdN%4R)+*GKT+9^TfA($arF8onPS88oBfK;~LMLL5Cg5ldmBRWMsEtv(anDp%Gho zQUB!W^o#={B}GhD1U2gT#Vz>sos2h zMabHlTjLufQn9s4>IwR9u31S?viCos`dP&WC9%ABhVblzqW0S#T%t zx+5+DNJw+_=Q-1Y{@tk5wSw^~xomXHVmVJx`j%@)!5-vhexl!)Fn}%lGSWb7O}Y!R z|Kt{wLSOrhw7`mgoM@hOov>g(NklT?(MG}0kW25aC2~0Ve<473a!#HG2872pg^zZZ zpeKaYv;&wZuPbA)bC(nL;!RysaF%6dHYNF+@_hX3G%{7?TP66q3xvGeZ}o#D)jeU% z#I%J&;C{nL7w_iu)e!T(mOQU1LCTi7IlhNMZgnxVHXFOe zDR~<~x8KM-T#7q!j`K~?^xxk!yCGPv$c5=*-#k|${)F^dEL>0fw6&Xw>dQc_LSK~SXoeA$3=+2@--iQ`V>obT z0-)j?F>dUg=!Q%Lu2q{C%}$Ix#^c^60Cr5g8y|8*FCWqk8Ur$3b~b>C53azEG9$Wl z1WaM&ivG`d2eqpQkLJ|jg22+A(qZgJI6Y2Vk;!#Po8|eMyLzQtSsHYis^vhxUie96 zU1Q=~qqiSdO&Mc~DSKn)QaqV*I2u04ma}AcznblzwWeu=qx8S-|Nl_lg(H&U&0n50a<7EJBS5;Y7U(L#4lT&9i{sc}wZzEX;2Ght=_qX*}oQ?qQJ=T>OH&pB$^@BRVyNWTzxZG4A6sYC0qt*Nh) zU+QL>RzJ}ZJ*%>9^4z`W?~5d>pIZ&fo&#SM0K&UU8;{gNCqFj>x)#0{K}<;1fWZC> z?gwU5Ft1i}Tjbqdtms|O99v`in5*=uzXa3A@405N)QYJn|D)`}Kq zEy%+TWK<5JppjPLG0dBJ_r_(@m?2)sMH-@4FhE;c;cxlRxBD1y^@w9`j<;~aR@y^NWj*!*H2VhB(X^0K_NkK zN@3We0TyhYU47Wb`4|{>+Wi(dUrptHxh;Gy=s%z~*p1uDec-w7Ugc|s8n%*k%$g1U zvW~wlj4o%W6CP%rXY8h)!<=Qm*gERvIb`~d&LM3&Wn;>vcO}M>mmEFpIbN(lg>$~O zKG=jJR5??+@h&@cT=Q;bSy*gU)U#J0spiehlXu7Yn$GwIUA*vC6z@e@wF;BFTeA+D zp%J{|47`+Sswa@UiqoR}%hF+$ebZ1I7t0vB>O|yvjBo zy||e|-4}X~Wn|J#^SoJ%a-VM5-Z4RrdzpS1c5K<(sm<@`M00|Ci@h-IafA(`a?B_4 z(CybieyTO^)*_%?a=8jxQv?)$j__=$_-`aI3vy(CH+Y+LjUEO^6$A{XQYo&MK>6s* zzRLc!5Al0rETp|*13l=#*;kx{0#{<7M@nLjTVX%dE*^T)Yh$9+dw$~N)*awz4N&qROHGSa>;2iLh$!qfeXL3Ba34v{y7 zzZ=d-PfuEwDY7{m{d5Uu*Hv4K)%bapo23P~C|?+6EWLi^%>eai{M26f4HTRHytGRf z>C-d;oryDeA+&p1Kt#*? zSp29EQUS!YMskO>AFBh?6nD++yqDaRV^KV#(Ea<`xIb2B4^va4iYBSX@7tz5q2;+U zK%_Kc{89aVvZCxzpyh^w@FsHAGz#oA6UN{bZV#Z$AzJ?q>5ka-?t3?-OUy@`7Ip+A3 z`r&sLgDh{PLSyRy^ehTj_+Q3s32hVsW_R$w{K_*=8**^HdLaPS>+ssA>tQlWbvbgM zOC|-w*(80d#y%VZX#qZ{vc~{T-)e|M3cTTR;68fDkvMJjVw48o3FA{}9^)Ma=bEy3 z553vDAvt2Y!uPeF6td(#ZiKmx%2;jnPs|uXbh9cysiZ;zy!#EebFoZ5Ft7lCSl4}Z zcrxPXZHM|H%TGVZiJKeq_V6B1!-=L9iH=tYW_zS{V#*%m_imM^W5uwIXJUqu;2+&GZo(LP{2GgKMk#`vK6<1X1!1M!7du_uI3#)3BYfxvdGe2ccW!e9Jt5mGP{o~K@nK=@;M6iJ%}?U?!(Oxj zGdg6vH}X{Tv7SjzsupK3p1P*kGnA<88~anoYp&KKiUdKtCZWft_E@no<7|(50+2$# zVb5FlGpMs%?BXI9clf4ETS717nwZ~rIQ~xgLrUz|nth+tMfC@QFP1s)^1qt4t=iW9 z^*1IODkY^Ml}Blr8+8ytT4kE?QL6+b23ELVqVwu^e8Ti z6;A_7h6D@`O}|2`9@yz!X+29w?lxJ${6 z=qf1&I6?<4mYyV??WXc-f;ZJTf?2LRy9ZC)o-IlK^_kvr9V5IqYR5iQ0+DWLLp063 z8@$FWeu|Sp&L%s$)l-l=@=Ba6owuB=8fM?}!^H{6H-*#&Qgir!7)y^AXnK|crY z_0_iL*HQC*U|a;EPz?5zC%os}^D*i-SUdD$LbT(FPu^$_%fpDZ=Pvg470c&=m_ALQ zJ;Qxxew)UpcjJ5S9H~FYxIdH#SxT3TX1elIeQ;ygG61gfSA9UmBaUZBQyXEMUPG)= z_Yj{j5a%W5?Vn@fkyNFh^Gwm_kR;&dM_+FnLw{p-0t;qg4%fiC#_iw8; za^Y*z*_mVVH-w=Dw2&#$F^lKX!m1abD_iAq$=ycH`aKa~h>(gh*1IZra zW3A?nul}i9jnB)^Y22#1F>w*rQTgPFe@Xc?`uo`qis2g`|@>odP)r zy+G!`$`1v>2hN6+ua}&bM}k^^Qfq6&v-x&i3qlB<)otH@x-#;u5hw0*pEX;7<{PdT zG{Z3^_p>$#GdL|aO(yN||FQsL3l3Yb<+U>QRRL39*r+!W|-10?%O%6q(Ob z7m$X*xJV&|bv0iUz^y&9t&(D$YO7}w|75!n<$3JAn}j--(D-mS(;k}cVFxaJ z@&XxO1H*srl4XN2IPhgn+)37=M^i`by;pX6&AQlyl8OucfbZKl|s@S~w z#R)FJT!(@8F=M;1Q={w#2Q(Csm~9+z-L1yskIa4+H`FJaj!VZ(T;-%9Rsj@by9n0g z)&mS@`nI~nkM5l0<-fAd3uVERuo=03iK9^l;yG*s zxQp;IY=~4kh%6$V7W;967kHo4 zXxzXou;XeXlTCZLMpzy!r>P~X%_r=`DsF0*we1JKyq$+ zoaMc9us-RQZsv;z`(Z@NHVi0jcGlvii!qgW>+t&KVk7n?BdZQn=%_*WC&jcK5TftK zu?Vhwe{#($AFT{aSoLACPh`y0%_L0HreBcr*o-?|%MH+PmWDTFq`&sxS@P?J#7u9- z<3b;Jtmth$u+Zq#V+)vgc{s*O#>`$azSssg`Nx7xB8CWSWjOeFLg;DKEK|aU13u4t zj-emYk$;mlooZ_`*$-g$mHgP!b6BR3KQ|ryz3B6*6Hpxb(~idY+Ayu^{Bio z7iYqupjg02g~u55`As~Ja^jdu-Zh=hZ%eJBG*pCF@DVJiY`5}l!s4a%Ux^x%c8sfw z7f_7ZarBs%R*Sh~VdRx`PkCVN4$IS~_N|A^ri_$|-f+pZx4x(%err zwcVy!cTpvw{q-A{h#CDmW(;z3vNwby8V|)`pX=M0Ze^| z+z_3OHo3j;ZtIFZZZF%dUNuw^H3Gnp1%mv315G5^^5Dzlos$}yU>^A?=n(TI^j*n7 z)v{3m=Io5+1m^ww@6VzAUC5&cGBJ1#OH{d#1(*gpo2t`l@HCd#G|2ojzCj>LJfw0Q zLsHk<@s(=v=X5_Ajy8EP4G;@qjkR;saGC{ck5);+GhIW2yt=dA3q6=kL0U8r=4sp5 zKd3R7YECNF4!{4_x?P(YZ@pyuELRNHKd_iCf7uU`4Y}lsWG5pKy)2!t*rpBP&*l(- zO{XfsYPQN&6I|qJF#DSX8zXB9cxm#Wl!2YB!u6f!iQL<G1f@cLKJ z6nqSiELpPwihongr)&s=I*jJkLxsuwz(c;ai+QkJL|SiGsuKR+z?lME?`gJpi>?5k z*zU7!Jb^>+=Z@`Hku7D}_ckd4e(NrgdG)e6E*WLwU}q!egGa5)I33(hsNke_cHKzc z01RvHo8k&{j)fh_cl{@BL_A{JW|h9+hUN%b0b1$|7to3oyqd-q6#~8valk;%)8>-L0yIt{s)%7fVTfE8xUz)JJJW5VWE1}d zw*v7MGHRwb( zqGV&GUNj;_S8zH86R%0MWNaZy-<9AXUzVvT^Zc;Ge_7s9@(X3yFyZabuQEHt5qy15 zXhJ)d%grs|O0)D_lL&hB+R${COnu>$li(kfaB|Cw?*F(IKG(JY zcm=v@j|Z)&2S1pJ2B_y|!c0pk79LM{#Q55m3@R9WAoa&@R`}mz7(6U;sjyJ$%q>iB z=KdZ*LQ_5a3&vHgoAa+J(fQd090Gk*kh*>lEw&)-_c21siD4O^5o8FD`Wo02fB~*$ zuLM}or=;%X%4?=>6qJz3t&3PN`YaBU@*pGRx{=V(ojB+Yy?63N!DyIZov1OvF-K^S?`q;H9o1fa@_Z|&>7XQ_|0=B8q0m!jPq0k_b}Mv}#z!%V=tt6RDQi#D-JN;v z)zQ8$#WM%lOh-pZE76L921`4!m+>nhcf?sWY2!DYe`%saHK?1(nX2HVd>4#4vecW! zF;uN&{oTQp^=$5t94GUClrl%#jY4d5B<1rGMDOm7cOQ};=DB<|tBfnYY0N|78>)9W7dzhqMdMxrV%M9j*xD8d!yX_JC zi>s*L=I&mm&6f*yDrm4G$P$bih|^M?Q|@@@eW8DAa5nv}o_N5oKj6W0^C0cLq?T^n zd8f~WGGO4bpbb`r=;K=E4jRIyRM<{9_#MCSfIHeQDjaJW_g!PNA+*>PPZ&-1v+&h80J};em(AyJ zPzlU_P1Fp4#S$@nK)Ka{Hx%9|R5x~EIIta8?J6J&&;b%*({8hKVh*4kFy0{a+y#j` zO}O$+K+wfF@c}bIrlza{pvfSyQCo}g%yjZwkNQou;k$x5lN`~%01~sWm73?;kLiyd z_+O>c zy{SqPAp!Voaq*hP7me8`-Y!%!T2>Y7Om42xgF7a)6}Yi`GT`uT-$q|;_$|a6l_dFy zw^wD!r%$z!2ZM^J__D{l!=4*C%{Z~;?t4*$Btn^>*7vo?Y}pXPUgnQqxGAyjH8%BBuD=GtE~`qb|LI-QElGro z;$zqz(mfUkVst(ejHnF5+#csGWA1smv*Ep91DQ^hbN|)V&bwU`hdp=MD*%(DLU1g8 z@qs5+DnX8m@*rG`ZN`|C2?UKVCFs>zF9KtK2JpcLd`Me6s^tTl2EiNQ9Cu;0^OH%^ zJ3?`D&WUPLs2l!AGAf`EPFdUl;;&fy&*E+^oO2&@nc#wKK5g;=(x->iw$J}N3okpx z)=8=BN}IA}7?b#duy#k8>wY$7%j$wd=43w&IosG);kT8~;y!c11U0X_j{hAZpn=C$ zBED0rSPpwVXa2W(iQc#{vclOh(ngN%9q|G>D`%IUZkMETj$j3nfyiy2zV-lBwCK}I}Q-NqJ>HIcCa-Rnl7I5|*QLF;CJXKXa0la;O=zZ$OsHBd$ za1-N#d;9`z!v2p;Cm+jw9AC|eY7wAEX9r=me|MlYQCVs2rMkdOn!-~>-=#?$cpG%u zXCMO59bEMMl|Vr3!k}lCBPR{5E(Y6x(k)yh3y-b4{a?9UAiMp5pgQmMLPNEhvCF9Z z^PmXp(a80CGBlQ&$~|wN6WynM5KVR~YhL$cG@L7on!@wh17Whex7feCe#62}%8tDq zQ%N4ag?UzeSRHmVG~9pw^5u+-4gDEoIOc(hmxs;fL_fPa`**e;ns*9qZtub4;vY$N zhSs`OLlLJrGPh8TiyxI~lbJHdzO$h>4K_bzhz8X~Y757TCQn_&)&dKoP(2C~j3Bmq_yZVw**VxbRD&&G%wlv)6H8 zhx@JipQ{NT^z#wZn=i!WBRdOU5(UT3P-IT>hirB)6ep7M0^RrwLT_R6Le}Xcj99rM;oo<`4_?4kHx3V4)j|f zT<6h89@hGZAdo%%^wZX($Bn94*w3AJ-C;)`)mGr^@gb-8-~Z6|-ye%sk@#llpaT!K z`S@~aqL4KC<7uQ{Q2$Yo5%^HiA^8mS5irn)iiX&SnqvFs=9aY{J+HSD|NLi_M>(#A z(aZSmh?D!EYXLA3pg#AwZ;H1g>gl2VS@0%4I#dfEDvHSs^ojA()t5%U4jzbJe?9J+ zL$Ex1=be9JA!sKbGeKy6eC^T49=4V(S~yFBWQfZP#;qFT_>24}1Ph!LlwZia+XyoD zKgYwYP*{ZipTMe40m9)jLm$H@t^G6lhcYt#FBxu`@dx`Ny+g$F0`t!j?1LWX|LEXk zxE$v}b|>#teh8*X#I#N0FRNw^Y_li>OJ-Z>tg*+&V`0-S%YuoP&H--$5XPS>fG#kd z$j1}FSHRcoWQW4w`Z@GdqYHR}P~LiQCNjj$Jn*EQQ#dwA=wD@J&!L2e49yJ zgTC)111K=MdHp*k;le4|aLhcBR;^_Dl2#mxRmD@FPx(ks@}rW>W|jdFiXbvE;u;y; zw>r|-t}R6EjfWGbrXyg@Bm=#j)vwaPnzzI@ zi>eB|KcoLUeV0f2muzCuPi>- z5%W0X(P4edL54wiTDNW;J_ipkE6O8%E{5cy$fz#vFFxp&LGU~;MWs9|U8b~McIl;d z!3F0#xl`4?WWf4%&Q&BUkS4?pZ+JMM(zt;r6J9R$co z|CU>Bv43AX#TQ=+ zzmGrmzm)t(9C3u*GZYIpL7x(MRj>cfJMUUY7^W%=I2|BT5b5ya@~7)Rwm)}q;g>|? zIRE71kL`WL__O~D9(%g6OUVQOotxag%x|RK@ z-JfjVefCZV!FitcLFdDSJKoRGbW< zkjpYnyU7Uwy$T%Hsn@^}hD;!R!d+bE!$4p3l5ON7QQ(m=jDd zf_>C!EJS>qtzf4MkLwDHMuYHVnY*}DESZf68^oq7{PXN;c+f+(LR`+qE-u?czb?G2uf2vhLO@Iz;!Ypw^p9wJ1a>I7 zE5#hn`1RbczxrBvyY8}!6-QXr^5x5LjeYN7NXC?S&_f1!=9epLV()aGlkRJ;y=F9m zV?Pim1&snK1EDZqeT7h%(+~>dp<%H&S?C({&+@n5dfN^;^pH?<(?dl6$RmHlKJ56o z5R{xwKVAOp5;+KSdE3h4E2J^S`qy52y*`MSP9MKcmCi15W^A~U2 zun}K9y~M`9^;S}ex=9alVO_o*;TD?S|M3eNr2po)SFKjfT8aGhpilhxQ}6$T35w={ zY%$fUT^k>A8f~RZV{JgfYjWa1_+5{-82i##JMOr4Ngh8`bPYV{k$xQHo6~<`^z%`| z#n09MmfAl<-x%W;bZKLC_o<@?5F!&i^7ZgS#Nbyd;3@OTBP$XG&qIIUHG3uvbIA`N)kFA- z*H6)>l+0t3@yKh{hh@%IVy5^YPE}?e{=+~&tO8@u-9T3{K$295{8aj;{U0^`zoRDt zUXw0P61+MAVdaPgq7!d~V)0+jJ1^gdiaz{^i$u>3b%eCY^y}k8L$AD=3Rm!jgnQ(p zpIxlDU3>l2cFx(Pv1uZ=Y?Ldm?1mj#x>>^p^{G1Wig1{N4#Pg^2#2BK{lD=;Md{o6 z(PMkT`RCc;M;soIZz}&JY;oA>!i%urbgpm*K;f+m8Ir}2D4+}n9(b5N`Q&5PpniSu z27IJnAdPwPMY{oC99_F^z4R(M2o~F)r}(4(`}Xf+9Zo$ZABNSdSKEI0QtAq9>!|)G zEEICv+duz4=%OlGkv{wXrV^M!jc&ZLuZ^gXwanHfYq3tiD+RHhPn)sPiDv^0(uGrCp!a?UB7!0< zebUR9h%azMl%!AGe41cNgD*_~4iNZ8HG&f()r2p}+umJUTb+IC;u=~4eYFn(aN*HoG^sf59&C5Tq27sd(VS`PGW=w4Z#xv|LG~GKspe z=X@CGsTlM;gcN*?81!?TFAz%FqzLruHNZl`wD1s*LC2081=}B3Pd}rBb;O?5b!w+R z+fJgBCVhjid)_2Z{=Z(~)_?UWE&j00V)#%|y8Pqta@MC`Z#(Sp z!>n}pC=uJ@`|qdQ{SQ23Phr;+f0zu&k^{L#Ls16)N1fJf+F<|n2NMXMy!hfvc2)PQ zz$xL80{v~#zfT~Bg|Nf(#h@q19CPx!blFl{hG#g{0$i3uiEkzE4{n`{rF}f zWNQ&_)24_)2fO4s_CG!_)ea#pM0EP;XTd=K7-uQ@B_kEV6b?M)!`Q`_T&#WSvx{e| z3IS%${J{od$D22>!%K$_9jtGk8wswlFnaW8glOH6&`-xFAn7x|{x?TI(Y27{M=bj+ zAiTfA_)F(ELqF&`qkkV4nf`|%m>GYXuQ*Sp%|A=9iwjLI*@u{fi)#M@5*lU4+I0R+ zbe%r_WS|3H6BX*nE)3U1!PEFFq{#GQFZCyGmRxN&(6mBekuCo zf)eN=IUol}TV2u8>g`h-N(h{yvZTeO8|bcc?VAqf92e0e_8z#%S7J~zSM@wk`H`Ob z7wfZ(^-&YRzJm-;m6^hYOD2ZDkfy$73J?0>6_0~~jzyvfamg<~frWAt`3nf{JP;UX z{;N~*wf*}4edt$!0o}A|QyF~UPW{g2EttPe^2;Dh`%uy8r(xHSiK#`2b?VfH;n%=s z&zWPhX3n(r@NiRS{3}fV>Dw$4hKnJ0gMqFZXngL=-=uM4J>b)Doc-gEC;}wPbYLZR zk|cSbOYi?>uy^_gAHL@wEef!mJ6~es-W;FwKQfp?MIfhes7p`CNGLgG7eY<@b7?&w4Ju8^y(J@q!Ju zV4mY;O_uWpUA+$DSiOA`{S&v)d;4#I3%%0*p zK#yyppj6aVVraAfkZ=fP8$4mQy&MM(_`;gc#V2sPU@3^ z-VVFCG{Roa^q{+Zs-qgtng6mb)0X@H_V&N1f8zfm(;qhuG3YgYQ6jaKcx=`GgC=!| zT1CsSJ=7sK)&HhnL!}43xmsD)GpnS{Kii{!hWFgiBP?tLx`hiD*#X$Sh4J69|EZth zD%1X%{-4Z$ywCgs{clVCKhytw=FW^iO+K0V=l|*bmmYN5E*#5lbMU^#=JNZTAN*Xm zLS(2MwYFvaBL*EGDw2W24uMl*CSDp=qQd-C;=o}sQ|g?sp(^Uoo9Wd7DZ?wkfPuiey&ia&}dN6s=*TbL|eY)BM{T$f${kE?#K#PkkTeE7l4Igr+eKTb;>bgs@@jhm-UcvrlS_(B9qry@RWNl1;Kg9 zC$t_6LDyF1*kR?5(>9AOTC@aWG873qW)TVeB?Lvye+ocTypYHrT2f2`Dh<&22V~U0 zDus^l2d6&{`)+&8vswW=#4w}+`)+Ti{K=~7ujyB&p32sjR>~F=2Wn+EF z25Y)&Gkff@hpY^CtMQa)!-kE(!r6Op$#w%U+lTXk+A@HJLz-AcrvKmE{#2Ex&FeoS zKXk*s^j|psGwq-0|No2QpNm9!FOV%m1;kqi#`%`)U(N$GI}$^1EBF7jMWX4q9@3+^ zN9)jIfD^-m$O($1dl-(Y8AmDzaxS9L=>_q?Ns9T7xq=pn21LRpEIQ*)k?D&rf5@-X z^13P@DzV|d+LW()f)76Z_%aAKkbFjl%TLS0qh#D`x$N zV;7B_6o<$r3rftT>FO=X4&~a>4FgY0&py1^o*1<%80e@6S}pc%ZC(3bYh`k2#B9F( z*DPCOH(lGuzWnqHuNf$

^+?#pJ`fuK%x&7_YhiyK-mRh}9Rn|{Utz5Z6`S?-tHq5mD zmd1Zk_5a`8|BKT9GV=fT&VQNq=XAN{`S-uE|7#Z)3I@@2r=kj&U~jNb=>C_K`yGdN z3JrR~7xn({+bp7@8>KX|@Q+9s#(@*wsE8~YmZC`x6hK3MSc+r#iRWGucv0YG0ZvlT zgU-ccp2+z2(x9c3rMOsA;1@d z5$(pJ@3ca^^zhQmHtaDNjb=a6as&Y!JTwIKK|6ZnS*XSlf5hY`)F1btb^Uss4Qn>o zgyEms?Du|v9q*0Fa?$6nWWqJ-?$|WT1`MliRzfaxf(Xu;Aq+A^IKTc0#WsHKk;V46 z5v$;Vhld+paLU|rzt+~R_jOjfY)MgNO_ZXB|H>9d`>%$9e)BcG?aPS>v0+~U2&!At zbDG)?N7l1q{J;`djGJO@2|^*>>KzNVH;mZL`<{G3YT7?{D4zB5fZ3$n^DL9EP~CjiJZW&)}CUKZR6O zJW^W!^NdY@)8(&UV38<2=*_U5ppOrZ1&|8uuM7St)9HKrvk#@{ce|<^c8$4U6T-xO z%{A9yfhfKvtp2m@^Ph-sg?=1=n=lYE(&cAQmnzYxi!%Ra=x@FKGy3P)U?(j+W%^%c z{?E*Rytfp6{$IQlG3Xjn!LHJz&Dk5-_#rmk7I499jz1nWx$~Howlw}y9&{oNa~;tq z)>b5>qccFxWV8WZ22&a_GQu+PD-KZ@m=mM8Z!+Y79`t-^JLw0fv!epNsAkxSJ|{^l zff1eu`t+bP#O3wH_*x%!aUsLJ@sn?2p+V>|8oI=Fz=tDuZi({e;oJ>$r{NxI8r*;h3m9oUdQA(LRO;efE2ET#qOsMd{T6bq>?l8aFFuH{Dwu9(2dQ zdHF?E^cC_!2@!hp+#`$Z@sX?LK__n{*m9pX)*T-7QsvS^TvRCPL_%KHEM09kT}KZ( z4D`S|p9OY4dsl06L<6V~7t{}Hu>eU|FxKf6PlctZ$Z_CQuYq8!Z5a=u&v(&80hM4NtX#H6giB)&B>qa_Z_N41HG{RFCT$-dsiju6xRR8jCszQ zG}$qMVMG6fFQQ(Ftt2PL1+9Nj{r|7`zl{88v&d%pe=`3SVf=B}aTFEx{-4o*M*oQh z{)hVCqQy(xM~(XrhgJNQ9fX`s?O)uP!aXM1Uy0sA^}_5A80dAO)?nDsAcB#jn=8jC zD(dT#a*Yx@{tKEVZg|Ow$@+v>HuK$p%YSqc6dlMB>I3g(14l(g#6R z7ftdnlNvRgjvpf*;Xwkh0!QJ;G|(4Jv)31mv8=M|R7qL@fbRKJ1#t4?LB0T#3Rd6> zm`%jQNe4D^+2?C!p|*(7{)hB*2BNvPU~ z*R*P_s(M^J`2_A_rAt`Ja#$1#LtQ)80MwmzqNpbwl=Ph231GUfpQ z6sTXPMb`8YBoxw=cUA#`V#$w_EFk2%+F}TCISd~3hSiyo ztf~W^C)5n-Gm$eU;`9>A638jvOaB|_Uv$w$R=xuF&UX19d+c%harSHqxLxvBtWeQ9 zcj~BSp=$H6Pw9{$Lx7A5j5kN5v*v2d2rZOnf+u|H^Z z(o*!>l3;7qs-s8&-e7}ugW`~6?I0g1L7bcf7?x;~$2CDwhlZ9agsh}C7xIN0f(&$2 zDz?_225Ok@0c$R}O`^BQysuf>h5536n6inTW3ubrj~NT24M8@`T@R8w;Biby41KuR9D5BiMx)9f|G zpj%li<3yQ^biosXe@v7m)W^{=BU|uZ&X5bmrK_A}k-pc3_3QczZd73o2K(y8Ywd&E zC)nc23;6^fsyQW!+4)^6+7Ty|mRDB#6DLuJ!r*POeuHgTiCtJ?Phn9)pZp;q4`1oF zp*JtG|Ge#fZazjZzWvWYg(}Ocx2b6@I_+-RW%y1)EbI=fBMqkvBk$n;4RU?ERc0)O8A zECRHUvlj6%g>#hAgMLJ%X;N=<^iu|U!Zo=; zMNEdOPh_~1kxCd@cFgn(kqE{n^PHr!?3$n$MBr#ylb01LS3vlJFa1&;(Xny_+#-Df z5`bC*eq1t#loC%Xu8GQV@**t(c*4XFZ05WfFwmd3yxes_Lk96Dd;m!3JATET69!3W zWds9`@W@jD3r^yr0-<vZKCvZJ`9wxcS(cNNXXkf? zfqs1Hz&>yZH>G59IOEoauw1j2dx#G6Hzz;0x4e7MBK!AvUkIUx3M}9};f#~)tc%Z; zyee{m=%^c2zeMV~+e`igCYY<%00&?iY=aT2xB?lQc2m$PxkZ5ITlvpl;SO z#GqG#2fYeDRMe`~@7n+PCDq@v|7YlD^q=W}Y4cB*TR4YlB1z_dpH4LY5k^xUC!C*m z|H+KM%=pWUzd!EyTfBIwPX@9-;^eU<`7(QH3`)}|50UmA8xggYW!5(jB0!rbjd zU5f+=YUdXRQ@+zDX8@K0+@Pe`jImy`aJ5aiYoaZgf(Az(c`s2CpMbxzq8)jBDa3`R z-zfqcfCHHHo=3}j1-{M*Tw9W#hVI?BEV6gUfk*tKaFq4L(@&Oxt_Kw2lzccrDzyE* z$mxSL>5`kMf5r^ocP9+==U|}2n;zT0`rg%S&rZ!Or*w|$>a7B3#mISTlspO_^?-l; zAQa;QsWv9&=}32aJQsajDa+|muPPQeYUy&L6~iLY!z-R>4XZS=7A;%3tg1)}e%t;h z{ZrQ&`fAgR{xkh=d+$H#^AG1{&S7!<`}~V*&I!nm^M7XiajwnGKbiSgH_6QXZyWFb zOSlg@rxch{3ftD41DgdCj@v1kY!ds26O!g4XxhV{i#Gn;gU*qvEfI9D)DN4DG?`@l z0Y(FwMkx#U2Ox(_hxUB@I=t8=QxVb;R6>YL$a28#q)$3A1(xC^j+(9mkK~mQPX7~x zxJ*Y3`fE#`v%E5hTjrK1D3YNHFmg*Hoc}br)1^zhR@Id&{P^)YJfafoF%fRVdU}vu zJTD_+r%ymefUJfG{nO!J+LCFD0ZabOvP+nqds#(0{5XWTKuLOCg0f=R>zv;@k{ARf zZWzRd5ErrOS@?Ajln9hZlD%utVtCNk1E2i;sGemfoO!aH-T5!tHZozJ@c8qv8Jy_K zdCPYS-t_5qH6&=E(t61J=!l2x&9SfQqf}nktmY^O6D!$1dZhSC5XwOFiV5QqoV z_s;FdK+zGa|Ka^Wh?39UQR7`mTHATHQwcyb%(9 zsGnW-$hQ3sDW$NMME}51Y{ME1BJzeLBIJ+|p2xF1gwx!G5SRaq4_<8)vGn-UPO>vD zJX`fhi+S80F*^sLC=n;~Q0O!qD`D5IUT6P$W~|MbJqr&K$Uq|HsA1*=&oa=Pw`?t$R0Ti3b^p`g6~oSVhQ8}TP0jXK3$k@Q zZQB2+Ja!~NZpZk~=pWk4^gnejsv$G}GUG4IDB;e*J4h;J<{wVAK0C)b`hR);U4$5P z%Fll^Ncb(AE!)3t&qR}|sP`X*xX`$!?a2B7W2qYH7s#BhKdy{01MAOZ@cLW3-O3c96gaOH?q_6eUu4+A1eAD`=GzJ=vjog z@B=+A6GK|?vKcVWJ!K-xu2|-!^X!9IHQ?ISYkJi*oALIK_VviGu{e`1-%tzm^&}<^ zqT>8m90W*5xyATc^t_0w?RR#Cew2zkvKKaeiEW#h~A^(EdFR z`4R>=aBP3-pRL1rX9AqT{b;_6VV4t)kukv$)M7Z3X?Xvg(D(!sX|5Sju>WAtJ)ggBVdYT9+iB)FCQ%w!jmQ z$e|fSZ$$;{cg!lX0a3Qy^nr^cWrT?~e}b{3f(YOjWP|i4OhAYWV$fe-{47FT5W|gs z{Fm=K_4!p?vjE(2? z$?vwwpJ#2`=UB(f;h7HNNoLZ=U*yHFHkE(l`YgntFSK{ZZ^YtE@`^fO^@I*5*=c_{ z9s7jSvrhTJADrhU%9O%&#O&>uul+%DB@FbNujyl7;X_4S;7NIk7tgkiT`smGVW1bw zW<5S&Y_#z&jk8fO&{wTmjTnDu2y{wTFKzquXkn$RmI_KFJtQiWwDDg(hKRv%LLbE} zBi{5RnN${xa==g?wk<)6EzhNTe>g*Z`+dKb&hUS9;^M8iE&%dF`GWuty&GbL@gD|$egZKrz z2`z-o{LlI1k9+@Rhzr}0t;(P1c-9oDIU9K>h*P;|xec=|?GF#Sf2fFbm_!i2?!)yw z<%5}xux99!)PHC3{!QRhJ5;s*Le zs0`pGq%|OQth9ipV5D&|M|eljK9qM!=6xd`-9M#`8VzU zmr_XP{zJn+_y0}pzn^>mU9<=vDgtg93_R#Ij-O};=sMm0Wy3f)VTwxM7m1=G&6q?C zB8PB_0~R5o&YuXccx^Bz&oMaUF<}@d!s(nR_h8vDFs>>h2Hi7B;OEg7f_y)eg(kDC zIF*PBdFA5^vOhr#`gH7r{%Y98g&fF(99*hdw5!Rx9!e;d%R^+r9M?91s3rqZL`V*a z+W^jbXRb|t00ug?SSOl-^pgxfab1OT9X8Q_o*mUb+b)2C&M@w%f6`YHfpCsY#>OY| zqf7?+Kc<8Q?8^w%t3V>eyh$G(Jt z&cybYfesIP+Y^qFC!Pqon~Mze+lJYyH89W>mjVwu4D=S)>}k31q%-ba{f{hwBzLFb zKJ8lc3B8I7x)DXk=?k81$~-hGyPx_Tk3hn(8}(rU;LX9Z5_V+OleNtvcX9EW#2o60 z3NDzniT(+dN>TrM7)WJ@GwLf%|Hu^;@)i1DlHn)LcR1G}L*Ls@4Zn$krLQ>u6jqwi zf2RK>^IvBCCDTo2{y}HpZ6r>}Vb0ZkBb@7ynSV3$FKvj;+fzDlAh$F%aGcVGH3J`9Mel(C+leQ0!VuXAl!^_>c=C2o;z9cFGec>~< zu`IV)q-Drrr%znU00M2D$T9%%AUY6U{&bWtpR>y5e!38bC-CE%R7$TZZME}itCO>a zV@=T~HeH1*;^irSso_A*<>wXn$}KzF%I8kTsdpUezkJ0k+xx&=)rF1gI9S;o_bxvG zH-NXHgAjv09@trtlyEry)D!Kr^Uerx%9gQQvP?-IppxG;=X|BwpC0sRpt~&46+P%( z;X!YY81x*c zos!RYTce+N&{a>y4X4V~WGRGcl-+dnsg(1n&QwmwP|q!=U_c=s<>XrsG^X%Zsd6P{ zhN>bHt;7V6Y5_t(E_p%vDkEwX)9}QS#J~rukwMg;p(hx}O!}Wp{K&q?E-tSwddAk% zKo2~#R$L~^z)zXsq@UDJIEK~dyv_Mwo_&7TSJ-2abo}vX-^1Eimp)fwPxBJ;1gF#2 zn+95wE^0=w~^ERxv*G7-Cy9bPfXFHUm;!e%XZo0dY!byU3LMTjZ{UARh zZSKZ4i~kvq6DC=}Fwi@ks70dssE`Vj zdcrU4av2thwzX`;pp!n|D2!u>%WcDL&8k(73T;xdN-5i;dowrCL6e?)(oUbE8P_OQT&#LIYvMtKi&Y8AYO3ewl&{#bl6FkxldOK#2G*ig8^MvHFzduC z7N-C7zR4P@6X-Z!q*wI*$F~DSlA-_qTmPj?m$6l=*=JLIo(Y2u30O<3J?*;E_ljJL(IJlcCd}^Wl8^ z^4`fX(8EqHAh7p=t?kNQms(CKe04|(wOKLHPtgKuAktfk1db;F1WoB5_%^~oeRIs4 zcF&+uGN6O-w$sjL{cf);qdjs+J|!*>p_j1!-M3&L^tWKB0=Lsgh|B3P(9b!YH9(Sr zq8x^`7Kus+&@UB+b84E2;xny;2Yt}hj6wgxGiU^BktjUq+{Fc6anjicy>J(oQFjct z)vH%Sr%t~_l^ol>TT?58MWWd`_&gM2{HY&yUMU#|wB5#HP!Jx5NL{T>eu#r$py{%Z z1$|FaPTm z3Mtj>wBt_JsBt6p&zJx8s$_Hxxn5H8LkpBs8B`c`#;cJ3JInuT>i>ZKq1$rhHj$tG zan=vB?fdE9+lo~y^zc{M_`9%UN84xbz3sgZ{$uxzdVm^KQrDyop~CH*f1>`6XnVNk zo*!n-vM;{GLw;;HwNLu|>#a)$cG#hzb?e$y^zXdwcKdGH_s*9%%(Oq-C8{y%*)veU z|9`OlU#?;~+i&0f)ViO3`l-#CGe_e568-Pj9Dm*n`27{RPb+bkxAViD=H zrc+6yPa%L$9@W4>q|b&;;;mURB%X4c#hLJ+zYGuh#xe-I;MO8~2%!R<3OfRMr>Moa zLXlRIsF6MldR~M6TzJsG7zG1;9q36&hMlyuD|%l74?1=zK~*u11Cz5t4Z6Oil&$EW z?e^viuOm!ll(s>XnGFwrlbws%fZOq~LmEgVALWm2%1p+s$3>!nNg0L5o$9-|a4SQ; zEg)~j5qn;OAua(YQM#6+{wYJ2ty;dyZoay&c5&e@FihN9vE!AO!a#3p#S!Adv=MPo z<6lZG5_K*&T8SzpZMQ3$A_l#bKElNC7=6SDb*Oi?iFAd2#_)4dXFilcZr$*X*w_Qe z74pRju0URGN%`@BQhY@TI~pM_^%dgMYMb=0e&igG0{#iPbWNRaYyYD(Z2$fP`djT< zwa|W$6n#k&6c~Tf0r>CO@j{eS-aI?`lvC}PV~|C;ps-`v;g)T-l3krJsKO76exD?h+czh~$$`)MAHo|OKx;h`Qje5mE*+JGNufRvR)+PG?rP_bk@L^V}WJw$U_Bea^p~rw9Toq`4Hc`6%k8j`3jz9j->NC$h zJKA0t{la$lzh6`T|Lgtlmy*9hgZkE|cW?BKJR3Q3lzs62`#Ae$=AYl9{cF~$VP$j6 zV*ISP>3ArP<8NE;f9d_7qcqCjvqw*Byh9_K^vz@&H0V|i6^&z#@?T2-1;<}Hea;!A zxxMrMZ=ruNSjhbMOX&Z9RsKbb@#S~gCA`<-KYL_yqY3xlsCT!2S?Vy`(*Lt+)T|?P zGTL}!ka^E8=V)+(Bo6!l1IfKcUZQY~0OHJ&Ro-McPAGsE=E(pAi@Zi=MR?G8Bl3V0 z=8*;py&^JHk(H6QM4wfK)T@wnufe{fJQi<+0py-r7Un4iea75rHg>@?mRAl2Iy~qi z8H{?d5^=#&<-$fvrub;`O_Dsq7^Hzd>AtBl&^d21?R{V?yW+-6VW7j%#dSgYl&R?Q zgA@qTgFf_@`z!~#a&y?M$u3zo;0}EBDaP?cp2-Ax0iTqAJ$M~D&^_qtC^U2d+l~f0 zW6%jNp}EjATl=7^BJY<0YRqW5-uN1HX(a^8SYs(BtbO zfGNek7-2PbC>Z{@D@-;PiPD44U0hnUXtNFa2La;Y0ZPl?|B<~N{g24l{{8y*w>oud z%LttFm(V}?l#}h4V~&;%I>OUST|^$e26^?o!uo%t|9g$U z--3R>0sX8_ZRmE*8k_mU57anSqc=NMt5vhy()?0ymMvet%x=5=PMh)l_h1W(42nDC zkb~{O0}rsb-+tG|y*ZvNC;F$lnW*=l)Bg9sKrdaYl#PGuEg0yJzv>$A;~b4({^!!~(W8eoZrsqm`DTg@8hER8 zlJb`-23f6G2_GsFh=8|~ev08VRFRU7 z%%?HSBa`mGxcc~$4-|twcHvWIh(V{|gptP_M=gl;3|50trh^P}ok1rwn)x^9qxm)k z26`UQ$SB4^20B7qN+QH1gsQ7rq%TH@pEE2d>o+Bi!?GAK)IUQxKK}Pad-l=M@-hnm zKUJ!)vLlaOAR{%Pf*0GYZi5^=9Pk-A;D8dIer&0IHIdKy$R#5+5vi-BTkW-z|sjpqR)*c=HpiP_l9jZYWgo9<>uEPn|^1wC<#UcIm zaTgbCv$#edDx&qBXE_LQ+4bTbvCSerR8*q4yzg1uJDqKTcyt=xG>FM@F}A&K%$%#(om^( z{9%4!{V(dje}8y+YuB;qFb@0m=^xQ;mHsI*(BVM` z`U8T2K8?EV+u!v8LD~QLJbTp9ZH;n@7Z5R{k6#YcP0P)_8&fMsFf;J+Qy9^ zZ;w3m=xx=9wG%u5utzsGoSs7J59L%=tLNhf!g}TPsGPO=4z2>KIIYtGMLBY zWvQB}GL>j@U|vEYsY#Na_+-Inds z6~v@3iOyw+%TtzDb}e!M1H;x8$RmWp|G0QmH+6`>&MsMjhkKkebY$)X80hzZM>n$c(DKyo@joVRPg*o{x@Gt#a`qC zLN%{kv2vE(Frci}uA8HL?Lq_j5qcX0aO~V&<;CY#+S7kyJ<`B`$h}9a=62cjT`Z?$ zjxAN(@-azFoVwcv9H@m#Gt!@P6^C% zD(BcPots$Mn%Ko92Ojhi^qiv+K!YDsQY<gogpq} z7clgND&Ylx)s8xqa8;{Rvx*hU*^=eUZNa?xp}j&m4o(A$cJVM-vP4PL&$DGqmkEI3 zPBm-R)b2b#&H2gJtXnJiP%A-_ot`75Km9t&Puo8R(HD=T zQlS0Q>91U|662Z+Mb(O|lC(eNt6rnJmBB*S1@q^r{kJ&(1QdnopYsp9SIN?)tX9n$ zYOndgxdQY(ZA!m~v{PSJp~ zqHI~KfPZ?evSpU+4AKp zY~H+i!b$_Zcc0$kZNw;sxX?gP(Q{mWT^9USt6o*RW&QNiPuRW7*F_b)|80(bLHUKX zK>uSN$9tVRwQx_`U<+V)^8<8ZkiP(6KP!bdLpdc%*u|YY+b%orh}+`^yQ&*J=tyhV zuGM-Z_R;cKCqfeIFwRzCoTckO(l3R#T_ti#sEp&EA&aEf6CU(NjcK66gFfgM;g0lq z5!=6Hi5#n1qnhQQzx?>)99x6_7?ab$l}-Zxp)k^q{XfN<1DAk&wK2#1_#@^<_8+8D zm<_^~KkOqEejeuK6)Q28AXbV-U3#xR3nyzava$I z9a-Q%fP@eiQAhxE#TufepIBGbm=jDg@xdE9`BA+>kUHW+frJ#1*nTc|%3DrUPEf!6;p81?Ftkb+ zkhR$I5_U|LQ>=b432OoN%m4Hzc*;<5~ z=^JmpX)nF>vf4kr|DAFw!e)*>S_aj{7hh_BYIm%)YuC<7hA^$wxT(>QeCnT1*?Q=c zIAhv<_uZ{)mn(JI4-XpU%9XeC&-;s2s8k+#-q$8#f!o6mKWa;tVR8%dSFBvwh77(% z4|FliqoDkxKlJW9v5+{&CL)|_=-qc0N&f>F-(RODbUQ;HbgD-wP5=wkg#`=3e)+@VS0jaX=#v6O%tF+DSsH57-5dPxJ zFYNZ)?sPJg8?;V1;RI`Yyn8hIL& zP(o`)hlTf-OYRU}uI>6o#=lO6(K75S!R;LvV3%nUn7rV!tf~Gz$GL5#3rXrB?#mU- zAXe@zKA0^!C~Bzsw*>QzA5`p?o28V7zc=c=Zpv*~+l05nmvSpdZH-Et2fP0c=5&mJ zICy!H*JP`WA#Y$ohzH*xE`txcy%wWC4)WhrT~r{33|Hj}tRH-wvW1kG!I#?s zw|Cv3c)ZcF%IZD^NPui`7y{=4l$H)dM`mzIU4NVV{o8%MDl#peC#w^SI4XKm(?6I>-bEA9D|0NovK}{xA}zP7^%l z^vh6vh}TgMg}>NgttJIa3KJP>QIC+kM<2h%t_!#rODQ1@7L= zqT4Hx1Pf{9eTw`Wj6+kQ#WG9`c)CfHi1%es_ZD$e|tIXFZbea z-7AF&PGPe7_w2+lyURjgPV`__&W0YvAv=GVsbET~k0r|;MzPFzB{GKD7|idwEq=Ef zal76>$48dHcf<-?W13zSxbPzAz&}F6FA}aXwF-M0klkmdz!pZ#km7qlq=pNO`n^s^ z;z`am_EOKn)wjEqzI2$jAx@90=ugY4>iYEnUZ{D1zCjqEw1$VeO4hX{5BHPJC{Wnh=r*wjTD9gcJP48U*ZZ$_RgPIC!P#WCHs!&n=M_migjbev?L=Ab) z5Nt;|Zd$O?f4oo;akB8yq7=a#i}}Tyyi`XWckjmtLaxJ8n`lgM@T^!@WQ#E8m7&Y-^www)`SzJ`ypBT`5D|9(qlvi{O8=T{l;)R%d z+$=PW3$%|oY?c}OG*l%nbA!wi&BK@Wo{2-ve91xgNfSAVvVT&jhQR=4&~JghC~bCu zA~c-TA-pbK)2&yn-~XfME0gav{{w8ZYKdgAM$0$o5034r&7kM?$t+1-C@@o^f));5 z5u6Ej-S?fh?2=OX0gu;LXJ_Jw*2wyrMGO88hv)Nvx&PI3v^-N0y|r%`l~ai(GK{Oy z3N|Zm2Dx-4qmtO0%ZNRD-q_DixA|Oz=6D!3-ne%V7!qn2@OR;a+HH$y++9qrKDtoHg*#Y}w_vgZnT>&ykZH7Z&WW&jJ=bpj8pPjmZENVm!|b znMZ`J6nQ&!E&8;^xmDf5P49rHmHNxe*Ge006ElL`;M5l%PLCa`XPJ8a);epewzPh+ z!4YyRHI|$f(O`~OZYUdZ>`nK;$fyn|^|*0KB*_B6-9YT=JHrFotbjq>urAZ}fKBoZ z&1t_LF!4gm^?8vfC0TG$tuc$lXz7ZT{&N_ z52qSMoo<^73KJRsw6mjubK-*~9d$_wJHUEeI75i_(h2KGa4;+_@p*?#i1Rc8f+sdaOVSl1#)b07E%}a4whDpOs_KaxeCrLZY}F;!D`6ho(bBiz}dvcN4Asl`Nd3M*zg>&Sman3J7P<&bb!mi0a1|jd;9p2W?{Uo%Ruh5x=4 z+3OUrjeGOOs;*B!U|3fYCr)Wwewah+g}H;=3%BGA!0labw?5!;`UUyuk!;KF^sq#G zxVIUx@(QV=AwkgI!c;Oie&~=~fvs#^e=R7!Nh*%9RwsWy4BTQ{>2GEp##HM}NgOiK z^-IO5F8x`r?Q#8iN2UuZ!;*%m^zxGRt_*JmKRN~MH!huVbv)g0D}S-r6%?@Mmzk%$ zi?(j6b=%#1zY1EHD@S!By(?v||JM87NH5qgRNA4feJhy#A?$Lw))$|o8j?9LC|Qny z9;~~tW~B5{!O&yr=s86Ky!$j|adk^ooSorQmE05!fiYZ#r16?%@M%Ff^Tm} zxp4h3-t59s;2BUfjAwXrhMq0MYCEMASQeMJj9uzo%6n};%z*`c4;lKxWT~Z;h>69( z94jO&FlV&i7scb|z|@OAP837ONWEvjNwh2dtZf(`kw6ls%4U$*2Y4Y~lTl;k^k9+q zUUF1P{PgAwco;1Lnn6$QiBJ!uN~PEJ9P5*=ZaDlzsflR%79IP?I&|yLNUWG!jXDzk zW!8!Ntw+F@?x*wSf7=PPVR|+W$Zr1$qs8uvc&O}bKVtb);)!JnyVP%^<|cJo&-s3+ zaUj;$X3qci8lOquaoXx`g~HH(FIxt6PbvCoh?veZ{S@7A4Jn$w9tF@*itDJGS54&n zefPVl3nctT>-&T|T|Suk;cJl0gTop5Z0WmC?XcN6YZHW$%PEOW9=%(dwM@Wq0-RR!Bzh&2L=3gv)$MzZi)PUzZowJEwk9 zSQ9^*`eNmGSkyCQqNPR93*ax290`AshD>pLL_1Twl zb8^9uqNtfJoi|`nr`36ZW6z@Ww+2u5_xf|WtlrNE!ceSivxnWrF3g|xD)p)J*u(Jp zjk{E#Vv15`!Sqd3k@C_EQiL*bc!am$=Sj!^9u(+*1=h44zl?0zD>r9mmuMzt;C@g6 z-G$2BA+9SK9s!E)Qj^l-Vy{~0T_k@5KbmrY1smM@he)WySV%mr4$aY`LyHL&>L{kSw8)1 zSJ+0(rHjjVr0%e2>97FIzKzG_JwTzdN^j$-nc5+K`#fN`Q49?%PBKY*URl;p$UYXv zi>($KH`@Eb+-L4QgobWkK4q%;*uN7zb3ajU(X^ylJ{ffsd*-KK; zK1`*et3FC7viy^^c!weyL&I}ypbPR>`#YJfyA=PdO)Dr5U#@_1YsdLz|_ZbH&lixUD zI#IR>+Y&?AjnC_1W5V01Ee^h#{?R+VIeI{i^UL+5lyejp58k#|bw7UKlLZric&hdB ze2oHZG`7)))vrh@z8ZuH20T z{oq5?8Q3~=+-XY2?Rub*7#3Bls>_6{@R|GRhZFD-EUHHp!7x-Trkk^f z?QtTuy5>?_u%kKFd!}*)lkiF!l6?%1e3aqj`pqjn!s&d@To05OotP$c21`Z@%hQp7;CR?pw5{ zuFKxZBb!wxMRDKR)9!+8qKw^p8{+HBfT$vko=3udkFA~%Xm&fxguBN$2kh)^l}T-^ zuCO~cO-wL87BgQh(D*o4>)Y;D{5#xov3m1^5Fyw-OO=WT*}Gz$p9bqLZUE1N`K2q? zJzuX9c@_*{EmQ&i3y0vF0%^Lw39ss0*&s>j5u#k*`?GJ&=79$LX8Y^aZEc!xG!DV+ zxuoQxi-t(UvQK&bGxR3e$T+Q=6S!0bJ};Rsahd}s5p*!-?4B@L30coNGn#|$AqMbg zm*tuOiXX!A%LZdtAG=I&VBNvKzN3vZf?GvfEBBh3BZ!aO|i|~AY zuFz6OdSJ3a*5LInL3>_rA*-8U{~)o0-+^(WnN01iLr^i`yk0F5S$NfT1zoQ7y$qC` zfAgEQE$b{2hI(Y(iN}=n#Fst=BZRgtxBK^^1DJy{$kLB?6J4 zHZ)a31YSLw=K>`NQn?U94fN~=sBwqZWANk!|JAZwMP$kX2s2n_4*}(VB3X-Z6ZrYh zDnUp$_y2Q*#K(%tXW~&9i)Dx#?wg-{^_D|HxyWN@-c2s+Tn|r2q((CzlF8NbN0VTU zj}S))K@8`q4I#$QqfKJV+S2<{GDrF6ks=ElNl*~@`Sk(kfVHfG$yooTb(Ic7&(Y7w z%2KgRm5j@${0bKqEYkbmsy1r8WpKyd<^ZEl9#L0@_--+{_W6yng~SRb$NeWJCgQol zdTioEORZZ|GB%F;6XSxj>gItRcw0+~KT7LH3;xt>WPXSmCWc~i(eE=3=cAk6N|G=J zC`3;W^I;+DtKH!2jgZ-WNP+I7MnSgqlyq_&dH&8H2{o{199z z0V$v#ul??L6-dWD&uO0`yTWf4X~`e{HGf*}`O7^69mme^#w69snEk_4hq}H#lP+l(u2w{)|JA6-tQZ`&5KeK#dhC-}wz+zhX zOP0uyyp2FAql~F*la|@1$a1REf(X}W%e#Lh8ty#4QRYot+rK{)fR|BHeZJl3yYdWZ zadW|1;#AlTlC+oZMiI@jN`Ge;n3*2PsJax;Ie6pCD+D{Yyv!{oZsQXN22r#(1sg!q z+XCsNnVs)s_tT9;8Wg&_<5E$>I0tv6tfb5~z4XxJbu272evP#7U98d}s~z@T zZZ8sZRnY&ralmQXTAE1 z&pS9eT`89LVY(rcMI3$`PsX(K-!I|P9z{vI)q3$GU;~zeSA!n?_L8@a#vQDndO&>S(W$qhiJnZINWw9*p)ilEu^jQ)x zB{~Dv$$vBj)URLaT_rkkGqI&8?v##F?Ij|s1MdEyX|<8TZ%ilCL!llt-LzyT626ar zm2U!t;*r%BfJSDwK`m3nkF&ZH0e6Jy{1JzRyX<|`Mjw?MUlO$MM|J>VZ)5&ZC;Lq@s3>*L~xgBjCQQ;qOZ4j!<&hqNz!LJP!G;0 zlFlut9q9PwqR_kW6;FgRvV2Z37U70y9pQo7Q)%tRliM@F5FmIirJEr!^U*&kndga^xUC>rsR)!;XMqnNe8QO9`nB2wxX=`x65%f zYDIFNd%Jz{LDHH=O|7zZ;oo4lHcXYDK8FYyxSfUtJKpHj#*LF+-Zyv$79Wc!;MDHT z=kiv^&+aKDZP!7d<#*lD_B|NqBHC*-Rz-=+f43h2l@~?miwW^h!3K*xN)M`^uPNNyTWA&w?4)xlK&=+KB%r-?KLLZ-ZP}aqwCC z&K65}-}jz4CY;D$-hR;f=bV2QqM0mUYSFO6lVQFdc+m;eL~5S`t;-)iLu%TSqVVMS z_?W`z9AE5gI84c$j`1RJg>0wUI(|giP`RQrl#99!BwSE|?YEM2uWIKi)4as0(M3(v z^RfTe$~|Pd<}<>>#N&{(>%+23caSnruK`LOPHWdzLOxD_sKeAB2>!$BB$9@}l-3Ec z9(aAN7Mkqf<>&7Tj!@mQpD$34dEv6x(Ul_7_IEwe<%oCD_yQb3QBd@d z7u@Aq^S@}J(<(u(qP(u!DG<^`>a?_I=O-kUwQOSAM*7;h{o+T2U7((Mt2=d7qGm`+ z+53|AUW~{MN$*o)mQLU~yMP>ghe&W`Zc4U324V71ZtA5EW~)&V8O8=N((_@IizG2` zd&Onh7OyITyw+Z?lFjiaP16NG8Pf)UN6Hl5h@&IF^oUP_-e9kPS2KsH{nJ88SrY5_ zB+$EbUnj_1_9#B1UdZ<@K20j<2GY3=nKu5eU(r;tbYwP?f6=5TWB00kBw-?DYhWo- zp*35U==EE+B;FL)Sz0pj$eSn-1E=1W`@proNjw=1V`(ycHr2d4LAiSr^SGPHRV;9* z^c|D?+iO`?;+Fc67O|lf&P16P2Zqf)1&lXM{K*Aes;A)bk9^JJf`^K>?@x&&^Igz8 zpaQ7s?&Hy%$eD*xpPwvDWwuCKPpnLZYld>stQO|bUxI7?V_ z(Ww}zpOSSD{6^1N5mx*4QSdOIlP&@9Gw`LSbc1cRJ!v?i3Qr)JHx{@6!&Wciqn`YT znO5_JDP{jMW+baysNJv-Wx@5og*-QSx;lH$=znMGTb1nK(s`30gP2ytnA$|8735z= zk}z&L;nKu}9xemRZ*w_pU9aOmneshbG*H<5jfd4n#d46}>!`v``@q*|Y z`bJgE2MHR6-J%R3(;9J~qo)HkQB+4RiO78~W(v1!qn{W-2hVFpW5VG3Kj4YGn?;(S zZ$JeQDDGA(18beIDy{Av=4J0Av)=ljt*qT;Xrt~k*L=>*!u%(y9Y8>|8lRH2f97Qz z6Rs3FE1q=K$y)l$VNO~?gIFa}Ce1@Au`fa0+!%KFlX!Ih4Y@3=_y4-U&Ki`lQ>_XA zy97?YYr}r7EG8SC$vslQjUzhx)HOJi4u+QMn}_3>3PW_6zPzEwpkqr(Zegp;^}FZ6 z6=T|MYIWseIAUCMta&I9XktZ$lxv`EpJ3bao22`wn=75Cvrenz1qy$G>%eGgoI4KUEt8l9YC2=GZ#`? z737>QKNBH;J{a~Ke*TNTzQzN`XQyXJh7KawBbRtYb^4??qWoV<+*@ofeOJWH^N|6@`L>Uj z;C`lLc%*`x8yFNSHfoHt@zRR^fG&TbcLhHTO7AkSCmSn$xBkQaDs-~+N11Lwx>LUJ zKdh_5a&o$N?>~{UHrmbO7YV0QTob$STFma3XWl!X(kLC}2RJv}qrJsS5WjxGDKG^R z-r7#MovpDu788$hVf>3tu~bKhXRv&h^inWg(!m>OXm$!Hh51{SPZAEl6i1yb4M)ZL z-{}Hqrs1_Rn!~p68GMdez@AA9fU?9*Q_R_q8Qx{O~$&&zA6T zT}^Mgxj}Xzp0e=34V!QNhm)CwLeIOGEIF@(739Ts`oEy$K8VZ8N#C7%aC082KG|RA z8gJX;|I31Jnj@7c3|R_b4<@LTbq|y}yMOj;q?CnTs_Q8uca6sN#^8e(n_k6HGzEUx zlk>w`bVdLohQ+N|7F6MlrYnT$g`1l8*Hk^A*O)}?!to46o4X$hJ?UUm>%OE?2-g|B zm)p;}mVr{W(WyS^_MhF|$=Wz$<0gcI0}duiNM0$-t(b9i_CjqNMpH2$4xqq=)yl;d zMk!kOq8$6fGi7BR+|ky-b?<<+4n!~NPmEy9dkKyM!o^1N)Q}|FKmGCu3nqVwENBLf zr-fic?y_E0^jEqU-(+=_6bNoajD%S$pfj1hgVKm?6_}fDIh#yc`7S3z6sbPb73Q}~ zgeHXyL~sg-avF)iV}5I1TIOrkV?9F>0!+7EreK3!6-2EYi_iQCbDP}l(8ydpXhW&I9J_CZ$hIpjKVi{i3Fwy3QQ(wsK~ z+h+Yuo3LpMLq1N57&NM;;kHRb!j)fGZ-Jr1V><+gx*t^4ImcylYQ}KyLhzW~pU&T$ zaECq{+jK^z($a6R{TI$&OJ@C%&oaQQzAF8v7DJq}sX7HG8=teSnU`&#N1U43v$Mo# zCK(I%95Z|uDGrq!_Uilh3=rmD!Hq+xA`Th~WmV(Z?ycZn^q5sGZs+TV7QddXY1BnC zLkGVoknZ!U0`oc)VF@^Sjs@3(Uz;Q1F;Ok!q@PHu^df}6b^sQ`QG(qFlSg%rkC^9J zGHJD=(;!;61V47`LXYjEnPDbQ=#o|Op{Oy=QM2R9tia$7Z_=B{b)oRDh%?MY&82gp z>6s=nnR`v6Qz`b9(Yl&$0khOiuX2lg{{tS!8*$MB)Rg3$3*A4_Q~M6WO`^D*KRq9E zyjqc~xvd`a2?MIF&5M9EZl2WMe_pVal!Tt~s9&uCCwPVZD^TLYkqdps46e zcrL3v!P%4(X?w5S;Y83#61zdE1ii0Yhl{Y7>em@O)<6unuMZ_Wkgk=n zADhi730IZBV@*0<2$)t6sZ4YVy|5-6n-w_MQQ`%BW?b*c+ zQW%-ED_H8H9ns9cX~lk>DC*KHy+-K{ zB_VrA3Q4F#cOv;{UiA&L=Qw}btL@D4QZKI6u=XOv<2o1}?gy6hi--qRh?xUY5Ddss zsK-L{p%viv2l*XW#;u6$&IWYWFn6jNZaN|dfNm$TUg*!c)lGLT43J zBvn896FtW)i&4eXBG;4*{mQNSPSgLRW>RGu1_Az)P*p)5IsBv1FLwdKQ(2Ga?K$h8 z2`uixU8$#1ubXqd$8#k-&Re<72NCU~LyQi+zf7b&bGd!Wg+GB{UKt>f+Mf)cNFPiE zXlZu}Z4k8Pfkk)tz7K<$RQ!htGze@qy_Z9qRQz=;$gUwxXMDoHWk}=k0s%!PRQi6b zu-plTfooR>{QJsGu6sF+U$K%XtDgN~k@obGI_rt@ufeyhmMalTkG8lmv{89 z#?AAqGw)VCf7AHMLYq}=7=iMN4|pRaBt&q-L)&jO2&T%2eZGzXZZ{et%?Xd_&Nski znrTrk9%fH6#ONA~PS`DtxcM4%kX63FhGJ~S@){ckUAvg`E8KBtwYGeIaA}#rJ?cT; z`LNQzcJ_oNFCB4yLNvN-{4Q7yjN?b7cu#A_mpuX1?g+qcMEQV4v}{qk>6PK z61v|2xCZbd&%Xf9YL6BS_-95XIGUZ~y{BOuM184|#QS23Rac33AIEY68ir}Bhw00I zg_WtyfKyEO@jZY3&A&aU{`B^DY@}f#?|Iy-F}4s&oE=h4T%NvH6w|6k+@)>U-+A#H zUzhL=`i~6aFi$8;hMPyc7FWa}b=MiGVPBXF!Q4YckF{QoV3-qehbX zDs`idW+yBGN&ioKdXBwKL7rB3+qSn`C@XN^ZM%t0KH@Bu7pJq5fK{4m!8RmwKf!%f z%iWD4EDMOB(I0pcVfeX(gH)x2f~gdTzvm6hF(kY906TBm4|w>O=GnyunWHL-aU<)zHyXm$b zpxM@DP|=@GW*j37`>7wN)O^wzMFq2-wRd;3BLcTdW8jS4FPI9M<#IIZ;%0Mezjswe z{>=jBYN0fQa66;VOInC_)htv~nw={tbER@IV(#V@60cMzxKELt2L-!?UG|g3nZa52 z#3UpK4Q&90k38#cReTU5HbWs@!g^J3%RL7_Te|TF2b7PtZVYqNrWx{cMp`82ER3E4 z6Q4-Zne`H&3hD7Dx!B?a`spdfRRZh8=fsJgzb;$;D<{`K68 z9Oo2K18`^G=4&d)mx?;DVDZ?1r^e&x;FctQM(WPI;Fm=HKY{jO51<`Z7uV?8P{q>5 zxlhPxJ|#y^^HBz2u3VIg(<%3lgH$3}8l`72J$^NJxEx-gQ|=$Z6TpV-qWZyS8+lHh zX)MbO=Fs9-kng_D-e$H3pyH6TZ81$C96_5j`w+%SI`^c}n!lcs8fo>b_h~i6m0>3T`{us294^|z>2hAx&zIjX5o?T#zouC?Yjvpd*F&L=&$Eu z*i_A*J{vj_fm+^UA4iHK!?6Yll`x*Wx4@%XVPB8+xRc`ro{$SIsco|0goO7^DyQ)2s-$rUF+ zV>?U%1-Vx2HEc+}dMPp%BrgjY!v?;FjElDsTMIrclo>JJIQ|5*aF>-dR_)4}xwT`% z@*ja@xc#8oC=sBG2#Q!4hx%9oB8lC%aPXIEPG~u?h&5t5x_ud)Ph2P{Z@T|PSl&S^ z!TD`mN!dl;j2@)Xet8GW)V z)Z!4@fCe0iKt;6X;l5=(D&ZlmJCGy`w`UgYPd3+6a>>$ zb}%#@imN3x9wGWV4v9i7=?R#3r%Zta5&F|^ZZn_*a}Ln&%G&Vujd#bK^&%N#!<*en72xg9pVH}6cpt=fJvOH!q8V~#qm^4jU8X)l=xSy*KIAf)kkDRqC)A&QBt2ob%S(>M$B^b*jYutjkm$Zlz&Ae%XDn$Po;aA8J`3li5F66b}lSlPizAYcIEd2#0Q()>)GJ^gq_$8CHmo*7gU zDT-0)@E+^qX(<8aNf57LMS}GZQPh_717rXOF~1R_kiL&fiLlWt4{^u)DNLayQ01G( z>jIFDZiZX`Aw)Pq&C?t3tlKomdSm=0UM0flN4qZ~iOOUh?r4%ZV$osIFL3hj)O2Fh z1;V46o|rx~9?u)dZ_3=5dlu5@|NeM2+^!=F**+OXI=2sdMAIN z^W(o1#=myj`rilUUp!I$b-0@d8gdr<`vN2mjWX&f!xMOD!vl3*(02F0=T+XLklKjF z>wb9K=4KL0;8yiZLN;o_9PlgD*AnSoP0Tz4rn2~0n#A~6M|rV78Bp_}8<(-2$_i1q zPyY>Har-8D;Y*sBvBCX?rM;(a`UC(9A2jg)y#QW9ghaQ!x zF8z*z9M>R5>ZTlYjg{j*{nzcU@NjAR=a|yT{=^Z`{pyLQ%-yXE87Pi+3B9O&XcWk1 z@q@V}bXc^>ajiI2K`1xZAEf@Wz$Gs!`JsJ;CTe${RlJcYN+`=lg!TKr|^o9mKND)! zSqcVOub33CU{*K?j1`%a08SLgbgLhUbH)VU?ejmgfhkacBZ?NMqqALEX zdpBY2xtT(dNHJJ??g{Y4*fINd!$WZYg)*(gM$W)jz_V2sW?Wp*rQex02?7Fl6W^(t z<5;`N9_H3l8?{9F1R?WH48J$`XoM$>8~j)GaJufZp|!m5nqSRbqRodZcKj&TfAK?c z#q5x}(KGnKoTtmog6&`sny!^1{i98w{qq4z!!ONL^q3vldYFH$&_nk+gq7RF9^eBP z&(+XT(|$XNG#AVy{&Fl7+ykn;GnAHa+j&;4ER1|#j_Sp8V29mkCH}^FjsB6r z?h6*XLInP!Anq|yK;5El`gS*Y=i$Up&(})>!_VGtnbC>Trwro4=yXdlQ z{;h0qZd|al)Nl96%q#-I9=p=2%*x&+A?W62YpNf_^;-rXbpc0L3YYe(dDQgPZx^Rr z*N;!8+~ClMA~Tj^xsgqCdfds53~x;mV0&DgNR!w@Vzb&XJW?)qglo12Ai3UJ=mn(O;7fBX!d;vVJBk6eaof81hyLx_X);(>@Q58`AJEU{a0OY2^5c`x z$S2?o@TC9Nt;SrLjYbN!%D#A7?Y~%mag%AHMO~A$wuvn31ephufKt8#S#3Z6I$oE1xyo1o}HeokZE-<2lCWvF1yrG--VN_bcGs-6xH zg^HCy(}QgH?LH^xQ+*BCQa)yGgXys{g5Xa)BaU)!_T(Z^X#p5E*9494>2177cwr-8cG5i@y4DIO;+s>g|=fYF;)Fi_^xa?ZRa!tjg(#A2p&Fz zb_OdG71Asn&QHwZGNLu#zR(!1S?Z5w?9y!ZJX$VB&^+daUq&8m*(=z46(tEgea{p! zN6{I54(>+d0C7;B1?IW<;6NA6els1=Qhx)fElfMyXA;bJEw2AEG2f4x7cnyS&f#eU z5;ah6Jh5ti->mtTRboD(^<3;UFwx8EH?|*~YG5(}`JE33Qtt9CuRHIjGE3#|-sLzo z)w2BBbeEy|Ez5zk?lvGbjXK-DX#2`xW?N)xYWiET!_@Pt8o@F6uLd@Y)zPZej6*Z8 zAl28MH~j-4b6`7P3|y4l&!JT{XnF0ZAg7se;mNuGcTySK=>GPf4QqB4R8!Kx^zfy; z%3E;9$sfoJ%Zp4FNLdaxhtW)!*fK&5C z(-?(5l8ly?|7n>MHmw6%(_Z&%Y;{awuL;h&eHR_JVO-lQ#7A?N? zcmZ0LJ^0P}h~`t~!*}X`Uh1!$9htiaSiMzJ$7A&@L{xM;qnOWz1Ycz*#iF{WWCPaL zF@8$F*`WuA_&??~!x}&N@otUV|MlzbfY!$mStp+A_>?4sbM#jahy<#}a{LRb%3CIRyqdivM9T)~Z-+IncaI&}ye%RO7 z+?-#c+8&Oe=mOtVsWCkoZ;kiDvpWenW>aoox>C_5Rpt-PlUdiIvWf9NFsz}MK&Jk; ztW!K24^;GjBzc}LB& z?$CmkKH@g3!Me|y*F=L3r8b2d9zRpH0$ttyGfe~K)tQXX;9v5Fpu36V`zK>n@5S|s z2H*Jjp`QPdA<`iz7~jA{<5PtXHV9xVnv;rri_xgT?3AC~uxD`fgc!P%LhpaR8ywa9 z@|x^V;OG2S!ES-!i`=@ue8A$h1`C*d@X3zJDk#i4nS1H)Z&}aXN_bW(YVB8rSRx>? zEol5KTgxV}!q_(SYHNzJIsjYQ%a{1%H2b-N9k=FjIR-tKB+rrLNplo!OiF5Ev8x+n zndH|^-v>&!EC%W5tu4ovN@m=o(yxYdEbaPrWb`pv)U)qCRn8?&9k2 z@NG~qlyg6j#%+2b>$|JgnASAojhGINmx7>rN{YnQ_9aRAuD+U`p}(KZvq|G;UKgf< z_P)HQY=A3!k*x0;*HN8E`F)7S(;K`$;h|kgFJ7J792SUpMSMXm*s8`RJOTOqE1jVE zGi&2Oc#LP>rsw}&-n>ig_}5^C!4}WOZTQBw@SV1@-yT+z$I%F^FKVbG*4^jr9x(UU z`gPVR5%9NpnQ-;)2AFr8wXWL%FNTuq{jUJqoncR&ya1c3n{rQeshu4wA~+j0I~S`! zx=R{Xgt-|oj_y|9q65@gvnKytmi*_!Y0dCJmQ2=W>Zc@QLVgu8LdJAo)Ls64Kd3=2 zo*9`R;9bgR>F~WBy)Jx~KFcxlf(K$ST~>I~qHOupXT^_}ZRA)?jq#62x9-MW=3`^@ z^$^WjVrYUC_PvV^74EMjX%nrQs+%Lp#O@{Y)Hg;%yf*JGZPieG;?ipZ;_Lvrc@s4) z#q(^xo??QVXYixvI6s8V1MfH^o2mP#HNW?s63Wq{?(Zu#DQ%oMLVnY2W92`@+z`)J zkG(KdU79eI4aa20`^A58$4z%%Uekld6dFIjI||q{YdCK^5qC7_Mjv?I#B%g+M! zT#LcR#4dLc2&D{#qrT}4qq9vE8Q-xt)W(nh)qKe2sj0ggPXTzl;4*-MHAlI4xN`6G z{s=AfAVdAB!v|no<+k-)twgbVb~`rzTF5%-^?%baBr?5uf9_C4@YMVhM=Vh;JCIr` z!pBP_nXD4Ltz7JMt?`+}MASEH6lp$(ChoDhbrdt2dd>{4zJuk>BE(#`(9tV0t2uP+ zQr@3(CB3qnYYK!tzW6KCtX7Xxm%ZDyoDu@uOUqn|@2I`;~5ZD}$Knm1Q>M=8QB(-`Son_zMHNf*Hfhzvo31IF!A5fYI{8 z!YD6sl>-7|J$J#Av;@5zVoh0JMp(zaXP+gVi7qteTiUn_^>>jGVJO;g|p#9UDC zIiZ?w=z*@XwMTj=w~UW->y79(;}%Iu-{AhUR3a26R%SZUSfV3^3W^ehES*=mXPC0` zSd6W4!O}8;UPmRxce9hWSu{ki2%vhquZHRh)#RgMKT#8KFOp^n4eT|FVBx_&HspaF zXb%lkjWi_(& z?*kvE%sF9XX=3AiaLvbi=E1TGE5n1zW2}(@WOv$B=d4$vg2sdU10IRfZlX}!SpCYn z4tJQ6+5AN%V*$y^+3QAvQ0p=+rsF_D`_J+hh9(jY`Bzm<0NxB6 zHXo>>O!B{~^JMiE;rFr-m-xp-Q=d1eOOFnoEQ(zcC_U52iz!9P?UA#AAEk5f}g ztndaq?V+0_`|ks9~j@hP&oVx(x20S?RZSa z)fH+`^MBzn`<1b3chxZOjhxRd#!cgxx6$EZOT*E`BqORN>ogF4=}T{!47u&R(?$<@ zb&ZzqtqA2fmQ(1^X`yh~nbtQjS zwm+3|9&p~8;|(z}Pj$2@FRG{~PyWCc&7>f9#i7LmF+{bW!c8Nb5u!<-C&WkAKrY?= zw}fToNoa?zzt?yy{^INY*G|Vgf!l@8;@Qje$TCVkTVe^-w%WC0kuIClbVaD$14SCA zOQh|Sj7yrYS?R$I4K(4$+s&svAsK+R5!2259OvOrfPHO{_QVE3Pir&sHj6F)wY$v; zY$nz)_v-Lrs$hyJ;?G0xkE<)Mt4f?&49Pna0WdeGSWo5Z0e!ssm+ zsPczuU&Z0U2IT=sq-~wM(gv%3=uK)Gf1V>P3#JwRnHutk+RH&$~=J9^I zz%c`QI}qodYjQ~9C=0jkpyE-!OZqE03p~7sbt*>wp#C`h$&p=6?s7GrJ9w zm=DJC;2RJN;0cAc+&;wNdo~OLvuZb)WY?21E%SZ|jbvpcb?aZ^Zf{=(LFK8wttisx zMI?|-^Ngt?((3PPtYT3PQRat9Ndq=250VvoT^P4L8cG>Kx9hwlMrsb9q_5s(rKNz+ zYAm&VH#4nnJmxHk(6ZII@+U4K;Gbog87`>F7<{o{=NRx1;?ez6+topi(-Arg9%vc_ z8&3fYtx7fTroQAjX49O8jK}}H6Uc3eHW5RRkxtQt74Ba*cZ=FFyxQx5q^3|?e()O= z#_mPG7Csq_i%n~eyA61sgP8xwu5Da%c}ET6nVu*aj7&^lYiu1pcktowGI99*W`XMj zs~|Wg0({X4Rwt9bEG#(Mzc;=E{-JW$=Z^tX8c43bk(+XR#f@=Cf#MseHKxR8Fuc4H=IFUF#R6xNOz9RrNekcsvj8j6s zscc1xEoQd#K9YC`F!^)@PJcV>F z;`vO%9P6bvL&U9I>DQZWK+H0POp+q>CY&*;q&)EA;Q`=~y}59=1MrTQV=qJ z`);O#kFV{ygIA*vj?+1a$&_9m%kE9yedja!RhPauyllvp3BtvE(rSO>(f#{$pa~(A z&hdDfA%|VpqdsK|G{ExU^!CsEt5R7%w=_gk-^Y`CD`zmESfTA=dqG0l0fP|adhGiJ zy|kAC(lIf=&p;#Wi}7cxUa8<1`&6B}TfTc?;kTNH90IXGEz5lU_% z7xq;8#@NMb$0=OA8Iw#C%5`t-o9TJR3Au+_x4vb|AJRES z=>aFj90Z-@CQ^9H^}a7GuwNd}Qg_pIYGCei0%sa?iVD9ZBjO*{Z(}>3)IWPU{%32o zwX5Ob0J5MGMQG5hCiIp228iY#Eb(z-)GFbb6yfPC9*CsghKnNq$wdKvAPUOCD1RwH?R8@m81si|sASO7ZWC!RexjO5n!KfaC?)1ZkDU8<_M zqmBpuoK7Ahbs4-liZG}8#jNWtyuJ|fS@nP{!r14YBYAzCKgQ9Ls5*xRdX$|tuLa}V zsK$;wvJ*>M)OYAFFfx*KHbUx0CL!JA-=gMR zHOz70>~U0g90Fqa0Ze;}rFf5u0t=qurlmg#nj)E*d_kak@E9ZeJLQUjt%v`p@b99R z^qlxJ5wFy9d_>i!*q$GA2L$50V{-W|7BIbeFi4>{cP$n;JRN1~m7GQyh*Ssf(V*U~ zh=xfQXgZu(G>bknWZO0fr&hONHC}hyNhR^1XW7&HsXoCw-Cr!dem(=XziZ^0oo$4w zrf}Dkmy0P5`+l)gvM01rGH7Qq=ayI-L8gvDN+-`tq^{7h9j6;%9xZFo{LqToK|{}Y zNd<&}-!@Vb)f@exhX+VY`TM%>bQ`B5+G&Jv{p$A5&~dSjW%9s`xZ6<}j-OH3&rsak zU=jy0Yy`;tF$?G5Z#WkD113cvG{c0{#Gu111pTpp)+ z%BzdQq!2Q^fneN@uCIDGuUICpj&6va=7mI{*hjqTgZ~C^@!h@?>WO!~UlSm%;LgX^ zX7`a9LRjP9@-#iMQ8sq)xt*4saYn>^c?!`ej&-4Rit+9twg)PX0Qg^k1!=$aa~GwW zL^TM_9k?qdZv3(}^e*Q-nGy}f!?Rd-(e?cm=1}4f#jbkS4af{G#j($XJQoPda#3**cHiixnc898X>-POs8DLcEy)JoSy3D7hIVNH%9A%4qSU$CzrtpLic1DZo~Rkv3E zV&Mzr(r@z>f~I4B0L(4^0uhm2fmyymf5c4K5581BENUlVzn(C3Z1Og69bt4Z7T)hq zB;$^nYyzlJg_AFhk;v3-)1Jw|%3=7MARr&re6GMU7T%TVNoDNNG|w8mirQ&*t;2!d z&ot_`f#sRly8;n444Y0>yo*Y!x=|i&`=#oW#s69Fv|nx1JY3b(R0`~5dY@qAuu0*$ zlG1_yp~KB*fI`8Cd$METHqT8@v{-e<*&T2CPZugv*vVzV*744?AySc!VDph`UQ`1~ z!vN&(s{*Z3pWlvUc&#zm_|KGT($6dWoVj*Kq-WLeaI`;}8^a^GKQ-D1G zq;)<9d-qE~(c>`an}|riDW)~A<<<`7ZL6#q+^b@$bJ-zcOk=#}uIoujF7&Zt0c??z zXVTX3;B}B-!zMUFc>7aSPWm9A?_@HYm&V{W0;@)EhPv;P6vLSu>P$43ps9}XU?cV| z8l+(ldtL!;;a6-T40V68GE=e7cCXGRSy^Be{mo=|XYGn3{0l`de_(DJEpxR*YS@H1qK5jN*wIm zqZ3qKQnDOy78C8as-_O6*|OP0YN>-!ht4kh4b5zO{Sw4@#_Fj-xx%HRNr)^nysLi? z5cIFp%qZNZwtVG>@qW{0uz=YV1NrYwMqvvT7?V0fXcRqKEF|R(dP3uF9%60#Ga5>7 zY~joRsa#g zFIlP66&V|6QR8?%DN4u68ZuF!kC$BAg*fscmbm_CbpeLBZPN(}2c<#^){*YRIyGW{ z1>!|$iT_)qc({1ur=CSNrjL@|SV^%YKeN=bw7s_6RAJ3SUCGCEmv=<(i@b%)| z9LmjB@!zX^KpoWrK3I5Uuq(ElDd5(m1jq1Z?~y9&{QRKaTwm?Zx<4y3DYtnNZ@Ngz zTV^D<2EX*tEFeQ}j2XBT>slpu{BBdWg=e>uIZBUjE3o{OcJM`B1iK(knf6COQguuC zNZt*z!vK%`JkX!MyU0!JVnx%wV0I*?G21dt_1Jc9yUpnbG8$=P{O@10FmPQJM~+U+ zk>3Vi=}&=H8&nVel$baY@#b9O6l-d}gHcHv*JSZ#9nsW)p5P8172jo9%YR{f?@rLO zHD#~ypMV8YS2ER?(3@SHfRQTA+1JHB7?3PXARhNY$sQ7<`%RW(7r8c08X0Vg;i9ZQJWtd^zK7FaML`upeZYd#Z39OvT4s%l7QTPs-8mvO)9vB92wefKZ{F@0P{A-g9Zq&q+ZCu z?~)lx8nkcEdp^?3DEQVgfxVWLu+;Qst+P8@cs-Vpj-Hz=h4G>m%g+L(<(7t@aS39Y z#~dxKaUh*becN)r_jjj``e>z7QJA2tKrKRsRQ2zVX!_cwI0&mlSB#O-7ZdUAHSP;C zcWL)TNz}v}>K65CbuV_fqr$7R$GCTWPKG5__X{N_?7yW`$8SwjBFC)IwA0$5IQ9~a zcnW;a(-*%wou$u-BKXzPxaE#%sMacS>|AX{8K3e7eZOKFlV8{ke5@+d7II`8ph1mXz!$r+% z%r#_>kW1^-aKY-Kh92q(R{$>j1a5X!t&rL~xd>jsoVM3EwKk3QU)4|GAQFKX+tghw zl?xENZ~KR+@jcYD1ZXmWch9h?QSU{6!xlt9cf@$%0tMm?s4?F1Ve3uwuvCsTl(1z$ zJ@3>Q45hnGplrsCU{)f2TiQ`yT@?uC_!hz4@lH7BPxxIOla=IjEsu%JmYI3PBq)y&dxSF*Gf7NdPj4( zy&UyFn_e5;Ja9*>mh#Ji-M@KBgMUEl=LDh_U zIOz1A-61$)fe0kaLk%~Id9#KaIHfKB3D3PkTzuy%toNatK4Tq$cM&udCZi6i$QT;* zfeb^SAy_5(bIEClV%mo$=D^1qq5qJ_A~yI^E;HG$ey>|(Q8l%`U(djOxPFGKa+FU! zg;x6Hay*f1$s|VKm=Z%JQ)ZPkg5G^)0;O7Shr|T4Lxs0eX}VqTFdRc?=p3r=?J#mgk67QaVy+S>j(qEVCpbq10|VS;Rw!vATe>gWma zabRf6|7c^U?)|>nR5e2KsVr(+41{_fXjfZ1Pt15M{s#8YC0kM=e7p#Hw4zB+uXAjY zc}@L`cYa+rk(fD!srP7ovTLh;$gpP;`PE3VfD~1H`L}4$eS{@(wj_b@mdk5#H2AM) z&EGObr-8pIk};;Hyj{C@aq3mWueDjJ=0&3e=c&JG&yy6@c<-+p*v?#A(@`dKRs|c2 zHfi3)_)Xn6s87GLA74a;BX_NVnzfo?beU`JI(G4TSHyG+!K@%MZ>S`A5Ot2E<8!KTLbf#iu|++wwSNpI`kX|56kI*bIoxMxmkNn(fkCw_%v zni9_wch9V1U-Opd6pC63PVE(JXQk!D2t*?!TJdh;?% zeIbT|?nxPGrx;(+72fN%xhZd~Ln33@d)-k+#xy(ym|b~JRii@8ds2xOb?V!v#eP#q z1sj<8`K5(PFAjOhqtJ{_XW4$=a&2Crl!Aj+=kdxXSRb~h0t;a&2wUMW5c%+1swJOM zQLt23@^=vO0u-s1m5e(r_87>0osr_$AmQ+W6xu#cV-MbS} zZ)trtE$yEiS|E8W7SeIca@s;D^+&0bmCkhYMn6)j#8%>;`F&9kc(0;He`C$<3i?5U z#L6!N5WIoge2e>t3GAjpna_1sYcBu03O^xdQZrxkLUw1fa)4w+GXmGd8|8PsJL%Qh z!g+WXhgwIy5w)1Oh1xMVw|nlo~< zTCqV$m7fi{#sGPONiCy>tkkkA{lIY3lN{s|Dk$wSH0of}tz1}EC!x?aQH0!xiHNSa6RXc8V?j48l1;#S_%?;~q?eC5>0w$F0i*}?ylRj8% zzmt5XO94fHq(gViPy+*@f=S1H#2kWMm$z-no$cH)AAQ@)% zwM^p6Mj2b49}OBGrZyddGFz^rN`l{}jBa$lV^L=w>XEndx!T(v>(<+fm!^35LJEPE z8E2pIz55y_)3%m;@fc+-E0*{-4)bAxOJnM2gM?9y&3Yn<%(!t=qqm1c=X?!vJPx0^ z2qEJK8P2QE=^HT>ylRqjPkHaLQLuT=z3resh1cSC(X*A2V6{IN|O)odvNSfPuoDzUYT*jZfZN&B zl8KgD-xBK4zn?_o$q2(Pg<3!D4wH3EVGkLu*!OVpZq1-J#CuOvPv4I=Vi7*km50Ee z4+cf=k{4-HPIOYg9L(~1B+M@zS)mL!MvjQjy$67axvN4lpBO%cdKpdDNLZq?cc zrT2*~fO(TxcqJ=6`R=|gruXX<%=H}Y67d~x!g&j7S zV4$#(b*6iDG#mT7@@efrp~ikcJ)yMvq8@!HZX8w>eq~D6V(cWQiV3@1;Be*k?+wRj zVjB0>7PU92x@M_Y99|K3ZaukV7TtNiZeOhSG$gk`y?9Ycrz!ZmTD9D?rcf^I9=D+6~wVMz$G9sn%AN={=ZS?2+?LGEay+J$dn8LBw8I9HAfzi;1}_03nzurJ$c(shcT7Dy~_YFI4gr7r0| zb6d|<0N3)AM4Gm)ZxLal7EPSw7FUbGylaSrEe?$<^P-_)EMv{_U;~2kv|ST|r7|H8 z6RCv@b`J#$bsGf_fzre6r$Mu%r(=Pfz@r&6Y3jf6-%-lBbW5$|4=r`N_H?!@Nh-D_ zT^dtp4o^tk2y8OPv2qw03ewkvvWpvHnxj#P7eotXM};-Mq1EH7H@L%vzYYu%s;G6(yGZ*eHrp zBzIqI_#rX9(<|eI_gF)TT4v0s07&oUezTBOv}1`S5cwwc8Bx-j3I3I9frMG z=<=T*zU7IE$_}C~6IS~v107w7th?FvSHVS`k*@XsCY80dMd>&Ty;`<92XEfUs}Tg-5Xm*1y+mS8_PE-kA|v#lj-pr} zVmUBs#XV@72i1FGwQgCKyndh-v#KiMwyj?R|2^_d|JSaJA`QJ!KgTXWn4*xJ^A8HP)c9>l*H~;x$lKRP3cNaG z;+eR+#h3t-LveJ(^>S0@fDD(KY=xyyX0ios{L*Ux=05e!#PGXzq5N0)?ZKt{I%nl! zM*?{D2pAZpL29pP95iXhYSq-nc+}@@PG~Ub`Xybo-T5%>)K@mBY2$q%({U%7Hgr9T zN3KAge_i4;iOti@lpYB_{t`!EZz+0{%g4OrefBWJ-T8eZIJi3Eq6|phGVOtw4nn0- zuWyr4rvJV5`Drd=N0Ap$UlhW!gZz6zq#piguPB@NJp=3i+*>q%CXt`kK&YEMZuZdB0`9gnTb+m*_QQ|I2?J<5=Io)hGGq zxn(%CSntT~?e)dKt68ll7vS-cy7Y1tJPM91@88`KH+%EfORrV?HA{8lrM||f^(Pjg zh*l#L=MdX80TzG1ldp3EI+={EtvzHNPkFG)K|##=QkJu95o+w$Zzv|$K{rQS^E>>chG%gja5I-i+q6y zmF{TL6e=;kKROZEt6=%Lfo>HWB{3mvB{KHYz|sNG$Pj%$5dHtPj9NRZ-rlGvKuSjY z@_CNpH#NYor`1a*e!{_vJdV=p_Gs^-q+E410LxlB3Y+njvdl+uWLmI*ycvFlhvm{u zGnk}bl9^b)yIb6nk8B-L>B}5{&eJ7>`&n{nN$JLt4yEHdH*cY*Wgkj|Y0nqTl!r zIDIAHMp2&b0qhz4-bM;bFf!lnuHKe}GN0EBLjy#i%>V1^FD8MN|GGrR2XSJrLrtHx zL$lZzQoFC!YJ~2ql7OrE&>ft0FY<|~dt~>f{fwM6T^;_@vMzRY?KZF+b0aU~hosTF z$1v@uF1sHTUU-W7+7{A-T-Hm^)6e*I!B3L85K2Nm27^vL`;K!Bsv`s2ko_OieU|9q zlOqPU!|XPk>Sk%Zp8T%p4@>U2pTId~JefG7zC`NAOQTWO3Iccw4%cmMu{Gop3y~}Q z&%AEgrmr#G_AdPVCa0WRgE?OCRKN`^A1U86ozxbS8}Abx4-@72Kw+~{RKKvS=v{q$ z`Qw(~%qqEiC!p}+{Qx~+Ia0me9$S+{1RZ@|?M&&Cpq@G<@y>}Ytn6IMh{-F>HkEE( z-JfFMp($t}m$z+yuAO~;-6>|?2+up(*w|7qH4+~WJ>}rVt~8G14&G2&9WxJ9{rZSQ z5AY5$C)qlDWCpf}<(>SvMH#$l`z+3&71gn>@C$a4_IR^t>@ zJL1jgC##B5hnIIFr;iI1uGv`k7`NF!KJE=ai`Snc?V_I)ERJdHws#;`FwtBGKG2=Ku>++_N?<2OJRkGJ z!Y9E0cAG~Tc02SX()>F=4l{$`G^Yk1ERTWy>2w_1o;k(9Yvnq19k(ydpKAf{=L4`` z{iW)oLa4uBxKYST_LH9)j%OAnxW#Z0(Qz-Ih<#RE{3J2fvfu2>oAA;(BOabgw=46e zvincmPA`_!s7Hj_mQ5o~r8TF2`IwEUNi~0s0mOcTXYOk7UFdqPd8LOxAcw7J7gKTM zNdym~2B-$IIt(~)2pKznBqn`1dO50#Z}b&!y*%N~u?f*<*r79!*k6f<4p%`*snF};Fq?w2 zoXbAj_OF})L`L_hlFt^)owRmn@QdEZ^Nkg919mN(xd&;fyU+`sYHpyBAMiULd8)XG zo>@rlh85a8G7d$JQ4IoFCz2=^kBECoUSsxid{8QV335w5Uh+-KK}xlHbQVMR7Zx1k z+lp4K&olx8N}m{VYBMU?lD;&=8{K(?IL^S`j)+ri0BB?fdO)N zC#|AU4b&87U(*MLdYp>s$Lf21b}osR%;cRV9AAT}+_eUCKV^?16MZEkccE6O z`6vT)!FF+RW1&Cg{T9)xC6X19IIGa$#)V3YtsKhZj1P0vOMogq>SD=(Mr_c7KzNjr zbLfmPr^i}5O|<=B1=lab#Hy!is@sy7BbK;tEX$4X=bvtrviOOD5-?Ys@yvIhLu?Fa zrpD73mb?Evx|P^B)^aZw>_`+W9%^&%Y(aK-xx`v(^b7o>NjYHsjgD zA88%_Q%?L!z@J{mp{z`(YA3;>L{@oA@VCCOAO2CI{c^J)jXh4#b1uC1kA8&VZMm@# z-W~ah)e8Gd`&SU7cK`3W^gFbE<+cp z+PP>B<6F3;R=!c@l<1v%sUBEi9D7k`r6BN?Hj`uqO%%Jlfsq{cw8!xil^E#)OW%va zAEzv_%x-w|Q_5P-?Y?k6^8mVrK81LJ=vc9Qwta z+*gjKOS*d!y~tPha<5fEG|$Z#BYOByo3|;OLYp@1;4Sc45!38*)2)RW0b{&&=Jz8B z)mhGY3!M@6)1@DWqr|pD%WUsnBt}ZSSu3zILFig>G5CFrWle>5FR-g;`g~@?G#+(J zOxhRvxemK7B5%5?a3>F(L7`-a+^Wy31P)bfQQUbGp?lw0I93ctJ)f_3;J{vv3RZLI zO$aKgr>@yTP4v2JOrKF=3jRPNGh3t-^!T_-!7(D*Wjdx3Hhl)YtfRqQKMU&QNS!Y# z089qzKHyMvLAmfR0&I-<#S-@!*ASK4{=jl8Jc9xb&#fPDEyQSGXMpJe)YJpHLjEu1 ztx8tfz>Ceq{cnB2_}`@^RiYlF7w=3xP=?nr<^koWG~>p$fcdj6qUR6LsXPhWU$yok zBG;51P#?SgS+*-xvckbs7~r3>>twj;6#RvRZQpbux2Pl!TOT{vi@&3FxXql4J840L zrcoHB{nVd{k6DrgQ{*+$%=5F%n$olOtbnbrgaIr{n6&DjLcjA26gX!k6)npR)kk$L z7PhnQeUjwY%8QC=-PEOHf>OZyN%(`L(q*tp`G{S6AmWx@ed{*qq{kRL+kG;!Zna@x3el# zGpj9wR11gOF*VHN`TlYkxYG(PU^Sbk=On{}36uJi&!9SJ-{_ZU|Gte6*0{nBcmTPQ ze`j8`eZd0ElcWhV8_a$#LGw%2WeU!O-$rSSiRW6z_OIG$Lw-1&c5>UG2|BoH z6d3G46ZcIZ9x8iEYz!TEZyB;Z0M))**{msI0oWNkgI5b8cVNbQHgbIYYSJi&o36e2 zTo{mSDU^zue3cc=w*;YTIG{8FKT-&EVb5=R0&9QlV-S59;7b z95!LMij*;M86cabbn3`&1LT0)p$l}1QSYhV0`}PbYVb-s%*k()5-+XR$H1>{UqM}Uy{Ky^TX+XS@f|1nL@@|gw##X&;)$ZH;^7`0BI(v4;!j^fnWb4u)!v!Eo8|l2p(E1hbwGTaC z^oD~0{ZJ%Rq@`LNHq5NAYq!rii=e1=F(6?GSRQJK3^C8 zFfMF}fTV;8Gciq0Ur! z*e~1fk$vsJ1)#+^htBzh{ZzOJoRM{9+6ZyGS9rF6cL>d8Z{1o{xI4dtcC(ue?|JO} zR?Ex@@R2&0D-%=B6=SI4wJ~P9PQ{Rx%>l$tZZls5d_u&HBG=);z{MDpE;O@iZ{uRt zz}{9_tHPq#=wmDd_0=66aJKW>M5jQ3qZhwq_2D?85p5pJ)amD5^#0SowD()xA+z>1 zoyAo9Pc#0FUggd&8Zj6LAgs!K`7uMBW!xT0asu8`f7x5VV}391yl?1m15D1M?5jk< zgfw58Fix6*0Neg=@j;l}FGUz*;8aMr45&~rg#3H?1Dmdm6!9Exn>5t-u4c^E2Os5Xh|F)$ctzC0PRinz3HQlCC-Y4LMb&M4!I)DhDr3s5Vs633UzP7*fs zdrAPS%i>tWRxtvrJ;OBea(3e)4klZ;$Ws?G-(n!8!;5T7vS9lAXY+9g8TG&qi4>2C zF4>-e%PQPf83TR=VT5|F)(l;kN`dg^bSKfT#Rlr47^D4 zH;yo4>r?QIQS60i$06}dv;wE)KOLIUc7^}v1zvB(+l&0XBQF`I9R$( z1!wLF!Ce<5EiJ5>3wr)+7wY0XHr4o3;tSDhWbi+T1<;?Ztr z!o`)YjZDR5Up169+UK5O3bap#yx>N$oag!ihjM^vt?!NdJg;tXO%0Mawz+xLTR7V5 zysU96L9vK;LGOb?C02*f?YbXutlA^r*QQD_at_R>^7*;FRYIw>|yrX8@+WWYY(%tXi*{bL!v|g3bW7ZbE>BS z*@MXKm_$&MQlC3#6(^ zN%_{r5$BZ=S2}`&FY$6KTxc+rqgM&=ykrtCjN~YC;2CI5FSy#UUNQX56J)n4yV8%) zTz8=PkJ03TkE@y5sv5?D@lQ)pz?BWuCn)-Grg6-h0s%q>-b<#&g z@$WOVRY{K(e~ZiXNQwP1s9T`0O5~7Mj<(6lPg^K|YW0$Jiu{Bls} z8aiJ>dg;)fKKF$L!fZi_+r9q2h7NZf1o%@`@1S~T)o@1tu zvXoc+8has9$7~ORsG zDS|dOi#hHAJ)Cb`9*#jZ4;CYD3`HK+Z~8P>yZozcoZ452>NzLV>;d3z>(u4>rxThX|At%=#{JJrv$S%f|CDaE!`(OMRc?W`*DM7T_L&%A&>O6L!wkJ76~+ zAdV3bq4xPjr_+m0XZ+=Uk_%|~pg2EOw_az=LHA)ZP!lMRL&G>o=nPVWtTDdL3-PKYy)03iG86^6 zMjz1YFl>wudbJsZj8TGzaG#xu&qF!Dj7y*@m3y{-UfS1;Lc?A90{W^J4wYdI>Wbk- zLSk$(_6k+`ge04CKZ};NQyFQ}Z{|i!9_+WUH8PuwGmt>EDPsGSfE1ZelG#Pe$j59R zzgKl)TJ>MS$T8fH`4uxPtgwISReFuOk@UL-t3Px<6C(r^aMqH8>&u^S*|RQFA!X9~ zOBu2?)r}>;hiYOO>eL#)RID@pSd?ZVp)2P2O6R<;{xIiRl=7CmOD^5b%NcRq!iKZM zrvZ+F|Ad0Iu`#ot6ECpAqj5&y?T!F7ScG(@>xUp6(ocUr;)LvR5R{8kU49fS3QRa6 z?O`O&7)iAjG{-2QpN^}hT>tmEV=dfdB$4}W{qw-D#Xp+QB1$VvJ^7NscO)D!(RVWv z)Gcnt&Cp?suxmG0(Y5c~q?dR5#yyO7(RrrgKKPLg^#&#$aVpt^KHDocDGl@u3#85fdwVdhX%zriUVW|5 z2{L{!db@}{YbHxIT>zQ2(lz#&cb`>;=3Nx$0voLQ4`J(katv@3*Z2blGPOJfdQl9Runt6~6F*Nbg;{%KKbDkpMoV zar+l#bOaVx%_iCEOOR9_(`K%B{h}m3lm12ZAHBD#Ia_Co4c5dITnCMcmrp*o z013nZe|>=@tjm*J)O9nwB!uWL=a&NlDY(}Cu)X0LMQJ{({6p>}HUNH!Y(4ssIitYh z&xXdkq4SGnG!uL%RkTNs?TzRcMVbnD4IG749ggCE9^d1sQPz$Bo#K1Z2bOHB7)*<98nj zSR09BuSg)y`b9l9q&#B|=T4Z$+s104(}gen{(v|=K0Gdwi~2WA7#gK;VDzS}GJB`> z=}R>=)+}4?L1$mIY2L$_bcFdJZs~>?=Ob_*Q#XRN6~@hMPLWJfI`mwifh4>e%&o!B z?u0I7*}!`SXk&n9t40^P-%|}*W#ppWsfV6`ULRZMD{0Di7xgKu7u~!vYq5wcu}Ddh z`#EkoZ#H1{ya-3StXfiE$LE`jE)Yg%3_H^0X?Avn&q*7R z$=M^ni!9S5$jijkQi3R-VsW^a3&ECIWI8LS-$(E;?RwzVe4|t#d#>9Lg0{4)X<7y; zNX8k}TH>=J3$qybNwq7De#B_1AP5sMPDu0yg*U}QO0}>BGrU&X87eCG)wxk8${hsp zgSnW4m{#$b?CxYCQl8~6T<7$Yf5|5?OXRjJDk_xN8qd5|B&fsmM*})PCsEi}ZoLrq zPO_OG%Hhs|&%IRtdesze3ut`$EOu5$+9Z=sUv0||%Pv3U`j8<;sqjo)oXLy;Tk?fbMJf5bSk;u1xGSIoDS1i zsW&eJ&Mp!X*g$?bRdHx>?4E*W)hV#A>RDoiMWj^Ifvjnq_4IU{2GT=_L@)1cPdaau z@Yx!jdlWUz3Zwe#_K+sK;cze4-v71i$P4UwWwFnAP9vsDHED#kDFK?66!`yvw+ARDUA$CQJA(gv)kQna{@F`cqX1vGu~(bH!sp^?7qU6QR+k^hN;VzWtqv z|MvWTbn{=nIF~unOci(JG1Ye$bAv;F%6W1dlz|NLqcxl)=gxIv|te5fSuZ8(%KCST|gf zz1;Rzf_Rb6TH!-GDpF~h!13STgC-Bwt)xSnzh@0HJD0C~8ob0MN{pY^Fm#c6bs!SH zVQ}1*DGHwEv2LbL&Q^4(9E%MX&_9-3ftT^C5*8fPE$&XPutR;H#rrfs~ z5=^TK@u`{)QEgm0k?EA>u1WZFfSyTp^#|F0T-~0rt6;)nxz!drcuLKPRET~ux^x2Q zPhf<H+4y$bLI1IERT$y|hsm0LbLk04lv-!=ee;Bs1EZ%UBW8i#pkfk)4)mF{g1}1wXX9~_-u@Dft>SG)TXL{7R}%g zPhST{hy6M)HL@@pj@U6Q_FVN<)vlO9dp~8Vh#r;b>$7h@H%0`NWc9Cx=V6ssZqq=T5vpGYrUL z90(|(_Eg#&j8>*}Z2W%z*x~S+EeCQm0`y=XE8e!CA9goIg|T8XO=7^s$!Q;vYB){6 zx3k&iX;3&}`$BY7jd15@ul2-$ea2LnsWCm{%8+gYU?yRWUvmj_u%=$x^msRs#fhEFxF`ev7iJRgTgH zC*q|&7LGFAmKOK31J@=8p`9<@$#Air#=Z&-Mj5o}lH7cwkZNXP~eeYJ||wOo594o zNzt<@Cx9(#*>a~oyK?;a%F8ic1-ovKmFH2A98_$40&W-SC@P?Z_4n2_Fu{ajF~N>P z-%dFH*MWi3qHR1_MB`UJwSS>sHa_X#Ds9lCNDx=pdmukDI(H2tmEuU1bhL|wUc`ni z&w11xv_HoId6n$A>P{wwlEAaNm3bsO+{UGxDN%uqdSz1ov?QRIkJ-S_#^6T{`rALc z^z$udfSumAay=DY3XE=67UQMF@ zeF3dp0Z>C!6o@!yavC@k_RwfqdY-X(Ff*@fnm8e}`)B6Y<(ejN2(vMceRwb%XKb=P zpJV#lvuN>!=(c$<*o2itw4eMkT#imgj5JK$~~cE;~@Dz;zr zV%w7i34b^u+rNV#>HJT7el@1~Z9v`U)NSvNn$J4EZnKk@Xu}#N@J#RaXFnBPZIN(# z;~mp*1=?BG`CU$j!`3*GP}es@Tlc=T`#~w0RuZOU_;);$MV;G|nY(YvmyL!0*)ajx zGYrI#EVSPsz2O^BQe;nc`@e)3VX>tBNRBQ6<1fFR2%IDaG@%=3Lq{67%Pawz>}uJ5 zS#KGA(aq9W^Tv%*`!(qYqiK-13IUIvs#3{5FvEgFh^^+rpm^DV@M? zf-?R42p1JojmkrVudW86X9I8zOzk_4aj2;jFy>G9_5AnFY7KqBpmfRIgl#C9Zk)FF zN#haU^1*ghkAweaG=KWIYtC4WZ95W4A>b_Dwt2mL$=IP1@UL&?w=0{yD9}6vunV6g zObA?9ALEBp7l*D8i@e-m3m9`rF-_f!4Jg8s-rYicNXjtlt6Aszhw}WMblPX7Ucwrm zwz1S~rVcgWDADHtJG(It=?5sQ?5x5@xtD!VP3Wfc9ug@fK}W_xwBoh5hrMYb(v{2< z#$@g~*WK9nX9uDS&H=2%_N=HVXaix&`L{UcIbI6Ck}O^_ZndpFlX#mHj5#d8WDFut z3Gnrb2MZ#=c%WwHDh=vxCyY>>dfI|&9sD~jR&9Hmw@rqBy#Xj~jeyH(G= z#Nuoo68@->SV-{hg`81gd}y-UrC84=E-;n_rv}ZT=U@zRo4f7&5dFA}s01}?wsL9$ z6ZYirn*l396M88_*pXE#Sz@7dx~bkWd{sz6NMt_{hnmiCrA^Zk&%H+Rq6YtuQr-kL zEbn)uKBkS%3v%}}ddzHNk>9+@1Nr^7(&W!D#M(3WqGlu6PTQ{WBYAgdu{~+|TSoPA zF7b^$zqr3V4ObG7C49+RNKs5{lydS1z;iSf@rt4sr+rR=L3C3{!GrMW$wn6~CZFxL zLb?_cT3S9z=%z`hetG_&_Jc9Nz`y!oRr~fkAGU(C0Z~O9d~KE}$;hEhddAAPvSbEv zyK!3MHj&+{)?>>4dtnoR8lx_II0^t_;Gwp$Sn|jEkDf3Fj!rZ>02KZ*aYlLDDze>0 zJx`cvv#-e%OFu0e68F75lXw?_PrCGfG<|hc)a~;&NK1#LuyiOPQcA5zNjFF?h;)f` zF47XxEg?urNjEFfB_$0m-MQq#?tWgL@9(^S@18w-?)#pZYi6#wCKPkZk>|l+tdRHC zp)YM}!45E^G*7=ul+kq+fhOINyqI4-%u3QK6?_tvLlDEy@w6G5%e}ugN2&!kJIbl^ z2X82Tyh!nyGdC4tFmmUsSgYMjfZnF8_TBirc_BM+@Iuq-Ihw_2lm^zkoO_{pEY`R?bz?&bmk}m6_!IyujgBe=(e^hM!E~4W?o7!e! zKb*W)p7#90zGCJzb~=TUzjJHt+s*`_crLR0vdtD{!(Eg)}4h|&xF8c6di zW@!}m$n(iNqyly!qd%4E+wWV2?&9>kiBmWz+L+|2G(Czpev(P6lC^$Va`IZpf}M@? zRdRORAq5ZoCtySKu*~GTHx`eJHt%;SplSJbMWnPyEp+gUzelP?rb<>0#H>HqYWw@m zwOU6f9_BrZpT@{b{4YrP;d1?;NNTW>UT#Qu#hcB-{2h+pB%u&Qa_9mt9jOWK)>kpL z!;;U*X66DZZIzR$R!Kjq_FhMD5hdTOabe@-_XyEqdKnS<<=$JMy{qyJ=d#(d3~c`E zz%N_G{GN3cJP%(;1=NM7nw)vRDO_d9x5qcgLUrTn3mwu3h}g2>6sz)k-LlJh-0<#> z9f2&+KPmz(WN~|MLU;(<){OR6ivT2RF7ZRUt%#J22NofTJXRdWho&|0G2VL;y;ihF z8RY)5&oO>`z$coEPoU@OBWAatVnc}In&%$NL9Egbj#_$XBwN!1&X40UGSijEy?QLr zsxy!`hZQ}T)-(KjkIgrMk*CSXs#O4<4m~Ei=Wg7Y6YK!@O+!|5?>#O?YcGcm+V3m( zK<(q0Z@+N%^#pt4OjoOk{|WlKLAySGC(OXme9W*rF2}i6?|nxTd8O7LBkemxfwT+{ijcB&2_*SUzbeuNiBnu{KYF`oP;#1 z5*;DZgHob=O>N#zu4x=7x*mrh5TfH!eKWS@kj#&AA~(?*kHpU<7&3vzf1ts1Xw`c8 z7r`u~&u*+sh;9a0Jk0zJhAj??8c|@iJ0?CoHFd-OM_`Y9=yT>rsOQUjYW?Rzak|Zd zl1=Y#y9rL7N=~Bprbhn$+b57FxR-?6226}+gU^>BPCC5kcZRqBuDkLvnC1by1Hkwg z8HY0N4Mda9`Sq}03C^3#o)k3}WbJ62pWFSp342lSTYl*X{HAN?kkuqu;f~tX9UL_2 z&)ud=u#=CR0c4T-vb&;@#YK>7z+NVM;5OmoJ@MJL`l}x+p(gSi7KjqN?>GGj?f)Dy z**5Vf^|cA>=t`-*sLdNAPmk0O51B|EIdvv!$}+w17D?#{`F91r`1QJ7-&gE!3PkuH zDVb6jQ9Pi;3+CTlTQ5{Bd^_Ql7+*1<9wDZHZClu9mrb(zo5p4|ryBL;b!fFpEc+>F z_<5*XV#o(Qx%6KB0bMd+!d|WYz}j5dhK!!~_zP!&B>(e!{lhCvVJsBd7PP3s*$ZucKP7N_AE-^`-kRLgIl3LU> zoTa+X(Es}zKMupIFVdS@9do%Bg*uF zAS**O?T^&Od{6pWkjvoW(@mw1xn^dL;mxj&a}5XU^6z*iXG~p4KE;)}#{5c{*!c&j z-ISLOGao?*g+Lj@$z8WovF|rkkLfX^;6$a`&y$x4MyC~&yF9Kh8K>U~3bvFObG5{v z1n7yrzwnf*K|@CbniJKA@v_wrzE&(#Y_)Lrom@jvvX`3_ZYB+rkvXH>P(AHPs8e9A zkTlG`JybRXPamfQE%@Rj)U)p-ID?oT&eDF89qhkYE{I&kAup%ByrFh^R(531H zsT)gZU&wJ*_RU8CtOjB9UUVR^`g|3|I%eX&GVe;<^_e#XHiDtsfjz|7 z=M`s|sN%~hE*iVGHvCz1;(B*jWYmHF(|(&>XUhItyWyP&FftCZcs4F|{n&W4d8%H# zI7Lg^Sm=ij?N~Lgqi$G9Wd(E4T&2>aI?dQc%GN4X+#6)A+eVF*w zKBo`)%AT^sZM}1%^iB7wTIFxC)ZuqAfi{{Mc)4AXQ`$lYwJXYHr7(P{WMyXli(WQ~ zh(heQqV_2QyPp!CU)H%=n|~rVv(lbT;t(D~(<;k|Jv@5H&%1P5?D=Ft%j|xi>R#?E zn^oesiv>eP=068BUdN8Vc=&SoWxChyr`P&hs~|I)NXDOg78hmo&6?ezV}(muq2nVV zU7N;o*R_$Sj@{2rezAgHezur;jO>?={kXzZe%eC-!3x|RW!H(y(U%kw zBZ;|n(4EMj&&GEwDxA@o_{LQ5;K8E?@aghH_l01<$k>R$<`ew+_N>B(KWKo zT{aBa=BTcjOI+#@_Rd+{kIMS?knYuxOQ-&k-e|ZmN1DSO;YXZU)O9|q<2i1-@wYGTfy z8}Ygmurn`YL4s<)NMD5Yh(OaD*zJsv*G!xMWUHQ-7QC~kxZz`DVVn)c+-87FxiT!K z(y#N;7oM<6XRf{j6tR%H5oTNUNZQY8@#BcVR(pU-+oln0)`-~n?9rd(7mNQXX+1>t z-|#qZBq_7xdBZ)lP8f~9K$Bl9TAVFaOr@=+KXM5E1Km0Tga6CPFh@S~vbh0Q#>YxM zkxuf0$m9VLg{rq#D68E0acHpZV(omwYM|nFD`L1}xpZS_9&=u*e4XblWgHx_MI&Zk zA}%h;8~-tfI*xoXKc6j%KfE1h5W$FugZspUCh|c|Ew@4Yfdk1G}b-9 z_{^_GF#yq&TDMy?zg*7XEWwMOuJ>yV&H-xi56K~kl(41{kByy={ieZ6g4(HDDOqwR z+6zq>^Tzpi=tJGZ0hx!I>D52J@rO)g+@2YT;FsnoJbkH%JwxOHecxQ>LPw>WeNUh6 zP_pJtQO)N;Ws$gJ5u!zkxfWaJu;YJ&%tRwXWt9X4L1t+sKG}|nG^iUPtt5zLB73(= z1xd@_aPQm={a>%wQr#M9eKsj1PjR@){CT^&=!usI>6Z9~6jx`Ww;EEL7W0`F&*G%$MNFH82LadG`{!-aKl{a%JVd&W8~BO)_BK7D_nQwO?c%1il9f{!@WmRrV@8~mfy83Z!rB~k z<8l#l%hq%9!21&WJ7~(#YuvYg`f~5WG;%=Z>MZXukvy(xdif34q)(^v!9qS;tzDGR zO{mc0;JfDF9`i#kA>`27ksCD1Hx_u0azJZUJKk*axUtB3jM(vm{y8TMi2H#$_lkPp z$Xhr1e^*V-yL3A^JtNms!+Ai%FmoE?YlWPFoer-- zZ>NN2gbwU*%krf<&NSSfw~{aYyl?J5THHa2)rjXrNpGs{4BMG19s^RM9{+CP7yr6| zpxZ5#OPpWzVjNfYF0*l^QHQ`110X()F%HwDk9vFCO!dBg=FH8z#gNFndJZ$dCFm!@ zkMoky%}z11Jj_^HOo2=Z58sBG!YjSDmR)QfU;6;15Y@v_OrdBB=RRL*33MgGs&uET zu`zm|74$qJIcNevr2DF*itTF12E@VLb?-$MTg=sjW)-FxGVzp50vylNrfTMW{FeE* z{B~#^+3L7vA+dB=-U+{WA=?VF^*cU!uLNhv?piRjlv{ST(Jq3JmHrO#}0isovMmUP*#J~gw!jnF1)O0=W9F1Zq;`dX2^9>Wr)9aXMn z^)7$*%7fjEqcoYnFFFNte(&<;)mBDQt#h>p;F~*5P-t<>N2<71`z{v-n4_?G<`mbtBpq|RE zMm2Z=%5mgYe*`>t(Yoo_sjq3}mcGbBz>&Fd_odvXd(NHHZ-)VRMFu1Mv|nQC@lF%K z4G;yE@irTyT#wcf+@B(60pANKx(2%tHgAbMXk1x^{JY5LM4z`JfQ$Th1F_H>@_b3u zHGlzY+sUKJk^gul`7%)mIrRu3-^{J3;L#6<`2qm~KqM3H1e`5ImJXWN ze&&;hu420~oy8>BgFH=*m9`*n#lBcFp5n9pc;w5!oBK7YcDdu$Lr5v)-!VxuVfCj^ zp-F<+1pT_Ye|;vSuy&Xq^9d+K4s**H>!wsO?0-DlSJcR>^9`kXn3JrO&^IDAw04MLs%8P?n3R%otp!iwL^=eU`|RJE|po@|eTiS#``z*lC<9qm-}!d=va& z7lPTMYeZWCTSxf`8-W8HAodMQUxQFps-HyS(-5t5a}&lqbXzm2grl0`8;NO*+Pw++ z-NiO3%9|FUTY<^N-v9;yoU1KLo_*`dz5TdFop z&ejgPjt@xj6Gdv!Vo1n!cnz}!LU*j-sc%l7M2CYjkPM_H1aF?k7@;aZj+4P^I_L85 zoV&c~kMeDvolHsy`tBVYL4eye<=`7-D-r5Um%xcIkZ9m)5Qskb91PeQ7!}vMt(*ks zm%2~_zk~*1`vx^EUFfC!J=yCqIO_Xa5cC`5NBRt4)Ii=gS3q0abVg#65Q^}?bg3aDyuH1kx5PX+QJN9i@=YdPlR))E(Wi!Dt zfH46uIX&d4RdO#R47~&^&bl3+qmy%+jSZS}97q7ZxzNKJN0e!$W&&q6SR~A#XfJ%% z!=B^BD`?~F2^d95evLUy@ZB_W3?zK&x{dL$ZhDTX_5w~w5jD~ULjGNsRV>qfSX*)p zD}W)iX+Ln~Ab4TVE%-bq>g3k-h(p!^Iv(&3%-nS@1)FZZm{fL1Zrn=9IjupqikT-JI4+x4 ztU;bAYBjzG;cQ}}G&3)3N@r90%E)s`;&gH{< ziYAWyDJ+dIkr{@X>XY>cbgFlINP!uMhgUb;zF zh3tWA1E0YoLryH(SUd08D9p1TPf4rs3q|rx4v>qs$qKB#r~*GgAvgkQ(w9K2e`ccu zL@B-q1~kNm`q=1vjdZqCON)qfFL?Z>R6T`U*S51+w?Q*d`S2kJqiiH@!B(Goy#D%A zszDmxknV)oQN-iPPg#DlB?@@urBz9}LkHbS*2q#%c9z>rhB@8i(E_i;bgHOYjOwG$ zK(9QPd?kzMd}m}`ZH4CGsmzP|r~9ABzRjuC1ZW;#Q)LL}Yepvl~v)fd$+mhE2L^X09XeJcpi1wTRzL|k; z{)cIr!oappzz#P?fNDTug+tfLIAC@c3hbXMFTUI)ZXDf+w3C(}dGe00FQM}^qQ|K* zN98>Bd=Z*59u*@UR(%Cjp7?!9Z|M*Y=$*$v&**|Ju-bA50QD$^L6M^LU*7#h-|$`-tOWzv;y3LPRbsDrqOIXX$s!#5vE%8M~fU? zAV%$EMXJ*-bdRht2q=IM%x6MmDuWl>{V4!6aC_H74D`i{QUi0hGiP;c6|n7!2L0VW z+v^J0ZAH)hK+=HiX6#lZDuH45gCJ_W0dtLy6aupHSy-+!2XtrF#-KN}RZP&W({6I8 zZwox=zY@WR+;}XoG2{%o3!#huWqLI987GOTnqa`B=zyAQ#feh=Z z03+(wdRfF?;ppx?ooLfrLd1&|{?mbCRb^0yX3?x_7O<$9*vW7}=tOVJ!0yi3mTGjt za?=NsL)x!r!D#n+lI@2YvcG)yzEfE?@gKqtpO5j@GrS|FIHTipeLUze*E=}ODXYmS zvddX67#Nh|%6KeYc3^dTAkisWnF3m5Ke)}Qh-MNJm6zu=@37ldy#|iPq3q6& zO=#(yhOUnVYJze`D)q}Zr!magjAi&dALv*Ep^KQ7@pqUpN3ekM zCVZ4}Ej$x7Pk@GJXER(#bnL~i01X(4m6FqbCP0A|y;P`G{6NU}UZYqd#_ec7&@kXN z#BXN(r&0ZFxR%2X{ThH>Uw2vgo+SWG=V4cU;4|u;is0iNjoD2Jt02-g z>|2o%?!R9cA*Dg9P_r&ke3B-wUWvMK(NE*;;GI^uM90?H;zMCHOvLl%PHUFHy5Y~) zpWiQo5`1rpqD(I@e{%zr*~s9uD-*Xh6)pcdP-2Ulz~Nu2U-`icYEc8S$F%|~A_&lV zxZkX(|X{xru+~nr^wZbXf zV@goxjFOipDf!AM?$@zE5t^^4SlmRiC`~vx^A)WFKl~e2fcNo?F*(2LA{&}yLhBIJ zb%fo)`GZT4e46-4w9cyMw|8AgDTbOD4KFRZYzW0Uju# z_@8h@B;6AApT}?W?1;j_HZ9{pC(~PS!Nk#QIGs~ztklU1+P2*nN5Gxn zl0?T*mD`!5dEnv(%k@l;z#)-9eq_jt$R=1J1P?O{-2ZCdmc!wCa+*DwJP{)UzvD+2 zp5h6N2vv6-temh|T>PdZ1)+BbzRIR0puq{n;%>o3fd`>;lVHX6G4-wUv_YS)b7q{8 zN3!QxT24W?8(Rm@lJ&p4Jq;}h+`4SX4Ed14ud1{d$Si^yy-KG-(9N*Rqu`+{!!dlp z4A{aQ$gtMWc9Y|&!M+L+!0 zdlz&&5oNcjwFF}<9sn8-fk!6$k8H$efl|y)uK&x_XH|ghR`X(m2x>bXCIEc`GWq=x z+3ZLv*|-K;J*-SWsE&uuMI?TsmPncyfOIbyMGN5c?ABV2{nocQM>R z$k%18BNJWKF{M24fP8dBJT_Lcq`a8}ZnjD-a!=VWFdT(wP4x`_0XBSq<~5Fd%ulRa zEz$uW_+EwtUl^NoyFmJ^{?!MKI*k6bi8YTR%Chhs=I57}1K&pM_A{v{B#@`tfjp+! zi6wz`MECgzxvF*>2(0jHyvSm-s`n?tcRNC*$)AP*O_^Dfv1H)qE#+SK>YBj?OfMH= z^lD+*2H?Ur#S%sMy;jUPsbRz0^Hwfe8p~@%B_WQn;0WeZ*VA=LfY= z@%qjN5>+a5YW$A?ZACskzL8Gh@7#*cApRb!vna6qpSHf=B-lM+vC) zAv7qG=@PN?6n^z-EdlS(Bp}tGgqBj24}qrAzJdyXc%}p?9BR`ch&@os-Rme-K%|lN z=;WU(;4y=_-pfrSkUhorcRw%cDW_f}bqc!z8zCI-!e@b-%acW?ni);{>&xdES}TES z6zcwo=mbe>8zo@LU+*Sg{AOy0&>9H)@>fM_1myroeJAH{GlvP8E8q0W|MU_TvXOha&ql21ffp+v==eD{WtKq&9?{2?D{fzCEWZM88xiLU+H$EVie6@hNm=Crt_xnY%q zM%&=SMR;eIh9#|=U){-e{(1;*db=5+LGbA)#V(9a8B- z3hJ2>*NG@smwx=VtH+^JrH!=5g7`ZnqJ3|-*%MD(K+{Y-ImXE9L{EpTc;Wp8?!Tmw zj%p#8O6WX@ah^|04T2IHvZ~i|nsDe8DlP12$c$5 z57#%M?e8ea@`eK&C&M7SPB@mTh%V{sTpsJF`sT!AGigF5!3(-tZ^cEWExpL8N|B~z zVY!D-qdd>#RmoNFwt$;#tGRA-i}jC)=U9@La?ewfYwEiGgwlJJU>-zm%9BCUwNFK& zQ@Em(n>}L9gra>sWlI5OK}jb_9J%A9y_slm-7$0$pi~B zH;-oxpB_$Xl5M}JV(^r}@6*a{RpSh4UHBDucbwZEfc9ghXrk>`a#Fmhf%*EbB`eX1 ztewhom>)}evD+>i7&+2OR{U_`i(QQNNtF|s7G<`~yYxxMYYnUi3;l|$S|fc~k1-LK zZ{IL6K=}LbeUdGi!VbZV5`cYP1YP_+ZE)*kn@Y+T9>$M4hhx^~BDl{EPi@Fs66^+( zK=s?sxi9e5|L!NWHC#ebWkQTB{=gmKAk^}PI;hfKJWB@)$>OFl068ijv zjvfc~arJ%34>|rv(Q#*lof$9a`LVch^t~b;32PNIVSWB$8T>$-paFknkIzF2G3L8X zk?4MVp6nD^t+d#48Vbd5^uSSYm;x5M^zs`!wr8h^JX#~_PbcPkG2#yiNAmh@n7{de ze!&dgUjdqf40?k-1|$uoHeO|RPL`sy?SO%P;KKR`M}WpnE@bH^^n2c<+K;?R@qvDA zA*Fq_k9XcjwK4ojFZ(L%|BTM(TfBq$q^0n~qUlW>Wo|S(KRkRzSA|(OQ0x6I@!)zy zYWO`>DOY-9G^SzVjL4;uWfg?BPo#)uKC#!~qxxFbQh3Jx9YIJl8AiI^8B3;x!@eG^ z!M1yOZ7?41tWzhRo1rsCf_c*XpV{5~K4HQf9-YiISp!tI#*)K3<`0o*3{RHkbclEr zT5Fo4EBNk!l--5wezASL(W?HH4`v{F7JR9pm8hrjYxqp6tGl?M2c=suxz1p9C^;kC?wCVwS^W02}v!27-TRd))u ze$0NfZb)4Vvfr$nAD82*&_IDG@5LfN9NXLdQxy5>d^T!U&Psl1!x?Y#>9acOLhO=f z#ewKKAa^a&4jkk=rg4^Bc8%||S8z6_>-S33i3oYZ%^y)7pF%^)P0Cu1Tbe>}`iH^W zT44(pi%j5K7_n60DW{^GtmS)=Z($@Oqyt?|u#p5rPWGTHeFL`P&ZQ==h3$^P%7?ux zW$qDw&xd|gEaak+RCa!n*Rce6tp5L`z+$#ASRkBbtE}$bN5q9g&|_ZMFGiJM!q0cq zA&f+9!uz`c$tn#v)ec9RuZ7W#w*g|r*QuVl?xI%tfAx5bmfAkc@6T^NwSs>hiDF{8 zSzenF3W&F$xf5a=_)TGR5FOk2`hph{+9GkksmX8&bSTiax%9^daD-0Y%Zd1X!vI- zzkK$M211v=)Y5URK%LE={Z_h^_`lfFL zTsqoDuU+T6-TM-u5lwCWGY7%8zGDNJP6*ZIp+})PIH)kTvLjaL;El@pbGtJ+htRBj zbw%t1ZHMyMay}e#wjoRbYa5w@;z1RIVwC)B43$WD)JV#HnQpY`(tEQO3iBn zK*w>8#|HcR5&6j2o+Zj?W2b7T=NIi8{aDg{5YO+mQvwq zY(e)9z4bYcA{K&E?liz4A0pB=@BW#vnuT(|r&P|EfE78H1-kj_>#}%J)RgJyJ0?Q{B=SWabnMDkJQJ-LTRl6((gmeII3ywgx#nH*)wR)HMev#|!Skk1pO zmC0fAX#aob-x((0#54m81F1l~@IWv%V7xJo#|*{Z4MH_T-w~=UV>MB}7}EQCuH;9R z)L~XVTIKO}dt>pY`NK{2L3j{i=e3CNls-fFo9~%tA3?7~RzmR#zt-g@V7=nr-+JRz zDN>TC>F`inN$4{RR>9K;zQ>3#YEka5NucFi`K}oDeDb5r8Z}mB&nyrRbCNtZe?N5i z31S6)&D;YC8VZQoXg{W)4Tq+ls&JKwv}b)?DSxo|XQF;J)lJ&-AD^wxm&Ja`LyGmH zVeM|6uI?svl3x~*pR44zk7Z8j$Wu8~2%eQg$kdS*gqmc?Ve4G4qc{y_2a>Kx0vcx6FTusl z`dM<#XI$1%79omVa}i8t6<;$BqfHDN#t=IhXPBbL@OOaWM;a|nUT&fjv z)6`P&M>{>Zz|FPR3HUCLCtAm;&D?P@PWh*v&^Sa;^%vQ!cHJ2J`8Vu>)b*&4#;pWh zZbW(b4fZTyZ%*I|W2hjlx>9(7w3PIz963E^mV6lkdP4Qe$jeN#4WEqWQNc|6C)O~i zwSci&gGaM{V*aJP_Gq>#F?K*PE5BesulVXONr%lLx#ML5omucfA+C_vCz`#sk6)~l z+fy!=vqWH+U2CeCD~d_1EkiQw6^!bnm`ZdUg!Z-S8=tzVNrO+fPd_TH&f9ptosb{; zVqW-%n@XeDSjg{3!@+k%Fx47cuk_j+r*WuFmSO0dHA9Bfb0<6}NT3E;oz*}M^{s%S zJDmJYYUlOlqn-fZ1jZ=qKRuB9q4pj~C0rdxPA@^0p(_RU_I_8o&sG$UKQ?@KHfsPE zkGTPkHZi<#NzP zG)A_oA?dUDYbiu)ZXCITlFNl|(>fCal$MOS>(AkXg=lR13ZjsNFit!-8;2nU0&P|C zC)7!A-aS(=z&D=P#-@KGrhzAtnr-%(Kr~EKc~FB%F_eT-SuV}}9#U0u`pXU9tjX++}a1ifvpmONu)=`p-m zFHIq7d#D+6W1)V-K6qv1H}dyW77ep0-y`nox(SL&D-};EX$}GHY5^u|;M!L;Y}f~4 zASXefnVv5urpBCDv)~>g4t{>KnssFlb_XSrW+Y_{2HbHZz%uWml%TicLDooZryPCx zfDV#;%!<@KgP>no5l3$*;!C|^i{&O;uQzMhD~micsArrd61|N}`f@wbdC;N?orbCd zkM-tG#H+*?FXod>`De!Kp~*c~BZmP`Kx>2-h&`~6=U624E3l>;DBIDzExyQ)xf=itUi&<++Do;{Fvpo4> zw!yOy%CFx&LwfjG`J;Xiklh0^ZpyLrt%QeKZ#6`TDX~Eu3z70apH_(Op_&0C9jTG* zF5*pSlKkKN8mCaEEXxA=s}DNZp5Dg7EuQg~c#z3rlb>r-tZ~r~Bq$B%<8qbM`F}KV zhCjgG45JhZeK6Ji(_Pztu{F%nCQH&w0Sq5hhcse_mG99si>)8mi?O!LJCI7W>snl} zxn=VsI%2QZmD#>Fo39HRbwn!|K}D6}={AKTwXdY*)s^A#M_MYIindd{0@SPHb!^1C z5exg2>{H{>+g}n^#879jKSG5`j#gEH%PEN`?`+>!T-^4k^YKA&A12LizNj$}CCrwT zy%&cwE!rFyQz^2Vt%K#zj}bZT!W+=arWIFq8=Gv-x@fnOry8XC80FcwUZ@_U3?PZp z5w&!9;}I^l`&QFs&}Pq}fvdTEl+_L&!1q4ffW1_30P*FaEPKt*)C#v5Jkw`ir9YbJ z7D+PxII56Q-RIc&=XG7xzV@=)V&6o}06k09N>X27&+!+F}=5fjT5nw-TO!uD6D>cQ;nWdnxOPldSC!rxe|7QQ#0p!*hD z&2x)XRa~V;AdP$WUZ>b;s!DjOO5&V;4xH-5UvbcJ{nWVf<)fiesZrs&hNyA)Ah(<5 z{VLhR-x#8hF?gSRv%w)WU2JoG?G8Nq8!yW^N~VeFphgBFZOYQ2_cG%>+z(nV+R0}_ z^v(2%qp>yF4$+l9#ul*|oTR zI-(z!30DgmaBj6Ji|XvYt8j4Q`0~0aYgaN!LBYZ9lBy)b zYPU_GMz}21N9^e9ZA$m3sArG^u5`c~98Vcb7P{?)-8Vh4TKgxJd^#DRh!SI(d?#p< z2_rcu+uWz8A#k6@asftj>VZq#Tcw2M>plBfW}`>J3i>8dU93!j4Yt7huElxW6iv~qe@Wz0Yn)i9Dr zHHS4#hDSn@CYP`e43gh!o5jf~u;&t>9r7RcN zR{JmJ%q{&>%@p87Ma6do< zK{>Y(W^*8JE9l8pSq1Ny^$;&ehOQx_J&f?rCJwd#`AF~Q@mvPkyIHBojpltERql1( z-!BnN(YBY-ezC z!G%^a{_f4;Pf3gyd=VG(_J!xJzs5Tplir~HG0zoSN4(EpHR`#-*>hj{D!UW8;1qp+ z6B}&@*7FE6eQ}!1+bzWUC#6RENlK!#0TR7~lWFrac+KYZ!rzuH<#!aLDL^Ldu59fo z%jL59K*`7;Za8BQLx~y#f|%TtsnVZ*d^1)%CPm8a%%HVAi}#u+Wnt z993)EE6xvE>~OPPJORg4vBOcV5_-rOt=IGX(}C;HgcDt;=geibbj-WfpFD5IB#8}Y zV9uVZ*p{&(fSall7R;#+X7K)tN#y5$OGkJdo`CrTmF}EMUT-9yC_je_XZ5fhTZkr} zPXZ$ts~tz^|3PeHVqnD-eWDYjLKCun%LJ>Af}WL-`ZUz*Zm-v{;sL!;F($^vI2~9o zK0AM1Z=qML`;$GS$n)&cb1P1j2dXiY~L;z{gjW;2A? zvCFyPr)jYih3dp%Gs~|85q@VL0!Z>H+Bo=4yw>BcD<_z^1@2{D(33D`?n{V<>>jhe zj|RI72cn3DCRN%f-D3zcf)V`$zw3lE1)obmom%!v61*$4IG8#Ck*iXT%PS#Qx&m}s z;4w{ieAm6Fs*#A;hrZ-&@p&e=n!hWwU=&z#Qc0ri;*a73{&QL5^PQp?(2VSE?Q@P0 zKTpa_@TI)J6~#cg*VwF-#56!l2AUF&eel(8p@ETad+Kdty+^uN0OCS7PuCc97|Lm5 z_r=(&nA`s3IwN|Qj@&Uvv7REzWl$?ZFL+v!oua4|dlM&ifrSEW>pyh8cuhJ8hXIH+ z;RL^n`?^fP{3#bXvT*IbqRLR+fq2sSb?|v+i(<9NtctNis0TaP*M~@-H7w2Ot4BTb z@8v(%d^%M(7<%_~Nb8?;2Y`kOcigRtv&k~no4 z^K4`N)}C2tkHT;GqVVN*Z#<1?i5>j7pEKd?hXs~Jub4JROmX5ePX?{~1i_7;^S z`)OQAF&=i3KDAdL^%FZO9&#?&Va?Uym(AHVC9a$a-IAmH3rFbNh~twG8BZOw+qzNP zr|4AROj{e%+<#wP5ermDg?EOLMSukvP-__qtv1V2QsRB|fG2s+Qc7HX>|J(J=9_=o zcUq{Rw-72td~D0#SO=E&sPnbmx2=-IdblRRUd@9-0;y1VgE!B*^7IAP%_SQYBxy@h1W>FN> zy1N=!Am@5ff&hzPL?08+J^>C4!@xQswFzvm2dO8IolGPzwxGW)=F3rTNJt}&^l;x5 zOt~?Z7y~~TlK2Ge?#bB)@OS@ak`;gf)s#6-N|yor1`er@*8Qe@A78}jO!yno7v}lt z7d~0d@~Man^;gkXGi$hzexv(u5wV6d?j5Rj%AO@1cKwE%D=cdKF*`dM5%m60Pq6`TTAoMe7!uW*DWTGSwzQPhxePlTAl4qKQIv^eXHAW~mJinF-S|6hQy_#~ zR)m8OsUnAql9^|_fd8K643O>it>?e2$#g?29)`fd4*kv5;JcO(fQxyD&x|6*2nSCc z{w(s#-=NtD{Z>Zx6*hENBer|1okZ{mpH6YjIg5eEkLtl6#ozQ%;;}yhp$@#F2O$Z= z4fzq|k6Tnfat=-(6LN}j$J{pmNdKQD2f9CschIepFc=26@?FYlph-dAb0#!>GXc<}kA!p;jJR9vMI zoPS10N1DyZcA40VDn&*~|M0ioF9i;vwSS9nDR3<=9~1Wl%sKf%%ExkVo6iLAjP5Eh z|G7)IyIqZVuo#9G(~^3Y;p46{xZku~kn-x-Iyxl&P8@c(KJu-)AYVXvS2P={~?*t>ZPYMouxpKqW9r_XMV0Xw3~&vxF$ zft6jS89n8PBcTky>;UX#knA+w?C<;ylD3;>2KR(I3t}p#2J2Y=(xXMM0MJ zYN?_K5=2o!0P7aXUo>@stp0a~i>#lDNKBWmHK!lxw&^)HJY6A#P%k*M@zLMbO}9Nv z2AapEY!Pw^MrLR7H7yb6>tT49D>b*EV&eVuFV7zT@18bl`n6bdqz*@FbwY6C6FaAFZl(8hOW(3PeaRJ|x__|qzxMB&MW~)@V`y!?;(yE#^!muR| zi>I$POYdj!dP_p9iQ7EJ_%`*XtF`W1LI1s#DA0TzQ14R<){f^Tb{33ou`NyE-jkVc&GFh=#IfJ39GwcQZ1;(|N9rEYc(8;1S?f$FEXI`S$=W3CU2a6)~!L< zw0_xy z5^`Q6;f&C~6pknjDC-2P$LKmpQuW^Ph+rf?Zi+X4iUcpMw$frExWlr?mCj1BB<~8s zZ184r<2tE0k^DFQi+URLq=q^;#}_;AR>OUnn9`Fb=eEn9iz2wN+A(C0%}9)G>tv9r z`1bA>8zEkDpsjGmm=B*~*z%p`8aGF@Gi?v9^QZpL3H}$F4TQ?h2CUuUVT=sKP)^Mb zyS194!!XS>+=Nc&r63CoMB*_&E_bM9FD!$gmzos2-zu~eL z)m~!q);%jH@9*}ExzcS;Eo0@5ulu^=toAYGyYlG3nrcS=btNO!ovvisbe^E>~~ z^OiU4+%t27oUchI`}aFIgO zy|#bhvUPFly1qxvBoqs3?+s_Yg>@6+DUEV6iIFHx_?4V;b?%3|ljtYfY|i}kMNd7T z+xtD&cl-$lJ@V0G(zJ}5yDJeA%YvhFM00|64_5t3muVzx+BByCm6$3sxHvSg3q2*eK zWw7nH7CcuLn{C)@v_vGGJ>kY8hkQ0rzJk?OS?-s_HvEo6h1cYw-g8?&#yI5}0p^yo zl9WS#N(?>Ad}lI0-w*-ji#{#KK|Lvgmq4aBKjIeuu0>Ji+64VhS2cxP4X;(c0#zgx zNCd{1zPh1nWcsXfV}8X(QS`8DPr$uTJy_!)hjzZpM@p-alJfhLFY^|9A(PJ2NPA34 zAoRY+C;dujeO??`5_6GkoWi{C&UMaJ_lEV$z?ph$Q|Dmau2}dyBMkKQewh6SrT6j5 zH-Tryn30@AhRrk@TF}!l7mlj<%f_(^)(Bw>r>r$R2*`$Zna7SGH6w!QxEdQy!5#g5R$cgG zN>0q0^v|$$aYo@#7bw^T{jEU1`#H2;~Y_Pgg9TLhvc`ctvvoHBbNKyuJHI zWTYM`nj|Cn9U2@ht=z=FMSK2u)gO17YPDf266apw5j)Eo`SKFWjB&9Kn?mx(D!y-9 zu24i7=lzUeL}^GW5HP>VthaqfDy*>qEwXS9L*PGKH%EyBZc;N*g&mAr`QS5a?p{z6hG>(sWGc z+Nj#WEOb1H6SqD@YC%h14!PwfRqZ4f<5wNtWm-3MSx)7tYmR(s&;u%CAi^Jlw!x0@ zq>PHQ#?t{wTriCVf#*}{&TxEsahKN^NTGMUefg-go+c5zln7IifH5!IJC5dWnYSgG z_?}!Lq#Yl6U3Ib5;9GC+gzb(dDKHDKE9M(*$js2GY#l=zEOX2y%| zm*37IRwl{;E|+3e`EOl)+&RR%{Gnu6zEc2p9tT|0w*8~^xCB+n+{G$S5h<q+~k=QD!{|=R4@DJTfdo{X`C*p!M4>F#Vt2DUH*;s)8mY~9+!5; z4}ED%F7Bb{re~t(#l{-Kgj-lcp$Y*%qXq7*?ar;JB+|HUo@*>SSKcKM)~ucb@we=a zLU}jo9HRQ;lIlb7g>Bm5U*bldLo!1MiM80E562TIkZFZaj$zP-Wml^7@f`OP;IjrS zCKBGa#39E{;$S`(2-l6o^rm%C+_5|Hvq_r69Q)>LCbVVe`5fv`BF{ihwz1zw+lrY< zo}0%<`6d%F$1UEp-*M4hA1#-Uc{_NRXYIsd<_L<6P)xd$|< zfrHW=q{e@9an1KY&ZP03VQSoeF(3C>k-)bJNH+9M(F2mLc(7G>7xodh_EJy7KpAs4J&62Z=Lt5Y% zE7jvsFee?@WeXSx6e{kq&k!T9-sC)j``Fm4ti$m+os$SM7HirP(ER!vjts~z6?FpnYB^dIX9uMa=CH@t{uvjw=^d8p*n+7xsV^=bQF`TWfQh~9v34n?DRO5D-?Raj^ za9alH#3T*NR~>XVdEg=jJ>8-H0Wo{$j^{u*39h!k1`?#XSZoy?&lec zo%nf5&L);^=pSQZ!bUwcKo~F6(n6XM%0%1aG~y8>*C%w|+hmGH%gq!w256dW1ALUf z9FASkzD%Qe;`2G7Z>5ZT$wO5?X8^x`Nxp$HcfkcY74`j}LLE>R{F@?8hG9>%UEDf6 z73KV&FUEu8=qS#@@xz`mEEuZ3i3a-t2>G*jE>FQ+)MB3P=|;NB+hy~!f)akw?^oXH z2;d|x-ABE(P~m-Kxoh>7k5Gbv{yv3*$<(*xVj#gpGff=@a#HK-p2}9qz9!u^gcD6F zWAU*rhiE~P7wdDtjK%?X3($I2T{mhXs}Rf!ItbfM6KA{xCB}55217mSH;U4Jx;L^2 zD=vh#O&rjVnpK?rg_$x(KnG5U8}#o?FzK3CricJPx~({-mY7IB`F7eG4ZS@>kN%l0 zX*2;zR|+2vifi8E53(@~zlOwo?*u3l`VI=ZKkt9x<8`FX5qX7qFLD6cL~+kG^?fPl zH)W)C<<46M+{$u#*2g_PvO0O)J*7!+(TSl947<;OMWX1AaYVW-Xk|d=Xxb-1%fu)VT;1 ztJjZ2_6gwS%j+-9d97ScE5gAVauhCfP6q4d)+`(lD54|zO?6#5K0`*r@vmJicppWH?*{PMY~drL%E=mY~@}J9Xs!n-;#&ZYnq&ai{B^;odd#B8lo6s9ol5A{5%vnn2LrAPkILa@{RhgKNsV=H=++BB0_(X0? z35&skqqJ0FT>ICr$?T0k2PgQ?HM`WDsH0n+ukzAJ6sYeFGAd6T{Q^XDZ_@7PQtce) z5Ipi%5Id}GV1eJ69+G7hB`QlPl(-+KdleU4P>_^YWBgXpYS;uCiohT18(FA|L+b7P zMr_b1*VXW95+?-5B$2@~=1ADjPAURSD-#oVMk!Mb>PFTI?#obC`#agtJ=7j0r7!rs zXZrOKbFpI;H|%@6%#RT{6+gmXY#pblugdn`b>xu92KAa4W&B~-cO25vwz(;c$%^px zu+!47egO-4lp7FYf`R|%1!wBE8Z$Gp1b8z*VRFxNqg1d&Mrlxa7L>QI8uYoJh6^u@ zQ>CG+ndR=Uw{@M~T^)ExXw%@?SjnyVH4TC4qMZ|+Q(DqF=skyMxd9?0qN^!fqc-Fn z6&upAXBOs>Kn#I$B3_jH?RK6Ng$+PWWbRLr>`1}lO>DmI9>C)OeFaJgZx zIs@Z8w@#ePNEDz-Tjx96-*l}W3fGNoT)_?sz4wqiOP zb#8v(1&nsih3oRoHt$$d*lG^Te3Y0T<_gLYDG5)}`|AzueMARJTSc z-xi;P#)LDF8oPu?y>U$axs+fBc)P%<5=uz}&I=jXe+DLK%6%86V6G<$W)Xz{-19k(du7;{h3Vr1D@N>abK%jlW>cXi}e(c`Ia) z8=ZT#nVy4j?F3SMt^^WiAyRw$*7iM}Y~%VnVBhEoM#@sFtmpc~ zEq>=ID6(}pK~_0@BiqcZxMK!4q=Nh6?B;u{UqY@8!24vR8L27(M}U8#P3@u2Kc1UI zp6YIcmwa^)hVg|7;D_3i>UHU9Wa76|yB_meRdO2)gf0?W`b&V{Jc`4oW}dusA{sD? z`x%7LU~|pgPoS*;?UAj-wg7x5z%G3#Qi_%kO1^WYx@BpRvMw#xCzW3!(3 zPY*ZWQWE`xH zpw~qt1lwMojUXlqQRbMON(+0&TIWpY$Ms#Vt$y6gZf0wu0g}3gQpqIn5-SF_#iV1* z^I1V!BA>;=J)olIg_eNdM~4bI##@#U9VJty5fKZQX9;+$8oRg%?EKsXEW{j6Qm}P4Fe^OpXR7>0Rs-oD^X58WnQj{aqLM;t^-E zO7tf6Kqsg;=9NamWU@q`=O=SK`DZGs%o@#O1tteoz!xZHnxdq4GyS*oIfw9y4~ir~ z?ddMM9TR($UqQ8A4>CB!LCBth>v^BtP4t)#mqoM1@^B|=Q3no$g?nv(Sy`&(@>*R_ zJ~&%9%kr`#bPs#h>p_ZiAplbrMCS2qwrboet-dFiK?yi={Aj@I zl76k(XhU7$%&%<5HZ?RokMc(Ls~n2z@N*RzgKI5f;)ToW&*v$It-OC0Zn`Co%5bXp zZBt$UC}&fRd)>=DiIBr!t6~;zj8`^t=eViOJYH;e09%7UDErNuJe@N)cN10272oZGm-+@w| zuGvyt_a_FW`~!;T0Oy3)aKf3|D0s#mjjF;!^1Bw_RZplO<@(W)@#88cgR1@BMq+Nq zGJYYTwCSxztgz3*7xQs-rK7!_Yq9c~=NOY!WK^#m5PW!+ukquee6Z&D>YT??N!4Zf z&Se)+Iz?@5&9I}#D1KL>U+Sokj4KhIV>^3GrsTGK51`Tun9@Qj=5>&iaLmYUDjVr{ zGo`3fM23t`?ct26y6gmNui+0c(%{Yl_cRNa3y4HZnebt+E zpE1D&Kc8M5LU)J4pEjlm!+S*w)r7Lo@l{>FM3u!VelFEvnZxbbSGAvdy-v80Q`q~| zhSKQ8y!|`PPz+|rvnLAbPrr9-)Zh(~ecOKXDDBhxLY(*O`L)>}I72*l*WPo&@-t!1 z_uN$A=99PeL-#%-+I$|yE4T-SS9~XRz-U?HC)8gW3Arp5(re@NhKSjS^s3PE z622p{NTZwGVaTN5yB^hKrx$fsogIERn-;khSG81OvdPgkuYyuEUj2g^7aJNNmshg9`|@9^30q=)?Kk%uJ}g))(Rg&+3ZroWcE`v(5rl(LbN~$&B*xwc~*Gg)^&Ndw#P;Iina*O%xh?;Hbrs+q_H)v=qtyLtirmi7B$*%SSyevDsh&{<^5n8ZWqenl^4f!>UO?bVBZVh%V!GT^tROZ zPd?If-$0ipt8-mBh4cKoz8#)i>mF$ZHr<-TAg6$e4j@_~Eh(M@j(?M&T3gE`!r+*y zf#&*yLEQXMpdNbGzyeT<6Otd``uqgK(q#!kRUK>6K|OREGH5%BpWE=Fy%}Oh37JCz zWVJ@3cM29txEGA(k5%2XeerI(T%{0zQCZ~L`57nO@4~S0nzIjBW_J9$8qv@Hx?2;m zI{Ad^Bx@6zGrYj-TtpXJre-5O>ZeeRJtAw~=ZCR}hsV8A&rvMmC6&P2qfyBGYP+w+ z)v~1{=ArBS_-MdI#)kZ+>$wXfYuyVw)u7k*^=V5X8oEFiSVpURU*+|bqS!w#D&s$L z6c*A=m)&X3u>XmC0HwME6HK0QpxR(fotFTjvJ8(%#*yj@CUW<_9qoFRL&O_DvL!AT znRQlG$mnj1Cw90j;m6~E6E|G}v5grDm0@EFCqpk_n4|b1=O0RfZ-$)76YyO1{K!n^ zj?+mxMhiXdOk5BF4n2&$`9h zgfKB;=eL?KKdT!b&ux!8DjeYOw7X;i9sAeG)p;-GH)uK9lYYClwbDbTRB`;LeK+&sK(l|2kPBV;fupfCGth`nU8=O=S_yH?Saiyn>M$? z!phyg3UPfB@(fuPF44+YafZ0ELm>X7rL|74=+Oo2}t?2t+LH}z3--Yah z->U=1i$a*d{NF}!f*HXE=iN+r{hOX(_RQ9|I1Z|H#`hF+SV>@=$*$qXyOjOJWPJjo z!6+=70IPaUeaGI9(AHk9A~JUS`WmXsjAf)_E1`yt>f);#*iWX+hr()a1PsPr(KcI{A1rp~=pbol}` zQDYgC(8;{SnPurU%+?J|!S|M|J+EsL3*S8km9W@2l=7C-5nxfchGEZEJ~_WydrPx* zw0ETwnGmqda| zNAaLI!yDv7if$&01$D!6H?BGt%SXJF~suru;UWSK<$d@8bg^5UT zXL*Borb1UEDhs6OM7+wWAG;O4iG!5>tICOf^A)iGm;3Af z@Fn?P&%){+7#!~MNyE)5e>Mc_pUN2IY$clbmjy{B*s}~tD)I#z%vB3m?XYlBk_pi8tyA+Oj2cD=q~dJY=nQs>5tikNLiV?R zyj}-WW|wT`M_xzTKOhr_Dc_Nc?q8E26p7BS zCieVxZt?VjQZ`EYOj!9HsD9#VY6S5(3A?3gefU#qmru{SeetdceOYcvd#A~BF?oW9 z?LS3>-^?HN5oA9s!%7`33ZP;&iL&cS<<|BJ``54$&5clkN8F2#VmEX*xhYlZ8SYHa ziE7;AC*cH!vaF0A>qtKM9{pIz%I;UBgnHKU%S1T+HeVjWV$J;RNq~nR%P-$Su?xIsfTo0-a;T*XQ zI%+#tyeUyGOvKydo0Uy-v1YbL9E6!j2?0qszp`wi9o5^K&`?PQ5nNVsExaUX8K`(6 z>E)BGxVpEj7~WA;M>&@gSiUmqJY9%nRCjqQx=UzR*Ee$I%a4Xzk z&{Iy8DP&UW8PVqX6Zoe{W#3Z=hN=c-em~?Ef2XE%0gMP{7^I&=9`<`ymjl`gf(rmG zCkF@-ssXS5$a&cEGUgu^_|zoXE}p+h0DSx9_a4y!h~C`j-s2T`1^ZAWfw|guDs;cf z{6s}I*Y;ZNd#~V*2d)_1zNz?UXS^HPVN>KP?F3G4ODHT`RD1k_K!gE%51r&&I>aIeDCs?YMqjHiu&u`F{_h6xvg zikQl67uC&e{2_(Bxjg0bR%9RGciJqIb`-IwyI2~c;75; zxp`NP<~-?U8LT(S9uL<|D4AnzaF91h<+_>jT2UWHI1n!y)Y9nx!*o6dajdBh5i4VC z-8`u$E>X=S`R4LnsX9@Z7=0|tqNl-1G_`DY($itjrA39%dOxqBw?aZ=Ph_sn`mC0#hyUF}{xVEJJ6Lf3z zkMbbqNcI0{B!6q~;q5*}L?&t!Ne*sR9i>0Om_h%J`sN-r z81r{pMz4-kLSA6M`@v^2GbJ9n#D#PCOODa2#&q}(lqE{8C2y{ev@D5xex>zc3z#=4 zN{oZ!&)@@*S(0J>2mjw0&;i^Z^qL%FGD)pHxny zBD)|(Tzj;;3+?2b4!tQY?aT5RpnT78nZ72Xed5{YkG zrQ+nkf%nC3N%NVTb6O53&SPaf2!=1&rM>pVTU%P@oyfm&G0H}o8wbCbO_*5f;{%kJ zC{u;XhjKqrcO)_+yPpH6M4R%`;Lh$EcjJP5>T$$wmilVqZ>v+ETCR(UJ5QUg9@Ui2~<0ZOP5=CxeV5Qfe22X?QA@c{xNA zir)3UjR5Tkhi#u<+$qeXymu|Pvz$^*72N!s?%JUt1%Hv)%NSesYD-~Gqyhhtm&B^> z_p?w8vFwy5X>fG9*Vq?JZewOgdBTq#G)?~~yW)%BuCSqpiUva$5O#TZrU12BkqGQzKH!Y>v6&b3#fA1>nLfmb!#SI1QA?wF^wp{Z!W%a zSzwq$R!ak9CV;#-0-@U05qd(QfzQ2nGCIAtF}gR?^G&yGOS@MM1|*L?i|qU(e6ocD zw-<0%4);BxQgR$)(Gxg}btzi{@-ye(43MN_<)Zgf>=#GhKKN zs(|xAEv3eHNQ+f2LUDki@I}2Y#sXmP`3O-yhmnuM1eH(L_~8W z{1)8)sNWtm-=Dyt=4ONS5Qz%z=vN?F31MyLaB4$;W3wG>j`A{sw5dfmvXb=jcOPZM zySX#ESsa27e`7F*OAtEO0z9_x;c8t*Se}j8nG!DbL|K4m)*IwM%$ngp^^!TB?2aS6 z9FRe;b<>F~#zZ1DsX@Hd08dQ{R;63t$LPz)+*OvZMYI`kRb}%P5`C6=YIwvPtQmT~ zb%j1<8*D0lnb{l>2I34%*cM`S1(?kq>kNQ@JVL{MjAx`##94g#Jn~VZ)DM*$ZqPdy z`3~z(1nUq0=kZ_u?Cc8&5F{VW;Kj1XFzoS$jM^BE^=kTvl(0aa@j6Y?8n`xrCTpp~?L_2}DRt}p;y`bTjaA^|AD z15XE%y*Wg^4}Vzf;U3I**^WO$n2sUs@mi$x-f7dkW&AQp@^=PJ!&(SEC%)cZ0`q;# zYoRKYFB=f{ve%YA6W^$MNA6F4iJG|gk@R0KCvyk2CGIb`V&CjkApQ|6Ro&91;BSLl z-k44xePow45L9FxX=i|>^`U;<22a!=t%bX-2977yZ>MJ~Cwd!0!3*c$lni-hhEJ}% zT9-j4Pi^v0)_NiIS+GfEC!@NY!#qGF_57^j=>>*1KH82UzPQg4``u?bZD;+U>^LlM zWtn5x6qDzs4*gbw-tOd&23=$_9f8AG`hSAE`h?$U|H$EibC7|LFcxbUSaBaX3Mth+ za>uvuhxy2>u%FpF)v<)s{KS=uLPY;KvcT8I|GE?`*lB`pCXMe%qG&<3sZROWfQB`b zG{UG{`AEqOYqgk6mODM5+?Nn&Ba7{4?*~lHVF<&cs-^t3)gBeD{$QXN=Fx^JS#{s^<-ef-$J>+M$6mj^ED^jXA$c=-WpnDv{^x=X0SpED(2Bv| z|NKKvjgg)-#b*{n%{L;yvl4si8iq*lcJn;`XezNtP<>^dxb*w8Uppe`-|=Rd^|R`Q zu;>%Wi<=_Bf}dnbj{BQtf=+?OM)0mA2by> zXK0S=5MV?ntgPW5fuDq|KzJ(+Ld5HQ)~(Fjy9>PR;YHc>YFJv-NC#FVbOZ4*9yoyy)ka;~+27qGrTgdD6-O2`FdwUXS3ngTYz(*qsPO+% zm~m(jW?q$ee00je@z{b&_b2muzoqhGp%QAI@I-Mb789p@eT}f-uTJQEfz5^&tq!SF9!(^mLZ*7n@1UX~ zDJhURt|-9z$`4DEb|z(-YZ<&)Z8-9VWoOc!#K=&}TDy9PfS25<_>O z02jc*x3qSB2Yx8@YEgnn)*$Ks1*1-SG1WK-U`G%Syd8Dhq48n-5!VV#Yi`v+lJW0e zrgk_NEyvum2c^3iyq&MxQr#UH%zlPXL}&Oij+GEf?y+J9=CU0J`(Iu#f@o=8#fJB3 zp^z@q@{C*Et4V1z0??ts(Zqc|(64E^RQcc<6~psU+bN^u`0>b=DS#W9j&ycr4O*@` zgTPO&`}3JZkC$B_V^*(y%SHOhK_KgLCmZ52j8j(Ww*X=_40%D6QAboOM}z6#XDHY6 zKG-`%MTSQum&1Wrep6ovkf%Y_eyaRQH^+Li=kU zfUMDifra@=t_-d4A|u8e&5u8K!F!R$wy`69eF_uwr*GY4w$*ZMV@kOj*lr#It!LL^ zr<8S0N7mj>1=0{$pIkZHzj+5(o(|k+Yd49S@>$+aVlx+FbqiMZFmEVnSkzaYbSsa; zINFo7no(dxs}aHNIYK6bP3_|wA*pKn5r-wxGi~@Takj_J?JRhRsJ*9uBVgE-Z<5tJ z?}hbjg=vzv)V}%o4BEp_IH%hHGH&?exDFizcbnVIT7$H}a=6%t_rTg^2W^TY`~lM! z4j40lpCmCXJz4Fmp=W=(nSoN4)H`~@2S1R&&+Y^PBUgrFc_=Y&pIv0p7^Mo}O`c4C zz7&d)8dDqmQR2QB8fii3PijUY;`UbOMn`lw&+#UR-8Uk2=K;f z;Q{R8_K!_)_M-g?MRiSw|v6o;Aw}tkl z$-ooVHJq|>AOUOnS6-6^rsk~{irwEyTq1!9P^hgP=iqHX;hl;U6zir)MYa?7=f4pQ zJ$8Mxmwre(|Dxc-zC<*qi!ZZ-^gV9rhvrSUb#YtpjixU zA9a7|w|_Z%(E2(mGw`AxS8%`qy~eMXwjue?Cn?$iDKJ3mi=jzwz^{P+ykYe3vi~W- zGPn?yWErHd?Kl0uT^PfBe!~`gD}Nl!o|K6UEPiI(f-&AJ?$Y++YJr&;TH zSdpE=@#@&}bn7|tI_{O3KJHn>^v)OO`fMb5)w0?IB?%|f5x6!ga+!Rlg_ZLUrSe?5 z9j2A;zH@@|zg=t*T@&bQ)xYk=wM7{@!*DQ<3T_##=)yq0Rmc-b#0N4maRJ9~?zDZn zbkqC=3*QlI0v#9qy%(od=0v&Qa(3h3%xEaPWACl<)R;)h&RRgCENRTK9TNSFV#?3F z-R--E3Yjs++XI5)CCe2=4x#Zm)`eRm64uDyVFN;WD$CCQ+o1pX)WSjOg;hfRY>U!| z)16?z+NajjoI}-pUElD7Y8>}P5I^WRZOuK&a_dix5VPqFgB@@==vRA?t>JgLZ+)7{%7d1txAqp_|etz zhZ+Wi>(8dDNV*Gk``!Pur4jX;H}0zy#XehCzH1V4@g;YUw+fk+BqFEPeaD2jj7oVl zaR@6mHTi+T)Vgwb_%m}j$ssg`yn3A-4IEs8XEywVv)ET$QS^*>HP!)fPmj|l6vMNy z=9f5;cceVMa)Ulv_99U!;y?!|7{Z&bP@dFhUd# zTq=>qt_@`n84$cC3l9XN zP>_IDP+}$bKO#w{CRv}ywxUeWMB)~h%>R}hLTc~J(b98%Fr z9X^&xj`^URFN0S}U}{=j+kb&qslS3wh`}!C;~A~K}4%UGZ zAZj1F&V5|GEx+d&lVb$9b$`*}+k(4Bwpy6%h4UQ0>)Lji{7Tbwn~>oeRa-6yoGs-F%IdkP7aN zOhPeLn~$UB>(2bzPnnktb~ynV{C`Hmhm8YVgbyw(C6DMBck3RAq7)`b7v7qCeL`{h zj=+bPEDWQEh*vs+!LY+KEXJGl>~mMViW7;+Q@hB=y{GOgDlM_y686-yk)J5p$LZrx zB)4;@zENu|GssY8Tx_X*AQmk2NwOESxlNrjKF>%`kFfGtk)m$B_~o{_b+$1(q}!9l zZ~L+8iip`TuY}bw1@@H7SZF%!poYylHETL)y2}5ZYFV%UH@GQ)h_rg2P+T7_iyuOq zkkw$MeouUEZCoDy_}u+k)V*QDLw}zjwSQfF{c9O3@U_KK+5%wBt)G$29S9TF0=&0C zaJ`>;Pw!+450!KEmP`)tveY|pZha_!{G*Zf%N&$*A&^}rsl5W^TPeh|h8d(~wAv{l zvzL(86vL2sK6~_{J|ib9(|LPmzbY%mE416MPRP@QWZc@J#zs%Z>JpdDkiO7)2uWmL zMZmkyd(;o!XF8OkiXT}NhL}ua3rUGj;;h7e6{_!zN=K^PYvqWD1{}{%;5Dv#vtyXF zT>NxXQbk@AzdpW_ z#P*NitZ~ZZHy*OndSje5bFJm_%g_3bc@=5vve4`V?rPui=mGHG$NY%Kf9t%4l6yE89dDWOEy={ zomf!1I9?vhV+;I;Kc80WZ!^SOsFaye6Uq}>>ddb*#+1kS<@K`f4|rPb%TnM`XGq6= zRmZJV&;7Aalz1s*Y!yuPIeYwmdiC%9<}KP!NHX`62b0W0k^CUbrNi88U4;4Tp{#QI zPD`O~2OF1vdsMh#4&iLUgIfgSYvDe4tJ4-3!<&dHcjxUp(}THH7>Eu^-a*oStO#A; ze#Q%YgwRbE+%^6{%gE~Le8UrAE8c|xBVO2A1Rg1-zz+&gjv{qehP~lJ_5zc+$MO-q zZkxSl&#^GY#<5%sB^QzmA{S>#jC5;hPm(y=;4Lbnmn4hC+1cdqFGe2Fncn8M=~N}?iM z)$>Ann@Nj#%%zI2KZ;Xpsf8Hw(NfcYkf!GZIGFUUi81)3f_F>@BD8`wtLi)8mwY#I z%$GPr>`h&2f`ejOSYo*c8P-KVzI|TA$Y69CRqNnLn#WJk6V)syLRX%zU(UspTRJoY(iXp=vrh|M(>Lbe$kI#QaAw@q>@$VLezh?Rn zK#RC)5R7BD{uuNLWOxBG4h2+>Moj3epHO`L8dj!By$WX zwpaznFI|(hes$743Qp(uX6&xA4SX%NZ?&2;hS!)9gYK`uR=@lgJDUH3T+q{JC7ZE; zHO$CjKlB(5PXr<>V?l2&|5?W3eJb+XnQJH%lF_vOg)+)fE@PN`0MftXxIXa{J^=_B zRjRA!_56}gJ)6-rgSi7KUWHFZY7${I700WprMtgsq3@3p+h5RgpMZ9O!MHC!H9Cr+CWJQ=i z&q`@PWm<9;d?l?(zHwINo;aU#&%DpL1D#&1;y3Be+|kXq_yWtY3aJHO4$V{A6=q*R zDqUUYk%G}obWemF|GjZmg58Q|YwbhGdQ+3rEZXMJ2Y||5Q4NQ>g#u2v%%S?RY!%M} z!-NTdO=9Z^3`uO+p=GFjP3!COtl#TglkvYEy#wh;W0K_(71B*oUXr3U>C#^ZFMfwV z#WG~HkH|^X;^Nh%Q<;InWWWCOFz}Be*R3^cFL)34oPL(B@P#RDj-0Fbb365jz&UT} zmX@=Hqf-|G8dF@C4#_+s&`^~!-P*kT$E&^%crzcMj8$BOMA7QKL?8Q(g;R1QY5wLK zjPIG9Z_w)zWGw&gri3M}sV^s16DXu%;;X#!Bv%%qLx)lHaec@z-n)ov&FCzzgXS%Y zOP0ieqhT!?WB$57L9&Cm#4>(WPS`X+_~u>loQaeR**@2gVR;)KYO_e_y^f@n-xpx2 z_n2TvjxOIG1JvmWnAyCWz82!|?JOQ$gC`%+R%9ssZHjBKl!}>%y%%0aSXka1Wl)+< zdsdh$Mrke4DSTjgXbPSgf1=X(3Cgl~1|_gbITL~+S*PW$ApfrJ*NZ`l3MklB^1U9! zb$EGQxaFD7J3;u9=MioxPzcKHl}oy}lZZTa^&4V-%ov){;5Um;pFWSsK{-H`ZSvM( zx@(rT&d4uDkJ-b1T;Izifo3en`PNErVgg0gNK5K{@An}ko9 z<4*I8dDuXPeBjP!g2s?8SdpvSI%d}d;SWggsR{m+4iFcgSlVgOn|G|2Ob#_DS(hSDSP`Uu5$V~p8 zft%XnH*TqGm!}jFuj#$AP8-KH^YTG2Oql_h=|}Rq#oAonRdQrEH+<9LaXvN4UY`Sa zz6=Oi+{wuDYi2M&_}>CQHs&LQ%L~~<=~;}^gM*I~UljqKn|ulLD88c0Xksk*i97T; zL{!y@AHf?+ttTyu;vQ^So+*ZwzESXAM5a*NRqj#y^pGXprH(3d?0E|HK@I8+Uf%bw z-G?OVm62JC0zFg9@%X}P@aX6H)WtR_=tZ15JAPN@ibrS`S)=ybhD1Mrk~`~+_d&AjGL2bH8On~qx!BJNiHcJ%DcltoOe zoG)(l(A`X)j{CHEh1M`(o(R~r|ucX9tp||#Z5*V7_W-H>p;9jZ_DL))ui|qRfo_!_7eK65; zD1nT`v*DET|EYhM0Y8kiMtYqMIK^bQ10xi@8I?5G`baCyi_>(~tf2!E6*_gWN zmL_I&v2eOL$$DRGeR&*e_h?wRrmvjrXFx=|K1*RW>rJXm*Gq_gnl%@1K==Etz4Ehy zP2sik=#6WJ#<7e9P1AgqbbSivX{=PBUy;|SlOlf8Z>9JA+*q{CXDRmbfMt6mt3K(+ z8S4#dW=pQ^;hb({UpYQ*GNd-MfU0H6s1ai`i8ta}dZc!uMUk;MAVNuz0P&{h0_V z*MJF(lmza}s_1JF`8)r6FvAt{;x8gA$X=$pckfcr{4Q(*N_WrR#~llAqD$sI+U@&cB#)N?F{0G7VPMo)*}jJ>%QuwxbtO^7Z-nh?t;a( zjz+08E3aVHUl0|Ytb~a>XWN9WOT{xW!jrVVxY}^JtFe z&w+Pm*qZ8QbIM-U@;qHz1>Y5lWOV6Aeg~=vDKba=p=dOI$@w##hRh?rF;ZE9zTiy9 zatl!PZCDof;;tRUsR$&!Vk}{tR+}Vb7T8z&XfH;#RotbY!r%jZ^G3!?hA`~%qx6a0x})y>P0WO&r>>Id?J z#w~ss7DoX^bxO*$%SgPeX!(ZhzVRq6u{bZ9t)#-eB;lE?WS{z*+0x71fLtYJ9o84#4c6Vf71PFeX+#4Oj9Qk)g3wC}-x@1}<#z{6U z*Af$l1$beOFeNLSs>flGRb66zT|Bh!3J!M)Vd7HhbBJ**MIj?_Cj1&AXj=Ycq|jBe z33AogS8L6lfiqcS$x^^wtnkus;@6sKy2-7`A|EsFpAkHNtX^A~xHnIDwf z_(3tEg5GrO9x}BZ!&na1hb9aUH*OmzK(gShA?nEYk&_kobNY908h_6h__y;P)p_q8 zbxYhCGB1w?b2Z$Thl~f&Q$)ZLSJmr#W@LkvL5Nv_;wf2s*3sQREmZt1&-!>MPiKVj z=(8Mu7wI{_ig1WAmn}BWF0+bQS`IBFkA=9lkuuc!4xy=O<2>UYA)H|Dh?s~>PanG;g6Qr%+Sf**JAZ+TDN$+%*^>Kt0{YdD{={glZC=gbqN0eKGrYy8dteMDEk(WBr~} zy5|qz4!lG@Rn&*BLB1nwCqVuPGc>?Ivy3#Zkl8u(%fwr7|B87>)?IQWYj_BI{HUF? zW3889WpD^{NHYp_G)cj~+%ZYDhT2)m97ir?uKWj`;Irn|XHO@^9*NRY0cDd9oM(6g zT1TOr)V!Ygs;dE0X-oC$Gi2NmA+)0G*z|VjTeJCX6_N3LC2cQ!G%LVhkE!q>0bWLH zn7BN`+WJoJ_~q5oKJt1u-`+0z@;LAdK-CF;_tp!moNTWf-{rj6nOK;viT%DfY5ILz z0Rq$de>8n{SX5uswX{e{H%ND*Gy@{tAYIa>q?E)+Bi#*y2qG;40um!#(k0!}UBfUl z_nqJSz2Ber{&Sz_o^$qDd#%0qx?h|Se2sKE04=wg5u?^ve)t`MtU`y%osf614r)W7 z(h!pI;@wiK=%?#$vYf?6r*@z3?9210pOnyFsEQYt^>wI1MWJp&>1B}nUrJ3&WBx%h zYDs42JMb91(YOun>}`f@-1B_LIs+bIaR-2SB-jtRZqDzmUtmW6h-b5M7-b~7O?Ou^ zmjwMaR(g4>l#FTK*f{kUfpA?Ud?#~~;X0l?*FzeWd|MuV^<>VkCR0vO{x8FWz8C@D z@K9OH)Wpj|~Bp6qeO!HH<$X*)Sx*aCwd9AdA`tOtQ`G zZEw2~60sKg?2|DW^@)$mPcPeiUt0Ncw;qFr4Fmf7fW!9+orlb$I#~>|`%ezmp`c>X z=OwS4I^+%EBs3*qwRH)1@Cl`C>);#8RsH_Tn8Lsw^~>Akvs^n@PG|mtR`D+6!t&^p zDs!~i`OnL_Yyroc!<3y)68ThWn?S|v&PGD+7*B~k6U74X$W<8bYENiGpYlS9h5CsZ zx13PSgq6)Nrr?_Q`>l|s{&6Wt$PdNr4eIcgwGhKAkN$5kl;JPWXm_hlDWH&m|B zg$OQK1$6RTsBC8lLXq12WI6MuTXqMzif1!6P7}rDv$%Upo&N;WAl8B52w0)-iM`j( z<-Iu86G`TQ^O9~Qhs_@4I95Dgbdfl$_jPIrHI$;sbyWjxm6zJory27?)xqAw?a$@z z+3-gU=g|=oW20r%9csy1^fJ3(S7seqr=;yc{{mqp*tX*nwAoM1VHWA}%qj(hA+|qC znHp-j52SX~B2&PqTZShKplsTQ1m1^rLQn?qA{m^As^o~w?lsPC20d1^S^=DpDLGG? z*ed|5b}Bqd5retGB%J4ep^C*rCT|}aQ(oyOXVPlw2z&Ugwo*Og`F599+^EU0;g{lj z^MKj7;^dGPo8*$6;rH<-JiL8&t2w5*S7Q7ki&F}m?=R-6#>&6U;_v@D#42*U_2oFF zndi7oDxs^<;>PK4^jim|iW^m_DnDXF^y|3d(y?;_^%%4cAo6N&*T&fYkrK?4r+Er| zsokD`Gr_kLv{%HHW984I(Id<8!}W?&>fzYek$66UdKoqSmyi}UHORohrkXtIcdD^n zeRQUe3=;e;Bm~duKs(NJrWf8q+7mP(mtCUHw}rAu_ob%FL>ljm_a{q6qno=HkD;Y@ z)#!xsanMFMo)R)EIRzVLSfQiy?j-P!2q=9WbsOfoP-m5IEw<=*Fx_&I(D%r!-HFlV zav3~0UbG`|w;GGwwP00x`YPTA$LaRrj`0}@2$3r2eR1qZo%6kq;{XWx;3I^(559-( z)yrBU-5(GHbL)3tYjh1Y{2h>o5W8<2b3R!gfC^~>gU|PGk9dn2V@OY`=f02_4*GYAaX^u0s3vN!LDkUlVXy)+;t9U`C<}jBAC0Y+uW3U{SvR209-2cPwhVRE zGB~xfTIMOc=5pUbMC`vZ_zZP_c%1GDW?%Xk8LK0A^E!xGY?6XSs0*n*@b<->;zA&M zmM;Rkuw*cCdbe`DJw7KN*i{vYZGH-340ppGS|zcbnvj} zV#}s69f7d=A^!^IIz(9w=CF+DmmLb(E#Y%i0K(4u2}ygj1am%iz?a-j>5+8)e)kD) z*P6@@)bdy-y1_0hk?0l03&(v7dw7T;x?~1DM0bez#&`&gM5cDFmnW?F?YX%A6k7a>szdv;uo@_$k50$NB0jIzuRp4se5Xr(ubW3^Z*GRVTsrc(nN!*+avY^- zBoy2FqLP$}ymdcoHQExc0IQ*^2IJqG4(mUh&9sxq4>2Z6p4)wi3O-%jbC`YCGCEzZ z`MgVxIN_JwhJw@~o+|6yoDC139})Zs{})?XL!b1PhkHIDs@UD0-lZvc&Sv%B|JFUH z8CnDIQ~~ATOmOf?d+pwQnj(?BX-C|h648mxdgBc0dK*MBZb^v*s~5=KMKEqS4R^m> z0H3RX@Faw{D^)G&w_-TxmuYa)akcQ8DL=|PsW5cBm^}BOD4POd7vxMU#KsQz{#G@f zPR9}A3E3{?!6n^v$K82GTqn5d(MqOz-!lQirWS|^KW$(r%bpk{je|X=2W=0yTt3U& zQx+;pxn&}V{j2Z_L17$o_UfNQKfM*>2-I*<;x}_dJr{Cj@9aFlts}!S;N(sx2OL8E5oYnXfMM~V4|&TN>y%3g6r)#q0O~g@01Ipk{>}K@ zCv!#YHY`KzsGo@dykd1Q-hP_Nj5>EI-z96i^4g!~3&fv-lRpwSY`yzXFn?~q$q`r? zW;iZgZTZ3jp*8$h@RQAaTcd1p&ZE^Ig^#=jnb)n>qDh%|2-lUinSKl5#kxof6>@-1 zuC0GyR5TveN97w-j-GM83`2L6r}S?6Qs?ZNZuPhcuWegcIN{e8CRQwXw3a4PVSs?# z9Hs#<#&x|se7y#>cr|eiatCbYQJ$;j{GVTu|E%P`MSN-=T`RH*CX0MjL=RM*0^LtD z%o*seF&{msy~cYYtQduP@X=13-4WMf)N~z7HT_W26&|ZT za(;g`ok2dJS@9!Tts+s`gE6Rj#do5U1%wf(r(Ymv%P(VMy=LQd!KU9tFalL?{AvnC ziTay%r_%{ne*2ahDUyIZ-~!G`{x};Y&gjS}dvv+B_J^Zl=wqMUy?1WET<-Asq#5$z zz$yS`eo7;!qDgxP>Vv=r@uxp4;Rz66pb-z6(w#u?Gy$vrt3*%*t(nMJQ`KJyLcdHo zk@seq)FRUOY1iP+4>y^gC9FN8P7fDK_HMy_DZ4gWfZ_hVn2ja4nlKkj;X$PA$1ytU zJpfv$d!+7Hu-U^X9O8hetV1KA)3f8uUf5Q!6C=XK_eaI81kJyBPqrn4>wFm$wHuhD zcKNvcc=p$x0wwM0h_;Y|&*PP}{)v3CPi7&ue`uWa&D8tcaB`C|?I420yBaAlgFhul zKGaDZ_#!_^*8L6DMqJ|hVka7Eem`1Kz*Dd@vLk}O)VL$6_4pWE^Vuf5bJ`7fIRq?W)PC(0{vk@sek+Sn5fCmy~6hLf*U!E zlV+TpEF^G?Bzf(;eUp7E;9~Tp2hbviBq1=LySlpx z*l4BgTGJaRT#r#289cJ#XB#lAs5%1vU#JCzsdykg?ErS9&~jQ^4RC=~-vajglt4{F zJ|`GeC`?896O1Gf5%o^|vN9Dk#|}nUb8`grN-*5;VZltFp|EQW?+;1JMM)rx(>EgS zo}XO$7X%H0)t}FXz7Qn9@pC0$cwNSBY})A|7M9Lpx0`l79;m=e!S)`Z>T;2OPxw#D z#I3JU#TcB7nYb5iq$QQZGMu9^7vfFzr8<6T#Pyms%xc7jgm-#S!PT=K#U`|beIsX= zW$zdlRK}qgAajnb1vzycfM;bA>KmXX~ zxX8a*1+YtDj~+^uF(_&!_)M<2?QNfHEgn;#@KU23qX3Q|6O`xH93pq*m-L-1oJ*1SE*d0dB%J}=+F8z4ixaP{Ie%xs!}8|1^A5PU5EN`HOtcYPkjzG{Sn5k& zer?_9uP_iu^{r(k_~v6+>b0ZI^4}ZZRCkS0N2+Kx&v;Gi5MIC7t>qU9r1CdCSwd4H z)JBmgRm)k6M3h-Ew=*d$IK+>nEo|Q}mj|U-XtiMBOX9mg<~R+=vz^>7s=5wkFLR-S zrpq!>gM>O~-uZ;|{$Gr!@X-KvVC`5g>y>f@T(>(rHh7C&Ux?mn>m}Bz)G5m6YOFUz zcqO#i^o76Hj>(WWbr!jfta|l^NUN`w#W90Dqs^zxy9U3rfnGWO!ME4@GUudw4dKla zlc5hFV%L`5xH}l1NnKApA;{pv?hZkG`yk}GdyKgIJpV?((FpDP8bw_noQ@LNxXS81 z$SM8I&BQr*ki%u{3q43>!qVa8AV{;>-3UJMS`({rA_y^dPLA(z*&;ZfId%ilk+pe^ zv}j3&nip)2p*Rn&X-j;Go_2kgmHGk7>a(f}Mg8nkR=0Fdr00;LDfyz8eLd*8dyEa+ zb4_RXGag|c--VruwWZ;$M~Y`XK1mz;Ow8?hd}eOW@8t*k5RMIw@M-Q)y!SBpi+z03 z78*QCj`1wnP|fsBUv)a_2g6rE7`l}l>P&el#MgqXp#+uJeP(vxcy6H$9x=rA6*W(< zqB8mtTq(lp=i!vzT@g=w z=g|F;ebV%(&2!NW3z2U{^xsGShy{LnjC?%e(@7>PVhasV8E08OE%)3!{P_B*qk!7)my}1qIPWQ2nE!B*~&sJ(c~n z-;e2QOj(`|DjJhK^2y68ZYr4>*K?)8$o_*Po#4!}c`dM_pka~i_RF}03Kli&$1idB zmW%fvacQ?@bzPPv;vZ%#38qPhICC|qny&qI=vLIwS@ke??7l(huZSJ%RGx z>lVQan+9s+G__5Vd()gI@)PW?+E{wBa$I?^81a>2iDMPz1)Bim64cqF(Oy;7 z#@Q(5FnK)>e-`Y~y7A3u%vQB9cDLjx4F~j;d~r>YDb=a$F;a>ilL(5ibdL3$&4pM5 zk}Su|L5A6@26%iqJe!3|3%>d{)-ZVgzF(gbd&3ckUOcZ5rnkmHjhkl3hr%_dn}&6g zU+%!^Ju+hlDuq@xy)ea)b7P4$gjmQSHv z+-;TypdWUIyfaXGt?sh}k#T31*P5G-AUDfscvV*az`!T6&(G%M?tF_41)e6^4Myt5-|TyoL|f==?BFDI@ij<^o619+skK2FVfQVzx#Qr3!(M+DDa@@@&4N724NGk|^OmVXYMvOMRY9I6m_ zy4{yq<^WUNPva)L-+>#j>f-qD5XA5RI*bi{!1gryxR_|x|gKC z0Zfos#QU?bQm&cB2lQdokVjH1vsH-||KgImQw%6U^V*JI1tk=Jxq~BZXKxL^WCvl# zvW}%+jYA(jWM5HZ_;w+QIuJfmdn*_}!jS8`ky(5O!J%k)tl0zR z3HX|^Wz*!NhYEpU7}2lDx#jcC-km0!Mya%r0}c* zn<`{M`OC#g$CHUWs5ONd!1aUap(OZWM%N2nB#x_X@X+`dRZ*tx{dZfGK5(Dr_5b_oi#|*9?STVClkO#e0GqOIK+Ig{+mxIrxA}(56Q*o z_UYYI<{anZ`^GVD&tld+l!z(d|Q~Nu$G(%2lM|^MWDWi$U#gz7?q z@hptx;rnODdaUsTP44p6kv9Cref5tgjucf_laF}ibk9EJ-LA^=bs9byY>SNNXGyAG zVZC3N1z>wN>*({l;Q27I0~vnb^Tb{azAA1a#Xh3?2iVUaZ`-Z` z2^}wa_-u;DgzeJmr4|rp`&dU-qf+rN*)!j!wG^2#JJgiFbKBUfjaAEp>FJGyw}QoK z%MrT0kv(rnXNUU3jwqf61y+C}gXyRzBI85MWQ(8{L7_uA%$tSS1Y1=bWfLr3{Ku5x z9NLG>4~%B5yI-Td&S@%fyvNRq-uPngu$!x)iW*3Mfl(b|71G%LQKOaj7 zE9s}lD&`_P><^ugx2>R{#HMN~I;YdU&+{2eWvRSXHMaPD#Y`{Xogft^HR^r03edOh z{v)L#Fc(5=?%#d2u5I0N6$9?IW9CtVE8*{`+Wnh5Hb}EuKfdq)BI~*|;5VAY?^vtL zzN&BB??Dy}RRfjkNDL>a@r#x3Aa60h}KCU;-{8R>&g%7@?LS8L&=djd17KDwqfN2M@|NXdC z@sVB=n8);fXygzqD^-doUd!)iw2Mz0bPC`*AB`!$x>n?)xSYf^!KQlJw6WR!dN?$n zEZq8JPs8d;Lz)vWr^lHWMcwDzf#T`-XJWug*LA5}NIJP4{|TFSmW=83&X#x@bylKK z+V0ecUyCPEO!CP??@6V;&=9`w{*oD#)3L*VFkCtl1W+e(yBqUkyAX?(5dyyXVL5Q9 z&DSpH3R9k5={^&bIS-$!fi=uu0eM7*P6aVPQbTO};S)>da#uHyi&Lp!Tn+OMl)h$~ z@E&p@8DsYnEs>tuAH(*eEbr;f;X=*v(vO{#H^P9Fo2of`y2{!9}VZ|6?( z`5k?zb^OlRR1E*e%t=z3kkN=BFGR7uKwhU3PZO8JHY;)4O|SN-ruH_t6d zPjBsh?;M>G@E{P!L+KOgD{=If(p3?C`s^J{Hgf!LHa_>yJOkfDcjJ&dg`RK5>Ia@h zyl;KCWX>W7Na|YKG>1cVq++qjS_@K|gDLPmwPAmH%keB2uDAo@-&xIraI5$bKgJ*E zwNhF7O(Id?WVp%xJ@~<5J+*N{N;O&fP%Y$3cnYmq5U^3?Ilj_%x#!F|%$9;6c5jy` zV2b$8i`*N`MN?V769d}bpISQkCD#=`2V=+5cq0R%#|!yfKHi89%c*C^;*J%55+G5u z{)WuT@|)&(vFgq0*65`DaUa$*=(k5eC74RerZS8O8Vo>Rb>CvY;A$? zz0b%yz`hlian!Jb{zIgU`fKl*69_q>bMYJjo-ESzcGcMif^&2R%5a7h@GoqA3Vf@NsuH9Sxf9 zLVf-t*&Z-&Kt~M;1Sh&y<)6AsOdoP?&tIVJ2}^wY?6H1>i>!QYRi=*W$A8U8=8GTT zTzu*pmVREsIw*L4BbAQLoPjy6%W3xJ-xd3vWMv5`e&;vn6gKX&BHzxZ%egDM9v{zi zJwzCEmN6Esm~MKbd~DcHcrosKyjJcr-2I^T@K4(j`L$N`_{LFmvo?h+M3wroUlNBc z>6s4iehOP2hr}_PWr(#;w`@#N!OoR`4_OX;7IgT=2$pp2?c5%EmqjHIkdtjn_QQLd z)2#8Ieb5>5&haF_S%>cHzT&EWL;f{X`^Y#q&4aJd%mz6%_=9Y41q_=ye6{w**zZBr zP6O4y>03Fr7JMR5yYzcC;Nlbl$_n6ol;`&dbu~&pUIq&d*MGM(Y78R z*#-FlJnFhko6aF*O@cRuz|+`Vw?pQ*PA-Q_(*Ct8v6$S)(3%>tsw9d~LslHCO}ItA z6k=B(*0*XT@O^Ttif?tPd0#g3TS2S~TyT5km7Bal9Yu9Iv4gNnCyapH>U_K&{ znp7FT%SNbWh6#G>@3re(LpHydIoqVZx?=e=?4Uv|gF-Mrdh`eYI2p`0{=XsnaVXA5 zW97R$vp24$8g!1XJmmV?j zyOR%q2SzMNl8s$ z38nWrA1O5as^!!6T$2ezTxwl@uHXKoCdY;c`|=YXG89y>{;T$2Ll4r zhk48nqd(sEjXb0Tf|Fyl4vo4j>a%zQp{##N`Z%9@=;aHavs$EP{sDpk`)fZorSDsh?$M zEH9KgklyvT`C@^`5rHd{^Y*BopHOkSeK*P8#}edJCHM~X3ND2bbH`OfYKkH&7oaEG z>Yuh!pj_gRg|%8i=1bAnRj-FV&fD2wNsk}tmj-c|qJHN(=$T(=v8M?;j`R(YduI70 z8R`u&4Y02rWiS`@mHf4DVprT7I7?{gDVG0{$53QOq|fm3SwufUD$rmL&bmlg2o!GM z!*~V5LB-IP@3iTRl`Hm(s)UujvP5|!3V!}miv+^>3JTQ#9h8#j%lyvP9vX7>AyNZ> zJro+llIRWIn;>w8){lVOLz|Bb5=OPG zYr1j6Hf3=7a$)y(z(+sow@P}Jb*T5#C}+$&Y=Z50v6Y7H*jo;GD-ll9)wcdV0 zZaIunmuUc=Z}xCBvv$UqMcXgZ?o@1We|rD!X(as+ev*I2d-|?QM6C*|qnv*6jR+c@{|i)f+B>1J)o{GLgw< zNmlZ6RT!S>9N(P#*jwp3``MFOsKcf1W=az@6Y=>y&K-1l87RL_=~Q4ZTLM=BN~#lG z#hsyHXEy)r9@KAu)IMP9ZhfT2ND*nFy9LjXJ+U$UT9@(}Y4I0Djr+mMNb~vI`5yj;f~G>l5xqr?j}gFt^Ev`(fJQ zlZ-ebQL*mDur!kdKAmjcD_@l-%*vEs%Ui>-FWvmhDibs@!+M7aHAulvTbpz|j=R&| z>ShZKcP2cUPEuk%s&^IrzRKhiRQ)TCn*qoiuJAP(IXGK722*%kuh~nMTE|?=dxxLec!VL$?=@q5qIpg_KzsxKEL@v)dW@2Y2CV_*a7fWTO8395=D&l4G`nR{ znk3-f(yyuFEJKeSjjoO*x>2?d6Yszkb5%yMYy86B^=$ioqn7YOf5tuX@*;Qe$)+sM zqjcPF+!knwns&{-D9`%z>iOg+V(}B2Fjc$_I&;-G3NjGVIBFPU+BhDgF1t}9ja7a? zd)VuUjX#^Ztz>Ul5quU4*(f}xLzh?T0#OK15jEXjn>yh|1vMY12?nb6-4UCG4=Rg^ zGf(GHJ3037HAd9CsNm7^?XN?@jV7?avUMz|)CKN|sfVY1b?MMwtseoaaj zvT0#ogh+)7ROw{~p+9s=)s3{NgKjkHqYpc#C3e@Lpl%GjB$!`u;A04+bRpzohW++x z=g-(il5#MsUU@GDM^c9GeTjv2`8p+mpgh^a3L>~r(PJgoA%enY%~7hxUpeR=X8c!p zw2J{K}eQ3P(1)?9pFGVD_w>(*pYVj}5R)4=-vuv2U;*^a@bi@4=YZD`t`FleX zP7020&<5zL^V6jWE^cuNG!mR5w>T%6P!3bG1OyTPB8v;aDI*p8lxaceFmu4XiTiTS zqOYW=?7ZN$!KJg%mN{B%Mj|I#SSvu=qZMpaPj}0L`%nrq(?^s9DM6+MTZ8=+> zGpOst`I58-O12UHi$dU5V21QSWkPK#t>rr>5#Y9Gn&ZefKWbKg%+VO>wOvR=>7%Zv z#>#js%}dRWSuP1~eKr(wv``k$rX{{2IVN-f%`lr^I>zso$Rad0xFk?L=gfNHTh<;d zm}}8qp>x;`U^W!z*sazGbW2DNs1%d=3Jw|uMKfm=rh_q%p8pqgkB9#IF`QtaVht1> z3^+K}#t?0s=z8YvI0LLnPUWNKrpU-}>w-?XKddyPA0HJMX|pHI?0qY*qn%TGEzAFj zp7llhlK~O#$0`(Rk3)Qa6MkA&iDU$4@jBB83Ut`R%nf+2OHYOLf8KMb_VBvfO(hyT_% zX96p+L{G!wwE&;J^z)2gyPDOOS$8GYxg2SLBuc8faX0T%!Y&TYzk~%xzQ!0fQbTK) z(O(VxQ&wfxmhj_<0=2F2RA@yJtl-6}Z_c5OB}!%*HKeP51B!-voe0H_#=O;%mn@n~ z@U-E%uec^5;~sh7nnM|!q?`>mVXgs{sJ-X$7Q5qqq#W}`vBg02U78>R09IUd@d2s`?g>6Y- zf#fKhqZh;H5bB|f4C?OC7{_$%*wO7-26@4Bxq#O+_5l~pHZ&J9im0~?UmIA*yy8de zWYc9nXDx81~ZljE8kJw7C|VLrvO-WF3uUDQRfe&i?}#P??V-yTv5sxp{rj{ zwF91&4s%XMt$#1uyqxgAIWKLn*LC4JadULZG%oHvyAbIf*&WIuFd0_&w9Q_}Nk~DN z_t-Y`4Z9cFzI9XQvUj**cKSia;S5?E7^~|Ayv2Z}Se30S4vn4b=Uc!cs%!lZk+w%~4rP~QMxzsE@ zwQ?|)I1%gk1S_`FFnGwp3E{cb>zG(a&Dm2e7UZ$0|K{I&!pGlU;hsRdw7DR7-*fG$ z?HRcII2<1vCxVeXI)T~$i#V5<=*AW%O#DyY&sCVdrDC8gd`H?HZ&~y&RwF4C)USMC zgosPTqw)?9`L?ktWXlVv-MR3)?+mYREkWOXwQMta_oM1QC?gS|q<=BWQjcH<*AD*E z$_`*jh8`8q?bb!oYgBIS;IcgW^HLo)NL~Ko?J8^U#<*P za~ivv_?d&r0ka=hH0Zx<;4}3bi^(nwB7+B!g}jC@UKc@K;8djta+AK|^lR|jx5Na& ze_lUC5Xw81n3S8r2o#^<}{rzTZ__`^$?Nl*b%@BR<>_V;x6p^LbAogcpNueZ`Z z-on&3IH`CH3+3@SG_gzcO1cGhjrFNVeB?yn z$s_5saQtMAbHx@l*1sZ%C(kxxg#xa6hzkl?8+2zdq3{x}%ulkC#W(4Az#r{-vc${B zaV7t9Nx%d`@3=U4*oYx3*t&%P51+&kix855LOTYEZ|T_8Es~^v&s8#q_uLHgRrQY+ zwSqlxW)^)*E+Vf`mpdlhw4H9(@u}0k#TzW%Aa;SNRA$r}b$xm@s6f#7O^xql_r|C@ zlKP{Km`vgQu22mkV>1O3S@-L(lD$EB65OLph;sz_T>4B)ln0TSH!6}M$#YW^6+zX4;0 z1|}6E*VxV4@Ee!zu_u6oq-yngq<@Z9VP)NUCqjQ-i~Ehw&}A+asnU1I3n`k!=? zf9KT}{FwpgFmfO6?SbUVROQxvY?Rsf;6p)b*E5bsx>#0==V z4R)%h&@y6i7mj3#X5ui$P!X09oo(GnAuBofbCAg3OdEuyUZ2eE@o_l@I%34@PI3^> zOXs9=rz-C0dJ6mHx+Ju?km9 zp_nOxX0{vh$?K!QRW#pj@|n{pvsXAiJ4J6w6gDlFnq;=|>w7#n^(K@@$NRG$=Hv(R zy(tkIO@j0GosR(Pz73t~G!H^X8`ZD*MlS)r{>!oP7Q}OZW{Kpp`kMIGbfRkv4rC$% z>JW=Y2kl;5L(td5=>`=Za*IFx8u_iSa~wR^`szF?Ht)_r080H91ptb`NTwhgy~MjH zSL}mJtMm^5#S&_H3SJRjr=h+45u6FV^)M$5jL940JY{~Kq0Ne}>xM1zi*pmAx7C`) z%dY(9!yW9#*(ZJ4pRS5=i9TLbt6qmu5a&Y%EWZs0bT7bO?Mh`K(U(qMB5Kmh7WB0?Kd@8<2ib zUZyli+;+~j4PK1j6}3f>WPTsHpVkyi$09+~(xE`7Ed1}bEpP>52OGbr>d->~8E{?9 z(i?~tN+tsMjYXn&H$%zy!vS$e9zToH-1r^gJ0WAT)a=gHpFq6;2kvv$9s15mOY)IV z#3O)3|G-A_BdB?E)emq1k`f@<<{J93E6M4}wYAQK;xisfjUEIJh0KfZ!Tz;R(*SfnfO)`l`HXY>SOggUXfRSa0aPWa8crk`XwEl zw@+Pij3YMU;-!NAlrl!Xdij)`COl}{Sv_0(w=N6o_!ueuFfoXTV7fMqe;?EH{xfU& zAlDL>K?FU->I>OD7e^F<8ZlJ=UxFmf>E#&hgGPpiV@T=co2R)L;0<7Jw|aNT1l;1B z!^ZuQzYm0rz+(UM8b32`Xnpez(fCJ5bAF`36UAA8ANxmI8Z+>elM(m6GxkM#W5LGg z*ZU#JvzodqwRM6P5;Te;{yBL zqy|ry&fNu++2vUe^DdP81iYg}qLDXUzSB6-m03|7WbXQPAP~71Y6WPQWSf_EE-wmAca4_t#%8<#1aw8JE|IB-XgcZr@h@VDeee%aiqszr2Okfq~n* zlpJ8BX6`M;yx_C<>tf$ZWsr9#Pn&0u=c2NWgjmx}q+dGl^MZyya{LQiAdqMKLFP2+8rP~sPpZ11=72HrEWvGv z1eCz5m#O6B;JDErX?yvi<4-(Ggjt;Z6Q@Z^N(e0`qIE%wuHXUh{=KnCfW|2e$IG39 zncJ)ZBaKK-RR&T?$zq_Mx;9(T-nOJ&v@QHoM>Gi|V;l)N#|WfEP58;yE@}_NjnNurgDyTJ3BfqvGeoq&Gbki6nsDu?>IfN+ z`XTfij4!kPS+D9!N|kzsU$u$-Jd;@JTk9z144}rWardC2n7FC|X&XDt63fJI6MFv~ z*BC;tr~@RJ18wV|wu_897bL)l2wqgVXz>K+76zZTjR0d3>#Sgb?kBjUXY7c+jQ@?J z^A?_IxI}cn6(Fnu-RF&uzUoa>*#%t#uIFsDA|bh%d^S4hK3stm`O9zos3W185vrWp zf|i{_@Z-16w@?A|mQ1DvdrG3s)AqA$^^A(+*N6*Li!j3Xc^0npRWj2}TnH$v<0q&K zOfTWeT2bhe{-;RBra0Im@i4re?Xp$u8WM=|K+cTwLQtS3ls`w9pEnBzT@yL>L8`QL z!OpFx3&5QcJqt$akyaZnLpG;^2M)CG>DZIJibfWKbzcYiv9~R~?7%dn?3Npebdh)c zh(`qBH5&IaFUxBo2djOz6VqeLu%;!+#0c}B?*loy!Lr6(FjSkf&k=?MSz!o07V-$b zr`einb3WTTs}|-a0u}i19||>{vuXsk6~jWB3nQfU$f|oHWo~c^P@4VR@v)9EzS5BJ z1ys(r%`*85g~VHyL8`6y7i|>T%#edwE$P`^6|3I*)R$gEyBfdX75wknUHYWNIBn?av-K`rLo=ifi9A}(G_AP{9n7DQeYV*X zf+Bd?RAgzwp-7mf9f#BGx7cRXI^Dz1j^sQ?4p*)#PfCpw%t02JkRFhWa}7W%b*aeM z6jFyP?KEi>{jMI75D(G^UPb_}h)CSq3~9f^->^J3B%H`gI+cxMdWNGhEYx-7TN;Dk zwZ1`vowCt}iA}KfTF{==kT4j@#}CkY)ziw`+UTdY!QA;Dn$G&6srP;3G$P$0 zDM&X+35=4G6zP^mr4h-|oq~kKkX8`h0#X8_yFt1`x@#NT&Uc?5zW>0sbI#85-1q%l z*Xt@A1Yg}x*7ob;qU2lrL~lAyV{IB|$w4;3NtYiao`<5YEl(ziisDDiEeT{K`D4rxI? z8XGT^-lodSEi)bzgGm0E0Dwp{Ac!dD{1hDFDe(81FtFolN_hq-&=5SQsU)5iY zAs4~youWlw)Z^Ak3-3QS$4n$LCkIy!x8N1|~d zK=vi?vW-dcAf*Ul)5Lv;MOlky%b}aevpKo$md4L}mX1XLM}0VyE118k6zq;m4f(u1 z#g;>#lX%$gG`FR@TeXJG8M$$5#8i2uD$A|vv#d<>2KZ52J3-6|z6u=H$lUvBF5r_{ zExD3bDo?fJxx<&SKlA}7OS7G&fkDf^o}IV|T;Wdnm`4O9O`%w+NE-{bJ?SRY&}^-D zavDfB7x$Vf#)C_cUqbw55`04Tcbt6hoLie7ZtLB4)N@oyLNN#fi{I{x8-|AUUV6t@ zd!tUrO+UjkEP+?qIyr{qpqfYPk)wmhbOiEhbWBtdw-foTs%l*W`XXGCEr?)LHKnk=1fL$hRTBA+>uhY7C>!aNX+d zB3jjcd8jMu(C5rt!S`+dcNP{zVP!8rxCgN*Da#TvvRK)O^*?q>YBR&bClxZsel*c! z`rX2~-Ya=Nkv8|4`r0x7*2j4;U(3$i4|8Ji75-OS`5j@W2#Q~Sj7C_(u5xt%0x~A{ z-|zlrFZu3kf}c;RhLP%gog4fNOOak@FYh{*y7=^PirQ>$qjwH)QwNrd8%09(B>QNmZ>m<~j6aT4x0%6NoJ3-Y zX%{|+>#_mvRl#jZf`k11atDd!9Ad8lbxYa9sV##;9~Js9!-Y}jpP`}-?W7+ZNOuo5 zB&P56nU?!K%)~~AlpeZc5VTRg*U-6vtWyZu;HI_{XN% z&h4T>OUU8tVfB^dSYEW{!%fCmY@YZBek&`xVxAp{x6OLLsIOk@-=CJILAOWW_(Y&r zi6N-J(m_z?Q;T?3zkzjV`G1d1Nb7m6E3#_LI#o=1Dy2ba0cSfEayzN_%f%>mi3MfI z>u)OfdC5x`#iD212n`gb4vO(RU$Q=qIWxtW*-a2I>OF`Izq0-hlkaasv0O*%P{-j6 zqE-4!OG}R%xK=_^nA$|55jmz0vtwi+|Bj&Xqxz4xa&Y2cElp~dsfU?<{Lm@a8qE-Z z#bqjG{dKvv1LU<9{x2p03q!Pk60{1l9eJed7AL@7eS_8+{;3eO_)pXNS7Y%*!u7eg zXsgLM<|$4Gd{Z!xa$9sU_$GhfgE3L{A|46Glu%?2gKU7W)2Q9JjhT3cfR^aS7#N8T ztX<-w0ri=^{|MYTeI0?_*JgJo61WM5oEbg;TE`eby+>*IZ@Yvck_1tvP87kQl%x9X zY8_gl>zZX{ApbhDUv*3ykAuCIO7V@_4;d9{lH@^1oRJwadS5kO+u>0j2Ch5Cfpad& z?(tY-N;&>1+0dicfjd5~RyT?qMzw^aOMk}CX5MWCafEfKS|kG>MNnKu-gH6Yu<4e} zCvUze63*w4z$j?MHcM>;@4Lr$x4Z=L{$u2%Xie|1t<3!_R`Vbl~n8DJ?dC(ku* zOD`vs1NeK`a3j~|XT?dAA>Ox{!y7JmsX+Txl8(i%?#I;eb>N;Pyqq$z=?Behu4YAy z`g3bLlAN}G?;O7HS_^iM=)F+_O3ift>X5}x>H~|j7kg5OX+u$)#9<85ft_4|1mZOb z#sk?p(_TJ(`YCm_xd)cGy+5Mv!f+ACwoX}C`M^MTRja~tHQkc7w-&HLD3pM(74P68 zxru8;c@v;8@8_er{%hz9XD>Yv$`3;@(uiiVl=R?9W)qo&!s=^cwz4RcHh(rRldOK) z4Llll*)2($%=sr|@grhv?U>l!D!Kdf$*z{sbrz7o^D%?-7h|K2`Pqu*Ed9nHTc}`N z=Utl@L80OSBn-{C%3GwXREKjF?XL9>_$eAZkBhF%f^-%v-7O_WvEG5K3T1YZXMZKU zhZ=-wT9QQt2|8Zy<=EmQsW}YQ_9kUW)iy7hU8iyCU+5m4+GubxcF+zivOxjix^~2m zF$h$&Yf_T5w#Me^?PQ}e?nCvHIcAvLtkNVgSU_;kcBA7@WGM)dB;s4~!VrMh9A=|G^(jbm4SQ}hZao(-9%zM0Z}!Drx$`kOfhf_8TelFo zX^Mt=qk`$mP!%;aHuJhnqmX4}8tVdI78*r}1%BDO*>mmxHg2iOuIqZG4*ESmlabfN zBmswH7Q=DC=-)?(HxGXZ{24wAK8d&w`AWhh|0uu21^;Tp;XcS`*{xEWn8Eu87hZoG z;+njMroBY&SW`7|2>o!%V`}B!dR0k@Cj7KN2}z4Ev`x80&Z2grCkC}Nn)DkTR6oZm z`_V1$%LJaU-IJ(9gGIpEPAiHyPNVP4OFwLFzr31`V;iNn4RLdV6C;bjicL#k@S)FZ zm+#hp^e74oJG44ccQ0C$I!ZizFYiT2{R)*KIP~xdc9i;ZM-Dd7IF($wD>O|^`Uw_k4$H0uvmz1Oc|c#0Stj-GB?jvKBO zn;aG=nV68hXJ*mywpDHRFpY-&{!bwYo{5KVvxUU>wqQaUxfYW#HD~Ajvd#d+WvY zA((M!C#0t51PX+`COJ2Behbz9^gb2dBj10U zW(k>(=(e+CIs?cTx7kWQ-S^=BtO_A<7D)whgxCR_t4c7tJgMHtz0og!wZ57Bw6w>9 z=5uFMxD>H)o`7Rl{do{KtJii`!BKQ z7}9eMdO-<1Zja*=rp?RD|KnOvxv~P{%8>sB46gytaHe=F0h#`Cso!&Eem)I6k7yJ7 zy6Xf|1vE&^-e0H0!Of}QHIL=Z-zW3FjJ%lq%6)Cld};gxhtqINrYw5LBPkN%x*g$n zJ@#>i;7eNjSng7~PF}3<6lX}EeL8hiX71-M{kN|#c9$IS#G2}II7HZ1UPIo9XGs$! zU4qZku6HNc{ymN003&mgb6$&{G-1Ue@+~<85+oy?*~0<^MA#NyFE5NM`9B*x->btn z{A|1LfD$qLqt()ST^&>H*!z#UWok3sH+)kOb@eRim34?)CA^`|2JUHxr(e#M%%~bJ4BptcM0G60Pw&rdVv zep5ZmF!yzSkv;%cK26J;l)ok^81ivc8sHuizocOp`Kns^%M;33*V{r0BSe2LU&;WL zA=5%L|5uV1@(#VeJ^E|EdlRewoe^2^yK+?b`{&$*Sf8JkP_o!tAe9@Jh)Fr>z z`}I(I^}Vf4QpE$?5Mg}>tj*~1Lo}v-p_@>0!5lE?_l++7hSu+m4CyX<8Q0k;>_Ieo zglw*I=K5*^_(;O}01S%DP!V>)S+2MaJnIFodKYf81^u|vhS&9srU>AaV}eZKwhitn zB%Q<(wXd>ww;@05`M;O}xCA|fES1Qydq%(t6fi5poT^*We}Pc~gD^y}$SnvVx&`U! zO@NsDJ}WBl0&g$8Zx~c}w@`2V?qs~hWDn@M78yEZP%;FXwk1oc+!rGPra&0OE~EJF z*^mya8IFD^VwFFS^l0>4bbHicphMZY;&IXyoBV}dp4hvJ?79f^QOlrvsa{5;;|_yf zr`jt!BZ1pAo?Q}FNrw7eZAb@jw;n9gTC-AqffD&1*s*@em4Z)9_X9JtM)}Gu?@uo) zs-i@!>4IMsAUDE}tpig|sbM>}Ueuy2WV~%0?01hok8kL;;o6e#7I0QIPHD6!v@SKri z?1y?gH2oN~HZ#w~#ZaMj18*^uPbTU2Ww(>cQx)&0VmcG;1=a<6**;-KErKp+jzFYa zaepZ$GSWcIJcMkkdLv!&Wk?x&3WkHn{YM~v@Rg^q@S3tw>Z$~du&~j^g!dH>@No7g z%_^{;R!&t%^xZFIjmT*v*0N0@TFr#-+P1Ud$Hm*9&w#=ZSZ zk}3FU9;?6#b@KN*sGZF_9_J<=#YU(+Pq;rc%J84hcErmT?=L(O{TTIU+<@dI7CSNh z6uR{GTstD*9Y)fH7c*pK@3J{*@uj?mH*5;)LrQw-YxN+H2h(989Kh|l`&>VJq6#jA z=4%djk=ub6b}HIa=Pu%2JJl(?of5aqM)Yf%_eb2At`2H0&xGWBwcCj=qcLm=g0Csi zc5tO{OXP;>lB8s|O5sVn+=j$sRe6F*f1JLS=N@oQn~XVW#@b4#T~w;pHi*b+y5!S- z85t1&k0THc{PHPm1jBQ%&>JyOu8OunKlfV2efU<|0?=4k_C;FT!BsGjD5B5-bGg(ZW z3VHWGOjyQ`P3Lw&X!ne$G_JRl^Al$x;vVqWbm8tBzxlFTOuv^wZm&7fPn>Z^Rw(EH zxrvZDJc~K-ZfSovQ(v)PK{d5gP$T87h7C!+ns*|xwUyPw{%3!PWl*o?PwbrRa?xl= zUjS}Jsot!k{#Zpol($MwMuHi4=l$6Ome3q2(?MSDPY$v+Zh7<~^`kPL^)llm!V18hsmA`#>6q@h zOl=EN-0km#(784l;7 z)b<3P50~Sod2^QoiO{*hln0V(aREOqAZu1H1DD*Dc*1AypgccnP#viIwp|z6Dy^#vA zN<^md%Eu%?Rtmmpy=|ET#P0(BTX$2dvuxH|lb7LbEuR#UNhtqXW8R@YAP=-72|9Ke z`z3q+6!|t~#a53|wGfd;ejD~-Rov4rl!qP%!tT^k5ye1E6IIy@)Un^qw5Y4zOFyRN z{e|2Fl-a*=2=RT4LSrZ^R-h3833W~mxmv2+dZ2&iItK~+muHZ~T&NIAFL7G%&2#F% z2tP%%*&0Lzea<9@_kl#zhm1o2Js?%t~#ime$4>RfPq9KJ>df)U`e- zOt%bYmoqNq-%uMt#LiPsVigZM(RnAh=Q{|~W)GIb4JgDp@Z=I0k=_V#So+P*{n(D# zCiK?0Uixm%3-#spQo%Xe)ZS~cJ2 zLa?p_@pUYE+Un`gXhCZapMc@7B51T{4EDzDf-SM4m?o4kUrjbDwd-!7%CKT}s+yi# zNPDCX1jK%ktMw8xSm;$HQ+P9>hN8U3yfhJ=S0AF%Ha>faF`}k;e}b`IFMQuG3by$- zR!FSc@mPu?Am$w@&p)64sIGlBb3A+WR1vZ>oeF*oxB5BkwI3%Sqloc2twg$mcfO)Z zcBr(-Fe4k1vOT}XzYeJi>bF42D`D)QOfphGGUp-Cjxmpy@`p6V>dr8EJvtRS<`bXoXcTAzw+7H)4b|xc=sct? zaT8Jdmbiz?BC1Q9>SzmynoT{F$JF3fLXaRleuI1}i1%kB8p!K7Y2w z5nw}qjZXM^Ny+YO#2(h}o9t1}cF#ouR)FSm>+7ONzl`jB4j13zFpWse-C_;>WYqGz z1)I`mHx5$o$kHM0(&`7im+MqYT)O(Csg!q7EL-PpZRzpB()LrbgZwAB2AmD*_?!7* z;QZ^CXSqBZ>Hqtzjkk&!?#pFj&O#r*p)wMO+FH{G`hPEc)L7egN^oQi zmVPWDH1^_7r~m^iv4;5UF7BkxQsd0;?B-%xweIGRMEo&6>I84}sypoD{VOl=ax%W% zZ|388NIhn37gINj61~<0+p;bG+VDMJdyOBqej|H2-N5r%rKMo_{ai~#jV%;=^j|<1 zVMt6lHQ$Bp0?J~ESmH|X3STNg@p4Y0#VN4D=pA!J(5;zUF%Ro6DW|L5Vw81QptNl9 zDRw<8dSJoImu1uIa(;6vywp$ujFum}+hI@`^Z4%bZx+akvDCwia>_Z9tI{rgEPuNj zYd$*j&#bLGg+8fez$$TxMD(8ly~Z}KMJvlE-()y@zftNJT^=7u37t05p(_tGP;NLh(M1!shX z*B#~LTHUd5wP|mhjf4StgoK3Al2J4FzHd!`H`U6vPo_?q*-Di1{YTPzJn=_tC1ri*cs+yE&42aDN<@Wl08lu>you|> zac)FqZnU8P#(3NvZ`khL%eZbiDobK;&W|KcrEy7}yIWOo1NkXtl7Z(x7P`8wKYpP- z-ijb(_3Qt&9QUQh&<{}Ud|tJ)G8NnMxF5|^3pRvnTs|mpu<9P;G}jmfO| zYRjM*98yW<2FP+pjRgCPtraWAnqy)?%X0!;av4B5t~LW%uxkKT6bpM$ZSq zgkMFKe2sM!LLZ@U35{mAn0)D%`Jv_|n$tk`Gu_Y!?Z58EjYGWq^mS^xvj9~cc@c2% zFuCKxIthM*W(B8efZ)}3v^C6h3$=GUN$z#k48|3s{{dVhEC1F+IMCU9`Eu)W z{;s!5!KeCll1z#VIdQ7s#QXP`gaVs?*7+~xUh>^0YU0ToXLTp$^Gfy$xn*o5$4Xz? zzaNPuTuN@(`QBC8AHJ#|kpfxYb6;|X?eeflU16UxRf4ijtF!jDyZ00N1}`2;#sURG z2I^Kuk%k`<2>iq%B-LS)D*Ikj#Gug`(j`ruNKU03E}>W`O;9Ayrf-;J@-;62->RHR zDg31)%p(0PODkL=C=-MZ{gIQ?EZ6+`^)nd1ZWdS^ISxT9XV(x;KA!KrTi~?;L%4(n zFxUU)MR3!Tuqxg>ei^-vSp*G`PU3Z1x2%c95x-j(4{NfA9%E=#ftAL3S+5HZ<k>^TnR)w>;TLB4Msq0;+D)Nnhr=1eOd>Q8kGMt z1r5J&%|yNlZ%9a_t}7a!G?x+?@)#GAXae|2A1pNx>QT5qc6cXX@>F>8FWPu0qCOTT z8)c*6GUc++itgnMyv+C@Uu4*MluT) z1s%CDP}KG&^N>1f7d_z>*kn*(I6&xNq}OGPGEH4dm7~~f9q5hN(uX7Iz5&%5%)n-0 zO|$D^U>M`52}G;nT5sYai`tPR)nC;t1k1D>Nd5&mV5xjPgMwvlfJr6b@JEI@w3947 z=da{3!DIyE`35(M`RWoy%ZFLb7OLrrn8hq=ubc3Jp8$OEwV|LSpsmvOmo*WP2YIfKX8V5Ts?`U4s zzwMj7>d%1)gk6mpVPfT<*x{!Q3YOG1c6LZoU25Dy^3@&)2@qg0R~UB{_zKLmDmKv< zM#mIlY909d{a9?qtJtUK&|2%sSV$P*+U7d0e?`5@lAQ^I*hc7mp*+rp%PWD9hj$SX z3OuxCXJ_96M%7pw9w8+g*_dT@MzZ)sFhiN-5X6#;U3RqL`RUiZyzf3+)GO4ey*v}D zOxw~qhKX+05{MtUVLN~+D@AUKYXy}o|J-J;ka8bEu@T~J6!pZIW6u^OLSQW@+{ln= zeP>mTh{}&3v^`&W|Jtpxkb7`SmlR*PGgsoEJ%;#g+lxYCcGxe`yNxX9IXDmMxv}y~ z+Bu*Ri21~`O1H?C!t}f=@wI1{cBcJ3dFBQ4ww>fBG`TcGQd|;dqRfrQNod`i(9rmNDqG%KqU70`a+BC!XaNR0<@V|N{~Z+ zHHt~JpSGgBz_{?}JD(2X($WiV8j2m&eIC~6m@Z&SyNh`*Tn8QeQs;!O+%^+ykLK(T zw7_YQa25OWH?Cxp=gs3NuBwcb>-nXwN4v4Ll1zVXI2+6iRTDjk@ zzYz6EF*H%0CsHIGY|0E@eEICiR-z#4>=-lx;tYsIzcf$S=J|Phxi?BDl>aJU>cgD$ z@_r~fhThL1cfT5U(mpmq2?hPOpOVXGNwiIU3pEj921`*i$P8UCa;A++Z-iF&t3vgr z$?w~>*!&16B;GG}ycR2c$~q%j4U-6azDyK5_jtn9^RaYJJ?s%tNH?TkN2+8A?a}d5 z+FAI?0m)cl0NHf=^j&}%;ft@SqMkj|eg$jK)R-Xh$N5`OAXKFjfe=^~%Rz~gyLhpN z*hLS7#&(ZLENU9(-fjGNmfgHHslybv?!Y7Ssfd@2)k&Sro2utatX3v>&zHAMHU=`Z zL0gFB!3nxY)>>TAkG-~F^YlNyba^v2 zwFIv4KVLU;*~+a@Jn$euO@e^FlNG$@1Upw71c0URLM9=bM-1pwRP61oBgI6q1jA`I zCnF#vRwdrdl`+T~vmQp=kwT|pSQK`HMUc3A`rFhd6NA+u57YrVl1AUO9FlaO_+F%X z`Ca;eZkdr`mwTpHyVUvweQJAP+0}vr?z@GV@*j0IY-}Z`b@#gR&Xf`d8F%!|z40HX zk7J)WKGVlb*yQ0o+E8NFA3D(J-f!Lrsjh!P66KG9PkZz!;+*lsUr&mA!xw&7Td%wb zH29Qm*@y~6_I3y3Urdlr0r=;sf?M3vu?#x8L?kzlEL0Dc0x*^L-)bX5T#ZKC3;pJ% zu73R11n3HFj`oUFI;Ru{@NNE58ICXww0{}dcz@y_Rag>zrED7m`{nue_vEcH0cSJX zXvh%7iOyb>*TpRi>QY8H)>Ki5SkDlUO2K{mQw82kBX}C*M>}q9ntY^>wx+#EzjnE5 zEbzv_CoIp0s_QzxAvG?Iz+|qobis_-@7PZFz@G-meDoH4X(lilv6@PPL)`c)*!^07 ztv~To$kFz;%hctV?)WO#2%<8HnAG|X`s|hclu{{k%=*AOXIo7F@y79u&&5jhLJB|O z_9h4JenDtccFM@cZZb*Bx1^ch3pS-6*BsIm`8Rr$$d~Ezk`6%HuJJoAj#$+9o#^Mj z(cn?q;U_{gUA$H(LP;uhgZZ;&LJ;{oQJ;%ZdSb{;BpY%+*sAnq{d$NndxmR#BDhby z8b7BW;jHu>qyC3W()~Mm97g$alBcI3ao_djzRKV2f3DrMI}J{Kw1L>YoJL%Vx)RvM zcMzBoamZBOq;fZl3QkzXwg_L?z%kgEMqsq2&lN^1temdczdO{&De#UzWa_y&@gKIw z`q$Ta-`icWS1Ibdry9e-&MHbJ&c7{p1O$uC)jzrlx=7Y~JWj#U`G*zf`dkeL$^NY@ zjCB2>6KgB?n7#D^Bc1t&3}in2#E|-NED8KJZ3lca`O@d1xxrCFs)tvV%bgIuKbXF} zu=Qiso4wBCTR7F!)FTHIBw*Y(0oeywLd?Ns$4)Bxee@B@81% zOnw@rG|nkGfaHLcVesEANg|yLuL`SP@g^}@1;7@ubnsL3PIz|7 zthod~mPYt0YmSjNA0PZgaZu8+3XpG&=HWB|Zd6}}97cdy?{7D8d$A%qu&Umm`8Za* zj!Z$1AVCi=obhFYzh8xm!k(#|PZU=w^({lBsfM9NET_nivJT+!-=@`VKCuEaazfld z2B(;>ZAEej0X_ZmsSYf2wl1fyv{(A!|Gg!;xOkBN*3XV z%2FXpL`eu-5?|`0SVoNFf};l@!l?WNPO&#cdwvyLVbIET=h&;oZ}Vr?;)PP zH>1z~6dp40a#HR%H57La%AvZc9wSG*0UD6MeDJ-LEe_tkSg~GyW)r>Quf7VTp?6O0}P3mMc?~oeDP+I5KKfNg_h=B8s z-rY&iR_tS>-!?z0hi|n>W*}` z|Iz2;TU&cRfF|u0EYfjP-yWwsGgggD*w(^6rF)?Zs~WttT|a%jrHIP}DA-tl}Bn zR&&p9hpp(vTn+S|S8tzxj3JdXmHV27jVws$;KLA_xx_s(F+$0nX}lqKa4u@Fl+AO0 zI&G+q0MWc*={>KZc;&*KeTn3$#?(RD%_ETKw7)?KIzaXNN0yL)r(tVc?yf8j?C~%| z>9Xty|F=34>a8L;zyvy#>EMkHe=b2(91s0|(OOKs8vbkHR9=d~68pe^jxl{s3NCtWtNsh3%%#jGX0xbOqDv$=gb{x;Mt8XQE$kwC=Kdz(*F3D|D zDy!PEyxyVtKVLHS_1B;5QN%fgl42*XB1K}S|v}gBC+Zw-br{%AQP~ z+`H~9h0)g4DPu_(@A3%;GpSOxp6Q^BR5X=2F4*R33$1WC3!gG$Z|F>f)uUIM&x@a= zJSs6IADjBwLlT6?+U={lR;--6q_Q>0I!Lm%ujS=;MF32(K3*b zs}+X(WGvTqj{qf(OE47mE1Q>%R4J4#Ek-=7K`p9ccwo-aY0_&TDB#5dZD7UEzYCema^)6%U#u%np-1lSj|57a*AjD zDd$X@^oc>}P@wt!k`HrU{E|`GWf^2zra#7fV|xs3rsJaq<6vIf!RdtS#@I;9;IbIJ zu*;N?elHHai^{FKXfaE@eAqhZul6e7`Tog~Ce^$ke965plhZ?9k%A?n(LNr^C^BG;d-P@+{U%-93r60=QotM z1G`pb(>BJ)Y7u>*Em^usS<&tmNTpNbh;xq(>f7FyggDPa%3yz$G{W$eWCV|kSai6= zBk5HghqK*9-qZCYWf^kuQFP+sh09$T&1e!xCG_;iNbz6teNu1R--Trybi0|*iJB!l ze;pYrVcd!Qk!EE0$AvDeYAAwu6G3GknWm*w@FH&s$F5W7Qwn#AA~WRRLu393`{srV zzWwm7{>BORj?3sivB~g{6wA5XJud03nZZ9QLEdgg4Usp?l|_xUChJu4Iy}Dbo^k+L z*q5F!5sP`FyY=2Ozalb73?n%y`=_uZL^(%&C#CJ@Kho9&+HwUj3RQvFiW+mKcnW{N zjB#Q__rpP`LeO3&+&pmmUdAUwLr{w|FFkj+;dw;TtMCnt$STJxa`u*xj~s+6bzs2` zK=EO-U|X1r5}hW~@bT!T4A#0e3dV~bo!_uu`s(}+g}C*$zz=z(Jca6w9rer|pRdrs zvEGEYnOY|-QOMtS6Oq266ER%!{dY#$elt`jJ(btxQuJ|(Ng@~8-Ss54bTP39_#m&* zYCor>{~pY;+&uVdG5M?I0UcIvoWDlL6siA(GQg03Sp+`AFP}Br@=TR->>ESBm+R_ySuRXM!e45@rE9{y)O27jV3%N*5MF?BBXo5c{ld4QDJwR6h1 zAYuaH(#;!Ilo$HkS-+L3`(n|-i!?&yzrhW5U-DKKL=R?-CCgq~?6NdN%0u%91;wY7 zz!8-#eHR$8^Tho8U~x*=xTGV&>6%C^}fTKByvzLrVn7Nye)SE@AV|(3Q*V}kr<4A4-A#MP}X>GY{3s!!$31@kdE_p z7^?zA0p*@BbiL5H_z zT%!gc>8=lPumq_FW!zSlYTCJGLXDCzuo~(q#}9C!{y}mtE-Xy5SIN%rKdmg7{@wuQ z5YDhjq_xj^Y8cGNbZ~Z{alEi$P+*8UCuq)>5^ZeQ^!ZC2Mc`<#>VH^)7s>f4^yU?G(|Wxnx*?o6j;KLcUPvP>{$7L7KhBbY~(;8Eh!t7x78AGyQG zno`*BiI?Lc`opKT6_??$eRsBY048!%(2+Djset(rWdz^*I|{LH-dWKsE;VZJ6{eW^ zc?||-#(Tvxg2$5{Sqi&!N`~kP;pP#I5eGe7P-hEuSNUP3#VhALHGV2M^5}JlphIO# z%T2gL@ZGPW6BRCX&u-$^Z=73(Q`j0?LPl(N6-(cU!4FTQU_%DpO1w-!e$(!dI?0NZ zFZmPuNd2&oDz1=SZTe=pU(pP}7?Z(CmfG*{xygC$nzg{&3SlThUb{B?5=3{sd@1Av zW!fv3k(!&91nefn5AngbfAgydF?Q@Lu=DKEmE8mPSB>9V$H{PNINRkl4om!QjP3X7 zzSA6#y}|RZl3OG}Ps7NcQ-aY5Xa`~t`yGMey#INJ%wL>a>8&`T3ziVPw!WzTr!#%M zPPvz^N#+b^AyC$Q5>uD0S26J-v2y!bf2wBx^3 zg1@+W^JEo7M@Ww-@Pb9=SBLP)6IJtj~I%JOD zH}u3MTqU}H>__)F-6fdbbmu3H6+tKLig=6(REqI*CjkHTqNC~v=hfhWZ5(L`O(gBs zws;5w3|lY^E8!K&5II12_^e(Hp8spLtB^#ZZ@S|(rm?KRjdapZNflKVaEgJ6GBmH_~F z#3m9$m1-X;(&)%jK#R6NIOM|a}PhorLmH-`OTEqO6Mx`)ISQdjF9bep0Y2dW_21sU`|uwrU|zSZUV14 z{zL?kwO4SO#w60-ERH0$yargYi_W3>6muY#sTcN{y!O_9(@sC6dH)eeq|w z7>q>N(h^-{x)ka4X8x=KY|wqSADZ2pwAJA3{iBd4-=sa3BjuLDHOpjBgh9J}At;`A zfFaTb=s+rjDF&lUF{d(Tm(|EFa<{8bI;#T-Gl`FMHTd31Bp~-=*c1<71{sNXU4~|q z6vA}K2&(f4D=i6zMhnIj3G&t4FE8iZ4;HjKITbqy_Tgl0jAAXQkYItrZS zTslbo<7n`cBmt8w&0H2An2FUCZyoheoF2slwY@C_pjnP})(k=DB4U}qW)-+MJ2Y;B?S!OCH7 zq;K!I?0Rv-$sddB^;GwAU63q%v#*1Cx2`Z(oJj>4g4UMZD@-uqmuAp6$6ol~7xRE| zT$dXe9h0-H%fOw~Pje9AA7P0DqU@xy&BySEZw_Z~OWBR9jWd%jUTQFnNQ!&LVgJX_a8(w2dM@Sh=sgyj zNwb=sTq=3$m5XGFFJ+xkMIn!cg$1j+FML%$YjeL5ct~W2))KWK8Ri_B8xHm+snx|Vx3{zy zprOR7+_nr9>8R}i!tHJ0)m6=}-goS+V`!<;1V7qXY{bBi> zkALvko^>B8hd2ALIJeS-4afY2M&QD~l`Ple;WCBEByf;b69IZpTl-ib29bi4EKO74Ypo0gn=~ub-DKt$Env{fGGp(;bIp2d58{V z>I(Ub@#f)+%S7=t$zGM9JjP{x?j%pE(Yz+h&`@vTwjQ6R(%o?kl-R26jfTwEECm(a za}8zYe`x)7YS%(dIoE7v7<4l|_y&;2m?zy_1!Pq(ytyW!=YTn2)qfg=%>d1A2^x1N z>9Ltopv7yWpU431pZMAtWJQIEnDnMp^1b~2Gf7Il^mBw{d&JV(Ny?I_Qavx(kXdx4 zO~J>b;Y8rwF8m@Y?MCo=Eub!`DYTIcC)az-chVj!9y@#of&%ljh+dS6l7Mt_**$mO z(2=$O*p$DnU9@YFHrX5k3{I+x(>lSx^AF1mwi6vT$KHr!#*37JdpzzfX1{{*P`ede z?|(2Y3xGNdGnS!or>`>eN+ezp*^?see30v!kKW`N0pE0bShF@PlHbroMW9TVMQ*ll|JdeEc*5|lCIWZ=Du)nMi1%x*d)$Ii7i=~ z_)5xc#tdrR6_%Ds)NE&*{G^?6QLiN}&i=%#AR3=@?HIz7+VGdKhv6Rq+D3Z4Otb^t zK=$I}N%+i1ZWQ5EN~=uRm;FUZyhxXn`yvB@ywK}zrLGC(`}f|Nt~?mcxa6%e;jdjt zl&AFvC3Ro#?ixj>on;WFjbb5lC2oFlbJ`K~HKJBC{k#}=OE2*7<$;IQ$F zJF$muTQD_&i1Cj%(;OM>Rbtgx(54lWv{3$ zhNrDta??i<{vn2xDpAdb6xEKq4=Dg{@gf~!u^en@Y}>tIc~&g#XsM8=sgbaa$2LWI z?P@__1>AwaFmcUHCZ|_J|8rfg|K(>$(Yk=jh35G^amn}aQGJz(pnWx*=5m_P4xXp; z=OBSqsm!apJ#6dSXStYo%k>!|)hWY-#6M>d$Le33DmaV9Zfu%OgDn7gz)Gv_YGl;g z(Ta0Wg9^Es#>Tw$TAGwdzo`zqCK%MWWn)o~EwSPB-_2>S<>EL%fD|Z2=tC!_Gn^be zvXZWB8%#*o`i93N%KVA5Kg>I1i(nMQ;b6h+uWnfwYtVQgvI-xn<|^Tpz19p(otVrL z4c-`QDBapFiD*lYO|$nKu%+L0B&(TwKR#ghjOE_#YU0Itm%^?R1F!L%(teKGZ}X=q zW+7_>w~&Tk3Sz)n(&?`~h~c(v17Ea~fNb^j$iM!oKPdW&w&rILKLtrtvqI~$-N zw43Htzw{%CM&xH#Wthu&QOdIi!>#WWSeipN==P#}Z#71EKwZ z)Vn=?c}8^No;R7CwN)3UI>2bkb|5X=SCx8_k$O6@dL-q)YI1#>!49c3@fS4oOnH3( zlNBM1=;MTx&yIjg1!FvziNt`ZirEhSgCnf%FKm1y=uU3C1aW>0aWTFQIeSdI$@J(E zQv8{1aldF_4`N@VfZ(l(f4}&c3a)xMhVx{~?6C*QfT<=2jEJTJ_!-h5H z?(otxJfl|x6$D>#ds4>{Y&Ng}UZ{2HvCZ@Em#is%tFPqN;vkw1qz$CZmg=F#{^S4{ zM-w^p+{1lS%tOMf!r|jG6p)!}W%E$pUBK~ez25OBD6Cb!XP-C%VWLky7sMK4!F+m^ zcxcZ2;RM0fA$H7{*@-S1>tdV$OIYWD2i;MuzwoUvlZ*^&k?<2da{{wb_PQqwCr!Q+8`?|uVGK!6Y4ji{ zp+E}`Ll;G4#ZX^9CQ z3BJS}K~~GG9?NKTVLM>1pHGtYQVZK#qP-48J zWYZMan$$&e=m$kH5nkt8Ia;=KcP;_F*TrONWpM{y{vfmsk&672rt;PhN1Sg|&LSa; zlt{-MAjQ>&=nIH}U!3>nC+^Rh#pFS64Mv`8!!_6PLy&4r3MeN8>*sLfRFRLqjAO)AQC6zg=;$KH-@Mb!at3=C`CA&jJtHioKWVde!d z75f6Oh#4?;5My4KtKLoi^W z%83H3-X@2*)HcZ@8qFN4RzcwG;rvM^Wf@V!YtNoK>IRTE8va`qA$N7`eNmw-M_Trw z-nIK_;N>3u-Xv%-wt%&2rt6+wv8Ih9y%v9!i|HL$9v-Q9P@@l(<>v?9=C&RBY!k_R z*nRXKM-cZwQoDXn_2Pot84{nBmh^X1D+ZkzTU9%L>CSBN)_=8=$~J`5Dz>bJy3&_s4!xUvGcTZQ4}M%P7`&X1Zy_eY`6G!N&c_pzo~=C*K(46RrY>Zjy6a zqw--?d!BNXYdK2%J)0QyQJoVp!-1%c86a6Dli|G;L$6iN|K&HZM8NaHBm3Wa_}^+# z*Oaa1lbNL)v=F*rJ|EEJAMa&656($@GW{)9ykucQ%sJ;NCVn!(HHl= zX#9Sz9LzLjYW>nwJm1L)RoTt5k1<6ahQ(gdo;djT^^~L2{!6?ha~>!~fgAsir?ZTT zst?ybDIg_{gp@RbAV`BCA)p}AZg^re;!o)+YDxhSn3G~-MK554-=WeaSi%- zIDmcuU`r+YIU-y>}%%-gWz8EvVvgiFwc-KUlNzO}T z<@PXvjLERB{PirlnSFr#huc+bh3k2z&aYNaS-NbYn>izg0~Y_Yg{Ehw%~-+hT|+m8 zm`d%*JrOo~YILnXSqj@U&eV@$xfV{F4Yd4w{*Zj}?<)hNpq~+FcYTOzxKEZ0FmY`_ zcQ0t%`L5jVmrX0kX0$R>()4|NyIP$T^}&NQp^q?$Tv6L zJ&S-dc!0dSZy!>h;qvsb;F()xO&;=-xcw~*p%i%J_CS{H5!uDB2t|RX0jQ27f{;YRB7qJl!Op^rf71@VTm4&rg3x0v~9qM z-Wztiz)er4ne-e0`=0O40d}aMvGO%>T-z1*WD8o&tTz}^2z5Y}DL~}_t}@=(%6*cf zP#Q!=M@A;|9`Ku(lKnCW8vX?P_w^s({pe|cD!c~gAiA1_L_;{=I6O6_dsd!cMz0R8 zl^#n<|NbC*3a|9}8zZ+p554ACOkl21|NQ4#B&$!`6NL0a7hPbj9C_*5UeTw%7jZn6pIMGOBo zk%wE#iDl2(QSp)Ir@ass0Df4?NO2?QI-8M92^I(3kjTE*SIeGLRE6;2nm-8ua%+|P zL|hy;&V_=V!1}w;NLgKWUEP4=`08kDjr57sc?n?q$K2s;2C)$}nAh)p{KYQ8xZ%#} zBvc{*M=%Oq)kARIhGu+stx>46-(xinY=osup*iE)jv$|IE%N7-DR2TU6oQ#L8{FA& zB0A_*vC0KPPBP7-h=xgIQ)~lb^*_YCK}t}GED;nWx+Ud)!J|wT5f|8yf)k@#Fs!OXXx!%<3}V@> zQTV>XN_)#&h3keh{4*}L*b`sC3Tdcoo48^#=qlXLzry){Q~qWP@1U-%WN z?SDO2xBiZF-_ptX;C`@p%fNc^hz^E<$d=qDeP#!y!L0aH-v%Keyn}xmf)NB*yvRC) z)}VYbxC8au(W$ig4E2Kgm#xPjVb6t%WaN z_Sgu9V~l=z6oQw~((AXI+e$eCzaCd>&zUVU3kGGwWmO!Cc&-gT-umC~-a{&T&jAyR ze+7L6?ZlLX3*%anjG^gYm%GUgS-T`GSuPyb#1 zW~8+!G4I!Jnb3i*$A6!IyHh)pU^lm37}JH3`?=)H>?z1ZXdpph%p*d5qw{Y_v52SS zalBZi!stO6ftvNAw7bLc49l*~8@L{SvLN|-usZXh1(x0$jRmH-BC7KKT)eXDsk2)qH`#;XU+{S7J;B!H? zoHVX5@hq}`;|@LMY>C1_$R7{;L8;(oNAZs=QQ&ekuzcn6RRw>>_~v)HRCYNyRdZu( zH6KXv0I+ZKsr6m&l(&V);u0b2UwUGH{HACkk9%57{Qew6J|xP%Ic?ePNC<;sLl+p? z2HK9|!LLzM1i1<`I)CWj#N#MIlbcY(FNvvZZINRmeCde<|HRX{Qis(g|9;}f++#as z&N7TQEqA4DfN9-F1X$ce&Irp|UB!mozKjHNxm(NDKx#8eBQ#0eE$=?#Be`(}a^-4e zk*C6};v1%auSQpY=|8u4=Vo|jc!uYr)pvB4PV9!4taWW5ByZ||2&!JwUdgS7808m&o5Ab6S-U{^F|o z>(hiXT;#$?8g<%qEzJcD5&pE_QA17W*GOg%N)K(=_;EWU22c-_zCz-{HY47UM(uVQ za2o@Rx11BD+yi{F)rlk~a$0S2TshJpV``krtUhWJgnDqn^cKLYco2nlgRdHiGqV5E~D$UW)t=)oCP5p!uHg4@wLl)7K&@xxHg|PoHvi8 z&=^eHbJHRQ3)QnN_x#CT%Phj5Ihb%*NSgQ4ZSrfK7BEo1F4xy&un22^GRiSm!0IL3AtL29 z!j)P3DOMnec)0ENLVa5HA`?Fa^$@fd1OBX0k^EMtqp@E0Ot}mYv;q=pXsaGRRqm$w zg16u4nF++VA7YJH{G9zoM8x*$C7U_JBt8z$2SvJXQ8+m4z2Boq-?L#WXKfqRz1LHJ zrCcOlH$|QJu?VK~^amY9LQ=>R#iSem)yz!k8;o)vSbkR@lB0IL!fQJ!>5dr~cHf0a zi~G6d*75uthS*I+p@1HZU)>LOm!b$_%E?LI1qo2`WOd6F8uv!=DK}s_!0Z?{9pH2g zXtBoC{hJkZt(C77+6;YlzKhsJ%q`xn_OE8op-H-j+x&R5g{nt)?oQnlXJU24IHL1W zxn1t#`;(orvyI0*38N^GcT!+txP6?K20FYd|JU~wxs>=qjWpR0o@Y`ikIcU@*3pZ| zCmcNX9eVUUlJ!>N>*PXH+%)C$juP=U*CSsoP{;;nz3wMH=bF@Wd-!QDZTbM$MFJ#k zJ^G(y)}vBs;vsLmqYS-m!%E>?9#$yJ9(mUw)_sk*AX6JUO7;NQtrG#thD$;Y&py~b zE}u0zxwTFs!B8WPpIZ*(-v*Pgy+wZ)OHC-q0RuV~8#Fhmd*$AWIVS?Vn-uj{`l(iR zeC=GCZjpR;QU5ehH5rb5A9fMkno-v`o=8cQI*#6HiA*}Qg-lJH_s7oW*cEwj;-+wz zsA%SqJzC?e?GJiJi6^od?Y7Ul9~KW4k49yF^oxmUx0kJa^91iJAf7fc7F?WAH4qh~ z%Z(0a^5`!9`b959ePNn5k&-j8;m*u@i_LP5l-IRz(<-H!OGTJWi>Kz3YRWNkKctqh z?J7@hpO(=?38FjrBT~?YGfvt4pj`qcIcXdA`_HCXXUkGPWo2rr)4Oq+JibykebxF` z`^oS{*ZLu~`NNKrFZ=Y$n`86pl>FZMw4(pXYW*+1N#E5gVybH zmPBaz0V0!DD$Su`l90^#m5aDv&O~D!QSl+Hxoehn<^s?*KF0JNI8`3rj5o-C^FEy1!MxiqY zl8XV+MN)MDZEPNIX%u3rV}Fp7Myru`GP-4`vhb82`E4IYP=`wru_TEz$^y zCz2E;&~X#w%lnj}`glYG5gY`7#Xk!BogZ6G?5h0cMnNw_=V!muNglGf*Bn{Qdj-sK zbA?z0*IAcP-DN+oT7j_S(O%yYk4dUzj2&w&cRdqCm4U7Aec8cNk@YW4x|S5j5(@hR`=h-%ssr$=;x)}I}sCI5Mb5e{$lUlcS4Zc^bKKB6%tsBrd9eEp(tChFSL(M^Fy zjy|D8vR)~~qx@+~SfGhR)+D!t_ERZ!Wvj<-jDehlDu{jR^u59;f%-!Q_%n@;cDBjX z^u7N6C0#KJWhv#aT9JI&Vzf_DHCo;dw_CRp>(3K3tN*kh@NMZ=;C7Hs8`78k5cO3!@@K*pS!X zvE%nT47VyG?=r#)gkQIKDo`wPh+bx*|8b-f{%Lojj+11HrE&68%){b2f6^BcV~@17}V%b$lh^yZF0%$Lj2mP&I(=LJO|dazE(0 z_mw;$=KDkrZ~;mt^C>ZG;Mf^)L1`R|$GRhC?`Lk^@5Vs)yNJ?E68kyxem|rJmmJy; zxnSy;mWft>0mK*QwEG-@pB-J>{uA~48KD@t1EV!geD%>C5Fbix5=06mf7=ExY83p` zaknDE-&J=hQh5;3L=v(~OH|b}PGQhyPMXzp(i8wJ;VTqI7OS2QW3Jn-c@0Dym zqE}2dZ~HFm&%gx#P0((oJRIpX`>ZcJsNPPjwC#az%>Z@qKdsmkzMk^dnTcupuPWf9 zq~PwwbTfuU!@dx&*uos?Mo?7o59=IlbjXK?bOG&ADBrmkLhF7P;E??n=MTJI^X!u| zi?Sl!!oPO=xEL|K@9Ev`xz%`J*=;fadAu}+t|mSqiQnAHG-iEn{x$mC_}kkQxOCba zzesPw)~Yud;`=OA;8Apb%k;tkr;98-*xvAXvK=k$|M0KJisk=qEfEf9Og4i+P89>g zvU`on^uGxGX(Tvg@YOEMokvh0UB0D)lU+#TL}8zsO*i=UfEvG+-hfsd12bb)Rz=GD zPY)Z`g4b=LciU96{F=>!n4o(!cD-h9Ckp+vbl;!eew@@I6Peg6#a-%sbf*}Ws%r6A zS#eFHz+0_>Q19L$)A5xv=;CDhW1yH+1n(+e%63c9tB>)c#0W=VwBi|KK*trshws(@ zv<{XBf$s1;B1pTVebaHNdjL#zw%;uw+N5xP$$3kj_<{MN{1VNH4}x*Fv6YZU+!mOX&&9US7MV2OLZAiwh zuN3f^TndFt!v2lU^`(c_rBT})3S?}iD69k#?dlh;`mhh)rGZoW4pu&*P2phtBIr$l z%g6mG=To6=3e(eN4jn)2R8T2H9f>@r%TZGQ%A|qpEVtmJtYB~-fp(HY(cVwuKJ_=i z%Kb@XrogKRr`pe7Xmuxl#L$Ea(UzJxgNNSC1pO(h@mA0>S8m143#%X9JFVN(Y%VzLTD8FO@uHSdF{|N3t+9kI=h0OY?|QvzUM~^9Vv4o$iaJ80OA?SZ7)>`Z z{sIXevF`)V!J%%Ouh+N0GTMW6KVrp*#8Xn?I*i_@tWAa)SMjY_QI6XT7>RFUj4_1+ z7~k3sw|qzhWhfvLaiawMyL~z$_4BQ0tZ2;eoBSa0QkLHwQT^L4>RX7pR@BY;?sflh z&6s?9E_grRVT0>?#M67yFA{rJ*dgvRr#Mmf5BI>mcOZ8

7K*<35;iVSh|^wgC}7 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

nfP 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�xre@pH{}K@jw=^DhT+cz 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 diff --git a/examples/xnft/explorer/published/Screen Shot 2022-11-16 at 7.04.44 PM.png b/examples/xnft/explorer/published/Screen Shot 2022-11-16 at 7.04.44 PM.png deleted file mode 100644 index 0555f0f1d261e9d800087fcbb7cbf9eae102f032..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 456036 zcmZU(1yo!;w?B-#7k77;A_b;U+_g9qC{Wy82KPdtSg}EiI}~SHv@I^h-Q9HbfwWy!A{TO7*))9ol~`Vq1{x3VYD!TlPGsG`JvAJ*GHYRXE9 zPGkJ8qD@!5?+r;d&9#l?nEQew$s2k!kfw0LG{CSGuhh~cZOlQz3rY^Wiw)e!V}p1*W7t4PhKzu==BB~!v0(k6Kr z`@BVAGRarfaI3UioA!r@tAUp`SmJ~#U3K(AymBdY)#*d&L->2)W~8x(7ZDQS(30~X z?dPb7Ve#$O<0wVhv0pSQ_O0Urf5YSnK#2B?# znZoA`wNPM@N(h%RgAc=js09R<7BPkce-KNC1F?6Q8h^Zq^^_t18Fr`hz&`n@73G{< zuovjJ*ZVu-V)r}e5&RBH|Cnbf!)p3V30+EX2AwA^tRKM&Lm>7;0@b>78yPKLT}Zve zmfEtl8|~T&rX~hWWK85yByVqxapfTVdY+S?ddvt4blc&k#EyCVa9@F5?`)}G4St{5fMxcT*kkAzSJ*j`V`FQxC zy}k|B?&?{U8wOLwx-9v+tkNO)(b18Ui$U|SrSQI+`?fvd2k$v$olh4ceQ$pwSy7_( zW1|rpv4>@5Lt`3!@H_SV_Xja#(REblYkCaS6nZ@7h&XVAj3@<*iT`} zD6K?Kl+;iEONlczES7*n5cx|?8q;u!_fOjrw1os}Sq;X$6ufQHON0X%b0&}$j=p@0 zHq#6iO`M=MDP{Cv;fo0zFG1tTjDmzokq;sr*v_vti^wLAK9E6>PKFS^h96jc%|agR zpEqRA2rsoJaw2^jt^e+iA_dQ-0 zqU%82CjPlJlqyVtpLza;Bqp^i5kmxjl$J_4y%Q5Pb8d8CMb3GW67wNZP28y)AM1;z z*y*^0*rT|c{uljtn@m=KIJqgdh0k5eDa^bTp?WIDs*Cax8XdBStikkEpVWVjZPR;T z8Oiao8hr9iO-`x%1WEOd`$Ad%S- zZLBDz-mMy3TvTNBb+eGDhEeZJaifAw@^A5UbWS?`7QGX_g~~1c(#iz=)~bB1?ovp! zLb1^#^aDpT(xR0y?g{aU^hpGz*{Jr%;z5I)nzt3R1wQg8r4sThI(eni+TBXsvcX^o z%Z)j1d~`aRNko-^YO&7NCxtQvFsqqonr(?~?JnbJUiO{{$UddHx*4hE-k8PMq*=pW zs>s^QQzB=qc)ZxP6!g{C@kL8bi}<3^;?81c%TmjuSF@L?7m?T3L%l=lKL=9-UNv6g z9pW9TUUvtp6Hme;AIKfE-p%(~diT}h1lEa~j%#Wb7<@IT^EEsBEd2(c1uy}A2`Pq2 zAuoR)qhEX%{{t;z8m+spB_78l>{W5I zLR1nb?H|d*mZm(R@%E{Q#Se@71(QvRq8~$ctj-wS7S=tc(@!O4y?Y!JjtoS7MdM8J zOp-gJ0xJX41KD(QC zO)G_gkyvpm)#NtoE(1|k!*{~V4pt9_r$IJ;cGW-ke_fAO|2!sXj5>;} zYm{w#Y1=)XG_sm6_33k#E=YAueN>8hipVCx_$u-0>#ld~$w295?XUdL2I{AuBbC4H zFg?7u%)x5jNDj)GQGg^|%M@x_+HAydVCvp#{>kOcUVJ&~ve;{{nGhZyl9Qylr|$a2 zQo{N)5naegNOWA*wsh3ti?ej+d!M`9b@5lbI(xR`Pu=qse*PCr{&82?s);JQX_63@ z`^-h179C~#y`Z`WDzbI#NbE(jB=a_(jaI>sg(#1*%lJ#a1iu7csKnu%2pErB!(zFo z-}zT`X@6-^sc6On?^1)Qr~l-oBG+K;2g6^6M&B+^DwV6o4BGUZOx4YJ%vM@hgVd*u z6IxW~LX0xoPXkJUHo@tZe|jtLjvkKcoX(fDS|>kPKMZQ-MCQ1-;H@reIqRD>M75Q= z4S%k|G#Q5tLThYuetf%hwrEZG=6e#mFloGHuG=*2wwG$${MLA>$q`yR+==WX`bT`m zxpuCGZw>iY=}vMjr{iw0r#_hH@yp{8o*`|ygc87THdI*6ao=&o>DWQVS5h-sBbAbi?%|t($njgz+pqGHS$nG(jABZv@i9={Zf0lB;!?Cs)m{4M;B)RjSpn` zOMy_?SmPKiU@!Rer~mj>3@<;Qu(?;~{KW2}&$;j18veJ=7Ex0V@Ql~OmWSt1R+6q%r&^ZuxIF@)Wxi`Dph5uqm_4$lH?5ieJ;&c4Om7*C;opA=0P*ci0yR z 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ξ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%0AyYuv#$`MEs_p z8C8sNMli>M+aZIJ3(RF;ulE|G?0I(ngd?E`Cm#-KWD1-Nu2^{c$%b-6qk9m3>fzHp zcwiYlj(4vkWV@j>(Aoz#Q)^)%0mxA*xkIJ$><`M5;aRY?Lkzq}Jr>ij;LR_d^z-Dh zK;)C$3sTTZs<+HfMU3nsB;^t)oZ(qwf^j%7=HFx!6sV<;Hlh$(*#afRmQ52?LFFgW z+ej?fB8%)v*yldQCZRI)Ta`4}Yw9tm>PPL+KZ=GAWV?==C*qYw-zxAJ^OHuKT6xwe z27l5&?ff!;WiM`VuM=LV5o#q2)Y-J;h#~Jx9xBA4Aucdn(3rd3(k~O+04$z=XUZu} z=Kal2_!~G`P_+4Xz%~u1l1cFNXe>P9Z7Nbb`r=7Z?hbPxAodF62mCRyefYUoC)AJQ z`?DbFt}BRfm1lKN@H_X)f%xOq(cS^n=fXS9S#%3o`TcHBQj*I_k8A%Q4k{b)ygs0O zbtHUX+h0Lg>)HcoO3Kin|2FqL?`gC+?ZVig-!Ftd(7{GG3x#hM77r-&fDDLs$e1Ir zUp&JjMk-Zp^mwDSf2<~4L!d8NlK%vK)&Rj9F`A1~$!Y~IdqAUKIv7zWW>Ec>+lHlZ zE*1xNxZ6B&ytoZIjWUmrgpOcpGOsdymU^DlV=k1hWTUzi+V97au1 zAcB@u`$Jr#e=8Jr@C)~*#@{LJQK#nl_~RqjJ1eUrhtK}RyZfxSBzNdTL@gnjs%uI% zR|x$)y@QmDBurXh6jez5yz&<0!LnXqB-jn!EH%TF1>SU;G4HQ)MSvUpUx5q0|8&U| z&;F1!Aq^bS^kMg{^D?}@>M=N zh^gOPP|jkPw2)l^+l=*{?7+%tJazQo_oqc7(cn&+d$B2-fb8%*`yW)y@;u|d`jL;c zt2z#6={MioPI1(9fB6ZMUxYFAi%@6IwsRs|UUux?RyEm5dpy?LzQGo!{~?8NOsi7- zC-c`pv%19p`Ct|S@#NP4V+|7}|MhP&H}3h_!ts;K!8qni26+qW^#syKckD zHgqxL+!oE&HkoVZql0~>>Pd}lked?4H`3cIZTzp86qaKqBQ=aGL*uAk)aXY_4OouR%`}Z>pIdhwNL9Yq9YRKMdVxvwHR*QfyGaBt~h(J zMK~2Sc3uV4CVnv)ky}3{A&v|6IF&Nea+s0L89=B|dz~CjpJ-?xZHLjZgup)u= zNXa923@j;Uz2fRRX6?ed5?jmn*UlK*-Z*l4sz5X2PxIC(N4GeSeEJxf?TPtrKCa{? zFYs8>#JO^tL~OJz^4qyioqP`UkMcb@X2jxm;2XVazVhRCq_6DB>LFQ=#Q|Y^U)P#Q z;d@qOr7*Vl0ilX|w(5mr*9k4jyYEKT>+mH1eWn-TI^lk58CEfviPj>hfAG>6aa!x)NDOy2|p_JYAcYt zhR$gAZ0Fxpv92;UcvW2*h<$%`#7*rcvkC5;(Inrxh;07?A5J2S3T#5^)DpS6*4*KJ zj%aE4XgP`vz+RzA3ql)e#X2vp(RcMp|vjJMt>h%P?cQ3)fP443U87R{mqH5=V36I;*CmA2iTAC@= zAp7d$>IAk%$yBn@L8=at3m$0_o$)S zQ5nBE&2=cnv~t&es?gTPCS3XoEVAc8wV}%=v8fa;0QF!D5u0$KI$j(>2$}|64a@pK zkRL?e`J8;o**-NcO%ea@;vB-tKyxPD#JMArfSv_Joqe`s94MTANy4A6d-|6?i7VFp zYbF`*wrkh^dLP)d++UTfB}Z~+IF zWr`;G(m9Kj=Vi4bv^KZ%N64QTlGVs#Unl;AnHjnP*ZV8_T3pJ9kkLRSBOXf9FFjHl zP;3vIB3rD|rs@8W&G<1vne(-t`pg9fB zw44B>ar`tbDE05=-h;(_meh(%Cn27vZzx~lcMaY?MM>6?P*-x-@N`vm?d+Qj(^15K zsqF~_2c2jIFJbiR<>gXEHLEzA5GmzcIS?6BK`JB4mnKIwWx!f@OpkEhu2t9-X9iZL z{WDY%w4L~Pc~vup<}0ze>bz@ZA@M26k;?}cyKO*?H|*e}riH4ynWh-% z-w_*MeEyow$PH#1NoM_Uyx;pvBN(aUj`-WhT2#$AXk7R$(OS|3N!J@i*-*bp)CuCH zE8R}o&*p5?4if;o6J%<5)_NM;j*B(8yO4o$QZzlg@$NPS51R+#(bF~7pghvgx z0vpT$b^An(kXDKW@DJx8TqnL9dx)x2Z>D2rwjfmPR(uA%}sG;=_i1hS>)xY zEnuK6%i~h!hXVQ8cVM0!tQ<7)CIq>H2_+br>Xpidw;qrVQhiH*&Q%u!@3V#_UG419wmHQElB?lQChSSlK|K( zPQBO=dX3E-8Xypw`x-HdB3Y40)qa8t>41g3m@8q9pjrQG+@k#t*{l4V(Z?af6d&pJ z1_KHQ=S&#H1HMR*t^4f4(nqkj<|EuHkhlJ3>~C<>5%{kk?^tqa$_PWz6~hFOVPjiG zwg&wP4cmkc(3%gw_O&{NFDPe3t^4A;{+n)iLsZkA5Sg0$r@E&i%ZPeiadl{EAu|sk zQ{UZ}fai*1kc8eS`EXa8C8*B@@CT@ygV`RpJ_JdDUHF8$s;)lHqahwpBnV{JvSddg zz)h~WowbKK?x0+DfP^&o&or^z`O|BSQCQO^G_gB}O@zoh#hbdWrk6&P_F9lnb`V7I zThoZjwr-!Q`=!~i33{U#C(q(jOdqa~#|9^dKs+|pIGHXPHEeU-E(&_V>FE0X>F5>u zkw-L)%jv^%ky^;-l}d4#?xu=*P&l!$?u=jzIq6T03n0@1NW- z)HSErO|FPM|9Qkt;8UxN4K*>c&2dy=U_!nUYpjLWj`x%lbe~6+=rOz@m#I6q4`J)A z{1rnzyxRS_YMs+*H^qeYIfO9hd|YNlR?LsvK5k;-4)}_P}&igb06}DlNcp~ zcBj$GzG*J>_kivuwE{Yn0IYHVT32GUPcv zg`Om0&!AC@6`%44I?wMS9emdB$i~o~TAPT?E{y5@AmSgOPD-^T41V~%-p+{zmz}~$ zk@TKjmV4#f;n`zFqZFwxOEaWB#mMhxm!Jv=_LM-K!PVLo56S6J7J+k!O{MH|a&lsToJW&6rFZ~~T zR;8ML?yuM7x~*ubweL6S8HZmu(Z2u(yr){yNal`-m9J$Ng(TV8Q<+tlO*c*pPumu{ z^^wu#_ofb=auHP+fuZ}*jCJv4^d$n8eG4@}eou3ndkK`zXo+^*K2&jD_1T=+X{!rB zi5urNi6LVa#udOlsf()bu0N4ATo){Ft~UPG;CH;lk;QIvo~Yr2TcHh7(Qf3HGI=d> zfv7%``;F1B>A-9+>?+@A2bK)9oa=Z1%Rt5UDL=g*!)rT*r_*0Njwtk-%WK~Je2rJW zL}}i29fgy0D(~QHt?9HOzU{Ix(3uuq^i(0NHItJNBXjAH*YBnBKrLTsl=910clo5R zSU||pYK-D1J4};?l;XE~U(lCkVo31X3e7|28~0`m8ed~?@u+bYZI8-$CDSiYC{{xJ zZ*|}?AkUP*y+9T z!@r6HO1{$x)T}{NMSA`-v2pTfpLDDC0@ z+@Y)#IS_&fQTDr4B&Z52X}^#O@#gidOC;eQg#wi0jjd@bGzqzTDt?4Xl_*D-9PklPfseE;`Xu>+-f02QGllU(oTupkAF*!_{d%Eodc$AI{cr*lI4lTKrC`*JT_ ze*co2u^nj5JE}YzHNT~dgZ|-!W+Wt`dMo2see49$7Dua%QJD6}F2pOXu7Y^!^y+&5 zUi$OF!gbL~ktYb%Kb2{qgL%{wTbspwfFc?^hSgl=>e-Ro%HrN}@1NWryMgC-ws~0F zS!y?HIzW3j8*|~Je+I%Z0I8`D^FPL|^>3fI)v@D+IYwv11MbvX7J162d8tI27R!;V zE}l+O)3fKE9|3JupoChh=3Hk0I`SLHMdza7VmHmj^3=BCDNkfTe4alzoJh%Z-+9aT zBcUD5T2?G-Q3*yTP8e(%?WNet2aKG1t2Xv4$vtoNUWmSm-{#J{VUMj;aJ)DKsx0~` z08y&~CARIcr!60R*vN@6|7^7*qDNn4dK4D(=RN%Ns`f3=xPneu2gjgl13v|#1u9Tl zcgQOP$oxonTLT||hqUMSs-RSZhtr?37<%lq<5rikZHiB7}C>0E)EQb;xa6>UU0 z^cWh9;nLM1vTt;D;KAtObI)vW14^`J1V(hU6!BQzHf zh$WBVyCr6L6~)h}ee(-NZ6m=zDllZh9T#Ih z%oKfVI0AW!_1B)!Q-E&tpM{OaREvm^b2|Be*d}GE(7QFNiV+wi>iSOWCp4Cs@ z-PNbRobIV1k-LjGdVZxV)dEF!D6XQr8_s`qaahXPudjD zB#UAn$DQ7?r!qP-5+m^vR1j;AKcE@?HH!XUE6-PR1&U9qG0%wOw@1AjFQdj_NeNo@ePP#3gN2f_wPChnzP(LzSf2Y_g7H z)R0WkUfH?ZwW}SdeLBC8M)!mn92&*$yUVfqT#Z!v9q6c^sj2H)S}ABZ|0)_9}& zQH%2Wb`&w{H*zt4&;MUouVpd{0rtO#&Pl#26+nv=vcZ~pBWH83d7*g;gbwV;*7DK2 zueq|KJ&*Tru71_fV!KkNo;UvHc&8DV-OZP|W-dxlqQ?4~Cp|c==iL7P?Z(@uc;iDT zmE}f(yBIwObp9^rGFk?3xM3cJOn*W-dr+l~aYIVS@HMl@3$(JYLbItXW7aFQPWgT_ zXOA88zRcms^rcVo>0U1S_~Y5fkkmKX>x$8;9Cr!V6Kn&Hx6_d4s>jePc^>_((?O({ zSk{dWORV?i7&PgIyJ1QOKq?VRo}msqg#Y{Yw@st4ssE(%H2rWg@cnsdYl1pnUC~(E z5}vd*|0-Y`I<(@^HE^FND&Bo=~&`H~ImBeE%2D z0^T`g{kLk>x%P+uKF6UrKlGMOkA90)kd9L?#k`5xLT@{A{;ww8uhM>Q zcoL7Io?b?YG=+>cPgocAWHJl2T2&tsvvR@La2fO(KLUGRNo(kTR}3a_MUy8Pj|i0m z;|jC3`S;G~Gr{y2e+x`2a4u!Kj#bYzgLyESj(Mw~HlS0-myHU~IkJ?myOvdV^`~MU zoSph6NW()RIZ2PUYg&;~Se-Vj(DT2fqo@08lm8slg45AG&xY!z`3BD4kN$3ypDzq( zT_pIX7!VO~ZruzzwB4`J>DHU>RMW$doHz^5&|HU@!zsOcZMWzPT5A#4-SKjSO zUJk*C+?V_X{4{yr7c$0q;QUi3?U6ZSzHD{Cl1VG=2&R11V#ZP`{=RyC9hMIV%6Z zZ*woUt%Jcf43or@z{DjN=IJ30d5V5$eMNsYN}mA_ zZcvM(8MiaG6bh?&OgZ|$Z%PRGb*@tYwUih-!xJ*#w7VI_DgSDSZqzC^9CCj4ap%Pq z7SuTH6ZeVDILEE}cI$-2-e;e@FPw_L&Xa-=4k1c$%opB@6^b@=dU6z$vk&W9=4$+U zA%3EowYv=b@!XI&_h4Pz`u~}&zlDPh^j9KPOPr1?@%j6;6U^07#xLdn7EXy*I|i|T zy`XF#{qJ_z7Ep(5eD&Y6pqd<|a57rjtiLzmrreArH4mj#Gz3RnMN<~nn53@!y5$sy zz@rxEVFdHO@cq76y{ieyhU_(b{$(-~#woWYwO8q@3|c8+4C*Gzclq>xn0m{AsM_yq zSdf+u>28olS~{eWloAO^DM1AUhi*X{1RPRIKtf7%=H-bL zJ=&N`cBrF_K*aN{`#=2oJB)v0w5>;^QG_H*E(N%YmpOv2Z;zs8X5%JCY$^QD?lv_s z`t$i5Zd{*H9B9}L?i#!`N%7OYgA?MRNgV7F-lh!qE~Qw?VwMAg62}>l+U-ld<;~!LqP$oV@3rgj;R}m(BD6R9zh#=As`z-PadN(t{{JaX26XSg?U`f zY@BMGnw-fh7jVpDZW;fp@T|evdML9)(S6ebys8H zqs+X$7vi|2-Yq=J0L>c>k4+=Gx(74vjV3?w=sjz6F<>)iW|1>b0+e>iyZY}i(~eS6e?urZI3(k zD>0svq4gD=p+^B1C)Qjt%4#NxGwIbfRP>3Io4e_AG1* zhZ}30*aEJ%2jG|dqxA^O&Q?@{?8sMkyTd0!rGbN1O~EkU;5c@0xhn|X-|0Hd7> zcQ+BeQ2}r>@?41}JInUs2G&!`+$BF+nKWnFB)F5i*qcmGG>_(Md#k*{Zs?>uy10l?&SmgmLm#UP$7La@5B~^v zwLjt6&v#-T-|Ohfz1B5#-_JxCcYRpl#rPGva?$!H7JdnqfE{IoK+B;kk`X}Y9YMN) z->pv0_fI~rUac-i0#8n=;YYZKy)F6-XbJ+D<;DFDu55R=gWK0{o{;2z1faVlsAp!6 zH9yIIBf#(k8l*B^1~`0zFBA;s?m@<|L%#O{nY&_{4~I!<32h`>Up8pGA-HbpiA$nsA`407Ujs-(H`A)-Mf)@CUyyu)9xA6%ra#Kgo+ zt0isd&h%p}-^FG7VT1|bM=YCQUiNSrv54{+~v!6ocMap`BaPaIiYlR(CQq_KY=yU>SAO<5`MT@P=CNFnCl|f%Ox`!gCMAg-kCr4Y zpGQxR+a+UEUh0A6Lie$=ZSH`2l*E!TvuIMf^O(&v*Eo=dUTOSIVBML%a9B{l=%ZuB z1UbdfSmsIDRcO8hJd1&6C~gv9@PMQQI6GNh1WjG?V3Q*qH0#lIa1rP>n za+DL_Jk}vkNjEchi9+h(u5%T0;+p$zagEJDGDIy`%A+HQd`(wTpU#(RVPD1{9PP&_ zb}vKc;UBCWOXF5$Vq0Re4u12@FzP|Qo=XKGvrHh>)c~fL!k$N zF9IIc*eY0a>ftTs9#}tIUp;{HJxl(*j8Kj7V@Kq&Ia0vs1Gsqfdd3zWjImn$uq5CV z>QmL+vA6%cXw6Dde>31Jkw^%J@WlXz&1?ugzaN!z@=oSlnF?4&An#g9)k90{ooDjx zon>F+HbYQP-mXQ3w};_|Z-3mQh=fQEDXi_)!^*Dj#FndGYO!ea3dna9umN6oasiUmE|1?nk3>^^D+n3DMK&Sk zCJv7ib*js?UmQedY*;GTI*bhUM8>Y{HZR5v-m(2=eNLc#FGjmlWIA35Qz`oU$rgPF z*oIOTgXS4`eJF77MB!B<>hN2{nZ%-wvcKCxfJNk?3pj=TL}_&d_$CsFK!3Zt`MZG* z@TjOFlMvPC`?!Dp1i;7JJzE(S?j*F0bAL^&Js`kdR1pQ-(SN}7=f`)a$Dao$@_U&t z;y1A>dd2kRxfuB1-zwR_3WiVb9x9heI;>6DXMFD@*A^&g1qc5kkxm`%jaJM(@eKVf z>LCE?jv)E@A|Mp2nXhwyzBjQn6issegJ15v?YmZ~cuZe_g>zDOhlK0_lf_q8_rr;b z7n+6G7csre_$0sHSkhD`k|~^)PoVKz8W}kKN;LorL`ng`=|}svc{&g0x@-dAnn8@7 z>QnZe3i%xTy`dnjut@>93Q<{2ht)69uO;L9tTW3q4ekz`6_EJQ6xR^|UtPL5^nM++ zb+d6=%?WwqSwx2sq^G}5pIz6Q@%S}ENbfPF&4vM#jIX;OXR_d43Eh9{3tjuV6BKDgwC>S}Xzlp5k`wKM#e}I%vHoNb*s8HXk zT3*c>&|83YOK+^1!JS^-LQ{8yr!0pTWq#Mrgme@ZE|oo9x{nFw9^04w&WgYM8hJw> zIL)#663qE${U9IHhMV05L*eJBM;M6j9!+fZp35S>Hg4a&S7fi-jUk~xxhaQ7vZ4*~ zi4Y6M^)2eLLB#E4*NV^h#kg;lX)oox8f_KJhEF};ok&iBx&>T*Ttb3Mj?A7B5qGWG;u#-U zY~6!KBq{_h>u}9CxC!Z=)aI+j-3`4P;Yjsn*aW~k{C*udlZW%Rahk)xv*l~@Nr(3; z*4V|;+Xtstr-fsBjD=H3_96t|j<7Yr6^3ZUk;bNCqocf9kFzLSe9_dY1TXOdibY2{&Y2-XFWJX2^(E|vTT9izEo)A8t-K) z4JG-(a;yK<0ys#lts~dp*jh?__ZZ&8FO)EeJ`wuzbk-fFqH-q)HHKz}!1bDrC+^&{ zc|=3^O6h~)^{6-s)G%R}ZJE4nATl0YS2%$U0Vk*oq~~{JNq*23@naw7(7T1=?fS=t z1dm8JYDj;_W~cI?wZ=pv+_cO$IKwbQX-eWTOCC}bJxhy;6Ys>A@7SiIhT3;D&qST7 z5xX;3i~g?P#<<)2tc#?x)1{Z$bu$AT2zUk#19Kla&0$^iS3`V$o1^EOEXgq72%6|b=#OLoFL3?e=5{njMa=>A+{U|4`0UHqSwp`hCcX1M^ zXa>fyrN+G(vQDma(J_+IU`^Cy42gzFwC~T{-eMEvoAdc_WtbmR#;a>9LB2|o%-h$! z4fWtGZpmD+4ux!JI%zBB%ss{2EGi@>C_HMjYc9g`{K>`;G+}P5?oY!?xC6K}ZJ@+H z{~0hQNF(^_yd=l)W*%wVvNf4?FUnntUPM5x3$i)QkyohHsNAC!1~$aoJdj0;jffjb zU2fD7$s+*7dg3ZdOdoGK=%RA;C6!kVv3-QbKDaEZWPszD44Ij+@dsJ3zAE@hj{@V) zhBuLIo>z;p6ozcOKEj@p7{#t18!CQg)?C8i??rR}gYH*ezlh&?1qZKqSC+Zy1HmSk z)r_x6K9aSuT)Leo7$yC#Gx z?1F$D-0LtAbV?J3%3@zO!5NuNXh-Ff4#4iYmMiR^Y@ecr9ynoU!2NWxzo9^d@xZ&M zOP4dA`Z#^&7nWI_iEvJnuq!E_HAB?*mQgBUQ=Wm--nH`Mo`K-+S%kCSs`y5EM1MVW z8E07bAAHy6_pW1kzfGkxaDKztO1tW6M0#@;J}jwX65eU^@O<&x0l&LU{8e z(Kr~l8VlOr9Xj!+2FS0?{bV)wa`1Ys8-!nnY-s+M8H|3%YE>Pc`!B8iR-3sAP}G)z zWnaQ{v~Ou65QP^VY1Ghdl1(=vR1n~6yd%7fB3s5;g{b(Q@5&#U)21;UT&r6?d?S>6 zyKUzbBDwR!`|{AgE#LO-Txf~cxlJNI*yxg$2KEGEoie@>Sh@INRDl~*AHdRd_mp2) z?dq`U>PG`J%Q!?4ra!#s^b{C<`|2uV_Yi)IBUrZ{MnS^|99|1`CcYz-K9KmQdWr&? zs5ZzTO5wz2yesebZHuN z2ug2pWWkJy3%RA6$FY^7P8;YY$+CT0G?pf`wcVIh2=Sh2!>zhW_>`M^S~rRDb4UBH z^U~(=P>kT3=X-*domoUSBexdSsrEbCp0j15OJlo{fBz;@6b*a`hyD|e;J zeA2geRwRo5!$XyXyL0x-vqbBTW0>U}ocm9e^P1r&SaV_O`O>XB4fsd;v3ka;83Ewn zIDxDkafzHaEj!{M(c!$jeH$Za|KPRIijTn~8}Xe0v+C>Z{d$90ZDuhX1_YP{fw!9! zyHj2x!r;3a%#ofy$nSk;W=1Epr|v@1K)r<)^7FnkX#_Z%w&9 z*SVz?_75|e_6wbW@-P6&HAXD5N`V?)*U1O3b(L;`kX)f|fyn2Ykx1JEB8jiu127{G zY-l@uoHF*?`{>rk&%VCw#L0FyAETf@by!n=626?aspQBmF&Xfx{l}9p+Dr}vG#l_Q zg%TC>QSnS6kOX%QKzaijqq_$S;?4KVwo-2>70F>?EPcKdUa zxW*+!ERu|4h7O)Mh&eyk{hhKh&r-_arm5bhF+pF*eb}&f+q=V7e_xyiDGO z(0afKXajE@ca{$+v@ru)n^-uEa9ng1A(#CihMrlF`uz0|7Y?C)_JTwCG0JGRRCe)H zJLDO{`dhWYp|BvMSMN0u?0JyFG#q7G zwCF^hXWexbHtMQK38G8~PBRj{W&~<%pSVoSm_zEmv?<>ilouq}i{z*@+okxdE*A(` zJI?&s>vBanWP!lJISEXpiE*7~T)r|waTnK2>BhrC0m{t)WWZ-SNHeH~MK>Gp2lR=GD~kHD9%)}BkLirnNp7~Q$_PpPsAY!wlGYXuWIWC|wi7)} z@Z+8X+uq1gwT_vFyx;H2f3U^!jhZJN5hH53^Kqk%{SJDRv0vmB>DYdCs{yrqrg)^n zj~)#aTm@rUu1wWtV+u{|QUgu7E4vDO^Qef>ZJhte_thclFU)e@Gq2@hfw`-J{w%toO=%jmGX^@ENH@W15sN0O&XM z$Wz<72FudaF`8?7H%P77i!kdTR8WQMr>Yusqhs1L}* zW^>i~M`D`4lkz}Ca*2Zj)?43wf9LVDeQZtt&1TfnginkzSz`^45v>}}CjkRFi^Vi= zYv+%TOZBwfW(d{Q1)zf&7#K z0}ERD_>eyQ_T~FKf{5FL&&Qsv*{PMrcV}2h{Qk1=<4Il>a}dG<+*o&F|A4{Z0pbm# zUlV>qx&i*5Rxo(ZWuz3gKR=V4&@7mxQG(Q8jB1>Gz*^?Bqb`AEVG7jLcQQ}1(EHlB zly*bRo6Q%=72q3GO-sjXp+qei+wj3tW}BEm;9`D|ucp_=%tN`u!rl0U95wJRu!hwhtQdBGoX--Rn&u3URf z7jH}7s^UZlK9FHLA26Kmg>e4fthsIW0^Zmnzt44VMPcw>T|{T1!tGmJ{t09KAGe|2 zfrz&VFFU?`teY~s$WA?}2SdWwgy$c9b2u(fQxZ)!ZNv5=El&*?+K^K3iCUgglmzGSI(C95h7U-2#12cUN#%AlY_(*4iwNC+Iz>&A%UE#QU}gGr?IlWI@$ z>CDgMg}Y+pRTXlz!XDZor^60C@9TGp&04To0_J1=Lqz1&2J7s2E#89r6y4T~-LWX& z)K5xFqe}1*9&5F!?YL9Y-YKP83AWFr;A0dj3+D%?i+L1E5CZDlpcjaMzA^6=?sP)= z9M{WElI4i@+gDLSI3&r`N;PE@2;Mi|tPi*ZHREzw4r_p$jS0_E1W+P}{)f4Z9WTvL zD$!wq_tCT6htagLi(*_T-fcak5~QIT%Xf!uslYsNxhp(azt0$boKR#Sky(&2cC7iSc zg;nU^I)jTrI3Ne^tcbnuh|WM(UqswgQE(3{5FO0F3KrW@Xfen7L|$Pa*Bk$VrR#x( zk39#MTNaKiezYdXdd4v+=F!;B;rHiNF{~$dI3yGb()8dd`^vF-IRS98G3rj7UrXBX zu7z0f&ggJ(kcyxBobMne`n{0COnE$u6GNsWv8yM*1LA2iH??A6!Qb$2-)4T%q)i9o$FqHV>6F6LFkLjgoAcd6_>e>J zUh-fO_Zx6j=d0A*Mt|=bWwNoL6MNdXKDmS~%d8p^4F@uJnF+#hi1C7$T4e)E*SBE6 zlhBr9`^cK(5BrhRKdpr7oyR*?dC}zfxwmmoD?$&MDatEEF+U{YpA;3mVIxQ7zREDQ z3iYN1@>Qb3FN$@U<$o`X)l6dMrx266R!yqdO5hdU5u9jlI}*%lk~`V3f5O9i$_zO| zJjI0sXHio>AM@u(T}g?&Jm8QKh~y(2p zMpNqk9hOFFz%;xi{VTG< zez5#QaZQ1KcKId%ViX74tPUAB25vu&JQQzi0P{Nk>R7n!(2`4ooF_I%q>fZuJdT2Y zuA9>({Lxvjww5Db9mqbcq5rz^lcMO-;ft42le)7gbN?Ty@uk_PwKFfEgf;iVs*dD; zTrgW#uG8W++UeeHJT6wU(QTN{_E@(F=>GL~@}&$4cfs{|ItoU?ZLS3`x-#UyIDFvC zfauVrTkPy06dNi{orc2@YbRhszZj#rLR1F()|y{DzK}d%-1K$(<$BxUymiUPfw;J2 z3vWL||0CK(R&u3xjDTs~kR9Ew|MvdI;fFRLtAvRtr>!|ct{EJmzt+Ju4h}3dO>(09 zy&S^sHJhhW@@ePr56`nT^3}Qt_}NTB%0t^P(HeecSBE}hWLpyBCIC)xFk~Hq=7eks z(Z6b4J)O~&ILvn{fz5nl4OI9|PqDR~^%~tq5R#&4)=tYQR`?NU7Hz%$Sz!Xtc=ERU z%Ng-E>H`u~FLSfPB4pGZ8`VDtkfR&49PXo^T|pv24mSzwfaK%~d+eRSx*(@5{YM~R z;~S!lV%vZBH~l6K*2tMX05*}hA-2bT5PvlND9R~YRo9@9EJw3=vO6%ZypGQ3_0i-v z!O&6;+4a-FLsnDPDsw}A4Qh(tbA+z=sISFGmRc)tW*tcmzj=*YOPck_BbQ~AGtw^q zN7He9EWe&FFjDTG>U-QBM7)mMy1#+_5q}4qi>7Hc`W24R)X8)e*?q=pPn#+N ziWMf_m)t0)-0!+iPu#x|pWx5nMVy=Xu?4i}PvcL$nEop99)=vw4%eq<9n26F+Vely zv>gi`y$8!!1Dl$q&7?M>Q&d!ZCS=gB>q6mOg-<+Rs9t8Q>X)N4;NbMbZJS!K5U2soLa6?bnhI*<(ZULhUg4N)dCv zej&|i9^ywojfD))(kevAU}t+uyBFX(UutbzY-yMt@8q55Sp;uR@(){CD}GiD z)dBcG-Z_wDip#*G_S8fC?c(V1@Ac~lLE6c7IFw#~5>kC#10bJd7r-2@Dn%U~**_ng z6B8?(yVnAYfF491Einwq1#U??6plcG&~xFa?GvF51HB?8^fX4wdxg_HHZ2nd4F;VL ziP)sQkM;VbS2|E_?W&?1@uUv4*W+5EhE!7VIHwuB;rSN)jLq>i$^qS*)sZ&&ft2sN2OUOovT6f&4d2AUFy1~n@O;^(G}h1w3kV)1$}9Zx5XpUHLl8w`Qfi=? z-f6N?fPKR2?O6-NQS!1;4Va~iZVq&&w>AxBi&<`sX5VI|Z`j&dRhR(OV(+FUb86Y= zW53SgxRZ+FUO0r`JQOk!*zSf%|Lpf+174!nQ8P%`2~ZgV>~oD1uF@@PnxPpA@zNvv zSfooP#k)m|efF%ie1f^31%Ae6(s{9?@vF(Ez$!eX)ZiJNy3XJ-JW+m?(B;SWQrS64 zC~g}5dJj(m1Hi&)G|4Mc?9#bAs&2-h{-2%I~S)uRgXz$b+A#s}0_ zX^Ew$r7WS|gz4$9O%hLq%SA4NT*Jn4v?K-fL4o2s&4PH24_aDe?uPv3Nv#}oF5abP zP6J=);%I3#?%m>_8r#R}=;)s@$dAXS$o_gsl*=@(Zq5ZaR@#`?ISN?V zI*R-Z_PvUu5@OA;eqE6&a3>`>xa!-RUwpoITy&Su=c|25-|X4U0!wcX0mX@{2u%`<)S`G&&a@h>`}p(b^-K#1d~-_D&Kt#O^$Kg!69vU(VFFI4bqy8gik-V<3D6Fc~p42|{+3AHRGh_)3 zkp#}r7ia*iBGm(sVQ7=EkF2QGkkGmy<05#<-4Mgt_dPv+(aY~!bz?$M=A`pVjC_H; zfqr_MHGE>_1EcWWfG_Ir=Jz1qUu^QZUenEnN9X*mw&o7KaIA+BE3dKG`_YqT5fcRwD@RPpsaKid+e{ zWfNtYI;s}8+hN7_MqvGBnb;+1ddM2?YafC*K60AsIDDf@2IK&@NH~b;4Pq&`VTu}U z8UZ{ap?=DQXv^B-Psc11$i)1IWDYc9^{acRDBtzt#FJ$OX&@6PHzMAzF9Z`ppc2oE zY6@jl|D!8FWJRB~MXa~tWzQw-U_yBBUF!$dsUn5dk7sVQTZw$kQHS7LU_UuN+D37| z&>{_+2s^QXLITk*k)4}DUOkX36gd5s!MG?iL>EU3D~HwCvMqb){R9n*jQ=P%MNP+P z@WW?FmQX zcD%c}z?pxhHmgfj^|T&YLQz?>93KM5dH(Faz!nwz^gvYV#Wh@|Swuj^(m`k7vt|jd zB_c1Lv87!~uXu=7#gUhykwG3e`F~c)ybY5F5U4x;tkFb*kXuv^aUncbpm^Dr%F*bK zoLsz@d^r9atAnN6@v9!b{17jXQKsIVpOiyN1g>qGYl^nrcx#54tYuFlI!MK-UGtno z=&h$;jjrAfN`RCoFhf9(D3J?9O84KGpfzZKgNWeROn?n3R;d)FQ^{{g1?7EyLJ>R{ zoxSLeSFoe2X_bXTej3RBZqhmWn9I?%Kedg?BXqHesZc$G9X^1utZ@LPdRsMTZY=^UgQIz0GET<0QQHYUc@+`QC4blw%_ zXqwEqE^kIhRdZ4KSb~L!X}|N?rSB(K&{ncg8vQAjv+fPYD=RWR)pB&#~>Bd5n+j-7eR~ zv_*EZ%q&cq%|G@+uv6rZH#laupTUxr zNmeqdsi`SezLIw=u6>L{O*NKe^S#}ftzf;Y9Ek|#xn&?EY*4~~&voQ0&fgn$azy=@ zz(4ea8UAn^CX=*tFP|a;>{>}HXX@OxA&(qn7KA9B4@Di9xQy{q6)kenaT{mNdx&U$ zIikVpOBc0|Rrc%aguW}B5P8*GQFiN88q*sA+9r%pnuC}qf&a!tbAU?}sK(v=DQqP% z0gD&0Q(wG|WqSVj{c70IryAoWRDJO7J{Cnml~(0yYx#jROiV?9>7?`_aa9s_dCg;8 zQziM!1BW@D=Uq1MR5)Ezm?jwClI!2x0N03#_FiUczW=^NNJHs8*Nr3QXC8#Qt|`}1 zw$Z9pi@SfE9ot=033=Q`BnzcpVQ=$fwDbsr&>E-!7dSy3u}DE#w8)31}sSeGxq z>$MY7Su`^Jm}1{stvO+78_; zRbeZ8uR|J5_1!E$gu&%AR~O-V8=E|u(B|JWscf|awj<+EuWD4+pCB}D!s(rlH=*F^ z(-mM@1W*q1z@@UybR84H-@z}WitCjc#*v&PIc%C4{>azo=_W(k^S9PVk%=cZgjnd_y;vJ68o$5yaUvXt9q;B+ z&Tnn%FL0FW2(qfDjEpzaGMUGp8kxoZ!v0baUlDB_y0nAWZav?s7DZfe=DcPselnLg zK)TNO|J-_5K%-lj2173I}b@bEP<)KcqGj4M5GO%YPc1!@AVp|JK}k>4y@A42a9y4+QlGV zg6~B%35kKSitZCo%?Y79vquV18jn(nXs0 zUWH<%m@>GiG35N4nt9avN4ksOPuZVqHW`+37e1|GS#h#A?T`Itc)J;VXT4vx5c)!< zIcQ--AnI8>(F=-oZW^&JqT6gafYgl_dtT(u)js{tm(4qFj(&EXcH1hdua{YPbk;#j zLQU*}_fGCCrGeMhqD$48f-QMfKDWl=){GbP!~w1umE235X;&AS(q}aKYcUpfmA$L< zGBJ|>e-HB)`o5QfY#PuKbHq#adI%?8_$> z*|=-AWQN2iieDOyRL+uk>F#m63H$N2?X$K0g)#-%YK)H=L}>IH%48Bm{=2aDJ`Mk% zEY-I9PzLfLdZ^r@@{@!{#xu&PurXZ>S;jU@L?83LWgRzd!^SSSlE#27A)H1wvx9)3U4>u!#o(k+-*Pf2nA z8WBCKr>(6$Ql2)}8xX|D*@JRF25y-3ekA&wH3&72;dK=f^<37_~;m^!_p))>Pl@05?8 zL1<2#2?Xf3XIT`Kgc~pypZ`I*aS38H_cIG>Af9JnT?%kD^Vtd#olBgX(uEM5>V`>3 zIZR5OvpqFX`Ggtnx|75jT>P_ZmBMx&KLNr{#HQ-KdP>c!^2m;w84^jkrWAGpVhstN zQ#Y&Fd!*a{5s|NHgHZUIVVGfUO;uZC!Nb0k`IV=foD9kR?U;{spO7ad9TdMcPms^< zr>jZhJ&FmrkISNCz$z!VF2W@p$aZ`1UzmnrRe0YJv0P$d$PgK}s_!o_Czx{jaT+n9JnNYGq z#VW^mY9L{Ia6w%pio4W?W`ACg;?uMEsyvHoO?Yl!V3-T#B7clg-KW-Hb3&L zK?j-JZpVZ{Fn9$a7>pRqyZK#sSeC!Ae9b`~Rg2<0u67wK{5ZdKuNC^8G9Uq$$jLjp z?xM6f*iCKHsvV!kV+bpsLEP-{U1L%_@C!9NrjJDws)A zul4(1lgfc?h3P8(f3aLA&GAu2e~{>`R&qDbXw9L|ze7u5V2}rt`!|nq?=}iT+})0y z>{6T!4Y=aAeM|NT`tV7=nLJkfC=7V7=?og&rA-laGdw4CEx_z@)uaE`#Vb{p`uAFa zWJ!7H1|&cs9XG9NH-sa&&q0PE1IAO+lb^(^>9KHJ0;c=prhbP*2@xa$@8nZ?d9q7s zu-yo@`toqBD62F%H}2l+vgtX(G?7+$+*}@#(EZ%kWPvetM*r@OPcS5qKmDhv#FV%s zYsi2B6_;>g+a^U)itR6~gAPDlh-7*Kzl3a4D&pfSII?@ZXv8OYsD!6{yBDXfD|nm7 z(M^*-ddjP_!*$JW(_ZBIC5T5Sj5u)q@g-rpKK^&rFY?z=8H63%%+~eEHkT;v&@VTf z#@1CY112mH?;R@9F)YCYQC6((w)F@f#wV+s7*VsI{fs#lysg@qn@Z|VCCsye>=e?f=@S$^}b6mf5O`|5Fq>&rS&NZGmO&zd}A_F zEWY)#ocAL^PEeJssEVoIdZS-v+!G%$E~{BTNlc&wl?Y2~^cQ?CFC#rk@U*9oo#wkZ zg~bPOfBzVZIM?p!RU?#{9C~_>IzmfS^=gGiJDG7O%f=#IpLb5o^hRD}V~~dz*|pel z+NneSNx=V*4K4*HOmg9W$Yx;l*vUdszkenbryX0Ewus}oT=}aU|1~z_EUaQ2ytK!; z8XWE0p`Tbv2)4>(#M!L+9KQ4y-y+<3tQXcvf_U|peEXnpSJ6CX2lZu4#v7Kre;n0s zA_xgl+JYb{FlDau>PA`bsR+*q*~Tlb9F0pGXO}n|dt4s*F*M0a=a&;NKJrZ%g-*Wb9s9FLXFF0Frwa@+AjhSeJ9;ervS66HeY ztA)+msJnsLLoS6!^MXaEBAtPZS4@zRHJz!NUZdFlcY>KE=DrVy@ZTFYm>IP`wlaGo zO7tRyQWZ1BLAR^2vQb9C)2t%%oFOftM)nC9>yIg!llpH?z1NfvQW~r$^Df{8eV@2d zzNsAJ(5hBIrjdP>6=qj1c2z$)9cksMhua65XSX}F9y8R|>EWQI0z1Rjp?+SV>{{ZQZ%Prg!{ojR;7|Y>%IS0p zt^%G+X;d^V+w|WHpkKmvj6+ZAI=_O7!t+K~5U|#25mR8p;T4jC&KK+=UN^lRC1U=h!@1i|xVCPb?iwEd=GX7CP`N)z;8+BBrEjz% zMv*X6v2yIsZmAPghlV{v`cr+-eH@-TL2HfHJ8nq8U)TO(6Y?-)s$2}dcTyb`qtDXy z_j~-2lM*p|Ec(&osab!yOzQC@HOOV2QqX***`-|K9c=RixeT_i=v~2Oqwyi9f;W*g z|1t;i=sugiJAGU)u(uWdqZNr(@sF6T(Y1%Fyh@WrL+%DQxZ>-l@;x2Nkp$i7flLPf zp;A%hC7OKS+CLNv zS5Lr(LVSO6c#gRkc^9OV$ye;g>Q?^qC}#5S6^y_Q$9SQvHinN)LoB32H7B@a45DML zI%u%iOT9;X6!<;aq@*hd_C72d)?#qS^(a_q@<8uIDhX#cFTcYE37Snzuy5ze{~tAD z_jxY^8*rpvA|`PM{AW&W*qI7*pYWzc$Ed^-^=42tOYgcrN< z)0j<>SMNO(n#xxaWgfo=%yWMx(z6Mi^=^SP-$59r>$&|pRu)1ry(<(vK0+Nh>;)7=<-%a?qQ}kY8WAt_VT)%Xc_)QdJ&HLVXQwiTR7neui-@ z)rJ2r>iYb1VA%{oXp>czp!{H^DR@-qZBO!$L_tW=_}VdbKelnryFO@(rg&JB(nh&I zzN&{y4}%oxgv*CyHy*F>aJg3%9SwBt8!PM_*N8}jYWq-o8U{PDoGQ3PV70e>3$bmW z9VISr_(5fY4V{AyrvDF_UL^p0FuK>|lkL zQ=|M#8=?6eX_vV?8KSF}PF&Mo84EHoTE-qny9uAHpk3+wf9zAIiGG-=hvk2w(Z&wm zMB1QDj|k=cR@HD}nd{cCgV0w7WXlguMb4I7RhilAZ6C&$zeJZ`b@6DgnPa17cM#gD z&lxhyohWxDFW=9Ad_$7}?!q6d9W9DmxA52TUk7U8GRpbI`@<{jhkBX4H&D1zUg-T3693Q}V7{}cI1=sO0rDty zv@wxPiLc%X9S{2#5+lse;@$dD9SOkA^i3B$YQtU2x647vx%YRUjNOW@TA3W{(trgq z_;vb8aW?`mX(ucRFvxmTW=O?rQ&W4-=7;gta2DtOOtrp1`-EhVUzGrbP(;&b8UG%_fdz7Rr`O@Y1pAY3K@$ zfz?soM<+7uPoJy==ta_r(yf#Y;{lzrOIYf`8dN`1km6Js0=Hl< z=8|iD&IoG3g}a6gs$|HQKb4WR5Q;6q^s_0R>uz|=cS!BEr7TK|GfulgeVR(cC;fA3 zHP>j&cbM8G#LW{nxojhgZgc=L_^j3GB$kwr%jIc<4k#f7eh7*mvHVBCLi36}A;qpc z*8cf>r@QYxVYIx}atdDAYcNZ4K*k4^c%pwrtf5_TO_E%!eYc+?agqDZ_VAVVHng(x znuSU4^ML&saRxZk?7HzQv@U3JOMtT5zh7a0rZQ!7FulJc0@k109oJxiv@fyF9vtWX zNW4bse-^>Lxy}5;NU*-LAA(FkmxJ_;ht=Ee>FvqFEMMw1Utc%Ch1j*PF8|(kHCseH z%j5p8%ikGi*hVyq<-r|vex2__KL%5+XC07qRNIurFZ%4go%o{VAEZ!eDTD(VZh5|Y zHZpU(X10D7)F>W!{{V@*0IO{CG;b`I^M3N?0AN+nPvM8se%vcJw((R4JoyiRik;;J z*d|i{T3xnJn%X)aWj8XkJ8}5u<3Ls4qXrIOVLLc%<2}HTz4bB#Z4-Eok33osdS{cQ zkLiV&D}duCu)^NKlq2qFmn{5A!o>dC>wp-0y#Y2IiU)eEB71w6)0rVf7nHgl#iur; z^m{F*{&;JuRp%!`w0%6GC^7p>O4`eFH&O2nsjetO5$3v3QGge@kJ7FNi^Ax5P-Q7x z1BKU@#}N~UT^C(G2ygUlE0n--HNj31s~r>MGEH2rcVrA)c}h;jCNO7cTn~FX97GaX z68@05V15oXV8Nb!cO@NLZ~-8Q6W`{wIoqT>iEn^psjVOR4ktiyX zGL2WC(>*kx{?9`bF6(^?b6z7O|My4G0$|u3NT-7!spPRw>x5d#zvpn)-E1<|C*dS$ zc&&X7OiR8@A)w-O1E*HMOJe?Ut#t^w-qbMv{^D6IL8B@9O8*oxJpXcY=tO8nMAH2j z%RgX6#XkWyIr?3d?y#xi`7IdawEh2M>MgvYdcUx5=?+EdMnFK~3rII2AmB)McY~nR zz|aUt2r4C|gh+QYbV_#)-7)k4GjpE#Jo1 zU={h4^SEy6=Ot8r0C4^>*FGK*t@=dYMX58GQ2oxfr{!80QG#`Gl+Mz~d%t`e8c`S= zV_V0>(uVpAzCS03E!rm}u$hoRihrn%F3OBo%LPbP;_?>m5S$%irs!8>fo83AhbQ!G zUcA4&Nff-UbTmlkYu{-uM4&x`&5_AbOIXa!Bgy(xFbD{I8rltYAs! z3YqIgS~_XZ$LSw_)VUaG0pv?1iBEZ)$VYO}Hf2|VB&qAvp#Z26Vj2PaW$}#8Hza66 zGm(@|1c(00dOv3L3;+sIG<9qG6;l3~kZ2$VHl)mg`W!TE{n};sa!wNfG#;|ikX%4C zG&E!`Y9@~+S+cfhIKuB{X%ks#7DfDFR7>{T@Lahuhit1E-(q@iHd^TEt8H1d%Y3Qe zp5>>6F;1$1q%>~k4!-U2pAZSM*%H|MkSuA6PbiIK$B{94IW&6l4#@3?gkj?q95GRZ zl?mA>x<=&g3%br%kYfk^_{L*s@OOUU9lZxMRjpYjPiyhkQbEip6pfan=Osr$soheM-Jd|c z4}g%Z+#xHMHRBa<1(_A*v>%|~Df|?rBMiB7$!M`E`I6E6K7TJ7N+Y@t`hzd4A%_gW zgoj1DcKkxLRJ)$=>Oeox(M4#r+dA+klPyI8EFqFtkm(a%Y=S~N**Bg4`bKt^d7#FS zok=v4s~3*9b~7b*V0_?=%V)6k$BL^6{A~YRsPC(LN`^q}+5Q_U)sOHHX#;-l9S!PK zNezR+1xXFN{$D$P!f0n7hf8x%A@`Y%MBlD80sIt|8HH#k;HZi;nF;-)4-yfrwS63K z^#%($mLaLk+{VBq@OWsy+T@k1M)ecU`n{re8LSLdY+u@qI&?Tol4AY)E_Q_751$)X z+uXfDSvI?T#2Ej|W?UDHZsg&~dH@A@+hT9;A7`#R zx0!D{0B-lkomhQlklN@h6)Yw$fylRr#?=q?WhU(=XXO?QkVwl48_wq4eveF_*}wWz zM{}-19UNp1-GW9<$ulL>ghigod_v-5+5fZs8_njLSx#4|b$r@;qV9i#& z=k`ds1l?Wi6zJ@@+>@6YmVe8bE#5Se4`Vq12B$&ypbmGUm@9+O4WZ@O}3P;G$vBrwT5CvV`c z5qr`>;tT}6VQB$ti@h-a@8Y6-CNybO(K?uey8Cy-SDNn? zlml&=wl-^F>RBWZy}i@|iO(6?LA|n`f4y7;s{`P-u6i0C5@pSzf6Nl~f2q%fG&qVz zcDP#7viZ>1CO=<-VKcB0DDB%lSfW1tx(e{ClL=VsnyPX!b_Z+-$I3l|p!})IXCYc+tDcUMmDgiNPEV)Mj+;v#8SLPL)l(0vo^bqtTltfr zAg1}Zf4}p5#mW^t=fDMf45P>;G`fowG#PwDlk=+-p&#Hv2cPu#4mv+Q)j6CNE3>G5 zcgl3%P8!}kRkTjSulL?V5)6`T;~7rDSFxSz_Yl8p;ioZZ`P*N>+f{tBXJ>vZpML9A=$I$U zZTRvScCZu1XJajOxoT#LQs>sOq}034;m1))9!84T-BJe~)n+>ktb_qI&*S_$HiX?? z|7wm;fQF|Zlgr;fcU~%sdWy}&OK1Uyyy7~olw)91h6Twc2Rb|~GlSFX+zG;{KSD27 zShFKRvU@i9UYZCf@~T`$df!@MIOS5HgI)=Dk@u5i3_kAs`ah@heWc7fNy7YsDJNqliMi65*vnF?4M;VuiIQCYY5Yx`QGU zThJP^rBm;s)qLFY?!N8QD*XY*6}WBwTj;}xwGOF>p2h;_8Q1>M5uyQ%JHQ!jB=>VD5u$s(_j$=H3*{jA zJI)V5^NDa5W!+leKjF7f#xs_4;N?v!@?z_j4jyl{5#n>(TJUHsEVDJoyprs}N20$9 zQSx3pk$_^;rgJ}c(Awn3ON$mYx&B@Fq$T7lerD5h=7D^<;z0V`vy2W20%?4SRi0m8 z-Ts!lF9eh3PcMWx#A1zq{a0V`?6pf15m?#$HZs#jTh4?G zy>6whG~+K1Y*X8Q0dq4bPLcWKA>FxQM~yxGnTyQ0#^#z{^71@?;qa(e*=nAQ&l3*=MvGTP?!$E)`mEAC5DjjD&~#G z_f%;S&(QDFn>6p-OMW&2V_A`~>+7!xX)H{;=(8^S>SDeM z#=44D9dqG(;KKF&_AeAz+E@QDt|7z+g40ZNB zbzH)d`&Ys}%ayS6rbNJDbw~}f<;Eb8sE5`5{YL^#A%AeEgmT6^CPCd%iWqw=%1s_e zi|5kEb$mG(zrJcBLTxP&)t9he>D~&cWqo4u{Q`#HjMU7d3EpN1@31@3;b5Vf!;-uR zONO*$oo4TL_J>r@(o)CU9?7MUaP*n5Y*ZSxyk>4|Ok@0jsIGCnl&wE~4s0Myq1M?e z^R0ZM#w2AD#n1j{*-p}^Y&U+J7XE|-cP=ME$(Yv9O@0HEE2Yj1K`=j)_>Z;Ix`6@&iPbv+{S>w8Ez*X*MlXI=akeXcaj~3%{h#Q1xMzRr8Qd6 z{ltPQ{_bDzGjt~6#lx2&v}S@6LOmi*cJ$g9>i50^Wu~q8mRoTj7TBnSH+M%3bE2MX zrMkNy6*20igGtWn>-9?5+8@>7ClshA8xE2qVm)4c!Q>1({x0}SmQ z*LJ(5cSl!5|6uj|Kzo#4O(fkh`NeK`UA{X@h0LU!OyeI*JZvd3Ic#+1HG>`;9e81O zx1Z+hf~}1mz7hk~G;EuRk{)yvlzHv+qZ-RU*ru134t?aiZAwa&H2eX{OtzDpeYD?w zOOqb>6S3Z!zAg61yf^KaiAVSxV#Yw)DOi5g=*2krJRU4&-4LR_K(fmRxI?qP@sMx! zj+mbxb5H1jraS)AR91+=&;DNCU+n4<@j^kK!u=BDL#>`r!?|sf9&((hLa^L}mfu_x zx4Nj7z=NvgV_(o|#=q@$B_Fjq4TO9He-YC(uQKE9-rk*RXdN61+CV)5S`SFJzs10` zx?oh-AZ9+~VDLHV_*()h?%v>GUi)WEUrEwbDrtj7a4sefCT z+Z%sYaYqtTu3o8(Y=76L+75Qwj#rMD_b6WafXrFe=u1)Yt!djsOdp!sZ^*P6RiLGgx<@%8#`Wiez5W6l1*g@|m!;cF^3y<|{Bv$5s{^p7(a zdVYQS;w|_C)A>2&tN6T8=Sx|WVdkKd$}5F6#8~P02u&{8^q!57E)TJVZsXd`1oCIp z3}XgKZ8G;psj0P9l|VFXdk~To?hta@elz=D{iCHNZOdTt@>@ThKku!bYeqb#Y${O& z{v}g?RP(Tc^#3qvOj#cF;%e&t41aMe+t#PaEKjX;qV%kwSTm!*T^3+>n#kAcpD<)w zZw&CU@2z6HSoZX>Pb+FwzJyZLg%;K`@fnsSZ*po3&gVkdVG7DB8-eqynHoOZJQn|O z!_NM5hD!M7?HYdQlV*k-Hd7wnK9WhN7|j$gGx`!y6pT}6t5roPxt^z7__EH%4M_I0 z2=jWtB6!+i^{nT$87Y?l+0N@3#e35#s~pl}NYa{T=vnQKk%UkcYR?RuFylI*b~paW zX`)ywyX>q>Zxdj2T5z3PB5(GwG7wSkV7iX_!g5)wS7O2B?=BFO$Al+zGaq3{-fLse zd%P<7*Ek1R$6$6`-6N*3HSU)o7aaG6UQ)^7xIxC?|6>8zj4R!J*s<>LO`qw(4nvJ2 zZPcr7$19F(GejrG0>_^@NQ(w1|X#pyruImxf$&EHtrech{arw~79hOW4>4yKS1> zLFr1FVob$cjJbWYu}9yf<7WAj|?6Ua<__k@-QXJSP+N8%3~J)F|B$; z-qCCA3DGx(ou}!y2Wpwru75o5cH?hWBfWQf%=j`ettB?2TacE=eo(@{OyGwV7J5CW zc*U7N{|Pb=GjMdl1Ngg?^aC(hY9!s%?{tImv!XG{B zggpG^i0YUz9x$Ddu>_6!V27~1WV3``5SAD|&dpBVLxw5uT%I@FW7HGbAzVadV&;o% zi#sKv{iI)2 z?Xs={5K{*@YiXRNh-SV7$Wnp4_l=@Xo0GM1mD_hl-#xx6ae`Cjhk+{zEzGj6XVKW# zOZ*VrRO$i(B+YBpzwIIQA6}$#Hs+&H!_m^t zgu&xUFlERD&cTbN@hBd`dU4Vb)~9lFXYUB(H(a&%r9+;qx#r^30Z;~1bDIo8eVaV{ zb8g^7XD*qR%mYM*tBsprrTF@Qb7s=_mioi-kR#t>d4!fYs#-8qD3|p5P&`^F&QG6x z=xw?W<&Qs~%CsJOyd0YXPWp=NXVP-_h9J$(^#YM5Q!vj7Qi}a~0tYU>G8esh(jv)$ zpZ?KvBO~ILAw@+mpWhAwe*InC+?(;(w)@XE(Q=K2`%qfk+fQBxZ-TBjIo}Q{->xK% zuW3BX!FrtDUiYIXNeaup#_l+sWxHfx!!@%L`>>(Z)KVaHH%n1G*2c&ENeH9#oT?j% z*G1>a#2`qKsC0X93-n#KdLM&BW6A6#I6J^oWQYr;oj{8Tk+{T<123!bsUDcjJ->ZC z>he_HU!%d6!a2;9a{ftte$B2VAj?ZiULK}WcH zV#Hl*5&^#_58{&mnFpAVY8zG(1Pj;!uU?a9N?POM^kTTAcvLj$X_3_o8<&r2bjLeh zz~dSHz3z;2Lh3C40?oPGe;HcT*wS4pqBajF3C_MPiWJ#jL55Naw=rtX_qPkBii$TI zL7r*G{~|gCwdYrtNUrUzVFdroq|A%shY54f{AOZ{t-V*{216x>`7Z9@`8)`M@Udma zFM@7PJ(S>`yX~!89rp#g_zS9c@|Ym0w#8cePUYZ;fY|W4kx%tU5lQB;qg5()bng^9 zjv7p_p4xS9+H`D{`+3zDf-e$1n6&Xj6=p>kyFouA<-R;s|9fpY5YTex5&Wgrph^=!$qWMb}UF&DW zR2h4Dvkoz1=50#k?R#X#cwAYnD1HXL@2Pniqi;IK^HmC2#|%!@=ff!RV_yX(FP1*U z*F3o?Dl^A9kBKpNF-Y07PU#6$%|k{}Ug#34*FhcbbS}{Ks;(UywvNMnpx|%a5MbIm zXR_%>gJ3()CtDPJ>Ico^#R)|1t`MTX#?GDq<=85pA3Itx*-r)+dEB1-8zKG=%XV219I8Wp)H?|!)7anu0OtE z*R*cxRA7hGZ&+g8#?UCHj?u8s4i37A0^%Gpm?x=Dazaln%;eD8sYI!ee@nLosGTbFqx~br3q?UCFtQ`-OO#O%5PPgynXL>goJFJL>$l zj6@&}KOu8JsEy?E`?xCji_!1q=ctbo_qZ?dmst5p=ub8-@a3sQ)=`po7gSiH<64Dhlg*+{bNfg_$@%yX zpVZ^1G|NgjclX1nLVDNp4OMg{wiFaUZwkxl(zh-<%#zaMaET#n>@6$5Df1iHSoa$% zn+W*bz{AUheoJs4nS)&DXPTTqy%1zb-R^q&5kA9J`fbSobFw$oD=g;}A~Tp1bjAlr z-srglX_oLyl+TwppE(2KA8>(qo_mre(+A{(=Z^f()D{H=?(!;mSZ}&1p2)x-T3-DY zMyF!@e`O5=T<*tOiv45=dJ%ss2;qVJuP@*AFcyJBr+VifmY? zaId1=L7>-H=iz;asHaGgu~yvcQ>BYR8*QmWwA9$XYp?1 z?9HofxcOnpQ6KS4=Nm*m`nDSDvSm;1`^WBxI8r&hF21Fcq5xQ!@ko7yJX?}hnhFzi zK178OW8TRa+wYz8jg?0keh)D)@J~GfW3!^3T8)Q} zN*?f&{rxd+jmHZWm5~HLs8=x!_jVYtWsRP^c5=g4yk@H2I8Qi}2s5GeSw4sZ%8s$C z5+LuWb#Zb@0DkMaOWfmgx{lDhe*qv;t!scBzHl*Yk6^^#Us<{M51BFjFIsMYK4Rj# zjFFH&H_OX~`RGr?7!Nb&hi#Oni4w1%$NPcFAkk#z0k8TbEq9n^^1I5AeE8kaN$Y8` z8e3U95fqhOIrJ}z&kNLauE1NGvMZOQobH&89rVz18aVnSlxhm5LU2rs#e@p8@}S1) z*|s7>L8LTeJ!ITKeSk~4;JJAY5csl#RAEc?*i+>yw-ptzVadR-#ByM{^KQgVaA}Aek5{-sZeDcjJmz{!kAmij_5|R)cO*D@&kmGEXcZkgJVvm{-_WEtv3iE1B|4;FA@X82;cH*_Dwd_Xau^sY z>wQEHlCn(3BS&RgQ!>wj&i2cy5DhD=f5rBjSk5s#$+Py9O^7CF`fZCjE~2-`Z{&G; z*Y+t;>aovtMXJ0tBi#xs%M$U~f?l57mJpGbLa$piCSJ0pZ20Xb<^JQ-uP8IQZ@-m& zFLIfjU$G!Ga-)izub5Uq{EE{*s?sTf?pDzN2dT^f{`Rq(tl z7I)$k&&?sLWs6p)3W?$y4FXc`1S@Z-<{6@3UC<8SiksTR6%@-d;JF96+MLP`nRqst zaS1vGo}&-4?ch{NgH7l1_Fv?48avN5+HPVT!2Mr%!kEhsKLc^ks@KmJR4xp)J^wcB=M2d+4cL~k&>1h#ICQZ?9U)|8P1o?E{x?Mg2U1(h$H7dvFwGFG$r%L z30Kps40c`!oew@VcP10PY+OZJ7GAgALqO?^D1xkVB4DQrXGeM=Q}uq!0ghv>)C0dM z6&$3=g%rS>C9fY9ct3{KPS=099$hW;9TL8f{pV{Dxa&O%v)gm{FlNm2y4t6nWMI`D$~{Oog5f z>^t1@-X+{OWEEGgyI2g-OPw&8!`K|O-zaQFThDsqQ5QeFzcV3*B04Ev?5A>R_=+=n z&nO9@6y4IaP5r8!^|{b_@3%>}M@u#N3p2Zf`^UIrPw@=A6%wBINB-OC!Plz_+H;(3 z$i7+S@Q_+NRJpG6<9<|{3&%!lC*~TET&`-nL+bV{UK09OGBbEcUTq)F?f20-1$UVK8~+=%#>tURa&LC z$Q1vyK^^aE0S!+?W(v1$dEa-Gc0J1Ut8e@Hei2Qw-ps|U*IUVlS|>11efp$!d!KuN zrb;~jKex?Sku5X=mYl!O^>=HDYV8KcMeMrb^fMu@`H-8(K+2VB0m^(!P`=ai5mj2P zUe$0|mP)OnVK;|G*qTpr5wntlXbYD2@bh(sI$Edan^2##5V($w=+c47LMZR0ejah}GT*1DlGfdem*Kqm3tQ@9uOA4Q7@JIZ&KnU+;xQZ#aJ^=Ii#1BdZ$7{?O3PBz~hBaHu_nOv_d+f^4bHz z2&rEmz6c+woQ(_kGo_HeMF}s0C$ZDPpLu=O-F_r+N!h{1=ZRL8xkDuR3m0%6cxtRe z6%?C{j}t0i?1QE>EKr^(J2*>orQppU&9y&3Wm`pQMn#_OV&e+;FGcAIkMHEkgO&3C zlyAe5tiUz61CYnPu!Z`hr_sxfOUAH7JdOeKjcJX^oN}SuUz39J(i37XPkwYTQs*zc zUZXeh-F)pnAs>y;=AWYRtRtR_dibM8D|aPJ7dKjTe?Ms0 zZouEX4Hf4>dQTk7lT{i-eq?)fgrFD08je+5fcS`t8H>Yg1z!amO<&`e4OA1HE~LVr zxj>?Buc%N~7dNR5^4+U=4DXYquids~hbPw~1PsvrctlfAg;b_v}~z zqyPY3f~WIpRaQ`HkuiBqNw;so`-GpA#MsYWX^H8&DSlJw+u7BKT9ji4Cn}(A5HgzU z?1Z*7jqY!w;-krL+XPbC6l$3Kvi(CDr|KFyz^V&5(+}$4R}KwbjR!ZXf&yikO57*Y z{7!t=Km7c1a3xwFk%t$(W(7bG6djlPPO)hk?Y#EeCwz&>X#|96&E2CL>z!D+V^8l6 zX%q+xB2EY_RX5*5#NCW`91Nlbxs??lGot%LX!&|hx$(24q57B9@`ML-hrhvBN2CWA zOEeeD!r%+#ryGrb42{KSF7BqiYpc@lgg}Ux6BE#VPE)19)nOy$gyp@GWi1wX8v612 zG4U4*C-NwK+2|Gc!NE?D({i)X#=3jpQEd%%E{$<|fOABMeX9d85S9duB9nTxPi->~ zFEN@7zkq#e9nl^=(%=cKwc5ZHy0?JX^a{Et)&Gbu(o=J+k+uLr?)Q!)z`vpL5fGON zXG3-CxR42!&=bED^mt(?v)jZ0CZ5-LN=u4%uCi(7c($Q^{MPIRDhavDt>O=dI2E!6hRt7zBL#JK!U{hK{3?4;Z^ zO}CO>O>6WNi<-tNd^l$jpml2Lk^1v7M~;kyV%xf50nNvjXBZCi!mp?4i=JDloXN-( z|3VXfKuRXH%yJGjKWTxJ`(UUvrtg-2{Djn;6NOw95KTR5vR()sMVnWMlLbaXzmm1M zOptk+s0kW-(FHtP3h%?ud4RzP#P+GY(>VD}Pbkv9bMpzzMx!}j@Lr+HL_Lk8!-^w|re8w56^WmJV7ErByOLe$#<~@3Zi>=@+YRIS7}+_sXzY}~%}lt5+BU8o zTAGn;q#Q#oSQx-+LRZdWs0$y44rHVP?SMjOA%n`=wCjvfy4g9Cw9Qvb?979DuYo0o z3i5-U=aT4U<_|^_c|NIkM?&5Kpd+;lmISrVB(E(&>x*`}jtJAKs}P1G;7DpU@!Y}y zm3kXVfnbk{@5JM1tG3Dsx#dqkB?I1n+IVB^A8aj)I*nv_iwJ=pzR|^hKeD#>)fIl4*#$^bi9C;)L!1Vv z{h+Bu5Rnm*=-EZ9v2{H@2_@bK(-8}u7cM+^rDs?RPlU|<&K56(rwr-;1qN?mR3(KE=%)f0%m_dn@2`T`lq^kkl-qCoL2J(~=_`b*3B=nC2 z_-7UA9ISN4k-C8|)SXWzbq*zGQ1&}Qe(B%qhluzK2H;UonqYCSByT{J4_>>&c2$EcF7ul(kpMS^8~$TTbx8>pe{}vnv$Y8H zISdq8i!u36ONB@8=|LqU`74YIiun&ML*HE4w^Ib;XlJ0N!daeIbf-p-7r1-vDQXhG zop~*O=a(_zCD#D(Ok6>sk`#*x{&2HTDDt%rx3JUZ!Se)fnvr<_g~l}V$NbMPpKbUd zH(fn?`>Qrhwi{u)LzS4MD~cBw=UCbuoH~`P@`cQ!XcI{nEG>mb?Os=Yr&WPaGN}zv z4x+ThW@h+Gb_hfo--5YxWS8+ZMBQbIx(jgUhICNplRdB!j=EJUT8-18Gx8U6f<~&n z;)iYksokIeY6b%ijKw1?mgFA7gz%YX5FB@c97CA#KX&arolxOYUIx{&Z93^9KsWLm zBHR6t$niKEz_s7(#L=w9d`>RG2Vsf}JQXoYnmH0wh!DNCMF|s_Zq;mIu-$F zb^lQ3$jV?~_I_VGHr&PIUi!0zSyd=E^0tdbE($*z{xQNaOvsLJs`^brmI9w8joc)|-&OfLiUE0=HxySV0`VJhulyc-Mp%Z<$7wJ}NGcP( zd0xyVpx3Hf`;VNBDlS*{Ghs*MFw$Sy{ZD`4*D+zYFMW}{a640bx4t}{x#8rYw>2xf z-JVcgCP}N9Ooa}21Mqq2c?pfxN%Mv!#K=d|H8)#ye2XLGN5@&$F%EpZOHp>7Y07LF zV3X-ELthPK?j<$k65OOaK5?V&*&V+m2>J7ICmMn!#%U4N<3XDfCNz%|^B9$JQ@gS+ zQ2d8MwZRj{EI8Qx-7Eo+L@sk_r#E$~*wl`J_F^H#xe*xT7pG-sZ&Z#R8Z!fppbR=b zC5vJZZRQTOx#t9trCLuEr4E~R_NoN;bL>oe`)r3RmigJ<|HenXo6XxwWz;nD2*60l z^jcC(t9MV!I!IhfDOw*sUazOnpz8Y_mSV=7$TaPVWY-wI0fs?`_F*IqV^zEv=7>iE ztjMn0hy56N6+nOFX^h5D(FZVz(>?qH82Y18wivy>DBt`b|K&r0kWkFEsl|ySdC+vZ zA98W|Qg(|8wxkr|1a+RM)Ip2;&4~uAV*=x;PHMG&X-ku^EbDR)?7E)yql?pGuqSM^ zgOsRfNald6AKgQ#zOsqA0UN`DnDKt|(T|+l0!@|E*5C0HC)SyPQwSJy#qc}%`NKW+ zT-5qh(pHk>k_~oI28nY5eGO$dK6)w9>(QSe~7nVQth!2iVL>J@uo!RglPsL({qoab-J0!cBgCX}gdc4CWEoP4S`N+~f3_}rCn zfYIuDFXnh5RWM1pR%`B1yWIY*Htsut5Pv$Yltj z4WqImA(U=irV*-?=!wR4hsRuA)xqj$pP;=XJI;4+-rX|0R)2!K+p0}LySmhOq|b;= zFXCU_#z-Jb^$vvnD^cFG3rfwcd;BKc82-nH^;}B@yn@z?sCX_{ZK-QgDWSV&(hp!#&A)-<#v6Qx%!6=;Q3(Vxkx_{Pt%$ZL=gCz~MhS8CZ_{Qh`sgf1To@zvURY z0*6I8zjklZc|M3ig>ZnZZ8Fi-Id|}zhgx{E z{jHR~{U(yLhETfOSi2WM6*IFEyjpyB)UlbdQ3c6ynBD7!Ff~QI{4!dAX^p>L6Zcp| zFV0X%dCXaDx~@fW2{3Fy8kh997vujZj!%x}?vY~tsBVO75;v_%>Lup+U%+@L_fk$Z z->C_eVEFWXBIMst)&4fC?Q8fI^5R9w7ZHgF(818|5XEI=C6@sANip2AuS>D9&57Rk z=A^y2Zmu0KatMVjqsAi+?ieuVKCATLxqF+GUwIlS@B6f?mn^v{pX`42q}r;xN4X~? z`5_vNnSO?gl59X8FVN0mjp~J(!_stj^X<4$m!i|wRX&2IZG=;=6Qf54s(q-}$A>?4M~KE?8o%RuPNt30gc{-p19$}g7Q>8EzZ*@!}J4ZNd# zcv*MH=qkXSz%KVL>bjZ^2$9=LCYM{h)6tcj2SEyVc|2dI2?A}*3)R|?Cz5ZQc!NlS+s1#VzHoxp6EqW&Qn*>9pf3&~ zF`$=NmT{ogq)X2N=x2yaAWxp|AjjGj1|5>?uF@x7ZoKB&Hr>GSc+H`j&+rWZ2jFCisUtRw;sc8I<3mo?4_foYDod5s@K3jynN$ zSH3T)3Hk5A9nA>7#-^B{i5E=AgKi5sA1u*0ct&~ccD|k+GmIV?tc22rCCsmo#9)V3 zKG?$rd>y5{R|F+~k_prNJ&MN}q!vVzH76$-FTNryWZO3^Gb1bJ7}pg~JmwgsTrYmd z@&@?Q)haLk2Y7QbJ_^y`H-Rt})H*x&NvOX=k(N7+<`9AXvanvbFYUMgQr+{vv^k!~` z{!&F1lp*Lyj!>X@5_e`sFV~kF-q{kYzofaTS01yL%5oK{=?0DrMQ`8DRM}IvtG&hn=nMx zKSdjihq7FGPmp79zKkcq*TgU145#&m+eiGI0)pv8;+1|!{U=+^-q%|3#-!GifJ2x{ z4)%-ZpFW1^-qp)_Bj4Uy_s7uuA(#8BTQZR;#8d}6V07_O`^pz<@4vzMsx*Gzx1Jov}`w{fn$a|)p3t+T0e zfl9pMJ-dV6Mx29Y(Z6XEsLvd)i|Gq+^cb%qBkr4Kc5b~5f}bk zTh+ME2i9V3VMiIhFxHH=fRK`_@rF{_&JTsiT88#h(1}d~>WJu%H;8@&jJh9&@qGd= z2;W+NYWIo9PMa5xkapa6umIjcF{QJOWZwG)@+ISwvDbiK7gtTV(f;|R;H#mp=!K)n z-YB6a?O|k|;{`NYTJ&q}Si9Mspm~8TIpj!2k9!fl>dUbuS%y#Wp{$4Pd3&T>JW>3a zDpeYWsu1A^Ct~oJ5mSMPl9XhRyu_Wgg9CgUeJWaJ?@7dC1x(|{`)Q}?js9DLH4n7w z5ZZo*J1_mtg?^pE&qU(%ltfjw!%4}_?`MWLhUw!vxi3og%zowWX5?YtU#B^A3X(u4 z=hv`(m}kb6Ed%|U4KDwKioIOVjZdf}3xsbz=?B6j%yvQ>iXx5TKo=%riP@&E5ta1@i*l!Ae-VBmPOURAJ9VykQ-2*ro;Sj!&7uK>^EOq(|h!~bP0a; z+xlJvH#p}JcxjP_58-xf97t)|xI5N|m=Pb*Zv17~<5u>9{Pg$wP(*u39?dsOn+JFA z*4CC)@ZR;F{c}u^ya!~~<<+)u`oH(+yehNmx38iu4yy9K@JLSn;~iN=H-yPkf>wS% zai1XS@J=<~zN)qU6)jdCo%U)vn>d1YOt9pO^eQ~;&r|da; z_StiU@e_0{!Uj(APS}AJ?D2PZ({z4|o^Rb=WT&GwkTp9y_Y@F=KbkH=J&ps^sSqED zi(J07K0$a=EMEmvNT|66-j1eiUxK0?I>m{F6-*gWi(J}mrqQ&cjjuWGnqLP9@UR+M zg;X$a@p6e|;5EG?NlFAItZve2lP_jqE@Uf)f#&o%iax@gI=*^G#eboumf=PkRqsQJPRb@^@IaU*7r zXUk`G*>GPy_8)FL1*%n)ozl;HRNOy(9iiBaHgsc*C;~n@T|#qYK-8VJYFmfTtXit6 zmQ3+gYP12jW=e+tQV}fEC|?!nsN2;l?-Vw1v|ofLqKk$(4n3YCxFIdK(}x$36h@?R zYkQ-EIAZ-GhbO-+qvmv)^8JtsZ3T9AGKS)Ra2WZb!dGApGt`COMhf1A?JXS2W#a7M z0afOQ-M#kmQ2;NwdYpw>dfEn~+dKW*=e`@n3uzEis?2=bqSCu@#m)`%@_Y(=)Zo5K z1)U5w_xE?Rr|+gLXKVU)wvIM-@WM_Ydod-#A*bwgQ8+PguyP9k3+`hMq>eJOIyeH# zSn9rmz=W`32ajI5;`NjosVxMhR9u__&%wcLJ^$VyU65yDRg$Xw!2$4V#}V82B_YmPI>0B~=V?f{#g;lz{?GXx?QLn! z^S{r(#sjDG(W)yf<=2<2Ph6@)`mp3g@fII*$BOmygvktNDZxoV6v??AF+cdo2(eq5 zwMVcvLP9|c9R8HC9nBx`R|<=@XY=M=3$9=+4Zo&~HHlB&0uvPtAMB6!6m`$`$*Iyf zh{)jCa$yD|ql(LXLz7Mrbc#ul}X?k1>ohdU` z-B3pTVK8s)RDLTA53W4@tb$#K=oJ%(B=!;I#k0P?Y&yp{#`|{PWnv_4)R{7imMRM# z@-jIC<5^exnBIpGD`rT^$C7*NXrjTa$cTF#cr^mUbivt$}HU zE}u^dEPQhf`|sc!MApLmH*!B#;@^HO!Pz^|XF2pUd-eN~cr=cUuKZ&FvV#CPE-19j z5K%9qm#sE!xMPbRa-9pHmx8SZpiWLy0tzoj6Mp@I2S|qf^j<5JO03;*TW|I3=yf=# zp7=5TgLt8_3upXS^PF(H{p$RKf%MbZN5V?v9rwOEz)^KbH{?;4z}~-%j9pF-qFj_tH<++5W~(pq>x#61Z5pO_{e@b%}|fYyRq&tB;ipTK_IT zz|wc4O8-l|*{160jTd1$TH@~T6|R{wg8|t*4*xW?OlcIigXnx6O-b{s%t6lR-DuPZ zOBe_%P7WGh(*D~Zn;TqV76g6uwkbnU5b=@kyFo3v$A^`tNN*pSVa^D-AB!3Wp)bmU zpH4V$b_?e!v39Hvpom84OfAQ#i8N;#HEbP#=a#HM&9#q_OnFPu{^(G7zI6l0c}vd}nKWwu>`X;5L{mX{?e0!31bv{2K|Po{a(#BOZm% zNblQiC@AU@k)sY_l0Ig0tXulZKURw>fG)2gh;PuJWc+%e)Q{eGP=RFJWAId-0D>W8 z;y)`BW^Q@oQYe?JT(FDq zv#D|t)oqE0zmB^tN>aKUDgN2fxPmr{lZ$2kqWV|>=~#Xyz7rDOGF1PcA&@o z(bR+7N1}l^DRY7oHW8{PxLZ^pX;9{R-DJWY3ryjE{005@f)=C%L}3KJ1`NKNoU*`i zyQOJ59%JPh-Lky=J%r#zBIK2FxAl9s3!=J8_}>P)DmB2 zTAI8t@Yv1`Vga``C7QHI9&{+`76VnNw&=xMr4b#6k9j~xb_F%(;DnP)3K3mo%JVebf1{^MN;#TdycJDR#g zHKoB@XqY23V*CG4_LfmmMqSvjN{Ey+(k%_rk|W(9-Hejb(#SDfmVpVIZ!@us)IQb z3a=iaw7j1|6MG*BFMv)y4ixB^`f4TA53(9hXC0UL4J3JA?`e7tL~F6?xEpX}g=jIW zJ)%BVY0TlIgR2KIr+{0E_md5E#2Uo*jd;xmaiMSbM zklKfDl}s6qi0c}8aN%f`3+>^Lz4h*o{m~h}&-whqZ;-=T%&p9eNY@q>_?BMO$&Ssp zhx_D|;otyJw89bI%DO)y3kG^6?&as5Kj*rxBkS7VZ9IVz>ed_OOxB?$1WCqnj2q9J z+QD4TDO(Jnv~MP&7Ul+zCf}lM-RTV5QsKjmyJ()(r>;1Gn3UgL#|5ntlvGIs9Cu>^ zN%`&?B`d~0jZcfR=GN<6db#o~$rxhcbgq-Wo-cW(hULH^<}c8*!|edg>5^L$>deY~ zoa3c-4Irh^Tf_QU`}#%M6B3mm$#K3xafskCjuP2?N>1x|j0=I-sW!{|5@vdhgS5bE z))Q!00$J@>dK6g6Zcg=`dJGtfu_{LY<_m6ohPZjU7zT1ID9K)6Vw_8T7>lhn>(HMW zgvt7L-XnosmS1Fnw(;=N<)Y-2dTKN`YHgVp=-s>HZ_FsoX&Za`Mik?zjV_rK!ae~! zXE`X%#bxAT@8}b)k*)sV%J-VoGCi+-Y{H(#)wG~HBzH$L7ZN-&AuMomEEpOmheA;W9dVty={&8lR3isWZ znwu5UjCe(%1)e-7NU#lMCqc*kK;*~YEh_iM?I^7-Hvpk`rmN4Om||ZpPJCaxUuubG z@w>v!HA0%^8I@e|dngFT6crw0oH8KR2h`H*Uf|o}`$-ycG*lwIc15Lx%4P|SFTNr^ z1ZWl6x(6oZi8WsKzB|cY<7q!?O`$|t^zIyIyK@UoHrdmq$Q%IK1Cm(pdyOk421Jr$D6DOknq&|U&DcWqv%N$Hp@Jrf@Bj?3sYl{ zkJlxp-hO`JAU2sllN)B)tAjs|p{!;4Q+q(mYpLf{S@J;9=&T1KCSrAMHeXm>OA04E z9eJnqZuGpU$helC*JDM>pvCV9I0e`2$5O_D;P2##@IOtf{ZO``!+x!>gm@0;IqEeo zPSozDvFTJDb#Dn?{~(Gi zlO3_VHuGDbFhy)$>b0sU&S#N+HDFODjcMJ>!D_O#R93|4GU)I?>3qvEYjUe}VT2D0 z4MFT(8;Lf-&T>{4)u*FeYPz}fYM&hD)mxtRpv{Y+JvIweu+nLNL)Crh>>j3RhRH-o3y)%(eB2( zX?6Uj4cTM$#2b|D-%!0;Kc1a(eUHi{gr=-IhxR&jUj8H%GxYAb0tvOjfCtdc(o4|& z5m4Z}((~-WK1m6LJcwWHp7{!QW~MXXbcZ-yFdl)egQ!J+nmyOs+xQ7ED4@DYRqZ$P zF@yRL4EecpHDlRv?-6{vqp=Ly%mESzXprQG<4q~v*u-!sG=FkHyQ+wK{#mIu>DuV2 zOlfvn1kn^O#YP{Z2Ia(tEZ(xe7yx&%uzo}!pnG+nZVI6dN`nhQ8K4!r0BQ|i zp{EFA5$E&7y$1Pay8UQ3PjVAHx_BI`y2(wW=ydIvinoJljb)U>x~{*1zj3pFj!(`z zcatH;lO~U57dlsVKH@2MBZCdXPw`b4;H1z!^B*|8U%;cnwpytMuWV-u5sC;3I6mB+ z>RcUE8kSA7ft{MhOtCJLn}kV6D;M#Ily`jsD^lT0{d`MYu<`3)h1UeOJcvI-LyCqv z=Y|zS+|jwUyU21#1Qr|>G>s@kaJt~ZC&RQ?gFwp@&}r`QJ8Dw(>wcfDcCt6ysz1Gl z?UE;P`iU~-eg)NuAgZjAav>jzA^Usg0!N8aozwfxPm)M)VLzDexP5JO`S=)&B4W)! zXW$sVZW=KrNCuo4<^++4=$(*S^{p@b$syjD8XEQMEnpjLERX!4CwuOv{hcXeiJNGv zi`=H5yMxxIhULe*pb4s>*VsUUL7|N0cgm4|cC>$2T!h#C?PSxumqU9ADyT4gtr`@4 zSRDVKznF9H0tiHoRJ{LzW)dwl7x%{GP4P2bmAHzNO=3aV{Ok|k6Fkw=M$W5Lml*rt z^YI}uPIh8%iVUVGItA&UX0m%4@cdC_xi0+_nG z>y-Qb3=JVK8be5B4*4B2u%e5w8NyZ|wu<0l;uq`oG0IEYB6e(AuH$BF*@Xxz;*O46yQ zXHET72&R6Aoc48EeUJq5LG94`y#M>xcG-9Z&CD*enCs&qR@TDw0doj>pVlo?oCiL3 z!ilNcU{H69ia_gx_Erj4B^T?zRe!1di1)SOqv*4bA)I3KsGvab9%u?7nEiep1Gxun zYPZ(GE${j{%tF3@%5B6AgEE9qx_|SRW=*Q5bFyq1u@`4XQw-ES?UOipyBwj(R;l2V zL_Q*{S1}X|HwSs8Wzr#+{xQLqzfTPTAuT--dQsTPC~|I&k5XEnGEhN>rDiwifRaKj z$ggi&&_TaVuN&|q?g^Ii=SZd5ob%-stH5fJ0*-wlNpnL{$Be(vJp-@Be(dU{>R!DB za4Nay-MfQUq%`&drx78b)W~k+hy$EAdd}A==XPP6$f81Pd5X(@UIWc92h;dWRR%D>A(Lo(YZ-3Kq>45bv1kVdVhh-FB%=64Z+jdB6 zQGaiBO8Q9wVLpXx`XtVO(wWAJ&*e$6U}{ss-vFYFGBNiYK_m%?&PXwr9_lYYT5_>k z@-a|nPw`o6nTqI3>D@e$?I}B%o5vEO=~mm|JKpZ)LKGmtT2{&h1C zabmk9BAl0;%&rC^x09pnx#ArG)KaY(Z4zzQW!4x>dYhQZ56el(qm1++LhvtR4G`gRT58Ip3b{zP7xR zZjpR4ORHH{a#6)ND!f5CN4aQ!bcsV-kfM@8{6@Z`zb@{iByAU*z4|H!Y245CG5!X< z(s4AR48DI3o;TLQ>q2fbhkp0xmzefQ4m+Yna8O*X<&QzvVugITbn5)u`p?17+6crb zRM`0l*i$N$e#-9|yyMSwG;j>EqW^~l$O|8FcGJAKIGv-4Iqd$Q1Ag))<1_MPihO&Q zDOmgQuNRI7%FJpUGpTZeS;G;=J7SCWHj_peojdEc`IRjNdq zkB7Tz*m9dEes$)4Ccr-P8+}T`iJ3DhAlHAt?uC8Er@trD6%dX<`|D-Pt1YtNq+@t+ zNp5_2FbR3Z_wL&gX=4mggISZE_=Achv}oC4yE~b2stIa z7aeYpN-Xt3TFD@M14JuzD*r(w1ok+o8+bz-BvXuVjt$pQ>9GD6BhE3z3P_-va%(x+ zR`^ai*$Qr!VpS+;OE>6f&<1_=nyW_Tb3?#}*@agwoX^lwTdVxANy%9!g)z)vt01u0 z)d}gJawt(&!w`y3_XEEGx`DB|#RwicV!=WL8V%OVUO+nil1+o;cC zN~?hN8Y7L7^M??4$6EcZ$BO7a61iM&jNt#ALYwd3sHAag-NDGl2h5%PXcc!5OlBaW zWotCdZ6{Lz=;yXtwEQ50h)nlY9h9m$OI2wdj)ndJRikY;kw3Gfd1r~tWhK2gb&hROQE0_eoufI7Q`p5zpWMN zvlahiYRXV^D@CG^$8OkA3XHU%YWzkd6nL8Whypuf?aSllnES|CEt z^Fn^>LFTTy0fYFLQZTa-*E)NtBkK3V1)@lyxv*`0!Me|18c`mQ_DK58%l$-KRFHJX zuqKGTCQW&(AV+bqXuWuC7bGcE3x?2S*G{bdH(WpXN=20Z%!bafTjYm`s+*9@+l$< z(|=IEROtcLT&3-SdI3FP5kX9DCt7%`+r}0vFotG?776I3Yf5DCy67mxJ7-G0x7#9C zU*-&7`tToe%sk-v?#d=4oOhVwATI25VW44B4xZK4+AduD>zohFZE$!40X^Z*7y`jX zpDzIq|FVUJ1Ztd!%g~5Np1ZUI_SyD+<`%|Oc?4YHuP;z2(mw767db0BEe%O=ErOrtrv3EXJ6nF7OD}vbhWN zm_FpV4t@SZ@UL?^3B$VJ8X7Wq69-rKNxe(G1Y1&QDp3e$y765#?|~+}3S&>7+n|U| zYSz#%Q#K(g@luMHZbJs~W9$U9Kt(@ulvuWl#)`*=pV@X`11oSh)czBD!2-LShuolGAGE0s|J#|3Xl^Opq-} zie7I#RvWpayV6jKltA~e0`6mB*+-&VmdW$)ot89Xg)=_Obqw?0hks7az~fcvS**qN z)!iz<7Dws`NLyRQwtXOVmw?SRVk-NCwmqJ^_`i|)U|=mrnOQA!mR69_;8@%m*>Xu3 z!0k+cko5r0-)vu8*5--tkCW_pu6@*CB zz1F6Zfy_mZ0+6Wc>z>tPJSTPkdBQsgals*1Nm7aWp>d#_jurp+l&hwU>5XJfxLlk$ zks(#H(e~ePGfJ6%uZ=`%=JgY7kOQugo~6Rrf159p>jUogxMzYM+-)FVSp7q~>|;2S zf7lSm@{LzOL2FU}DyfsGyf{G%p+j`(qK3BVZ@*7r)sa$dLi25`yo|BtLV3J@PsZ@b z>9fqi=R^LYRICM@9@IxSybBA1>EQiW|6?(KX{i6XdTg$cj|mkRmv$^_Q+EfT@hJ}L zC(Dz9te}=(wCIeIg(j%ITkR>+XZmuo`tw9dr4Gv1kKGYhv9L;ATU`&`@U|-j9yM`e+uAKlA8{+x#EBSy+knr`*T{GB8?;gAWC%q+Pi_+&g#$ayvwY~z`jKy}3 zDxA`9zGhYwne7fZwYFtAAMCVz3XO$Z3liMdPmh`i!}av7`cXkutk6n4(p9p`Uwo%e zB4$Ns&!ZXLXCCFqjlj0m<%UvZRNrlJI7mBfkJs5*^9P)?B-OIaV3%IFjLq1-M674K{P+Cw70D$*UahX8` z6t_omG6?w(ASa(2r=)N*Q-`!g1j&8D67eN?D5Y};Lijg8>wQD2RS({JKTu_2FKqYI z{#wG@qVsDa5*SS$%zts*&rI*W8J1+w+=xve zO(WFwt4@z8!7~xLi#S*lNBJ9z8ke!AN?8B#@a!@#9(Q+@={Q$KXwQEEl^r+s0IJjA z)p8T}^Cmo>22j#N$aI)nip)mH`pr{PVlVe)9VXfIwt`_24V~UOylslV`qP(REDlw# zaw)~SI^&4q7A5IG|4?e1v3}ZNR;mBqKsskZEUlzzivLti^tp zH054_#I6=BD%8Yw5zOrd{?8%2P=B%#;osZ)7r%xnh-W=Y4|DX(D@{iik=U}f#1T6t zIO4B77M$I^N`8e(t3p3W~_hNxpgF@8_WG z$f@hFlgzg{J3{^#{0n7Jp1=e*7EJn#d)MClk8MS=a2fOX_TsF(d6X2=z5ZY5pxP^V zND8Sl&5e!$QjWi05KVH>k9!4ql6TA^2mCZg#wQ5!9+px1o|oPw6%oHUaCsm(JDJ7o zk=B9#CG*ce>3=jx{o#B%w;ZZFi@N;7SY9_#_d$pl=DIs^AoT2hH!RTu5X4D%!i@~s z{D@2`WAZ%o`&WB0UslW@Q2zW3gZHm=Fg1gve?3R-|3FV9Rs>zeDF`O5#mK;V%!Z?Q)K8`zv8w394J4?I!)7q zO;Cd#r_}Qfn*#Rb4cj1Z6LKgc`B#lc>vd0dOLr_eC~gDN!;wnIsKCcKNX}0>WPDUb zXu)jnfRiB)@(e`=a*e?Y{9PyEc0?I!Ujx4WkKVkPe>)vaA*mN={l&&o&TQR9C;WB- zMk4b0jx7{Bd1$UT;%ZqtLd}m7rmnIaLU7Nn7l9zt!xR^LgNGEe_7!KJyUe2pHDqX zF^$%$sG%%8P@>)Tt`48)zT6R=S#6QAt{iclRCe6ha+|6L{;K8eM= z$8H_z&=J(EguTrMv@Mxd9ySTi7;)>@Qe_<~IEtl(KBG$RO*ty}Ps2at0qs{sRHG+~ zZyF<@t=a$4IkX@{A`oTywExJ5q^1+|h16BZZl`;Aq&;ev#P5JE{*85Qa@davj(JG0 z@SxiIHabn%!3~`|n5L6b9c&AsOUSp2()G%dnTdq{^*1Q^fdDD3K?}EUI7kK_$N4}p z@!mLEsuu=>bWRL@#tZoWi0%T2kJ9V$iO1~@(@rh98A%^qOuIzCJ0;5>wu6O5>SX4W z-nW;0N=mLxG`zxFDWWhuBxw;oii#?TE2UhSm{85RB##D!)TznXJk+fs4ARVyECpua}cO`*9aGt4U_!^B6??PluMfXt7kk2KzXgG`$f*xZ&$Lbl5AT#=h z9RKl#HFY8M2kCXEOnH;#==G&k?9DDbcMs-8N1x z^cfMC4$-(TcY1gYpA_^thUVoAH52?#k<($0Lz-zdBry5(IqPFwrfj0WvK*KZ^RowY zSAu-p`8jI!DDgqj*dJQ9qAt>+l%%c_@3MscCGwHHsD;98LiR;V+Y}O|>}P&ki<=M6 z&9SP^EX!nr&w+HFsQsUJXJey-9>{G!pxtcVtZQ>tnT|L|Kz^E9J;9FY>pTw|97x|5dultHJ)eqq6oiP4}*CzIkv2klaLN!8Oc z)siUWXhBChpGffaEmoVeS7egRf7uWJ{|EaKdi_9ou(k|6x*q*eD9xMDmo*>LGM!e@ zOSCJc+%5yQM+dO4#|H$xqdrKM(4CGkqVEt8{;}&l9ObuHvo||zH%v|}OeK%tO|i1J z)SXiOD}9l{%z~nE+qYRVUcH3aX{#bqknF&mP*BCMpvFQ37x7vOu0hA8+IkT!`D`X( z{?meQBY=k3=||`1EDOE#{dCsG$u-lj{KxqgucQV5df86&;4j%oXVM2x_ts}{ z5MVG!qOa^n6h^GYf};1E2>!#|8K4L0J2~n7+cPy=fyVV)6i?!Iw$v)%H(-y`!w-@YDP<9Za0AU3!xKUuxn?U3vWMPE7#4w;RG#19Wu$puXDnRUl z?H(D0!4$FdauJo!iLdC|ioL*nHUy)bHfd2lzIyEHIrH)ZigQ2CwHHTxl$R^9ilEW- zgDedqj?Kd^o8mLHHl~JuSb*UUA(fb}UN&3J%vjGN{SN5wXjJL0^|)vdy^NS3E{8?dw25-GbAch>#{yH+`8_wsvi1@j=zXm)!v8n?XB{1`k=08HjOQ61g zD@ZNyc7IJIlVGv21XTpcXb`28HC zu_#(@+a{N@>f0aw3?I;I+VJ@D6Ak|(&E_rQUvZV4t6Czb7Yp<-BJPf1{O#(`WUrw+!ERh!z7OE9B zyI#q$!&Ozmg%KBV-qq3N3QRq$ z=xDA=@4>+$0-J^RLKyA_t&qHYhJaSZm`HimVZnbpXpcqWerkyU74FsW3mvyuDCacd zWK%r>F@W9dE9L&dxWO>2HB*xZmX?EVOnqUNg-pfGFSZNG&n!*$|js5tZFExxnG z+_aV9hiXq-wrcbx>MU&?k4enn$*O*Cz05Y;Fg^J&A!>t?FgR=82u-i?HG9sA_Im-- zg%H@8q3|y0f~TKYQtHT#53U>RFKIumL;Ifky`l(NPB4jxuo9v@EiP)9=)fs%F$;j9 zqi>Pu+G6$IZSGX(buTq1}t1l3mrD(E^E{BoC9&^P_WSo=C>5A-okA{=)J zjb)W&m{hizm7QkZjuHpm6r?m6J*)8Af~pEf^ail;a}Sm73cizXs*|Gc%>+&=5F`D< zxJCE&KB;HHY}pE6nUY8CE%K2iilXvPU{PiJMx%z@`EB}GrNu6GC8_|yEsJDZIDACV z4CJM5BWacAe~&{kbrh!7u>rSUk9W#(V%GYgwfn9oI+l+m&()GK>%v{ch>kL-}RX8^bNY_=gaTk%~U{&*1-wfd`L3cBoW6#>@B`1_*+TZxs$?I)2h)TosEs<=Z*RV6LVW;f!_+B-lyOf6&H$ke{D{y@3eu?O`CAm<8Oz%%FBeD+-^#Jublv}A!L~`|GehSTcuQFN zws=!B$!*#&&eaW~>`Mhg7AOo-|0?)Bj7&UvpMmQlq;l8BXZnDD(|9#%+?QetI};p@ zCC&B@!&wJjo$6}tJiqd&91Pvt0jS=x&JO!s5pETqJa#!CgOPbqAUW;k0`NVN$^9^M zN6J-laZ*s&_SjOK5)WY?R}SIYw}z^o0_3O-`|Yu0hw7YRqT<IM?9&&xJfU4yS zkBFFTP3hDzH7hk>ktsW)H5#v6$xFl<`b&;HY)0D+pw?b$ag86k?>Vx-#;-RolYXA~ z+y-cEVPYvbD<0#hsXnyS248%hcr&#zE+agTGJ^SI8VP*{`wx!Wq>Dqj7*Ds- zpb7z9^9K_*60}_k`#Ezx@~3ZN8)1n>NzHwC?C_zhy?^8r^K)X>=sH3Z_CTCZ7xbmG zSgu z1-d(|IqSKg-*g}{Da@=%y>iE48>->1ym(h!89IR$`l3C#vl6z1IJknhPj4n4Pa@C| zUl5Qx59K@X+Nv5vC^|Qi*;i(Xq!48=|8xmOQZKtX>x0l#6*g$K)F>;4Rgb}PxFTYJ z%Z1XMs|PpPSqkq=!nTv%tdm}IEbPt>vCxcD?Y{{uo`@UTA@{;KMY~H`7C{6otT?s? zaJ@W_-GD!^c#362z=<9}1bWPkh=1qm-@>9f=3!#tZ}J+``)MHUeo*JH?5}lkS4U@0 zb4AFZoCuUP4#S!z8syqOe5o7kA#LsY5lSoxsH83kxLnGWep~XsIZ=Evi6ipu#YN>0 zHo-qrTSNxj1g3!b@Hb)fGv-@5-~Rg!Qh8|4BQ(lwsMtwJAQUj~0kU z$Ej@A8I`IPQ~Bf8HaZ`XR(*fB9=&?;N!qYHWL9)2l%>gPF#mWrb3V7LMDmHKeQCq9 zmqTn>+P+7>Ojg_zyMEY`)i)3#laB_$ss*|Q8hvnkDv#8RaYU!fv3f`>q8H)r^{0$k zEN~2~@E{2Mn%bmbPu!FWrZ1nrx6r8#F_QY)C=Ta&`S6HCb@&;Exk#P$hHGVUTpPhO|L5xB!UtoOtw%jyPNd5$9#_DvSe-&^U0ccLqcB)j2V?;GWP z;T6rCgSq4>q)hjQbeH+A8u(R-LNn}J;Xw!kt{F)4OVqa2DVTIDivqrfgeL1F(?Vp$46ru-_$;N()au&0_i%5d_Cr(-j*k$%qW7e4!QMI*)KQgu6?GM60Mm?VIIwY^>~0f|{3_dA*^rxv)%88g$nUGnK@ zDmSedsS&Fjm_B$`ko0weq=<*&%fPY!ikfW02vTt7mJWjnfLOr#mmo?ecryhYdZwk0 zO9Q(HSecDs6~xF}6Pakeay;EA4Hz|=x?$`Z#r!Rb0WbYl>*5J@$2TY6wvL?QIp8fP%I3JlnI3YW_rzx-5##R0kEFYnW!1=8@|fXw z)#NMxWFvoYv`F&j)QTuf$-;0xW^{i`@0t20j_OKmPyfYLN_YYS3Vxfx)zS{tSb2G? z@y}DJ{A;^nP(lcD#9K)WN21R8^XVJO`FYMOYS*a~m3J>PU|;Z-4?p zyQHCr69gO_f<-P41cGxHVLXvK&Jm=xilY|SU}8Q6epmnH}B*K1jh70tqMncX6|)yp$5K5 zwWjxYjpdKJE-bTA-!e1_((lm!iAv^k#o}vvRk^XiIT(sKKS6ALRGDTqHIsRU{Ci#@4J>Ol_Hhx<5iKjSyDUzD(djQQ2k4G=YP$}(aq_PaS` z!#amrP-e>ey_>mo!5*^m;9P1RvybE*8UkAzM_Gj5+3N+g((0v5c?UxSxNOg3Ai5z| z{!k^DK4*~vMw5n6FBULdnk{54y4I)BKmY`&ZdFl?ba)?133gY%>!+updljWnL7Jc4 z$>fR@K4FTAP*LuWRkQUNe6m*RYM{BJx%NeyIs9wAGPOH;f(u65kJgPbGI8*c4r21O zmUut+Mepye5IldjgYQl@8%<#CA6R*wF^ok zAmS_W^j7emVLr}Ww(P`J3RBK#v{YT^Y8V<-hPA7s#|+AX;H)0~$h>g6?Z z6qAk{Y&Uo);|D^7I?x6&E=o-~1`9>JGXC!MzJ=B-KrxT&XQ-M=8;##H?{%8Cy3X_| zE666s3(S!wl0$XYLJx2EhG^JhkK`xLrRPt(k@=-DR&ZBoXNvgXj$D(mcLfKExlGZJ^E2B_%z{{o)v66STPg+<9|tJl+fza0|K%U&jL9v`0wly^HKI z=CWm6*5ZoDyFo3;)Wcb2z0!}nD{o5z^GmSo7Pk?X(h$nH6SWlp1 zWB(L-!Hrw(-MdV`>r{sCmi<#_mI^g1LPV&!8r9;p|Dgh-C+Y3X`YW|x*%q&v)l`l? zSk)Tvl7>8jP3GCI{>%9GBgo-Y=pfq~snp`HouF$F^w()?J-A4Ck{g>e?T0LP)cJZo zPG~cRFXJZ=)cbJ|7Ye8%4=s0*3c-kb%MgteY`1Qn65IT%_{5C@r0{3aLwfgt-%tE|PY?su5vh^6zJjEtB$nl}JtkclQj{CB z&HXuNlJ7wfENY)i({rqx=3a2J;0BONJ^)Oy)E)wwL|7o2biNf{fe$~t|I&K@3Mn`e zCLWD}0|9d6q6Ba2#o;jwyXfu(!m=eja;%h&$)OYr_(q$)I+|>%a6dfyP4V=DTWyeVHr!0k4R_0or4u2Fjp0mlu zCqy(Q=*Fq_I$FI$oZ=VSkvl9d_HTN@+a6lI^mu6(VjlH)`ck8*p2p9@>)af?Q5{hQ z^qRcLC!FnZi^PGRcIln&eGPp}wpFfikEe4Bl62mN(BK5xUs81|-o z6oa{z=>wetK#Ojp1s{U5@@KFz^NCndXMS`%MY#86_eKN3H_C}7{sQHwABm*kS0o<+pOtR8*#Fo~E2p@f1pn+# z#=oz3>O*)8wv|GO#_u=T2(KA9ezGR8D-pnsmi?3vT(wf;3bIRXQ$iY#_3sR){a< zmjL6f*yi56MWgL$7uDa>mI@NxTSu8fBit{`c!#U2b;~}N@4J38QJ!*sidmF?DIbvY zhhU~Aw|W=+joROf8);LEXrLE#PeB+bqW9g;vDM+zv0fykQpR_FyI&zVaptj^6&#yr zi|aH2UU<-DZg`UVNi^th{1RLT`}Ac&)S=HeYJ?D&@ON76nt z4cH<*QVb3SE&{g4*w58&Y>0i+s3m$7M1(A@cH0G!#ThRW<7|GT7 ziOBpXe5Tmj%#JCux*w-)si{GnEtO5Z0KDo{hG5Lg@3U;k%H73$d(@u*6=VR<;KxHO z4kJJ1eh>&|jKEKW_{iV?auU?_CUjBvt~~t^S#KUDtTT^!rkA2e725f|I7J2-&x-Zk z-{vE@W8gy8@&T2Lx zfVh?27$+09R&(pm_AR8c?`g7sx13$x*4UPT(BY}{oC4L49-UUtaFS^eQXz(7{FY;P zfg!ZY^SFp~oPJ~~Q4sHUFFpJz=qC1Q>3m*A**Y9 z8AhfZCJLNXAmD3#Gv;k@2^D@gaZ9en!7U1=%)5?G>bH1KYFX`}ZuzVv6fG6Ptu;eKcf~X7W5vtyFM*SD z3B(Ie6z3G~(CeFD(TKdTX#bpTCl9)A6hA9z-7(&5;PceR71Mk?(0awDO5VXz7Y(YM z@*})e?Pjsms4P63ML0jV)A+FqEPvqRfdE2|LmJS-_q1BMUK>NHn*y_JBtz*p1Ds* z;OUGK+G?Hq5AVx-t@U329v7>KC&>5Nrs%eRlAJsx)nk&McQN{3N?4Qwj;DqT$6J__ zHs*TuRD=;muf;ygBEp?;evr2=Z}hPe4+knn30H&Yfgg>XIia?ioN}MHQXt7RH~cC8 z=cly40&an)B^To(gRB2?G-y`kqK`g!^6w1nj$O9u3>{fC_^*v-Qc=w+sDwyYOGF`N8fi{mxCzbPK#d*c9YGY?PxR8RR#-($* zY}j`NAIXGEH&jS_J)FX8hU&b#XK*zJ1HrI5p+77~#^?1h>)RQRQ!#J}})my?iL>b?Bi%46|Su5FBUCDCeuQ_67e&x>QSP z*F3&udZUlAA9)aGk+~jRq@WQ|98)9R-1MFeZ>AD5C)Ypdo_~G&?sB@c{T?Ez`6(hC zkq16XSsU*@_1xQfrdmHl`TgfXl*WQ!`{!$iw1fNwVYUc~KfL)$%mof-Ho=M?E;At) zOrxJWU%HH8b5)Sb0&X&q&d!KCJYYO+J$W&j$lm};Gt~g%VxE;^Pb7$nLQxwa1_IfpNnng?Fp_i7kNT2RdSphH(YG=+`?3f_$2@|$!_V{bFSxNw7C5-<(w}Cjp%@O;(cE52Q$N$p z8a?03`e1JCXKI_{+K`mU2u#4Nbw5kSyWO?;72$3^lUrC^@YkvLQZ)_c9J46*bk)a7 zh=^S|tJar7T-6(gIJl@~LsJQNFs;hb)r!Edwb%$D@RBK<5&?}PTQ^0@8@|g6gGKT! z4=VCN4Jlk*km!Cf64ZyV5}f)p;H7tJu7nRwOXL{@5nd*5XMa|c+SiV^mLS#tp+na~ zzFjtfhiBZkD5Lj-$WjAe&Z%_Nx5r%P%bY3G%oDz|yqktPX+_N6K0^YuH|KwCY1sO78$ttl zDnf}3QfcaDd{128B39%*aT~aMhvu)S&9j@5YNb)I1CKA=RK-+^eFDPq%{-Sl9Z!)n zAo)m4Dd{?{))dx!pDOaK(ugHSZRAlmO6ahU4F&1)pF1I}CJy31m<-@m#FX77@Oga` z+)?j3cs@t`&&zW_z=~k;hc_FC<|m|*%;;IHB+s1jg~8evd0Jx@***08@}I#ZVpUPv zB2u^8CCRnkpZb|%&=K;JE8$RNnJ*ZBw`4QO!~4}RY|yl!A;#mEBJw7d$*sJ=#9S?S zezh2W<8uxUM$$7_40?C*@44coBH`%Y4n>cd&{!*@B2H^m@W-vIjKPfMZgOL{WzEI< z7SwJXjOBPK)!rR)6XPnVRJI-Uep`*Q?fyhdyuux6P>(6|_Y0LqsL&Y*US;@87`h5$7xc-rPYOgZu*+-K$C2{6CiJ0&`$@iQ9pfRrQ;31n2KV)>-0i2%Q?<15y zMkTl->6$d%bYOtT5ke`io93r-oBrB^YL!RqRZvt_t;r*d+N{w3%PR4E$Asd}2C3Aj z3y(gD#yjM&+>ibFd@h~es>ACn`C;=5wd+f*J6BATPE#CQ=}%#^iX%ymeC4YvU5hw#^wL7aha4Jn${T^C(^QpJ?adR_fA0gX{zQ^$^pcL#K?og` zj{NlSDe=a6g#!txgr-GcRh(NVGsaML=qcL@l2cs2}p2{-|ngSOu;S3I~D*k-la#8n=>5#C1?W;*GfWHH0u zv5kC!i>XZscdQM%T{f8tAD%=LFr!jfq}ljwISY_b9At_LI~HQ;E5Z=rd+~9TOI>1T zRwT&eWwQWPhev z#r-ydp|P74Jg}jQMUzvQ^PoyGa)O^Zu*stxihAif)|SAEj3Yb4}DQTmEz& zx;$igl~L{+k>xwyb4&H7?MM~plM;#4y+oP!1PI6--uc1B)Oj~RQoCS}XmQPw`sj?| z9gyVogV{q@*=^ia>v14$||L-1A2c z3XIZ6$~i=Y*#SFd-f!PCV*Gf&$Drx1t!Q|_KiEIX)3%$B$I1MFtoyo;0LYsJ%S&+2 zz4$+`=js{?Q)EEdcqz|);TKp@*?bw1Jw`s*cXvMTmqYfwSfuvbDWS_|pn!Yok1GMc zqd+NMcme2UXVC~~NyUUf!aO)~viZS0q8Q(8Sqo8a!|n1sFX*nd)5{Z|*s;S{ z3BgZZiA-A!{XeX|^;?wd+xD$X1QaQyYa}HE1PKWlX=!Q65s)rvq((q;K%@m}l@<6+CyJV{$7Io1_Q))lM?FlZ0wiFr4i&+{)#m0JzSVZK}WK#(_;$jB`rJ?4kOnagAt~P0gD<_w{lgkKUF7i=svAlo zN_?44saA7rsSf;?1I-f2sDB7<93a#O0mAic2zJ5N+l_x)N<+D_D^&UGo1hZ$sl9UE z1Ju9YhA6c!!=KPUf8igv1%J)<5 z|KnlwDD4%F@1pDe)BM?+(7K?^?S7m%HVO0N#$Gdx`G#{C^o0lU@}M4Xd8B^&qQZha zYv7)bUfuyfWn%7l+!dU4+Aa4}8u%RwOc%iZyK+FWI?iyHtoOS(i7#v|!pltc?5Rzn zYrc8%?i$`kRJVyBi}p!2e@cSvuW3RzV8-r~8|Uc;E;3r_>14SnG0i-pMLj8zGPfO} z=HVc2*fH1C$u5KV;YQ(DtfF|X%1TfzhL(TKz}bdXYlLIEivrOZzd9&Y|=#KwNB|W#>54?H@@ZSP-Rc&9}v2CL0rH z2>&;gR$#oE44aixglDh)>YKU(Nsu^;R)EghYdwj-Gm_^K4z*;8T6^Dnn;o5sAa@7; zxX#-O!@@8aoUN%WSuTa3)xUsn#*Fj!=c95!B|YG0v9vU#ub{5Pp2Ueu;ssZDZp-Qt+tC-?%^c=(HAW04NZ zdYQ+7paU$d9rWMj6#T;2YXkPa=q>4GLxtUG=G-ABc7o|E!Y1;ff-C0tpu!gn!rI1U*`FFeZ7^;r7;}p~@u)jaQi)U~ z0IW5w^ZBw56bX8k>;lg|zO3!L3_ofw{6eYiiP4M_sSf&%V9Xv#sVt(mWzNQN-x259g zwoELf0v3L;=qxyXP#Gy@DHncgOdDU#LP&LOL+i%0#vnUfJ7C-{W2#9?G(S%=Zt*LJ zCLs84dpfJI*M7oUGE~A_(O~Q&#n|-6Txb&X3U#*z@Cj=?9mdWXYpl1JR+R95jM)bj`o8%-0ef#M__rf85^jnT)6vwD>d!m_5lC+LGEsBG+fL00fI}ITby?|?#{Qh)HYPJ`vS$E(HOmp$<*N1k{$5zz8ws{#+{&vF8 zPygEHCqoTSUW)dzw{x+O>^=-9$(!c;!61;U0+J3((+?lqKAdkXzn8yXL`JPq%?aD9 z-03f`pn#Q~dnIU0_wwI}M;B!^_5K(re_DM0a9j99RbsI!0=QiRggb;BmMY1w5+iE@nCm91p2bO z(>}uQlnet=2h_^=J5w6wg5Ob~0=)(;n(BV|^%dj{1eIHPzmSVRXpqpc)P$;a=`tPf zX=V!4dP8yvV$(Y;xldG4xah~|$ zUVaSYotQi5$1SbsrZ*WATd1PEX*4(YJla|27i}~tHVW13e%#GPI(K7upY6{pwN19HjBwXP8K?;F z@o(Ec;CUs?DQEb70fH30B>h&n!o4QNu^p8hfOq(2TDdd=%t|z3wvJ3# z&2Vj*x9~Xi!4uiH=@1k89VaqO8a==0hd7m6xrGh>=D)A~bV)$i3!E(%9J_EBmSWHj z((BFwUsRF;fRj#I--aj`@iQ<$6R$NUE4ZY))ENd|3+}`oPQS^^^X!9%MqmuvpFw6s z0L5Gzx3-v_^5Kf@GD`f9XEUj06ZHA-T3iIy(Y6w-9e3=IK#rU1ggcp|X%$C_x2>wb z4B-75@_8$|p|qYzE-bYAS^jra!_)h1B^iO^JR}unSht=mBq?Pjr4n@i0{H%bQ?E6( z$1>5tSSL4i)+pfMWmIZ^nfAECu~F2!^wM9Si)dfDT4wM{Z_ZLDd(i8`JQZk#+O(NU z5_>Kj0BBuKGc^OkzB{>u4E3|9PBe?g;97viF3;fOHwc;ZqmtWIB(e~sjc~K@ETE%& zNSsO5Ck~o9KpCBhZY}-ARwCEfil*yj*3W(52fh}L%Cz=_kltXdK5zoAWsGo&A8X9@ zcN_s)S$h7YevPK9ut5yA2LD5`G`U-wc%QR2agwBKv`eQ(@(-`pZ8G%fL^~))-3+Rf z@QRxJL|Df7G&{#_Qy#c;#c~adof>NmpV;bkr76T85ZqedVIPSl^`&S{cxAnDw@4se z#Xfs@h?Kgf*p*_+sdnT^Jc-9H-YWDe>A7z9^@W}icdy+Bs zjUCuI%0y*WSdya6J~E)q&Wo!3si=YNGgWrQZHr%76h?~GZ7+p#XB_crCeW1TX4 zGNlupst+_>S?h&n`n*mOiW^q@kicKccd;?53jjK%Vw%(G7Hrvyk=&@WX1I#IbnPY6 zT-!VHS?g-ji&j17h$bu@h}c^*Xf`n15wY#xRMPN;uYXR@&(kp$j>H@o!my52B84*$ z=)+!dC%_Zj?Q{&w{Kwl5lrGD z_79p7qw(3wMggCcs8f8n@IF2E&RkR^BaQ_!Aj1ko_SyY!`LOQXK;<8gK??++yws84`LeuU{gZnM z_ow?JuCCki4D;iY#+05R|4}TC;Fwj7u@e?VruXixRI6B0O5vcg#!=DJAWk#B78>R7 zTcfv(sJo}yJ`?>EyN6X@25fnO-aQOl23ga<&JQf!=6`4R#%Vi$cjp z2ibkD5iwmGZi7BDx1tK&RseaANohYmX4hOD9g)Cq{UdFSmtMZ5nSsq2yur!vShl<& z9$krcmnze+IL_c?=Hr>Q=AiDs;Knlnaf<_cul-^Z}?0qe1{-&fn?3SxW* z;%laJ*VxMT`!q;HN02s~`wsUL{l|`3$Qu{s=oZ#(P!fS(~$CnUz)==&k-q)o9|qpMjCLkQ9ie zQhl>=gnX{Q=6l+IC9nx^)*JI*( z2{r+v+X8V6xyETxpA+dc86MPDH-y8Aqr`6qf}b`%0bMG8HI1clw{j6Xu%)u6O19{8 zcKf=oFkARAx;&T#YDieibs=Tx!O}m|@@}!ekDc&qN_)*Xdew$_NJX{ThAw3fSYfXX zON>;|F9PIf=9==b2IEn{>-6$cerVZMY27#%(Vcnn|KL_H{{Q4wPhmvNd`!~L6OR|& za7Mt1Y2^~j{$ywH{|>HtEB@cW)rzdVYBfqTIt{q4TR4j}-TN|qIj9pUl=yApGCtja zdi{dlDsPgNdW}N;B42^7)6=Q^=CsH=;HqR`yDTSQF6IPI08;E7$-9C-v#-~Hj2qrB zB&qNFSb=8EcD9I`dAI&gZe=(IFun-ExPaX+f248RruU}^0abBZC5HpipHs>=QCd^Y zxS=mn*p^J8$N-)$%801miO<7Pr12)0>!d^8DH^EBB_1TsRLKQckmho~x?>oD{d(sb z)_y(ggA3l3N&4t(eHMq%z6*500v9vDwO=+tD5eOT@Hq&RPe5=&yG_@l`j(01TFcu- z7rL2a@4r43ZTM@Mp1$<+)tCcagndFTgO9-Ob(s5TF&Zpix@5L3mF2sP>15N+^O>kB zk`h~r<^s=8RxuLm|FWy!)tziYKI-U;IE9gEx#5(K5Y1D!5r0c>;_3#!|B$PRRi&nn z-a3J9DZKIMwtA(u+nzyXSoPl=n188N{ry+W;{Do2O&^D*K^O5%SG)*A(fA5>IULbB zAb;bW1AMEmK;P)mE3IGqfD^a75BfdN!2JtMVN}>|SP_Qjmlc0hpJ$ZNN1NZ&SDD^2 zOknDG45!65wNz0bX-Mtm^^Z0N!klEh{jb552T?9=^`9wRFYr(IQ1)>1A!^6K*hl}v zB?5BOsh7OuXWjnH{@VfDn@jI!&lyIzZ&Yr4e>Ub?e^V@ zLw{(sD$l_9nXL`;V8D8@cQjt%u+@e8yM4d;R6QyF+7Yo?73H|{2#2>?b?kCdMKrbM z3$KMey2dE#c`lQs>Z-2=u=3y^aZe6+b7M#}{Ea6bb7SYVdBtl&G~L6+T*}^XNU`US zF9jSDfF66z)BkVys@`@`1vm_QYkzPL48LVuQ%_N5?8Tn1f{x%R(Qkwd|Ktf7qyqgi zL@0|Or)UFvt#1IM@mNn8(S5Bm#43KtAS~w2^0DFzB1y&sLT7!NHtSb6t32&ohz|Z= zC>9q!MwkVGoX36mBds4!f^qKLr3MAZT$bte?o^s!w!Hj;UB6>FoR)P z2n&D+Kn9)CN7DibkxUjVcT&?-lQBw(QpWmdCEll$FPzlYpUCyC#_2g$u#@=9gSZXP z!y;$-)91z;oJLsmJv?yd&PTDG3L zQtVAD<8N8W&f4}pPbul=KQnw(k^^0F*>!fOPw5`ohJF-99Sc8nIj=<4)0_f06Zk|R z_YJ6(^3#4uh6u+6P@wEP)&^dFXLY=our=uYbCW9B=Cy{2gs?8jC!9`ZQa?y`7W?@Ar7W#M5?sc|%C0^sCne;S5LXFI~J(B>TQnZouQXn!1+j zX_-Fuk@CPTt&#&wIjPh3c$lAZquC-7gNj;4HFJuAkK-pMaC}RTW(K$K+17LV>`mOq ztswg8lRaB7XWF^EeABbzZG(zf%4xWBjGsQ31cFT-vGSW8%$qY#$EKy|DtiubAV%n#hMElfFf1nYrd#?unl*XvFw`(#d) zv()3}RfzCwfM@~6YXSqKr|kEig=1Fozh{gO7qGHBjev{%(4^0I+u^CLw6|(O==k!) zV&NdCsl?;{t;;Iy?S_E)>IbW=B_tOtnyv83<&!a zx7Kbi&wj>vW7<9}0BM;*q+tY+@k~ zkT^pmbS?QX%%;5>q;v1Gyw1S5w>(^CQrLV^VKiD%*A{psj{wWJ3Oa{X3w0$vmm<7TvwAHWxCm?t4oN9 z$UPAMltJTF5v*bd@m_D?2`Qzz7x7P6Q$UeIn}^Ts(~*8wkuGT7(PNg5q4>k+8}(NU zM6L(5hiUcFQBO!gmRyNrze){2LrC)1eT}%Q2`Kd4zTw;A4SXPj*6=3M=L6btX!V#4 z&xCbTwfdzE5ro2I+8ri|*Yr4<_H=qB1 zBW2_$1?Cf}Z})xmrZx)db=epPEUU_R_4|AbJsSg(9ZS8Ki=LgCCC*f{z-#6_U{+&S zn%f}rH8OTF%mqL6J<1D?bau%2{OKZno$tYKqa@?aj^B=6IOfg4yM5xAS!V{P_rC{q zl+`XHJ`oIgdR?gvV`4CaruSe&B2Bi-I1w2KIXp}}z*3RGEezw>qzv1qmJ?3>RO)oN z6LVexZ=(ohAc5M3x)t6wTFS(X*vm^1l4E4qNM><;*gqK**Bb>BRBd#NMsnBbE;~1i zyR}aKxVX;ruVKaVx1Ms;Srm`7l)`2y#;6#zH`k#b>ui<)ee2XujSbNPzh1~C%WSC( zy1ik9wvb02uP>zTn81>ySacKj8s! zjHv>S8gt9L8Y_BUUygl*?ISZibp8Yf6imMX*3PNY53iKp;B`>Q+wlZx8Rwqc<4sW7 z-8Rcf+t!S~Y+>8rqN1Fw8kf?O3mx3Rb_ALZdg|Edu_~@~x88SmApkeG_v=qiKPo=}xkLgz4dK7HbOFa?cG;VHC3lfE z1Z+E51HrXoFWk|Ry#X%6m1-i^KSMWsP#bjhe}F&wg)g~L ztXPBBrEKGur<&^r1VAeN7&jJK;q}{axBPa~>d$@8S(2-3qBQhBIqX>$)F>_HMew;-i15#!hYIy=s|ih=>;=RruRza zT^-E4Fc@wGW8zmp=yeSe_@N4jZV?T~#jgxId#9U+^3P%&h2to%?Ayq3@#Mn3Rm?s> zJ-1%07T+CYxby+!err1gtUL2-7EiZ4W8D&5)1Y?*aJdY&5fKoj*h{)eT-9r;h<*s(cvYm&5QN+IDp3(~)}z-d7T#nePvLLl3ZuV2hx(GJbGs zxDvti>{%anvo{~Z;{f&Dg1^uW&y$XRg)vynFlp>rd`v!{Cmrza(-Zm1lNS2_ch7CCX@Jk+d3~9yo}8am2iLgS!!@M zj?Ocil(%=Y6wQOuMq4~Wr^^_pO5f}(s96J^Z)p5Z z@NgzZB3ETh+N&UG(yc|;qAkGD7HBvpHR=0$fJ+<&BVi~vCVcRj5eowR&dU3+1NdOh z&+AF+nc!+jB`+s7QE^$4Ikk-zo|x07NPg~`jg>GEQ@}aq0Mw>}hxw*3Dmts;hrXY1 z1>uHa4n}YS&%S6rvs?QumUccv zKFWNcdn4F~7mSB$F>w=ro_NSrCrQ#LZ|jFBfM0H&-ZFu%LmV-(C6%-?c^Rl=oVoW1 z={&e)FFP!Z02E-;uva%H32uT2hH@T3aHuX0N!Hk$H-0!H>{E!hl{cy*EEL&_i(P4k zZs&(dK#<}OxE*fsnAYItamD_)a*vA)S&-4ht#69Jypcn6DIa>6bQyVX|l*lj)2=`Q+Ym_8X_vodRAxI`obLk5DJt_jlu7&3j!$^h+D&0zKGZxK*R+= zG37O7Ii&66X-LxaAUJ`k-}^eE*+!c#I_bWmFscjE>h??4G0PHeznor67(O3drI{$#DPENpBKEA#nnX(*CZW)#G* zcz!q+x>gU%vZ!yXO%C16gi0T+e=MHFz%BQZR+85G27Wbo+3gUG_?dYlItap$Qpebp zA>M9F*^iOb8FMFAwfa_uR>@b+={cJ-xEzcx71>q~e}oiZ2aAEqt?*LIjnhg~b4{!K zX!-K zbhCOn#_=Y$5sEG)cjrb8z2K_i{bjq9?D||;z1bhnoP#MjsXvUZ%;;z!0SxE)%tEzmo>ASkUV{4_w@1;IJv;KDoYoyv~ z=)-jiVNJ-PWEs@}2I1#-UEa^hk`j}0scz^gjP|Hj!1?{RRJ!>65wcxy%)-(c?ETM& zr$bBVp)Lr92Wr_+>)%0@cl?tYyreL?bU<^;w7N?4`N*LX_=2R*%7P(dvoT{IZoeyE52d~ad~+=A8Y^9b=bJ$i2$KO`02?&{grt@9F7<3iH>=*G`g(M1L!nGQ z`rDYNghl;b4p+6uC#U_2Ah+m*PuyFxV>kt(fkY2tjeu3rP%l6(3zHuO>3tb2tzY7k zU_skjqJCOSJ)MXC`FRL~9}=~ZIUGo|tx1G>VY*{TA(#RE_or!5)~9itXFT{O%zR6S z(HZ5blHhlS?9;<%F-V(uTo2YGcYO!X*;ow+iSuX4gm_C80w>cDU|*KUcLk(qq0Nil z+wZjbVRq|jH}Rmf`bOh?1b^Z2j5G32o5w5%y7=b3LOwuvyq=xuZt!0Mk2O%E&0aLT zV!(LJ?-}LqJ@^}j%;4qjVe`9tmBm#+;-7)1{LhWy@sO#yH?6LmMxtKdLkJE%6rcq! z*ZmU5+%>9E=y#W8qTyMYw7;zQ&!+STZE6PrhTL$mf4uXfA@kODAdvZ9maCMx@dyb%hmu`w-n{=makO$c(a|RL zSq>r;3t_`&WGOc=ZihJd_@cY8K>5fG283RD5#w#F{Iym&w}1mSE?4sFVfxNBi7vS# zLquDsHaBgi^3FyjI;-A=D^ld^HvmL4jq98-uI7kbycnyp@-#4+^3LzS6aajmy7w;Y z#k)83Jk;&<-`YRA2vA-|`*5lzFR9mNwv}fyaoN>xI=}L2Q64;sXWA?QIP_q>^7>im z)+P%;q1|!K0asLvCO0u|a2o56c+U%Msg^JpYat>)uc8bN*m0~MND`OE?H;zLT!k&Y zKPC-L&TMf*jZZ+I_+8P%Em4(TSkz&p{^Ck?k2e?>C1WgfiEYc&4j%+Nu_Ao3W3HT= ze*&uqs2wN4WG?Y@b=8&%NZ@71WIZKq+EbxY*cHPaGGA%B<i8A-nyc(+}4*X2kEww=zPJUX1y zsij;u2Na~T+C9COIH(7`mUpW41QqI&^&keNK#H|Y5HRHOvoOH$vuK0t! zGfj{EX0+Mw8x0S>k9sJDY0M8JIOQ2~248HgP(Fh224TaxzV2gGx|$cy9(3{SH{^y# zm%U?JJzl^e7P=zfhlbIvGNZL`y8cDy1X{yKq+!fXX`7SmtqeG&=qw5RbaHpKg*yUE zuja)-K#$l*2eK^lIRWJHVLgLhcpn~aIcM0}8VxwzXSFt1fTSlJFo)}a|EjDVnS+nj33bLZA^c0oz;r#BKS+8_Y{gXDM;5`EPlJuWp;+`xV&qJZ>BP=CSVG!iy)<}Sp_aFxOH4BdZNO-x4ed9e*KmW8v zTL9rTe-t?ua78G7Z57BwUrujrJRhpk#Mkr;%=V4|#0Jkk5dM=Jbc?|S$#UQvno|Jk z*ZrKS0^Cmjh+gCOpDlbuf3u=ISMuF5u4YUe(dgLTt4Y!rTx^UfH3cIkITr9%{$#;g zV=2+U$pPe-@$9xBecFQ3PZ)Rlum#J2a1cqrTur}qKBI*%kQ%LisN9`arw_3Akw-I| zko%T+m_@)K3X{1X8KOUEp)Y;aug`kwwN~I?ZO?=!iR#v?sx3_agGW{)4rkFRX_h|C ziB4|jYZM~8z(~u_HYl7OG#Y(wsg5pPLO8mjl73x+jst3xN8ivjkRHbr(6#>sCSh@3C}U7hm@5I(i!S*nzL6%qgpVwsj=0 z<)5Qp^q>23R<8m6@TAwIX<$LIS*KwyDdkZIOGuL>60ILP0sM%jfX+Pdn6F4vjk#5v zR8*Opb}pU1l?rz9`(*$uwv1+YaJ@87)Zpuq*ptgR zo3B>naRGt+laYXf(G0QULzr;Ku6_no4Qi82G8 zt0$#eR-Q4nBTMtxzm~O?2cFcWH8%fx1T5BtBR`=hL|orpr<6Cj&L|xd=3o9CB`USO z-5ApD{pmFIS+5wrgEfx`b%pEgQhPXbVFCox99iR!xWCO}J}fzDfB9;x5rCy18*J{j z)Eb>?Ew!wObKWFlCAd+1cAr)8RVvA0%!Rv%iIiI9tNBeUS4-0Eh{VCe#JdI`hvUx+ z#?*TSxwUP5eh3|xX4%W&=EcL$im=du>V_wzm%#x_38a)OcLC?2jPZW6v$ruTf**b| zdAKoxT{+xCBG|`3VZbIE0<8jGyp#rU+p!{+Ffq`)JcG$7`gy2J$vkcb7l?*NJ$lr= zF{UU9BkJ}uG1K00xZ@I7u(Q+@E)LfkxF=9^8x4?LIyhaFV;J;|^(BE+3W^-4wAc|* zzzy9?O*dek-PCBJ-HYp}o`J}7y|y@l76(o-U*zvBabh=<uW|90bYZ` z;&bMONXcSy%R;RM<&j)N%*+6h7Mc~XbacNI2k~rAJPwEkY|ES2dSHp^^WaCNP&c*e zO7Tkkv`k>Wz|+3$xOoS5T>MCvcEfFv?^S+&T(5e0F-K_D&tH1$5YXk)8$Bj+>*wdT zsXa>!0e=Ygk&=I+a+Z9G0g`Y|vzlXI%mkGI?lh&-!Kf^_rT_vAm;iKBt;W8+M8W}n zdU$B6Fghm$^G_nCgJGuD__1rPsHJdP!P?vCTYm$%-qhx4J>UJ65|U+8ti~WDiF@Sx z|6ozsZuIC|aFQVSRS&$%R=ADeKhwcS=r+0MDuB4iT%3W^s{=6OTxaMsq|GcHO5a>N z7UI7D6n}fmfIQ2qji?TY-li7_q9@l3FKH9M-r#~5nj8;i7vFU;xDMX}c@BG1==32k z3!jiWs^ z4y`&8-PM_a?gj&10ALLx5FT2cqk^+-)0|#WtR8RWhe~)WB^Vfo1JGrV2XYh{81u~B zYs3a`ftfD`J%6|WK68rBdaw$_=2R!3=8C>^xWopmQ~KNmWIY+*RQYO71s9d29U2%> zeQhG0mdc@V_g9)c$%4FlJs7$RBajQT|53)U>WYVwScKAw4AJ7eUoUqAsy-4y$Dh%A zNnqur)J>IT^-bNQR%aNxak^5M$%_?7z~Bj#E4@LVg+;z#T8q)^-NIM?_RmXqkx$&n zwx{{JU4qVZ;T}P4kAp}84Xv&(49W{glT*LA|2O;*YN7b&A&s0E5#>*h(cQZq@`1Ai>xQ zd^6d!(tUal6*Gaf9ugSWp=Xl^zId45Bj}Dp(S0+jWG`Yb8>Ukxf)6qDT7{+>N*kJ^xf?yyi$`l zQIuIUm?&{Gjaw+O)DE0WgxZ4_mU4P@*#83mrhS38Pg>^{tB{Dd5pSn8zid_?+20@%4 z`X&#mU@UDL+hw~^*b+J&Dm;H&q)!YPqn5=L!?Dw$ApcDXOq@*&B^JGzsp&tox=Kn( zDINC83~EZ}wpAxUt5W}CCNo`g0C-FN&b{dBzj@;Sn@NM)DRo#c@1t<#Op#|7ocou` zrHv-8CR?wr3$9oHR#ok9sW{JOIPQ*k5cnUwC+?qy>Y_rk9P-v!dzS9H*hY_twsDyp z8v6lxV$0s@Z$O@SpR8sOLH@LWY_%%K-^w*Gtz70>o|w4n(zvNg7! zcIY6D?d<$9nNp`>-?%5o9tMH zMIjK&CW9XAw}?N=-ybk`<4O{iW5!xjday_O)eS9l31yL`ri{|6;bR#NB)DJ&wN*-U>Kk&7XLZ+z=xgLi5VFg?s1&CPQx*nlbN{_ObqKP<|8$eP#h zCFaPi@s)a*{-WSxMaq_04q*J?l+DG@{!duh-UvsgLnV_>=prCJ{rEBI4*S@gll83n z!kgc{n>a*FDD*HMEQana$2CE}H*O?ZbSd4PB#Fntx1 zQ9n3!MkxS}ADQ1c8;cojz<5+IihW|if(rIOCrbue2H=EB@B&(6zKAq?igc7)!1K2* z1w{T$F+kt@1MF`is>Aeq|8O+@qjsUGSXuD1v!VksCIYU?qh=0cUW?n5tEiJM-E-xJeLxJAa!LNU?>Hbl+ zRN$gmH~)fgYI#fjPhcPn%^kt3l8#MvIT%uIB|=Tt#xM>amA3`WyQv(XqoxOSh!}YN z{Ihcqkxb4%s`bwte#Nhuu9J79E&~x+h?{tNozA=MW|L6@JFO(X=m0o zsqRHz<)W2k;x@Efo=1N&I@6~v}f^b_ZkSD`MDVh6k24oYia~0y>a4-*@fjN~cju@rhX@cA@<&RLW zZn*JKFnAtkzm0`B0@qyIo|;G<+q^_^vRtNCI1wHui14yERAC&GQve)|9}$q?3dP^2 zn#;}$oWavclm#3w&rkNK(7=RDFZ}I}P>=a$<^}u{5`oKsUOQj@HcA4*!hfDi`Lsz% zkPxLvoFM+}$Mm}r`T8{*k$Ks&FZZ;mWg;U-UI3mK`GnWGoAxZ5KbJc>FB><7hFJa= z^NXF_%OO;uD_+0rsZzkw9NW@A64LyV!dshZlT;H{5;Y;LGh$nNToxy1ir8;`<5)Bn zLVvkQCG!Mu6#S zv%@oK&yNGz@s919mz$$K-XNMy}tCYN7Jl`R-Sf01oaIkVa?vjUyO6sr<%xgYn2=~Vaj`eN zXqgqGWB+ga%rD6M z@ts>EQkRIsNg%kGvpVv8Do56c2FQ@ZGGHZhHBY!Pdj!ym4yy&K!_CR%h5?bKGl>Ddu@T} zSNuRoE5L~^u%Yr3LhkudV)Tb z!0sQmE+PH92A$vwbv$l`^xKS&3F$YmZqa9%LV&*nvjRsVLo)-A%>cO8uxC1TM&o|_ zB55?LcG?ck-I%UcwVyUWZDwP)tGLJNluW9oTvR!b#|kc^nPAHWh0B%kMs;h zFI>|J#&4um_iP7ywl=-M6S1rP)Fj5Je!tOUJMG}PM?n6t2Tc&vG9pw9+Z{Fuzj1Fc zZi8o?fZP_PsC1}gNmuw|^*HJ{tDLiS_2mP~SSJ?~g{HO9+b_=3+|*k6Mja1Oa~^{d z`&=e;{qWdYa{%Q|G(ED4c6$E-4^D?Zv|gN&h|wXNaJDuuG$gOd)bKf@J96O8Kx56` zPv&pc#|H$WSc3H5a*8{GzbwCLkMv3=ZYY5X(ZVZEmfyx>>(Ki3s=N}xSkyC<&yKAa%bw;vn-O8W5+~0$ zaMPilE_SqCI*SiLqH!#!@^yESwD)xy{%D}f2{Vy-0$Yj=={X;ropAMHG4z6MLNXVQ zhc*O#*I!`v=eLgCie-K+iW%4ro%3;jCDpT>8f?ETos(GzgwS<;sFls+P^m z^A1}o_C7QnUdznugK_3|yj2E`u&sjt+6{`+`z_S6b2`T<5()_#F< zJdFEpj;Kc#hgn=&QJT}B>!oeR&5F`eWb8XTEyDUhKU{?d@H~wlVaD>EqaMyHx+f5i zB?Lr#7I-8$h7<2H*B_&PS9tj%AL))$!ttl#Jm&_Vv3QtB+N&+}FM5t-Zoah@hljP<%1Gbuw z!$NXFp5GoOy3u}!s}9gZrkuF$z<0Bl8)d@iTxIKSQtr#9Z_ZTvcX07IE@&Y%0!$DF z4~~%wdqE5ns231f--umd;JT}uKL8?IvUpA5nO{(TV!{OIi#0zYsi;_{R;RvO`m-rt z=bP^{6V(g~DnLp-BA3X2rv@0S^t^6(8s)A@XkjwvowBTIR0kM$aQdHc*e^q*b2`a`bZLiG5h2CrOgq4 zRtks)vV53n29u9wRk`xT?(D?oxGAh?CWBvw53**+yWc(#`)!ObfXLMxHJlLklt1J| z2ExCtLo(cg(?Gj_rWDX~Kp&<5k?%7s8}J#vs^U$Wgu7hv9Od`n7K8azD-}m&*2!gV zAG!I@ESP28dfsG=TaW&AXQ+IPU%U>kFx^NqlH2~{+IS@6#~)8gzUo^0bkrzZ<(}5q z%s!$S&O+huTCWP0+@O5$jFyf}Z9>uHC9W~%braR4MPH`_6sH8vfcCXsqT_K#bMXRV z8wanpGqw40NHdg9{eiEmVf=B~v!PX+Z>9Hu-@1%Cw2S-*q44m|5Z|FS4|?Gn)JfNo z1%`e&xdI815J{st`UXjfMJK;-0As(Sdr;H1u~Q8gEl`DZx(cTFMy}fGhz^S97N*9G zw#$b&Bth4#_H7gy*m@)I6Yc&#%eT74w4tX+zCTWHmB;P?y7qk=*yanzVIYG+<1V@B zCNfIh862R;%tzX$2#R2$6bKpbA0!z|GGS*pdyW})feg<+INb@@wu_oQYer6NyX*6U3D5X|V-UGr z`G@q~JahX%Q_FJc3f?UKZ;k!!tvpYIRC>3xi_@!J z5$*N)3KA0IkLW0!USA1xro5C`blS;J{q2hu6z3HbLj#v}^RBVAnuL}Z9 zuh;)36>5!%z67cN4;7-`qZp8ZY89zqvEHr zH*fdtTj@5&GR9Vvv-i2E5_>GwA5faW%OWC~I5*P>Oz?eL7rXum?x{O%^w_YBo!U+Q zFc49>FR<&5?CyA@>CXXF1GGKJEi3bk3jqGB&h!`!%-kKQA;-f2wHgAG2b85H%VPRe z)FW)-<8t!r(&Y~*Z%Q<1-6&-|B6xhOf@6)}x}`$9vNEarx)xxiMC#!zJx~iUu7S-* zo6$JdK(%n(vuxO1dZ=YqJON`v&oZSktWd2To&CV+gn2+e&sV$eL0Ls$=}!91;2F1c z3#cB`H-jFt;h~U63ksJl=A-2cocY7t-96XM0C$S!#t#tkAlklp14sY&-$7U6!p{zF zHGPjSov)cE9NJyQ8u>;$NT^@_z!i}VqgOEr@I32KQWBC_tQZkd{ZGXlYM^STJNK@$ zL2T?N0uzNs*Q|1JQXd+i8eoemTB(ydsdd%43*P?b$w)LYs+=HuQ$QH7H5>Nimh364 zkm2G34mmIQ1*(T(AdAb)Y@fZm?b%vu7IMK{ZL1}2F} zMXz7EPtFB&T$5qX)V$V3sL$9d`^2|SjDN;p zqQKAX<8g_%z8Z`tcQfrI{14vVIxNcf+Z$C-P-&1B5K&QDx`z%W6{JDBOKF6mJ48z9 z?(UKfr5ov%p~C@TfZ^PO-`{@syU)Ahoaw!zXne-tQKn z$7?Vcw(oiOGqQRT$$YW?794nwGs^~JQJAWSA6XEm{@vUn`_W)whWbB2VK22 z&~vM@u^&rd&9dVlXBL&TmJvAv*4yj^8S?v<6Q1<)-~@oy8q|driqmbdiB8x;B_!O= zQ`7ink;ZxQ8#4v_80%Y?UXE%T_i%=**yvXuBznfdLn!jt1~(3K`b6|J8*~*?>-8{z z(?Z2TFo3RPY|#Yqnyk7~=+cG5#^Z+3qwbGN)S24FVtAR00*lb=BcF`~1QU7^K}FFI z5lrYQ^z8FfhEcf;zdC$qa{->@6ukB&Hh(~q!BCqXHvGpaX3icp^d|2xv+x8Z+;ZqN z9*$~#W>;w_rdY2VAnz81$~y^$!)~XCIeUgJlkdf}+I@8|4JO{@1Psi%-IezGTFc(M z`IzYb07GTpMN`uz`y}aMnqD{=+!<&wzF=0#41Lc|+&pK#`I7m5&WNqU?But6-_HVX z1?sx1=XDS@JLUzB4IDP~o4+smd!Le)ah|b~fVc6~**fuvo=^7Dkgc}iAS$n-j&~qK z5XLy*t3d7G0WtvsK_)=yq2sPW>cq=0{I`(`Ymj%Q44$TJ#pVaBoBN&@uaJtve_sKO z{X71PSWF@CC>(XY>@oaAhhN6zt#j48?oduOLu#sMadtwVb(h8tcig=lra1FmKu-up zwn4DMu2-V-O+z6$7@ss(V;nYaFlA2L{#uTIX7RJIIEb%?!v$E#=vO|@sZ|B0Q|swY zt;#2YaUxPr9v`RAxpxsH86kM?LW3wbgp8$VdLYm78VrXI(@NQ8qedAS_CBg=@eTVs z-XPY}G?=DA2DBDDq5nC5_bM&Oujey-S^NkJS%vndN<8xVv&yZd69NYGzgYr4h_#vo&rT?mwF+UG0E@NY2q?* zKJ)jPf3^dgzhbtPt=+p7{Ym{x^@S610w zoX^60Q4kILz$C3!dgXnK&=$cDwp`N>mA@DC9%9Vv!d<)40x>Tye0x{k3knlD`bNXX zc*Y1lu+53`;r7DzEZpU9jKxnpclG8dE!8Fyx}=MX-Q>)9R7P0-q+b69quJvv^DB7& za{XUMNpmVk0cD(1H0Evcwf^X)SB)G(|3k$$W~_u`OHxhZjlh^KE1?vQ z4sc)5A-JS?_p~g-LfS;SlKHgIY)KvMb#R?suViT=Zrcus{bo5s-2hVu^z0RP#^AdH zv3LOeNH8Iw^N_^g*Jmc%R)^8KGfv~!qQ4*4$6l(rnK&%OIm|d%o|m?4t370#p4knV z3g+0O{JA6b@%Sl)EX}V2)U+UeUyNk<;aYpan=bL&B(dWyWmkmIuqI5O77kQWb$N!{ z59W_eh==w!>eQLrj3)UE#0%6d9^UcpEEMWHs}tG&Xu>o?*>C0!@%9<@qd4FgM+}lr-5oHZjIbgZ0>SH*Lqg z?pmq)I&`XIWrQ7!=Ln-WmicMIpH^t}nE@mqYg&;JXL3lLts(el*qu{(M44-~sO{}s zoXH4I;}h(3wiZV+cR<8<>2rAC?N|hpVj*^>gOw-S0_A*b2~n3_af%1*JrKOQSy+ zb&psdVB+zeik}p)guY6ajfoVOt%Q9Q_y6YC*eM|?B`+XZkmiamC-2+R*wxa?$>rI4 znhGaZbE1ZRzItd58u8TbiID7?-c~x2@gT|Bju0pZSPa?jM~qpJp_1A7wLFPEaEV-1 zg|+FIu>Q1#Ik9z1tK3XRgQwJOKek@eU#1uKuqJTRlG0&Z?wt?D)b@!$GVtSPno2C( zk7*@e=^Wa?&OeL3;@q4*ZJ;kfJB}jt=F(+@u`psujgoRO{Gp&<#u4<16o6bgsjeD< zPH!JHtJDr_G(DZ`p#Y$OWrm1O$z=@sHm{V$ak&nsU;vQQ{-J-wh;xQ7uZen}bzzyw| z@#s^}X=d#1_`R1W_u1{t%IsC@|9DjBsWSb}@lod(HZ@K&%ozH7r42bopethouRoLd z(~&XLSd+sxEaStU_C5ZF{lB4B`S4Aw-I;(r1{EKE>e0x=;FmFdkO?lVcl^=SQA9g; z6dSa*5<^2Z=sh4;*Avj<-eK7|?K%I(^xY%!@W-qb~o zZSp%<<->f~?dFH^IWz2cuSA;29_JCKO@XV7{)##DFB}2gJl&3zxM@$>yf7ksszV?= zC~M64{?CTRx+ZJMor%f)hHj`J414Rh5%B##C;2KH!|PB{msH{k?i`Lp-B2A{PP2hF zb_W|q1V8cdIr6m5=?S)7^-5||rk+lGerDeawPETZ!{#4Fjx$zQ82}n25<+(|ayFu1t{f!C-`V#z0Zv=dC@mk8T&sN3Bnj=R$;Io2>kyRp}q14{TkG zyV_}y_WYasX;-mUoo;n=m(6=!5v;5*P<6x8+T1$QWk?C%YiaPxpP&S>s zTfl`C|CnCn`>L-KEdxJeu= zN*~(y8JNT}9vRzf2)fN#8!*(Ch{R5drZ2Mk&D`>sdIL!-w@+UjmImhk%{I>7i)FLA z07>jdu zdOuj9`NqCr?F&5z3riQfQ`aB{peAyw6ruhAzp}>8#jjwgXkT#HuuOEoOqQY5Vw{%$ zn6*C5oA`Si3Q%srKH0Dj+*YyQvfYM$tcV4L3c-LXrasV9fhL$CG!)}`MYF@qgMr8q zn%Cr`dT*{Ajcb+g5V{|uUOD73ck}+)X1wwG>p^1^l!v%DVjk7W^4NuXn=sGy8xnqG^7inDSHg+0_3ptYfksom%KY{(xO!=G?gb7 zqFhEDWohcM$CBLq#7*Pn#9@dLd|yJWg%76hqe#sabRC2VyP})x@&sY5hf&~Xmd3bT z2KR7%N)3g4Eur-Ze3dghN73>7;Ro-M%H_Rnu=1N26RY~5;5VI!bm8Y9#O|XSCfUU> zcxd=f`G)L0%4w=YJj^ zI{#X`o2_wwX;t>*nf|mD+DuKd4o1L~|A&#TJtpek6i$REN$roq(v2<)*d+J|? zKaZ4?`rp@j+bb}y3<3cUWo0l+jO8ny-h2?SB&wlJ#>s}I;UrE&Ih*oOr!qKq`fDF_fzV=yK7da)H$W9pXJURL|}^9;ms-HNG^G*46!~a*v_{3xxW{S{vX&o zkFfAHC_Q(OVsGjfyHj}N0U^Yb?=g#>n{6-|{JZaWD4B3bM1L9BeBNWAUPLQIQiFWoS|;6w4@Ek zIEFfIoElf1y*exVbr=38Hla|}#rZ(cjFukVSgD+yd=5>|ZA)2F=%FL#KBqq(5*sUC zQd_~(tn$AkMh7|-`n5hRU?L#7 z8A}qX;MS!v@U)l27O~Q9Q2%e-Sq$bSXt?wVDTtWsN*7FR!#sDBHgPw#1ZF0-7_Fxf zxFczLBX4n3l?v@SW#A- zGhQy(4yqZd9%Q{G5W**&lI0uy482wvuU@ea4=t49$FmIwcNi`Gr13z!#Y~=22DX1G z^-zpQM$*RC0n*OnPsYb9O3wit41-M_(!SU+$EgQ7XMgX^Fy%Dc}I5)orV zAYSj^AtCIb)9HBLx=4HF&6&8kM6q}}US7%bXv;U_QQ9}wi;m9R-&L77jSE(-dhxZQ zAC+GGGtajLc0vr>mgq)km3&IS%zEmOm|!_6Ke$n4gWbgMV9&gxpsYvSAP5WTu!<&T zW|AoADty(4kckn5p-^8cxAL$NHA|`kXNiCzwtKVrb#a-KZ^WFkkANL>~;NgRM6BVkteCn%vBJr)s zJ6fI}IzRYfm7?|-@4?!poIg|+T5!mEMq?uO{e3S@!-F`Lt<>b~U`S*4qDkZk;%#>NR8e-3{|0e5hxL`zvjHP3x*2Q*{4ZmEF+f!5%PBhjB?WN&& zs5`dx(BT`b?(c`ujo=Zk90i#Y=(M>jaK{6n-R!=4ZI0zm2>$trFCemp^cK+vqvOL* zYk}U!J3MT%t|s)PG|n$Sn)_qyTl2@4a+`Qlp$e;%HxlkUxuR4<-xeB+>%k4 z$Ve4pXWYBF07p{?OF8fZlG)`Pyo|#OfxWg_M1tX9+XA@67HP*Jx!Mvmg3++^n67pE zYz=Mugsu@8EpqUNjpYaNx95MHkNBH3s2zl6(D_H zBMmOL;omLhJfCC#tR2io`YSv^%7wSE4=Yl}S*z=RvSh2azbzG9TzMqYgYEp#1>Jsd zJdJ4IpyZt6b)Uug&ku1tq}6`1IwM2A2!Ht;PnGfZ zBW&ANrsc!j)J?ryYj<}e0*{7vLU(xH^H=+nktx!}WKnZ3$E&xWf%heTg1TBxLLdRp zmWLYbB7tKj8g}nFNid|=y9A$xrOvG^S09u`p~~m?(I;1JVW9dL&1o5 z2Xq``YLdIS-@E@OwCHP@?V(>_ z`aV7>@!$^;XOj5asB7b_(!1pU#APM@f6Qg2qqwZo|5serQyKb3P}N@<4Bk4YLqQ$_ z7rP)sT@3iiRXX%-l?A7D?!39crl=OoQ-6|}`YeYFjsbB=*JP| z)U8#rfvnD+&!YM0MS4IF04<&p`&H>@1NvhSo1Z^vtbB+cvT-oWZYvw9`h%|DOm-Xysmy+>4g7_&G&8j z=DjeS7oLNbiM#9%$9TTQxjim}XJO73H!&N=$$q02^xh6fIruB=g~M?&<#|jj9}@Cl z2uFDpxCq~dAdG$Zm^HwWK)>u~oUnLgGv;LLuXrzh!f;1LuDLF^hz=WNav~~%=Zod` z1%K-|0B(v8dtAHypI;=H;eq=?Q={!e2@^|-tV33C$ah~|dIq!;yX+g90xL8!81Lk} z^#)z^0dWihuK!`O+^(lN`3iuYh6&#!2!_Ox`-ZzzG{3rt^#(||OK=-)U7Q2g&EJ6v zbvOafhGcb?anu^#a}7HR=@~}bPB~UV81Y7nR@gRvwMW~~dFZ}?P1(e}F$GcAg1}Q# zm%h8{4CfwJt7k2R8|pb~de~NHXz@??=JyCy>}&xx>$t|_`TSeg(LlUIK!Vc}$qyC@ zKghbEqPYA(LPE_)6RfKe)JGJ_&}1wr#ZT=(zTWHIyd?(2X>mT4{iuEt(jtF_ z=35-c$^8j}t~Z>3aW(h6IOF;Fymdu|udy#6`0cy-_XEFP>>seM<9Sq-wdVYeYL>k8+aJl5sjE2<)b)R_i+G(n`OXkpRTI+n8B=(a zNh+vMFdxvV>ji=^XG1_;0@3|&YudZy6K5xlA8~fJoCuiz11da0UQD#=1=iu8C}+O5 z^82GtBjTE+=&)zkO&wCjSr%#C>XxMcF(ffD+CD;_=7K!WBd<7a#)PQXHh4bze z1}~kTMzl9B^5E*|iM&eIR{#sqB0s9qgp_RB#*#T;Uq@Y&!JjFaJxv9(S1!YadJPo)<7pJ_ zl#>F~$Gmnyq4&O~nZ5n0^J`;WKEAv;2=mgSGp%KemZe89P0~$jW?F7>75kRvGr7z~ zSWU5jGUgNKq7%z-%f?2y_4Js^wu9-M!swq4KOT9OcjjO^2V8;XjX0Hl%et|eq}J@= zhklU~v0Yu}BHY1_WaB*OP^LqCR>T9Td@z0KggjTD18#C991E$yP??lMme zasrBOSxs=Zd}HzF?5TDt^hmGiUR2?13?$|Ss&G^M<+%t4T|~o&pSc%*qhYlAbxm|( z&iU`@2hlkh@OPJD-Yj{`Skfo8aJB^);Yj@Wv-i7O1Mj!w{7@{LR4z%Q0v16WVbwe` z4o=|ac@wtjthr>*FxcZULHT=@-G>BcBcC95u%N4S%0I@)!hA>3 zoC6EOR%;bH#XQ1n-90q*=VwN|eD$V4)U|}Hs@ zW8kS8#?7kT6*H>;vRCNS|Q2zhOcHPZGv0ZJDP?C-5{GRVAeU~TC zfLq56myf}m@Nwyji z8cIF*T_+TfH`kJ4B>?1D%;wLb+_GYo`chkqPtUjUR~0uzdGcmwq*UC>N=E7G@5--e z-%*yN!_{!0h!jXU&2oCvDCL@KY-sb5uH@4?1Wnw{L*2E*@gYa1q zgYog$>Q^&Cp5am93l`zZTsL0s^-mLyPu0}11p2z~m<^x4-6+%4_?RLOs!|UR#d9dE zV|k+GJ1XY7mPbuE@2iAmf@By9Mf0nES7ewTxl?Sy(}c4G9z|w?U7Y+o#d+IP$|>8W zmhDdRKR8xSbVtNk|-WyUZq z^5TBCPTM!caXa-n;y-gMlOnOIA}+Zb=>zyZE<7LQ{TGDBOBYCp$Vpugh}oubG372GSfr#i7{kss~YM^#!}zH zot8a|mS#J)rMTE!`El32{#4l1zKxCMxqDv_Gc60*7J}zu@6zi{n#eVcaJJ8K$_zC-{44am%c{cP{3ck^XY~VNj7ZPC#IFu?hW125>a=C#67m z3yM1kB!-%RsA}Q}+69{zDup9Bt#GUjL3S*6W6wfef$djy-2paMcE^=VvY7uRZ{-7c zt8gE!tq^DNR7Q2pS354;z(gQnxz!XJeEVd#7F{v(lUf7?3Jrcr*Jg~kqI`4N{DQ}UnJhem9ufdf^9(F-}HCv#k3rYNw8%ZnqXLNd&>s^41a|@99$@#D!r2RR=;&Fh3-uo z9Cqvn6jl$wj@8s1wKRdL@|$7g_st~wim)Bz;2KA%+qt^Xhaq5`iGMQi*bPxM$|UTP z&O|M+S7#UI%ClCuT`-!tzURwID`&!1fK5s*IbA8UlaHFw-HZz?_e)P=DU2X924Tpk{4_g5o& zUZJ(nlumhek*C6OY#f0y^ZKy``Wk3nlv_SXBlx9V?;uM=EcE*A{h5kh2}zeh5Ta%l zDzy8Kh}Yy`;;q-Mr{%Y}t;Hb))d|8BJ&+kCMu6MtQgR}m{%sLr=#FhMFG|T?NA*ev zLsl@lGfBA5+ZXTHmyO1nVUO!TDFSmE60eH(9T zkI0mSWG?Z_`#munkXkT-?NGZR8uhIhX6VwxH)X2&b(HEu%JTz@0i?rjp4n3RmZpBL z>PtlIaa%I2<-2&A1%cW zc)n_tZPa);G?cCrd%^PuH644=v!XB*J!AX&SD%R<-YSDH5P3I{$%YwqS^Ekuzz&`T zPuMl-QY1y9D5_<*i8y}+VR(H4DxJEbj)`x;!00bM1@vn(t21efweorL!_M(sK_Z5$ zVlC;BFY&p@e9dFdI!5fm3$BiH%#F(W!a;3=94)e3*6-e&3NTgmevd(6`=8KMAg#I=F)B207aph* z0G}GaB2$?YTD%AUcKYb;eY0(zPslG;Y>nSg9901ql|8fp)uGz11h}X-XnOm1KY0!f zl(`bS=XD1-O9oa}kCH4i9tq!%C7nOq08L5)`=~G1=VD#^YBp6p{+OzS8 zd~TvT;K?G|nQ1z;&%e8Hm%m8z3*+CrmGW6<&LIT!s?rpXn!=p#{^-E?_dJzADep7u zYo5w`@xd{c^fgUoj6rVQk@DtCP}4?d>d<%h=7+0E*eot1rMit8drw3AhIF4v+wc{L zhVqzmGzRQh{TD7X{ipZ)NZ$fl)@wfBmHobRUy`;ZPiHyDU zq_8V>pY){g-AKK_`&#fm@yNOE7%vl~RyQUx9;HE!I}M{uM)X;Z()z?qMju^oTMc&z z%_B>gw2QEYuA!IaaSTJ?1ag%dvLwKNq(3+09KaY20Ip)(!Q^>bvv2r(&Uf#5KFct2~% z@CM9BgQ~QFst!COr>u)>S#9@jDbR97+{%J;$J%8{C-9Q3*!tCZaWnCEJWQ{~O*+$- z^kKl(cC|Ee>Uk)3Clp7A_)V;&>cN5?*Vx;{XXZHIDL-Is2>%e~0P0T;8NAUrE!7>S zzm7_)c2G@yQJ}k9<0E`)#a9u}p!ibcjzYvpq|dVtz7|nk9-{^F6l;w>x=Buy*Y|*_ zyzC|Vw=k$TwGdME?lcAzEw?p}+|=Gx%5_*RM%NyoEi$!rEOhhsu%n9E54wk&K-#<= z=e(j};}1>Rz23a~dXEaoYpF=0uM8x5Q*p4Kf8|S`7)HumZVzLY$z4nbwa{}#n;8b3(mbB(4x{ zQ0fbP(dVl;W+S?Fyr*V-SqN#DU|T)h;J)|;tw$I_M?lm8Gt=pA2y@t){*qfExQXfA z@^r2kEM6UryV{B~Cu2*WRvq8;ZM$lgJo)TN8iG>qqMRV+BG`g^el6U?ZAuJ}1ifU0 za)Rb-N@mvC(~^!#A{b`Qi_kVWrZk|B3*HNET#QpbC;73G5h(#~wjqzBG(8xOgWPuU zrg%QfjJ0igjx0SUe7^0ino!m}+lXOm+-Zl@pGfp#8=;hsSK7+|&gm6>C9m`|=YmS= z(o%{?-DQ2W>*zjBa0wG*R|XhJQY=3|%GJ2f9)(3EQc=$G;A z+8)Tk8~8s&l$T7||CxxIsyR_(<2=MXBxLPI(NF`_`_i#DxAFP(B_fNR|*v3r$ zIOi8HDE1Ctl?0~;`!R!UIV?*p=^qal3sYR7T50^4DK${4VcoOm+vAlJGt9URVcf6e zk!o=obO?kOQ|($D$JSVR1ey((niU50vQeCw{H!_OK)mHR`G<)I9tsh$r3LO&^a3x4 z1iCKL%U~FyU0LT)8Dx;xXQ(R#d+5_I&dRaA_{+dPvaLtT%Ary z@oI%vX1s9_sc`29SD&vs4tcKiO!QXDY|j7CPZhVkduFQdmg=}$dTkxvCM(Jr z>=aRZqB#+mz5`k?G41>AgGCwrPaCQpqhIb^-m|}pp3EzU5rMK`IS%J18;Wxp`&EC( z#}rVRG^ult))A9uKEJ-)6wfLZsNP?G2*MJ{)We0UX=tZ(i^OjvafbTUuw}wzHc1Yv z8d-+Xd3Uj(b|E4v{iPRE-Y>bAQg4=#EBl5tE70?`-~rwPMPxBjZ=tm695zq|?|)2H zod!0uIvFp-%Z6ILCnv&h<2_(6fA&A(oaS4{2*@L7SK+Igy_#D3S<#Gb|2gLb-(%aP zQTicfwiw+Df;NEd!fI7;W%$xNuW3_7Yt`_2xvEz8f$hr+D(Q+-N48H*{ERtW|5&H+ zIB1Rd*70-{E`RU8bgyi|eSwq!k?Ai<*?pcr)w)%x5L2E02y9m^dXH(B>BC@8OS-9) z$X3Pmz|!srBBo`5%}=gPazDCx4KdE z`RK&ddjg-=QwOa|TqB8Y{`u)bT1qU88?a`n zbKcQ2Nqt z7(XBPieavtz@zWOD4xmVt0(xgsFrUjRW%?M<(kS9kD1PqoG*_ke0Hn|;{5n00qfMQ zM-IzCOWtT-r6n_ZYOE*`Acjruw`ASD<9` zjoA38u*`zhyJCQc(D1JlJf-${?52XV>HFMun%1IgDtkF^f73a_J*anydNlU~Jmkp< z?_x~$pK$4+%(ru4TEPuYRH%{tyKe7d9WocGYW4FrvM%JnRHsfF+bvPn!5@{0JS(CW z6zXYq@Q0@$^y=c_0jUI*-?kpZnGoG4mKt5k{=idbHqZ&8B>4J)e#ZBabK{UUt*-P= z8rcq(gMTqk4x;~?iz@K>9%=Z3{^HBWh5sG%R4<>!-FVvr+h3n+YVY2*(wgV%P%3Wi zD*Z1jDq*tG`^=l6rfr*h<(9dI)#O@gI{HV8qviqG7gTRAv6P52e#qKuynqd^uxp;| zq!+r35>K}GWMI$JwckCqohN#Q9b9gD)9*$np|hP~u^a6-}* zJ@3!vk11r~s#N~6=1-@R)C$X?uCy?moN|q98_TaAaIli(FoKnK=?oXt1dc(!#o11@ zNw>PC#Zj3_s?DyDs=1pKD~{PL#5FS=B|MU6*D(`GFeouYZd;#nJ{1S-Tn9IGTLH)b zUR`%MO*&_w{8gR4VIbS?5#|Cwrcl&|YGn|v0obT_?ES3ikYUT2pO~LJ0Mgj0*Mz&o zI^{-wuy|v#S0IET?{sS0Vbr$ipzH>c{>qu_y8U{Be1MHS!Eh7LOV zQ>JB66f8K1BPQQ;88(h##6%SQP792}MSijw`SSQsf0_}=eaWGq^=s~@2on3Fs3pY( zNDjKEEHyv>luHvP;|_vMeh7`ocKPbzL>^ z8-M$(6)T_H1Xy{9=@s~ju_CI3h`_f5#Qlmq=+sXN|K20uPYH7lGC5>j|$j z`{eFLVlW-$S;+g78{zwCfAnpWi4vVnt0QI9H_+xi;#WW~%#Yz3wclA3NVVP7+7rA_Fkz84S&CE2`&oE!KrNM#_};AiNGrZ5!xn z>p_%@(4=hYhJojf>BXi72o8Plv;TAR;}dm&>0EeR!cuYI3tkqVsF$C{)ZWH?NJOIV z)76j>8a7K#KBc@hMq#ycy>s=bRXU;Tj{R5qiHwRm?O4o98*B%8m8vu{_%9DC%SHlI z%l86fk*RUMo*ZY-Lj?=%p*9Ng_KFKrA#oa?g^NmtxYY@_*INAO)@|v5k1skyMgdr< zFp&rUy_G7AHmf}vg>zQ7r2jvoo)rG))KjmIAgtMETd;1#A`{d>tC6`l&nEI(;T!A( zhQiMxl}p}k?!VjkH|jP(7U-D0IK;kik;9hou2}Ve1Uf-B2A_0gNbNWsmVkU4EZXx) zZHMnP)LWSRs#PU ze!gd~WZkdE5Az!$yRc0Tr+~Ie|J$l^Bzj<7-lw}ECb84Tp1KPTvn8AGXYR@I0k z=++h8k`T4Gks#M$rMo=Z6b_W4M<6Yh3J<{$egFBljFmyP>R5Cgbxfu5+dtG#0$Yeb zN$PprAe~s41lw>Q3&v&P(R{u-CkIdHvDjg>ItsXKKHw21j1>%T<9)_#=bYEe>$xq# z^w(QOJXuVI!+Yw;{Njt83g?C#ONhAM7d2t{cd%qt4j7?=LmrgN%3xa`DE-S?HThA^ z4qBT*gO0oZ9Q&hv_LN0n{*QA5u-OX+K{>1bbwFBqmPCi&X@5b3wriy8QTn?dMxhK5 zrLM!(PYnBl1Ys6Qk>Y1OW}bSdlsMrxb>K9FhF#vSXu@Or{Vq06G@xr(-X_Zg{Jha~ zsG&g=Vv26NHT=`**z$h=52DNGT7+}ZL%Wsl)cJWNR2AqAq63+6YafPY0(($ z51-6!oEFZpI@4xDsX2mIL?Ksc6?G3HBPFay6f+bT1C+9;ry+P{8^2Z4rD;1 zjwa(+`O>rdLSh|xY&3gFe`YKD>a0?hFad|-^%eKDULYBiAFn}lev&(5)YmbV`iHz3 z;f7cc1BLzfj4_wFL%$&lqqLI;K=?;AIV!Kx=_koPTB_5cp#WqhuHd4j4-G8|%5lnB z#30PfDJjw!m4aJ_S;600h85gYdT%-ym)2a<<;eG7&QRL7yOuw2qIc!D6$&wK9+5c{ zr@<{nN=lLFCp3SnKN1~ytU1PHkX8C!1T0uJq{8wrvgK-Aw!R?^9>s)Tr4^d{mS@Le zohSO04*g)A?Ym0KWxu#$wg@81!D|*W)!`|C#xSjnqL`W<0OS18;2R3Yg7`U^uFO1~KxbDuIaG(1L61_5or zd$6YdokG(!!)I`JdRN8fo=()MAA_(sjmQgKGcFC-q{2 zt51mkpkY91BW(Yij%kyT!BQLGoNQy`h#(&c9 zk0(wS8d@eb$v=D-+glwrr+Y9JKQ#d+i^F!A+}B>Z9WB?itvD-6OO8A`1jh_*WuOkD zboWd|s=AYp`0d)>(3zadmSy*g0KWLL3CDkDk%B+zNt32_5QO#TOc_j3;&_R9GjZeB zW-T7q?njnx7?eyvbO}!{UA~<#4xVP&+7AKeiI7vw9<(ZKF5)6;O&rRb&ju zse(MI4+>0xW8X2yOa$`a(i*hKY{5^;%qbDd#S`!mUgSuC=2t)H@l4tXPt^6em;N9h zDzF6Y`V^uf{PKc;hmE?rY?>4)6%^W4wrbBB^XZOiG1oJ@AH$5hVsA$hVV`ghsSlIE zO0f?!^wC(|XMz|&TZUSS`hnCUC{!xXB&|^hFJ#ABlBPpouwJ;ZH)ik4f8mXi3+bIm znWfrqcr+o045g$sl&|8Kls!8Sn1E0o3;wBJK~aHKMc6EID494?MkU3;sMW{YwS?-j zwq!R5qADbyGlsj1O&p6JdH;K=R^&{~ix8(Hwg1c=6_3Cabd|lB=0Y-r_UU|1xyq@yBt1Nh2V0MLu_R^%kSC|4EnYZ> zrReq6;8Oa{`T5G73N#D}z^j4T{}>7XBFu~&OyafIR4`(CWB>lUJeA>j%^brEzZ=@h z#McI?7H+}9doditE`>YH6YdHmq+&qbT53)*Bn1BeWXKxYckGoXD|l5d^6SJ&7ku!KwYdsiFi6YMknquak9vs2}mGF zU*C{mQzigWjPV=VM8t>bc}=hgi1Sm@iI^zrqNt>*5xK^9Kf#wX%B_rKaPjv;yt6tg zMsL5$q8VZ#>z{dWs9%IwU4u5=`6>yhxvO9(TBH~D0R$KpZ+l4}zmUecr)f=DbHA`+ zjFej=gZL&cBzUp``z4dhQ1TB+-7G%Wku#b5iinkrqqLSzY49`JM42OaMr6Zn#)5PH z<*v3gMB&YrsVvGLRSf)5JAeIAuYMOuJ6rm{e6&>?`m^G(2M0UwOrSmTR>`^u#>8(-WZ z$!W0pxo5Biwx!8x|z1a~LiDn$vh!gg~g1}kf0srh5d53gutp+f$2Q#6dF|phi zD3esGz06(0r=zA0Y2h~ZEfzH4pGANC$$Dv}^Nr-Ohs&saSJMm2cdyr#{}y%23-b_m zI_##8hX$^{fDujQq8_y*^)@Si0N1k@x$!ed_Ov&(att}C|&36D*X|1 z46rD5seglkP(^>KSBtJv0E0kG-3nIlrGTlx=TAW4*P0m#S9OSALsEeBY6mO_;-KD!@DqFvp(47$l0E%JHSj>aCRn~HvGqc7r^a!D zCI04mjI*Q4$bu;`Z)*J@;4NZT`8IMFWXfeoKvEJ&+I8QH#=I1>O*7QAm8W^>IAY_D z#U;bxWs-Uz5&Tc39B^?kN2 zJ&uO9cE)&?xZG122V)IXGMLXF?dbb_0~w!!wP80thdVBRH@b*==I>~IJcA4EIUX9W z1N+xgGxmi6E)R{xl<=9aQ8>dA!a2F+%uk(PHVw&#k|fyNZmFqm@ktMc1jW0&2)J4n zwQY`GQdw2A`;zWOs+O$T1=9^bx#%uCW*)>#>{@Y5C36XIqkB7Z} zx%M}=Z%M+xy#V?GVnF|~K%Hv1rha>YsQ!>6kY&4TrdC*5WxOpQ;p-`>#ibH3@|~xn zW*#zCn^682Iz|V`3pyd%pBk_l=Jo|G#laEgeP85qLRWU8fc+UwQW?Ss#!B= zD04D3uE0fRb~0XnfcoW+%8nM7x?_SVT&v-$td>;}A4d~$t-T6{=!g2$k1dx1 zsgrWllRJWwCGsx2Gg{~>k*uH0vO7FVaP(*~8W=_jgt3kP^YA}*yPZg3k3wIC-3OEz z&*_RJ19*R?S8#V^3v3ZuSWHh{Uv9mrj$5C$Q^mD!P+Y!8cu7CKaf6>qRzg(eKV}24a%K&^rmh#*E{unb1TEZbG-#urQ+rlw%0%qg$mq}|Hqlf(qA2##-Y-6yK8^` z;ob$+$H)A)EFO}4nB5}`C-?Edzy%9Fm|T`V1p_H$2%=yZFwqZ85{u0AXSzMt z!i!uHH4bam+{Q?W_-=AF1v3y}=6AQOLBHIk?E^B$_gkq@wVA|A$Dl*{QKoy!4W9_)UQ9o7am*;fAui`S zeHSa>MM#R!bqiAzTSS&MC-|$B(0TpRM2_>c=B}z%xBow4Wq?w4)Fp(0JkZzRj{gl#;4(VoeZ4B7P z;yFRD>$>mfdG6Qk-~1z-JNNw_$LI5YzXq9)R?qU+e#EwiE`lX5T34BnpOD+qhTsvn zg@nqdF?JUNGb-xjfnp9&{FlA_LYS%rM2aj?C$G=mQ63LR1j?H8xuB$O zaZ%)wp5C+SOO*4)Ccc?Ap>oVSGu6toPue?{ZPaP-7QFsL!MbnaQI>Fy@m2C94bTO~Du=+~x)#J`;LGTW=@oN|-mky) zr>BZ-a3C>oe4(O~yDE~svz$jhJ1xX`jjVndcwgM|p7t#Y>dm3E)<65w%7T{f$jrHU z=aDqLGUC&%?=L*z(mtmYa`TW6iR(tnK!=n2Pr}&vd}r08z^vFm!#fUt0J;&QM_pX;ROs& zrcgvu{CtIVUt0UKs*N#aBXo{%$vc<|dxKgMw4O=++XH7@7y}lA9cdT@NC@R`s!kG)4QVGcgrM=1okGcic&^xLr{KTu#-~WzzojW9 zpfttnT5q_(h`7X!Ef}URn$~7I!v9UL|L^#}xOX1Mdn>&de@MwW_r@t*?`?;wO8&y7 z%T+(hv}k^$st!^A7i*Fxv2lJf9Qi3))dq4O1eyanRxMLUQMW5#p z!{})pMJ&9G4rvQ0Hz!N!2F0MWBminw@WaedDr)5lO`x*@PxvVXOE3F2uTr~d!wWN_ zkq;Sf(mS$nu%z;N z(dub-%hb4Nt6?Scn|;4NDTO0Tl+5_rfmK2mkce3y0d`PSsL#8Z$a^F3o5jFMG8SP| z6x=O-(%@o8L;mG0YlTj$+Jfka*zknyq3|dRnN|O<)BE_=g67?sX%+Ye!&7soWkC77 znOlJw&@|v)Io+Wdn9xe=6g+h2*Y7x^mZGlpYaqw4Xyq+<87Cr?@$gy(6hT3jP|^#| zq$C+Q|33w+tK}bnpw8RT`G=>fZYI?ZgCCge^~IdUA=$+@`W8E=@kYlztWkg{`1Ef9 z#<>O+f`q` zlQW^7VMI@;=0FVrJ7!tXU0yL4dw&8~^A)7*bHX?Q^ANo6<={3=`%+WD?9N`DT9U;S z)UiCyxpVw_pv1Ft<7CgN2Au#U8`|<~2=LKZJQl8cCl8?3JdY;n5Rs82 z+e~2^5*I5_0AF$M|9_c;Y)k*2=9Uy$?l*nwJ!&H24XwM^szbjxNr)}cr2FRKk4|V~ zz#iCKF#D5?fq>;@Umr(Fhcb&sli!BFk)qz5$z38zUIT-xAqyid>lP@S3_Q-LOVZoC z;}5WfHdoCf1St z*>sZDKR&8GZ^7n61mWmnBZN^)lYY=VoY?O%W40|UQzkmWfft5jU6I?+H4xHbX1B&; z1k^I3xy(a|-l)hS!kY-->>atCFv$4~pxt7pQCV=FHQLk8UAJeqn%V6M zPZYwFk(|ZDU-MuoT4c*-ZtN%?C-Im+ywTUqdc5F_ob|-2OFI@Ky zQ1V#wc^pm$mK!R##4#tjaivXoK;W)-zG--cl}&=wJ}p7U#$K!A4jA42!BUrsIrO*u z^viscroWWMcNJGa4UHk_Ja{)&;;V|M83FyAQy~*7dPG@tWv@oO<^p_612Z5BY0{_0 zN4(8((PrysTt&spQhEFg1%?`DC6|bZ^h_v|0h@Ru5=3d<7VUIR6fox*>P8GGdIYot zY^8`NK*;Z)MlCxT5E05EoD_y?oFOZq2;wn2eq4*g=VtWVq(dm!8-wj)5dsrEo%xZp!O(wq52yyD1Dp#EJ?4S^spIH)8XF*Wg()lPH5kPhpNPqKl}6jH~+(a@=-|q__gVQXVZ&SdddBgt8 z&6uFl@uGKUhVMs^t9BjDC#G_dQeys3bAT=7-nxqU%w=_g{}Q+<4Nd!k?W*J;GlYx+ z#G8^0`_-5{qq2nTTl~Aw+o__iKCPzphhC0J%w>m@%fFF!fIw;K)9G zCiSIWVd`~bp8~!6W-+2fL4MQ0*&;cn>B(?NtUEWa7$(W`ztARa#q)nfM8ZO9CPo}2 z14E_dp8~9|&X#*4mj&jDJC=1RKjoP=T`dJjA+vCsHd4>EtzCIvt9bfJAG9zE1f7El zJBkO@69*}KJc&&Cme*hhMLpt4DAu4#5%`UTz?V}MyK))E!Y~q{8#68kfsm)c1UZ!G z%wbZ6q_;9(QO#t@xP`%5Pk$*Y0;XUXG`CDi_80+V2Cn47jG+U@s7MRQtEm7om7q2r zI<}Wl=e}d73O}Ln7jmiDBhfW-$-AYflz35(;dP{_dPfDASo&Ioutrr^uwRn|?K$!B z+tonad*VzlE(0TQ!P@O1kWC#EAa|%`eaM$!qs_f$4zMjdUDLwf5iZP3JR|_?S6t73 zUB4z9dES2kgj4^se-+H8^WfIMeT25OpDdz!#G&r;M;dC`Tv4!I>VrRw4|QsVFH*%oG_X1eVRFS3m8hv zyPva_mi2$nrc{kcLue&Q_q_1$W?1BX!#2y-E3z5))roaNc<7bf(oNOhEjLZ9PjT%}oUM*{r@(}hI8#>A;;3OV7H@49ycDqolkFVCxp6;vmD zzvgp+IQo+V(cR!T&N&3!LOOsjv7_Z0kLd>-)4sr!lj3dhFMw?1Vp{%f!y&f|{1?g< zt7u*q-w&3q?76_9XI03!q*#h=P9U5rwSjlfhJVp|)_e6~K@|NiHDGAg?H>kc0YJX> z50+E|cF_i_V1Ez7gD;e`;pb zWu@tx3}i%7d|J=CUY;@+gAj%iF-_MU>M0uq#2wg;23;qxA2$3nYfIV6S&Uxi?%Nsk zqu*_=8;LL|aB?85bbCy2T^6RWlB5=MEL|u zfbW5Vs^p0fFd*ODkU_x78I%lI0Lkgj%S={>ub`t2|M>8?k|{A4vsqmPG@ zxmZiDiTTYgwVskQZ~yUB;tr&dOYB@0 z=rVBMd*+RSCs+R24zC_ zLXYaUbN?6nbhS%2ZfV`8Ytu(?Z!bl80h-iGDp zHX{iyOO8vU8E+^_TncLRn|BnFIgqF*`0g)EyBawVU*if9UnYnCuvqL`3V3Vuly~QK z^+07sT-LC2Ei0)z0Za_p!z>CUBj@KGkCHQ)*?dNG?=B7c&($nU7J@d|qE4B-KOqnzYWPr{k{?m3=E;CzON ztWhNWA+eEe4J{wM->!F(#}aug3yF*pFInGK$73@l4PDC8#Fl6FYCN_{2T5iS&l1k~ z4dUwH(KqI5G0H#yVls^rbrpdT4?7X!q)JNhBw~%2+zzt0AQHM5)j z<$;Diu(O3BkgSU`acleh=9cN~ zKE#doD>h%h*LG`6d{u-PF(aGils0curHOEUT&Y|Hk7zfO?_Hv@;1%nc_b>z&s7*R7 zFs_k%)C^+W(pvuaGg|t#WJwQi{_MEpox?H|6WUy6vULFxn87D0U+7Zks%12EZS@eZ z-3kTs`<^#SNPRjl+*}3u#;w6vc64|9&&O?08a5o5QQyuSzH@SyMBF~!4apJOELI$_Z;HEy>Hqi(5^f^R@=f4J|H5g zt1H#Fr_lCa0u^TvrmU03EURbq>RE}-7IsmQ&TU|SXX4kweyn)<(ZHPl!k=F#6n_Ms zrG53G|CcM-aNvZG|AQm$Y=A*2^SP^RaN8UUam6jJPHnB#&lZI_?5X5aa zAf_u@n)F(TJd`K+H6G%9--UHc-Im?pc(U;ivDU4VZLvJ1);+ATJ;~ZZI1nOnh8&M+ zo@vx;0a1}y#%2)g%_SP)mH}3!0ciX?%!Zw%Neh;^DcPejamQ{fBLC-UwOte*I2+3! z0QWK9_Fp0`Yq1_1QZxEmO`DAf=NSx*)b%?BuD^4)^RS4mH)H_lEU8EpE#d~q>+R(N+v z5ElD{(#C*}eD`=BRB`J&`F7alj*q&}N7;bXhbD8)T!$*VsE#oQ+HwQbELmNr5aV-2 zXmQ!%f9xAyXa+(b&0MQCK58=^E8eslD^1oDW53Oc?UbF|>KA~rF}vYI0yE2D>h?^NfpR7AzYwXDRGKY17L-f93GUSFD ztUC#MIE_U0gGl#%*UgfVpwAiNwUZZt8+(nQj7v%KGR3KxIIU)ctjw@X7Ad^O?P|7W zgL-z}#Pd*C201AVF>sMPi1oluv@~}KuM&t7D3vgW<6p4`W#O96D4)dDZayYvQQ;7} zd{QF)5|3ZP8RIGqFd3AcCvbdn1%+s_B{y=6Nm*^Gu+K9r*2Bp?6 z#&e_~UV6Tj#&nuE7OlaN{=^1GLilMbCWVixDPT^9kvgG~PkF%ri+6^D5*K3<$oXhL zsTaCvgKCFCONiCmclCl61+m|tgfHarK3W+x*CGRPdiI*e>TmnXs~ z&jo=mu`vvl>qzvMPG7}b`2)OEAn}e6l)RdPiO;t~l4=tx_{J8f>6Pv4aI0&VEe8@- za^>L_mWo(AB&u+sTr7WvRE8O^4Y0HA+41r`nj(0=gDMLG>YA+k{~;9vK^4^fR>|KM~CYCSN4e>*s(O)gogB0a&s3`dT9^} zHa~)f3Xr7+hj2Vh%)x0idOcQK^ykJ~7|hmIKeznc?7Yb3|5`?*@r$$>|9?Qm^C9RQ zaWNqf0bty&R{lGR6UO2!l{&t@FGtXQ00K(jvDQcqO}K&^!4H8|YyYk!%HgGGB&-uQ zWt9S|`k5Vdy>}0yOMHyOOl7hdlHOp zD4{;y&FsUjg!Aai*_(}zc!Sn@tJ`f*DMsl+5IJ9O-}b;6Ll^k6msO_bZ;|2_#fEsy z2(B|JS5g24w`qTcnc3+SFS4Hd-_k)JUK!J}J)Vd60O_E9-Lk2s9ew7Lp{Yfe)$X#r z*F26v1}oi0t?Xzo>rv>rLeDSI;tal>zH+O#D&?!2G}`XqD2)4dK;+@j~eRe@PoShnL;kot1OfY$G%MXloG=`7jprgyjGPJ>0_tx*7|1 zvc~;N!JvCZ5<1C?>h)gEWkj6gbEMxG&F-(3e{lr*A7-#mvH#A#Kot6SNDs zPsi!Uqca;YT~k=GnJuT9lW*00?Q0?9FCcNKNxf5%F?1_?1LYp~{x$ zeBW4yQx+X+d?3c7=(+pR#uU(f{jA_1L@Ng|4N7sW-n!eTT3ZLHhN=F_T=dtwR#Rq4 z_d!v9wa$9_qtwkpjJ+IrqDN>`=^n zQK6K+psG}F%$Mbik1Ir)HY*d{#$iYOvw@wMFZ`vhlqWDv zLXL=@H}_}VnA85riQICvjaDJSb7bVVgRb=ALCHucrB@G+SjA)TPg2{|1yscKdJRM? z`xLK7Q6LoW$|hpva0Q{S6X8n4XC%>LJDzK?j&4)lOFZ%5a34!bNC4M;BCuj)0Vyed z+4&;y@z0T8S@-*NYv_SWjv41Kb#KnQn4e6gEIB>0E6pJb<-@Tw#pHIaDv*;l0?fSb z@c>AJg^U0?K7-fw)LjLs0Juruy!GUk8y{Lg_A3{eocjFYCN4Ypl!*^WJ1KJ z-?wgJsF?I=yU8MmOyEF`PWs`^@mBTFmzuibZxw-yjDoxfGU_|jXM(`-TEKZ;{L%m> zu_8gmUrN!UB@bFb2YBrCtc*n8 z$hOcQ9>cmp+@J_%2N6N+G@gm0^o9HNbBr5-+WdqA6JOHpwLX|RNijVb2pE{TPi}8p zgrjbwK+;Fxw16{5+ut+PKKy;)7We5&uU$!em}~}F!%#rnEL}>7a3&D(=Z6 zjDOXc5ja~eQQiucTH|o=&JFtg&F6KdM7T5_cDFQ-(Y}x%Lq!%Kk#R?r4&|6s!(;3r z4-_bKL`0U{KiM&-)ZfxfeP(#^q8s-!66u6TvUI;Uu#avMn_p~v`X=x&3=YI$Pm(m zljR~E;Y^a*Ykl+|zEk4N*Q4^cgrh);nPE!(JJ+HQ!IGVQ{bLl~9YG4Os#-P$u<$lv zmv$JQx%<*lS)_Xoh+G{15uK&{>sDyRI$y+@)h{~&J0p@)ZKj(K*96e8^&hj+)B8eM zbQ<6xD?0K&w>+ggV1>Re#6Jujj8?R7 zxL$LV7ITnR#&mQ?xw2Yfy?y%ttOX$EW#u29FHLOxuiWy}lLiEbQmU5NpFLO({n&|f z{1%sf7>`K*li=@yJhFwsqA6_aJ1yvpzWlw!M9h9JD`Gr`HF>s!Y!nwI7(X-4QWGlZui@hX7iBLcFn4`ZY>B{h|7MPvlj8KkeCO@Y48Oz$=?e?0yO* zLkHmMl?8HZN~$^11GN4?M6mGT6OrL}CXBPxZ(dg1`Jq851lZ`3VYiRj=;Pk0D!#oD z$`GI-e#}On2XNrF{o$;kb^B7LTnR1WKiuxgnV*k=CHtjV1ZVTV9JKl|jL@L`#KUUe zD^eGjC4YUkwks#u6Xw%aeELDgTXkOM-6nMA0!?b1z9ss*#xpW6ijLvYF9@8HHs8gp zANjO)Z92+eAG&iLm7!KAloB>X=~q7@tFJmP3X5Nu$5{08HN+l#b`oo5!}5-W_tB-< z;76{_8h|B<3k#sP0b$Qf$-42!QMITrVHo(b@~B_ISSxuI2Cg}#2{4AkZ9on8#<+Py z>Mod4<1EfUdLVXMU(F#U`Z`x1@$!NS+(LV~-q=i$%_~ynUCnuie~xGulWWJci`Q&1 zo3NI0qqp;^0VV+HVnB$AGy1}f)TPT_e29+b_JQh~g9@=Q4=j~LTH=Khz z(k_2tO?zDzYNxM)dFAoIES+9z68_RNJlkgvflY~0x0bMC%N>%c?cS<6JYA};s9 z>{X194%gr|w|TL_NPcg-y8)0qWR7XQtaEwf0A0W=!<1X*IHEg1`HGv_izNgZl6PO_ zDW7;dAlg^%EDn4Q;PE%da(T+g99eI{{BztAE6&&Zz4SybLS2r=u1#!37#M{!MNtG` zv5R1#S3KXcZp1*pJkfwm0mzInT7cn8VS)eIMcmywvvl9v=HYC}Z|S`3+Z!3BIJtwB z?ELkEM@4Me5A9jk9nSb03CnQSoL7mDIxo6m#&CAH&l{lmvI6?OC}dW&*MLaPdDdK$ z0K%9Z@-+}i#GH5Ft6t?=p-Lw?lua=k8shF2wli{QrCP^dsGH7Pw;y(uU5(=T{=RIY zdhpxj^y=Ir!EksNAQ<*Hpq$cwXYZkBu1gOD9_hFJ_WKy*SI;@l+2}r6=A9EE$aq-K z<>`!Xy#_O}4Hs!rE|Wuv8YfB{&txTW?SKjxXTS561U1Uh4K?VMW5_?4B zV#F297sqigb^wkMbqvS2Mv6Vp3V4e`%6zODwC0$Z-B;SL*Tl5c=(s$WJ{;mWjCiA1 zJubl&yZ^F4;j5cSlBx>)a^_Iht2VQ=SpbjW`7b;MC5PCW*1_?uv#Y`(vbW0}vrgDE6yG&eg<)FlqTaJRy$L$r+=ql~wiMyT?&J+u5G8fUF*Vh)^? z;;w(VbAYo$#`lDXQ8lM;TSfHS8WGG3FcLcsA8)22A|jAa7$DXP9lifzw?|wMXcXIg zA+YKl@J>9Q1j_y+Et8vr?MBl*^!fA$;|}Tki*YY-%2v`eSpgD;qu&!x*>6UGucWM< z?3kDpS8MvJ96uO^P>r`-m!0YN z0fu|`;SETHAK)bJ0i49UX@c38yEl4~A-BtAyWYJ!iV%)0-WD!)L}7jZMhNeF837T( zI@JydNJ))iGl0_ITH`tZ#a-cfCM+W=qjc-Aj`G`*e84z6`VEza6ASDrrRDrF&eXZ)WQ1x2-M;BYZa$bURkiUC_jUDA8 zplfILI=gVoQ3FB^1HBhIAf<$(>x$Z+1dLNzTSmw{5Qe+24`n}ds?$2XCNQ|Zd2tq4 zu{-jdSQ9V(soKE!fW9Hs(4Nk>Pojqv@RJtk`xXPEGJu^ibOdb=QVLNyj21SXj1S6i zn{vhGgZd5S|Ao#7nWWslK++7PcnLr=^=}_>J>y>=@oV0p+*Ov(#XGjd z6l&vh4deTtf!?WhIX+9sX~)MvDSDVv8O}_fN13y3lgFfie0h zxCW;H$naxLx&4m!*2b82v~+^SiICr|Fc~kN#>OP3@r&9z!{Wva&mDAPzRQ((1u7%^(lB z5(2FD8l>;k9?>;2unuWk;S(AJY=+6$F((Lx6 z02u!%ySjS9+Dzm%!}~!x(};^wb%HW52(iD;6r{{K$~q_!#Gv%K)X*G=lI{MDl7&?G zt!v#OJvaus_m#Dm4Jy6O{rIv9&JQHXrcXq#dh0!vT2kwr>zNW$k2h1zJD^B) z9}$4pbCm+R1w3pTZ|4&~J`mgk>C>5?jZUe812)9gnR@NOwLu_|>l#Yi`0Yaa*-5Ti zg96F!uzG^p@KaI^eX>eHf$7x*%o#oiMVt-St z>os_;q;G;{&NARCA=0|fk^80duTe<=ihg-{L5IAT3cf^ERlYTw@g4-IixJ)2rvR+G zjRpofv*7xtN?8LOINHSnUSPL+r$xQDC#&B-x+fJ9|Ju*#2G!gg>f0SNTJhE7hg2WT zxAN6UNme~SYi@#f$b1qj`&pn%A>7>9{0v=|WTqpoyB|d5R)TO~L244>7_f0jc<|BL zse_e|DvCZ1ec}R*!m-L2ZfdqClRKq@+W*Tv7O;3onh+4LpiSXT8?n&$)1g#-!2=T(H=q7ts51v zPA+X+6V0_)@uvmFidLdi4^$o*U*!+n+fVaQ1!#dl$myhs`AeGW17&bQloCT>VRBB) z$_Sg)3je90RgSd;Kx+Iu(87GAmf3C-_@D78{?QuyiQ#!9)_66(XD5I)=;*(NPIC}g z*-hTQAnY%#X{Ksa<(agpLz08FjOjY=vJm>F9bQTF-Ou>;t;?0%`v&f=n7_9O+7Efh zK>6qS!CBg>NBt`|W2v5W%J%11%(F%9a{$T_Ps@@EPsVXJ+(+UMA@b4no9#hNy4g*Z zw`s}IT^3C~?$}9Bs6`N_N82`sDXJ$MB=CZ|Zs*+ZI|Kag(J;2JfyS%;FNAb1qkvpd zS=g7@PZNK2$8pEHW6gi*j%|>Mw$7v7FRl@|KW3K0l!NVsz!5QM*#qT5l zD8~uAKToqF`k)Q-OY&f?xIDJZGB7(}_Y*YxYkXqGE4wMxJIX3244fAJ&4&-YXn8U; z@m2KT{4)@bIvVzs#kwDzbIU|mv(iWF1xp5T{HW#OE)}vIH)m;g)9q{DSC$|Z#8*{i z?AhxFA+3f4D~+PqSkEb!eCe@qx|O%D$*C908vdq`X|*_M06=^Q*tWc3prUT*IAL=; z3P{+DDjy|m^mSjHqtwNk?0Ca*tREX>fO6c?0nu3DBwgcC@^RF_e*$=Ttz2E~pkkt; ziSY-&?!g1_n3eHrM^yDli&4vN8uUi(h#`_-F#z2YG3EFs@ifjssA(zOVYDW$n>y3z zWXM@<#0Ek|Ti|IzFT)biedQjnSV(U8eefZU38g972NP_|O)sh(pZ>o3$*24{bz}Y+ zNZnkPXp{E+C-Y+>ZAXsy^Kjl@l=sZPf2vNYYXO(ISC;WPz+FL`vXePTk-c7Kt_Mss znzGmcRT7}eS!Z+{OQ7W{udl3AFXNooOXF6{f?hOBtt6tqKBYbF!TI3@G2SVAlMDF1 zcq{dh2GYc-Lpg#39_>w@66tZ8Z-2SpDcvrc5%e@Fw`8AcX*QgWk0X1FQv&hi1IlCc zoMVsdteq+iBZD-q=A`??SBBbALy_I_pKrf6LS15iz5muS zAU;l^d-ekVcHxJ_l1bD|nJd_+$BhG4ekMg4DRmk1PdBm1}8vp2<{pnxH|-Q3BffG+}-7N_C7mj zpL>78{pRU;x~95ob@j4Z^{xe(s3@6|qrJJ6jTsb_)TabZcrDdI+)P~+@>(d6iimwcXgrjPh$VEs8zDI& zhD@k`wuvMzj$Vt_x8U+HS}o`*N>|+8VDGBz+|qE^mb2He&dZwZ+^gJfPxs>~&*?mF zTPu7}MOi;Gh}3vUxUGS%wNN zZQCRJacA-D%ajTc7C?uhLRx?0Bfx^U{sQW!I)7C@6jW{mca{oSqOq2LJq#SeDd^Rh z(ogzV3aUTBj%khfTs>t_G3rfv(r{4klgP(uH_U`k>jXkG#2`5cP%dyi0!>XGkWf|f zdVemHP_w&{T2g2Br!Og7`GcG0D8{{d8y|_tM)0;B3Lmp}Z&sw(_2^*uVw`PWVdPE8SxL2ak#KHo))o9dqmWB-Lk{zb$_nN}{;PYczg|KVVcwO}+kSI)I3J5r2*GJF-Zj_*%9 zXP6U>^F=nmB>u{*={E4Zm&*)^2UDiCf{cS%ES9u1p+BJ?eLFxOH&p91kT>8V|D?0& z1QyyqtjTm7Cih0GU=03)zi)&IqXN#h7~SCq4q=7L2=2f+>JC;79$ZCQKV+4h=)!R1 z-1V0q*2T4#CTPX^Z&WbQ=E$H}{a((ziGi>7t88ni!ds#941mIu5`x2kf~V$qOQF0% z88EA*1oIRm1$7qEcRTC_n~ia17^2lX4V^#ig}g~w-H9FQB#b}cf30#$`#q)s<^-R; z%h!FoYbfw^>l^+4^YsJSeTK2{YrR1!crg1EJkuxt9w-w8wouD(!k+?-cqC{QK9#(` zdHv7jE(9Qw(25-zxW{ za>d(UDUFXm%?rNELSL-RVyc3j^EqI2#o~)5?j(SI!5778Y&)m?ibO|0db7lOLN|gx z)24{>A*7>|hGFM2gImz9_veIuItcKh}P_fOadAuCkwcW)8$l{w0Nktx(=SiEkpv5D;_7oyADmgc&itdR`e* z2uP7(MfH#kO3}yphhosNzeov*ryP!T88FX>n-3=vQJ~n4MccqVgW44~pv+Q2Q5UaM zrkp||{=}|~OAy?bgFS)b%&rrZm>vF|(~`3p*;Ys~7w`MNCEgwAupjD6z^=)cPFLA#4{*a=jx@%`@I6|V(C#F4)Bcuq9^X@A&Pw#YvCs@H)yTU z_PrJB=qCaXg#Hq&RCCz;h(sb-u*yvD8x z{qZS0bpO+34|WgQI;Dx=C$UMI`OmG=u~f{(erhs0vJ2w83e6&Wuf54iV&n(LHpm>2 zw8fZTYsR?6MaNdeWW@=pzM)NgsVGDBQ87hATV!6w>Wf~kv#Nk9XYq`h{d*$LaNeZm zU>!-Ye4DIyUT&_*m-QU1G77bnylM%v=pmj2czROxI<-T!`LDm!3%-V{HvNf%>$3P;QfI6Y=i2 zqrNmi4GT_y(+w!lTy|B5^Qny%l?_BGw=Zxk2WlwF7XnJ?D*SXA@ zrf_o!aCssf55eM*M)eYZlkggw%gy>icU?8vGzGMuioT zm1yg0?(^x>?qi6Ies!HZArFxYdd(momBw$e!>ScQ)JGt}kT*Ux@uo-Zee-u?*G=o00I<%XvdEtpnywRNd=MjPJO zdYYG6j8-vMm)Eshi`JahrP!$2I*le;4%d#>>)U(Hqt!Xp4cC^`w!Dj8XqiVooLzK_ zAd5J`Cnrz_=l&3$_TN<6QQANGraa5GR5e%i{d7|*JeH0!DUzS>EbViNYSa&nLcY9O ziH}kAB-8wRbu}3r<4u#d3ziEz+23m>-`C`JX!Gxw@30Cv{ zWXTot6}{up6@3AeEVV3o0sZzb?Ru;4S3`WZd>|dRK8o7)rHnJoGqS!kzMr0jpRa8c zujH;iK{1lO&1TF7D>1MNIOzX;B&*4e$X>{9H=6yq+essWKyFMvEW*npK}1p*`~z=~ zgqNe1Q;w67%SL~$+o8ol+WlP1*=A=B$Mjf2OCpqlfKr%>#!-Bujds6iP&p*;(|6_X z3Eve>Bzi|ec?e~rGhViETt(M zC(}+|iWiZQmYPqT6l8W-`ubt{mwtazR0mt9XV(Gn*oKpE4#x#vdr8qN(XiZFGfoT4sfbJ z?gv#=i&S%&w~a@QtYm^?J}0YY$&Sg7f~h94%))ifBhJ5Uxr83}7Oa;KW`5R`Kl&Ub zUB5|ri+z@cRJ#@pNt=?m3%?M~Q8YGN3!y_)y;7V`r%zqr8ns*KvQi8W2=hscQrwoe zPch~-J&J(m(B|MC7cnmweV<}0(DKgpI{haP-7vJ{^HkXgnXP#K zJL;RH1(iA#X{&8W#VsM;Pvjuv1-vMOM%T3lcAxo=j)iAoXDs3F;mi-bd$XJ!Xp9Pm zOYJ?jgTVzo1-S*>iMPy)ReDYy-_Il&`pPY}2DP;7&knyzmyBsPs@dqt>oe&u*S&_w z|Ii7qlb!X^PHH;xEbuk+PB5PC`g*;8yI)~*vZ&PX-O}{7Pcbbh&CU*OWl70aUBBvM zV}Zl)=Q2dy@u$9rGV`>~`ZHU@hVXi~!_fKfI=>85YkoLv$LZ8+=q%P)Ka>x*yl~~7 z=9#iBpDklqeQ_mq&A*z~eBIYx>CJSXa=(wJMN-5oC8#yy_eRco$9lx(;Ju99-rJX+ zMFsOEw?B>hyBDLANs9TuIyn!r?N!B@zUU8+y3WGL+5xA0I8z?ZPvk3%Q_#1Lw6hf? zcD-9l$>t~=s~#f}-1a^i@EAW2VP<7{W8mB}H?g(gdg3;_ieBGR$F1ksG37k}%h9Pn zIm%QMQjy+D;BYy@IaU`wOIhx=6x#8j#tC9EEB`cV(coy;)~xS-f1bhPhUhkYWVKY% zXz$)}hrTGd*Rs?cC4k^Qam9MImLb_H$wIO%_%x}17Ic-rUOf0C)naTs>H_9c&qv_M z;~M!ie7vo|_x+Rh<>c0;f5*eq`+eEHeIIHM&J)k?gpb^dtIe&pyU}|c&&=1$+t+5K z7lH>j0}t+3s_TV?S%naCZ|(ExE9>)yN_#hWM|ij%Jw(kX2EWd*FNH5oJo%t%-$Cu1 zKqQC@-#!l_=f15O!n{$``XCXH#|^dj^V!Rp<)LL4#%Nr_{UP9P?-z7vE;PnA^u+hP zkiDPU@;>G9I28QwHeolZiD__8^2+HvzM=QqxC3hX-^LF+phQw35?3TRC%}#(%uGw# zTwWfE9%v&#!9Wv0!2&I4;41)4_@^xaO$+tnuYM2|REQN6%zy4t0M5TZF~Iltn7_|2 z;)0>zfnQj_*F78b&)uM%>=*yEVTyojP{OLB($c_L)zs0<%+ATu-uYN701R{>I!I|d zK|$eC|NcTtt55+`g`Txi({k35m*X|Hw`DedXK!N0>~8Dun+_DeJ1@|*HFGv5bGNmz zbK-ReQ~Y%YFVOzo%|b!;*DcQ0U8@mW>#ia3IQZCGBSS0cjmk*ViNxu z4*UXBSUNj9@UpPDxw$dBaWLCETClM3@bIv(va_(WGXZxnIeFMQ8@n^vIZ^&i zW=^J#Ru0Zq_I6~y=^C5ZyEua>D1JZa&*$%Xnz>v3_epk6|9LIo1zCPyVPOLl{tsJvZTzq`zS#2BhZmS;KQA9kB&opvWLZE*iQDhGAu+5Zr{t0BzSpPcY{XiMqAjBA` z{~m8cpc>~qS|L0C5=am=#rbzXZ4D@mbZ4X7`BaD>ae-GLT5A=VNi}4FYP|D^j z;?TnR_k*#rg|@-}J4ZAMA^)T7F(dVVlam4_c>S;00i^$bH9;x@P?OVkBD1i+tLTgTq|oT&W(=er_T(UqBE33&NIQF}@En#_jd>XgKC2Qc<74-!ZMKjb1g|RKKl+T( z1fx^uDIpPoKeodV>xB$cyBP}iqrqME1=h26 z!VH1}u&UYpAtd9}|JWJATYp8t3|dqIeykHmZ8F3;L`J1kUlyn*C$3Co+Bl+Xkm6Mi_{1M`?hop&6sO(*KALLg{D8 zL@C++OV@lWOxWmrYt++lce22g=oi{5!o}`+m}zc{Quh6f#fbPnP6UGr6zbG&Gp`b? z5&>_Bbm9K3#f4skb*5N#7W2a--NdieEJpu70w94gA4?yT4qfj=FI36y$NpLNgDpk* ze2WRBs>LspBNPqKpDFW)v>=F>uRe);)!B}J@1~AI??{qBm6+V^ye3vMnp0) z@gT5nJrNd;3nSWFccg!mLr4TuDv7zQ)UZQgvQRNgDM_w&7Lmr^pvGKYyUDTOD4c-v z{Q#f}MAIzWV;P^%HW`L)&+$YwD#U0etY^z<=Bv##L641$hV4}Ej6970l9>NDELJfh zAN~|9cz>TqgIE%9Gfh-qP$SOE9sff=HdBH4wQf;vOCDuJXVG**{aVPaiq0e|zFwRV z2-`1tD1%Qky~6Wyk8{4pB6|2Xh21QUh^IR39`MTa7UP+m4NX|Qpusrm1d)$Oy*mDc z+;#)Ss)d^uyFVNOF=(9=z6wTpMP<8CJCkMzIV}J*cHnLN&*6wy95Q3+JR|#O0&kRW z>OlLqiA)_bL-BNvywNGk*nm2ZQnU%-f6J>R#7Jl!o4yk+LLqLBZda-By_hxk}G( z*D>~V8|*&Ycj%L?Le2$woVFtRox)!>DYk(Oj~rXgM;EG{wwaT>5$nFUKh~Vh=-Q_y zIjLB3)u-pGCk6YBUC#rN*#H-Eq`$)YD7F?VP! zroXC_pQ^65c{Qk&X#6nc3-BO2faUG=V6{h2lm~sF5%MQ-b6s;chrsYIcs<^^cWjQ!(^_tE_E@oP51NzqC-EKn?LB#%%zHb?5{oRi(+%jCw#k05tQ=%H%H+Vf*a-baC9gXj{YDn16 zjj}VXnL*roW-;Tb{F`-Kh!=M^r`S`AenIFj2--Z9WW$tzB~&6`41O*g*stio ztO!@i?ngFMQmjXIz6t48T+;RY>94}>c4Q+ROYt$~@FQL`-SD2C)8Z$FmpiA&IL!?` zSvhS%N=VKn1&c*^A~YgOEwb$h>6<`Cc_6EiD?5>yJaD)QrFR53%RYR0MVY=0Btl zfV}izc=uLY+*me!SB7n5$VfIux&mrN{7D2Wf3Jm+gxD))WIlDSPxCo1cid<@oUG4Y zkHwB_`bV`Mi8a#<^Pj;}u8pp&b%z8h*Y>k_D`cytdmYGjgI)n*Ts1@gCinI#( zgH*DGe55mY>xjUfa!+^r+0|2Hm~#6EOq)XqvIgFlI2^-(_b|IU;PGs6KV4U8ah1mj zD~VrnGc@ir>i53C8ZOnYF=fJoZ9N}j)h8__<#m<<7LkwY#4^>wfp8#Xr%zba8$$`h z0YzNHNzd7gV@?Uk11=fkPiziGzJM19Z@LF;?Z znvSAA5!t{L2HVnt({AbSbmA3nh$LoHCAkj9@%Y5~c z!UCht0LNMV;?48%ju_>D`7{lcMhD}j`=h01L!bLYx7*uo7td@0Ku=o4 zx6j93%M&2?y?o0lj6vWtt`*XYi>P5jQ>cXK+;X{uhui>o=#j%&DN9Yf2#*xO=S7&q zr%J4ym)nS*_9rG(7%ab)>-KzGQ?T^0z-~FDt={x_rR{7|wk=-V{_`TFHw;I;>&ELm zc`bUbTwj+Hd}}0~`li@pr1@;oUN_%qd%N~q%~3=7@lw-ry6}hnnX<3t(M9w7L&Jqx z3J#bHGfsg1m+yxc!CeL20pURB(&HE(Wt|kKTcdX83xv{?U|5t7o3e?Ji9FKAG>VJz zMx+Z~m-oX-hCX(&sxIOom|2-) zs8>$_kM38)S!Qf~VR`4Y$2;p;W`)~@@|EOtUUL05C5#6AVKV<9N(>qQr;~1%cV`>Y zB)v5mAoDN4gUze0XS1$E*A=q6Q^7WKx@>0)ZblQoeke9XvCT~nSm4BC?0~(l62-%D zrK;ZzMljkXg}P7HY!9h2cG7)0V(Z3`!Rr!3E((_x!iqS- zP|^C{?!FmI(;qF$eU43~P(fc!s&~QPxu;YAY?hqhgX^4jeAc>I$~0YMPN>Tyw{07)%UyP6&yUxuX1kMSL&STbj?aTRt3BT~5fC9tZj>K#DFTD+hk@0M(E%OVJRrHI zrC3PLQ^u8{vJf(NEU$FurEfobdYz07(_Eo(D1_i_|M-)oW$w&=v0nZa-(G(rQ+7Ww z3&7MD3#*I~Fjx^nMKE^*vB$K&zbr;vDayIlt-JSZRX2?0mbqU9Ufj zAJD%Km+G;47WxLdSK}&<@^X*Vk7a$Cl8B`U8uLE><;O$J?hV%R3?E_Oikf0 zorC2i(K`w5%>1cfqBZgXMUFL)7S1`hJTopKp#nsVZUOkAgyAF>FM5sk8q|Atm!!ZH=-z<9cr0)m5Oh_qt^c-`d$=j3?5f^*Gf!JlG5S$$#M*gwBdiZgA?2XlA z(J6FCn#Myo9t)7=NYEWtRxGp}K5llg)`xiw+bpSPhYp}30}wywH1bS7uy&PlDPPV3 zQ%B*~8{Mduhs>d<{U;>^X9hmQ$MNs&LRu5bQ5DRb1B6*Y`@r%|BOrd`U2Y2NS#QHr z>szqOg!B!uHWwa>B0SU`q=2`R+*xfgPQuLAs9B~%ttjBJ2!_kB#M`NK+#WY%4X$Wz z>ptY5Zmv<#6{i`KoQj?65}=?*)w7I%!HeoAv9`0>qt=6vZA89t_-TZfWqlAreGj-V zPK&c3L(YfsU#aW#6OsF!bqM9OnGc)5t7Go$6jF#E%|1Q!aUKk(a#|O4=BSP?x3gHE^GBYbH_p3|QQ77s+B)~|KF~b~y9-{?a`zp!2= z@yhB*bOYCIWE7?9w|T6Oxb4q?`?TFwQpB#sf&JUd{t!J#EG9C^CBG}<7NHyigCR_F zA^!{#`1YMFvCj87ZkN5;uhDk*$AtHX0H#5dNAkt){z)}^5z%86tv)H&xt)AIdH>0#Ylt<#RD1LF$!n=eUDhzkgp4~eB$~^eMk5Y z!i9bVKbf=x{Da+L%N@)5^BTg4`yX!468Ph{n!WaCR!2TXkd*`b+wD|g+j;nJCMG03 z&k|i}fwqf2+`oFfQrlE5u1+bLLB!(S=tNbEn0J#>;{uDyhq^X4dj$#V*)X120xYr> z1`Yj0Wc3fvPu!!M%|~1q4a)@ZS)gTN>hXIliV=!(yGGG()!{J8wx#>TiRdLKH3wIX zd-4wVPWsV!q22yU$j)l>s?KR|-}E2SeYo^+(@iGjdu9F|nKA5d{D?@3Obz6{H^ma~ zm2S=GC?^yIoqFQ5((&wPbOpGFAkRR~aj7G*+GTj}^DV;yvvzbcFSDBWiz`h^=mP89XLI!sw{}^tHFGiD@ z00%`#ebzs1opr)Dz$XG*KV|ut4f@bXM~Hr(dUoD}rr{wCOZ(ht>r3;4gV|$FCqf1d z4S%ei!$rY;_O*$*s;r`UW790Zy|RX2nft55kvrw=G+KyGRr~VkZV=4C#^{}GM=Rfc z6IhY9UX*;|a4CRpA`+f7&{pIsu)h(I#-C<^I1){g@*NF;lEJWCO^ z`r$i_NK!#z?TcXiG*2s>j5+0o zBT5;yRoqqP6nk5>QZ3=FkrXo$5ufyJ=16=ty^pVK3ecAuKZxEgCt(IbddO5!xWof= zk(YE2PM0o)1qIeACrDL{kqZ@{vphK6lp&?1AnFMKB*}*xkK(9kf!w0g2m25@E&d1t z-=V@b)2JL>U+-Usg(bdpf&|#Cvr_{Q$h>3LEYDrUUo{tgZwAEk^iS^IPMQ@4ZJTNKcHv4ym0=1t zls%LpU{6_B!G{zM3+d}4w!#|8SDR}5H^4S2xmQ?fEQ4>Hx|R$s*u>8gq6&fW%#%P( zIKFnTK{_f`|4YC?D4VEW;=@`I-hhc9Z56F)Z?43Efv8(=b~@2%Fc< zNF|$!WyLOD!}|5kxSXLx00^@WkAyobZ5By013sVz=Cx2$$c<(_m$irrFXFj^h^c5N z16>6xjj#~#{gn_d0F*)oz{f_o-dIjZDIVJ$RhAj~k-`8$fuE;_OJL@3R{W?;YHYoMGJ*6VCV%zyj)xi7D9B^vp-xQb#W&Bwczlu5bJ6Hl8H<;`@m%M}MiQ?~%VMoryi zK~R_~i}LMZEyRr8+>Y64b#GcwW;jtX1=wlpXPXMb(V0}{w!ASLdPkhl_ZH4AO{IY3 zVy_{pc$ZBaj75=WR6ka2HoSBA0{#h0PT^(fOFaKf3UQ>vJ)^1dB1r)BDS=1Ugtjol zk@B~5Yw#;UH#b;r_YP4ecJg?B?2WH@asxg4Smz2gOrF>hV+R?NajO1A2vW&jWLolf zcBu+~4ywuVhg8P(qPtW%)U-w(A0oK* z6+&!3+!8SDrRO!q?DExGE|j~~n?5$>aoh+ULt4E{GCV4HP30JA2B0L52@Io$(%}(~ zWwJefhBfAOER^8Qg`C1AvB4rW8ZZ0v-M)PQ zH|f>8-@J(O`q@vaDP3= z5V!J8t4Y?t@HTeJcS?T%Q&Jl`+6(YLt;+9qMB}DpjC?7zW*`4*adMfkZEg&)=d==c z2TCZGBy`cwEJo<(Z-8le7|8w10`k5( zXp$K*Q&;U;t>@3;b&-*jtqSAHld}&DKgc~Vsc27JY4dtj_!~ry$B@h2w>@gDtNslm z%#=21`da-Wa+7mFnQ_wk{v!4O1ZFm)s75QDJ%MeY;bZ7=X`nGYn;Y+R4TOu{3FUK@ zC5C)IjR|o-3~s?9LHoT68M^dkhVu^z z%UI6h>it+I1RtQgB6<0v3BBCyY?s#(K)g`|mM&uE*8pCsgpH$qsbdwSV>7j*eETcf z)?8o}=8ni#|D%_jO~p=s#H~=|1F3PMy$8r~~HjhO`rh`H;mgY2o(ikkL&T|ES~FT9eBKb3x6>Gf_3jq!)AW|u zF)WBq`(7kGVD3CW-B%!8yUTbBO441YaSkQC`xK>oT*iE)HGdAoTs~1QgxI zC#6~#U-dhT|3sA=&urWH*(rM0$jMI$+blfPVK!SnK1^uedbBD%av19e?DCa)+>V(0 z*cyw;)GG}1eYf{eFO3nLO&7I-yUKbSuO@Qr2m49ANZ#0OAosC;`;xbeV_0lTsJ zV6kDfEIc@NwK+mw$t2qfz#!GVD=anRU%;c?Y)qQ8!Of80`98XQ-aU@=j|ruJ5zeYA z2f}}=2LPp=ZB8dYg~3KsSzfQrKP~-=f_ivvu(?%#wr%Dc^M1l~h!c_=1veGn{P;Ro zdh`^(X>Smr+eHRxBnYOUruRql12&d%>%Fpc!y_NG+ac1l$!DoR0`60&kPQedARj58 z-Ct<4-!%OdoKG(t#IV!$7-ApH$05(CE0t^-=ZbSr zV5Y|6WJIu@Kqja5UIxh0#IHJ|b5>T>4H6ln5OUcN#aSYlQ#Xo$a6wn|ADBWK_u!!m zk(~uovCc{#@6nZFGhT<(lDym@?;Q{S3?#8Lgc=c@OFDSEU+TyEe}8{>2U*|9KA=%>_u^`LgiP zy`zWqe7OHi4J6~KOhCyuMG6_b=E#`vUfsc{TdoidRvrZau5`u(_WUX}*?qN;dtIOE zchc%_O0eFuXAn8Ab;07icO~qmyF-q>6_qfW$cCOQkll{a&%%q+10|E1PGpluK?BtQ z$>m1kf6~VSPdAhRl=lTj7=$Qc1o-Orpk_NnSFj)4@c}=U-4jAws#V7Wtpttj?qdI!u}$Hq*958r=jcmL6bFe-|&j4TJKYB%UVz z^p#!VoTs6?K&SzG4bZQ@ult!IkTnm7Vs^g@_|68#TEP*f6&I^Z<-KH(%_nx(1Fhew_R!t}AftRh1eE*;${_PkI@kfmaeIu(Y$!g_q&JMN%0TICYm`#E#$45Bf0s%; z>}3QT_S-2$9jx36y(UL-AT(y7Q4kyK3=Da9eFT30Z5wUA)~bd`0P1WHWqp~JQR@a6Z5lFh-;P6Wy)Zvy7_AGrYyKT@Fg(XY4kKgs{U6Y3Z? zK-#hM^~l-(Q22%p^!j`=(fFe)YucXo-p+>d91nc%OEqO@>r8fy^q)vw?C z>t62_gg+0J3)aJyb(sxmCf>=X$_~XBk61r6f5;elTHW5_(tMy%s!--Aeo(Rnmibb- zloS7SUd&Bja{fRVehj7YsmVq)A9P9aa{AE^XI<1h&N^U+td1Qv!y@!4CZA{&TMcE+ zUy(ff?{@1uMD(c*3^AqNfWWf#L}%~P6ym^=%nig|K=$?4ZpC@N@rb6Ozlp;bVS_`he4^YPIx&;mYw27?tvZ_=M%{-pdm0Wr#2X>9!3?*78E)O% z7}bqyQJT%iW8VZ9ujt!&L2?fHLp?>A)z9*Vj^~ETlkdCYf?D}2HvNTiF?Phm1<9fX zr!|0*$laWj1~>aVvq%WvJzQl{;M_ zwiK=Z%K0=m^=C(G;e{IO7P=v~qq(p89O+|pFE3m8j@u^dRo%RIU))~}Xl8k@*AtZS zIVW_9hwnE4Aoy7(5r5^lt-ukLec5F+0_fw0u{-d{b?2|hRKMG=D;pO;(dV3BatD~iJh z9;szz<8%|_vwZc)krOyG=++S5N@r_U=o{|wpA`k4bjQI~uiqbIksws;Xn_#PCpg{> zF|u@Usc|%VZicmjE4d%Xyc;RcR?-Z4UH0>w*7=@mKIAQD!gf4)o#Dl+D)(=8eLS~2 zcc4M+N$}Ip?s)5x@Zfcss;w7wQM}on{%SKvq>0LK=EC!tvq07$y;()$kk@9*sY@p3 z;FU9{E2-dq&|W24n9v;ZMSVuIbm#riY(|sWx#wYxhw3Broa*=Wf{k6*@!e&7cTR|s zVH4yw4ouh(Ch-83FBSY)0V3Wgb zy%6`;3|*&V#@`T6Y(k#SdUcqt6xDQ!7s3G(df$E>KkI&?HNzp1I_4^gV>R zs8dS0KWfkArWdcdB3b8IQTtM}kx$)$SjL0|i8XD#rkI*i6YlgdhE&`D8XFqNrL0I$`Xcq&Z?6|S#o7bh@{+kRl4 zqtK;=|58(d(+~d|g>k0{9qa8w<(q{7yF*cHO6T~<(s>u%W0mbJJ}(JW5dlUEg{)fh zU!D}?7->S|-fjlc#Yf=$7x%7dzD_CC?_wdh$iqOjFs1L|Dg(aJd&T+c?fBYVj-7k- z>zr8DnD0{euE)-V9zCn~#G5$^uQ<%6#U+b(SnpqUY*vy-Ty|?RCF_sz4G?wJ^OJRY`(^F@Ro7lq6?1ydc|YQ=;KU1kwC3s z6N)}p^t|RbTFEi~H~~?KLmlV6DQTYkcDz<`U&ITy;x>gPS1xEnSYDl28dU=AGe?f) z?DM1wnSz`jQ*E2=-h-c)=**5rnVUG4sojQ%t7-Pq50n#a(=8O|e-tD>G?bn{>ow8q zJ`0$Qo7inj`6g`)$0^twDtR<452bNC5e#OKm#z4oT)^@`UT>{tDocH7QIQ$s*H(La zvuC{V_1k(o_g<;%D%%;ptXMEmRCsYchHCa!zvH>_!+@D~v5 zXF(#)o|pX}dQpY-I|i}in7l4Nmn);S=bxJL{VExBd|G;C+F+m~zFk4+li0gD7Kg^t z$~f;Rw(5*Gjeb!H-KIZw>P-A@q2BDXYiDP4QDG2icd)$fP@ow-LQff|Fcr&_>zCc( z_u$}5Zb|WbYZ0kv4~uMmwUTnR5^cqkY-6gMo#$%vkBq5;!@%F$rF0k>Z{9zb=BtWy zXP#u&T0TYK3uI|%;8Wd=Ze!RRE4)-><1n!aW->9I- zB+wl@GN0+UJ4??zx9TLYvGk$aq(v>~E5+_KFki7(9Wr}L6okB|b4z}`)n=X^a&OW< zW9Z_WA?P+XH)=*f2B>$4H8JB)DazG@LNRj%t2;40LojdJNbb4Sb@ zyQ}=DumX;v==1II!CDrY!Olmo+I^$*!bRj26#~1U0k@|m?G%nj*-g!k?zf|6pNCh)z(>Wmp`e@o)EEfoQCp9yq-KQ&lBlVA(dAQiaj-!*m&}xzt zywM2P^E8{BT!*|7&lp`LDweWxoe)%_`b!U!6#oTQEbIh%YYzhjK$rr z@{8)TUfdco_mG<|nwFcaiW!X7xhJx88v9*C+rr5!`md4uqSbXzZ=3El8O&~@M430K z6jQ}~c2`wYiZ&zDo~08SzO*1*=0er;YcwASjmX1T~7%c3KX5T%-UM zYqK@u0@rb~`+CYp+`uy2t}FY-M=bOGtajMSvtQkNwwcpB_FwzsCI<~qMcsLXoAq6JqL7^f&k zoFGlw#;{}krAHW$oPb#uzDKo-MbiDM3^c{#urz6!eZd3H&S}%CGJ1)SVYN}c+E)$P z$>Nw=i8HE+j^vBjJHCBJ0Gj2lP8~*;$&V)FkVD>5DHu+>FJo{=zU~YqXIo)k8#SCw zGEAzq%6oK-bUJA;!x?lRzMXHphDAS+^2gn|DGz38VUwCI3UT?w`*5jawnRMU( zhPf_j@bHBEXN8dA@-gCI9G8we_q~Jv0q@rP18d!aE?HA-fk4@G2cEUsR)q_2LFQQn=+E^RvAcWHUI(@>7yQ(5V| z&>l5bv-|CX75GDON{3$i!I^Ohfq9Dq)Xcfs;Af;g+kEnK-`MBJv%;!ZxWj0}z zM66i2%zas}-ULS#g`#%x?Pk5H+ok1PX+b@2j?k3-vLb`ocotu+3wH;>OWlUfyf2(Y z8f*_YI-gJT0-9HHo``wfg+6BKF@-z}P`zS*7q{m^^1Y%h(n)~e@=NNQ&CsgiMflm= z4LX&bW~N)a@`I(*v~&Rvm6L8{Hl=n)mkd(D%1XUggF{H@eUvg7Z#nJho%giIGyXZSW zcDs1aexWx!XRoaUKpdE8HH!(V2PANoEebrfgqy$W`Jyzy@YlNR-Bqtd`xut4&>pCl z!@teczBH?$$;8|c)_Ls4y7gJpYa5F`q4^mt)Ze|kIgIB*l^r+)eqnz}LaVDhqz)N? zIbBY-s>95$rtPU@wq%zj=^OXa!N%kdPwvNDl6 z(FjZ0F^Np6CG9_wc3k*hb|XOHCE=Fw?s&Ts8lhl)3{Sfp&8uT_MdlsaI}uSlTnGu6 zcp6Qc8O-9V-*;%cA)(VRkE=iGHgg#2K{pv$#8^F6S%&fnVuJRC@jQyK+PGh7(AT3! z&tT@BK2D3>E7sb;sF{eblu}f~J>qPM9!l|Lk-dG8;Z|d?3p=TpIgD>;Up7jo*D!w0 zz#8bwfQ)v zbeWigICZAijMv1=0dTtpI>Ms8AlWw)^kMMi(x}&FowoI5^C?@oJX5i&;l(ldiukRE z0YOBj1<}lKri-j>;of)qHsi~X%T+0iqu}t72-Fs{zF)g0k7+q3I-(eN%pQwgvd<>11KzQ?G(|M{zvZHgT3(rQiz`RbR>Nu{OyOvvtP{0*RK+cVt@;&2pLh^sUj{&w$BdLHd? zcHDP*ud&+;m#9mMKGJ5LtVx~wn}H-%@Yh8K>iOjO2? zwtTx@)a?4+gB)KJ$PHbJS+40x9TDymP4N(W*s)5_81A_6rr@_VJ-mX$2~o~ayyYI3 z6X`!zD9cAgVE(Q-tXEdxEEBPOeY<`Tw zmGhPu+Lo8iD{nK)L}E59n;TCXUQ5V&lVqx+1iF=B*1(q2Nu-{Nh&BnjT@Zpwtd;K6 z1}}A?8z+h0dI%%lC&N{v4e2A;-kc|=mL3!m+bxGh?7y{5p@rei7RZKF?Q_|@wzB`k z%V7CH_E-kT#iSVsb^UZ3av5XLFEq-`(w;kO{Qt1`mT^^X(f^O>P@5gS6fFWG3(Q}9C#H5$f{TP;jBz^ieRH@2n-}AvY5lS+E4VS z%uHgeaG2PQ+8$KtxG1e3DgDwpm`$aO^$RYo9-K6jXPT-PlBYfTW;ps~lEs|1pOP>l z*kn*?C_rVld#-C?EHA{3@7TkLNF6oynTMu@0e+uPs6uMp7}a8dcTR5{HjyNi``e>k)Mw{j}m*0PsQLWPSq_8 zSR{`|x@D#z%p1C;o?Pm9XThsBzGv0Pb!ElLX8TA$PeV1yW`gbT~$ZZy+d#pjdvNxoO!nahLGK$R>$>YTK3bR==$ z9#*u8oTN92m_EAch4U@=b*P$PK9oFNkv>(h-)!l{;biE@K06B2s20_m$p)xR<4a;) zOAF+&ca!FatsT9?6e~EL#(pw5nPV-6bCkutwYSeip-Qyps+?$}@ByB++qrTN5AW#J7x#yx zUbts@Cq&BL{7?Si|88vmfJ2jBa9z+ zKcV8L<_}vjC*HfYL(ZlxWLo=x%URvS?Vga)O+Sw`bp5)Tm>Us%tedWnu7YB8NpopJ2hO z{4e{g=^UJGMr0w6o$a-8r?xP9_l-1~I@|Oj25iM>roZIh=U%y4SF8FR$xX+Su`#%^ z`OcJ3;bXXMS)1bGw*^0wdjf2)`oDtQlgXUHe3PBnTcrmK+Y$gTeN-o)eye*?-8sDif+BSUoJ zkH>8|<7iBS){w)3^R#UtR}USMZQIk)T7VPqFBX7Z6)vSUKMD!viCU%?+_A!QrzPxn z#!7sF4pY=W&bqgh%wZ5K!LpKYW{C+ZySQ08=r>R1+myl37dMOy_60c;1#X;*9_iPEw$ zK8J;TwDU8YI_^fp2h_k|gjdL^-^O;Ir#XfD*BD}`m;}hc(3jldShhjowT_r_t&b4` z#qEy~k{O%adp}j_`8d6By|IiAnZD2E{|qD0BeMBIZIf+x%NNq3^`w$qbZd{3phY^8 zCAAq-%!7Dn;tkqV#od8dSaQf`SUbiMEsv@QfJ>IsT(Y zCa82;lDQrx$tcyn^})`)F$6BR(Tk5qE2qpcX7FjV{HgB>ud^y=2GWlWzjKujnqnH0 zQFpSz)}#2m+tu7v`I7IexifWdR2>@$GtvCu<%3_!3UX|dVM48H-EXTxgl5T9^&2t# z@G5Fr*N#ckC<%QeGc^lyLdaHfWb?AR)bK?5NlsirjyOz<TKSxcAH zJAx2*awKRb5F)8_&?uCJHeR1$5j?6NaT96tcZT6s!)FU<8&`-8FbU$Q5I5~=_+(%W z*&7TTvQ4DVK_$$_zAfZKQIi(`_g5G@TalURhyc08t+7MI@=drPJ{^UgO&Bi4V5+vW z#5k|@2)ck^Gj1VUjt@Cf1!O%rtNL7>_VGKF^t45L>!ZYW#r3K(mTt8mG_3|!(qnxs z3KhZO;>g?*4vn#w*iQm^bCw3Q{mgs_Prm7~8>mMMVA?jS>B1-|PGq*-$LMl9wWqCz z+p0sQIXMcKgdW>F&%%x9YqlR2?CnMkTToDw)~Ij$J)?KZ#fm=oB-rI|U6`h(R7Pi` zx%yjYGy83dMMd#O0IIcAqGTHe1#dHw-V$U{{=9t0_3E1#Zz~AF7?WuLwtR zo@3IOb>hGvKbw%U6gn0ae|4lK^U(H1cA~O^0hOa)(EZFB-S^apbyf|{1k>Nobt!Km zs@$SA$5vNvs@^<=W-vB{<~;!Q4SO+Sw`*MTt)JJS2umeq9Y6)OOCCv()vR`_W4&&N z?bqZa#X($KqW%!+!ey zy6y593hzg){rar>n7HG|$yi~=$Aki`sbn%tJUW?XCWQM+vtTM~gC>laanm!v8~TF1 znd(t#j-xb)K(VM~NKRDt3q$({%fHCrg$EpjyAsCtnG7hM1=dzUa8;kO}%a{DuD78~(N&`gzM#%FE=Ma^i96n#noiyMagJI1Q=j z#euV7c!}xXx(?qQ618U0nu=7d+!Q)bMT^i+Q9M{=9XpH0eyjOBaoXa(O>b4Rn?pNH zlJP~qZFlnxF)Nb%H{rUwxQ25e4cC8k>p*GsnGm+Et7P!b{#^9wXRI;5w@G0{ov}If z#5suNFPnuGSl|48S;%gETjCjUhy4xCyS42EZ5dFd58Oq~I$WLm4-r=PlSrpXTSpphj>@xrxjTtFdDC3(3-^LC zq2g`9oej*cG^T|-M;iOX+A??*W>7iIO=w+!mLqU9J5XeY$luAO9@gWk(bKM*$|BW! z7`WH)74-`hvl4s6gZHwf-@%?*9y%WGew$-**dW(sn~%L0K3qE-Aa%bPBCpQ-q)EW_ zOR&%LfGzrH)Q2zCH`A>t^RcvO#_jg*m)TM*|6$M-r;~L(`{Dk1dCkR^WUns6IrXS^ zhUcEoN1rtI-_>zx1DjU5`FDCU+;$-B{1L9adjiqVeLkTJ{yvfvm(dGGkJ@}3@ke(zU-iX!w3^Rep?ZwU8IpaB806FbebG(9`!NPT*#+i9@)us`Rh@H zO?1wS*pJfsjd%PG5`JgrJ3C4xqn8Q_m|F#LuhG|%Vkr`*2~vHbjtlm&47$hvPNpI> zk+4w+o=W^KGQzw#xr)AjU5KU2z5H48D@1i0R~58R|46xEU`!`O2@cfn&3DC`yS+E6 z-@tF18kDq*d6*99V<%y;E6%Z6Ch{8H<*cU=J z>HhnVXVjR@BAcHa*ccqWqd9!c8zz+fRi~mo(5<(&?d6fJx&amL?b{EF@3`b)H;AJ= zAl_~9z9GV;8P37T0<|s!OJ>W|>WO5GHjF0yR4!V@(t`c1>4hNG zhjqrB2`bM?+g&VjJl;K@YR}yfsV^E&mIn2PYAkYjG9Qd1{>b3;IQ3QUny6)zto7WK z+a_d6qWziisyZ@XBDR}ugC^@Q6W!EzUH_~9O?>D(YOx#|1m5XjVysr~&kRg^u^FS> zsYV~ew7p*_@wv_wyP|jhEQURGr=yWOWCj>r0cRip(I!*yy)%%9&7NNOK*+&7+;qsM z?X>Mf&zDCBNzMleY1rfvuaMl{ANj94q$}V?Pd={&#fklH*|a3iR2HgZ2#}Z%MO>{t z+4IInzxBS@+Aw)Sud#fQcc z(Obd7(JXuxW{w04KlO3K{Y@I8-5Sp5$<2QFlYSXWceW}!R*l=IJm-G^71Ui@d)kxH z#2Z!pX1J`E&l#}i(5fHF``er(*)|?)#Mo~?F!s>d)>W`{<w0JXIp)LjWBkgu=_Jg->7~#eNz^b1l5uZYgr7%0dr^Laq3K)_4x{ ze&zblfsZi_+{%|hY5w$E+=@?a% z1B;uxFL)dur!ZnYol(Fel~&HOp)upf|G~V~T$1mqR>j~bR>i=kxcpJtFdQppfrW!r zO&(21v-R%e+Ey*pXrodWrQ5Kc;SrV>?jL-4j%5zzP1|iL-=LVH*`@^yb*oTvp6?&Z z?AjcsOYJ^dze`(;*Hd{?zdgy_I7ealNavZZ%(u)bH?456UCy}LhL-XAP0}%&ZC3ZY zHE}6^CZjot&tQN%!Iw6>a??M`ZA7zdCzgae9$ef7^wCFK9JpZ)wIWv znSDK*fzX^>reDWXG>Eq_H8G-qm4&^S@+a99@eUfXFzWFN?SMv zD{?lcqGxH$@BB=BYD*269&TNQwNSRLiHBT=iyc|EWnWa zjpF?8zU~MPD^}>xq|5*CJv)B7hN0eDqgEJgE+6i-tJM7!oI!C)Q(gr}I2oJG_#WO3 zXcIY-nkH(tY^~i4>06IR-!`&A@)AzWbRZ9NATpPaT3$FFdE{+) zlZ9O@=+N{wG{ai*$a#l<| zvfI_SF$?`<<)8dsO^*rqa26HtF~rB-!1A%SH~*tbw;SwC*_iX@YH^dp$Xqd&(jO&Y zT6L+)lNANC9ogoce8oSTGL<|C+J1iF2|V-Sw%@TtFeR7D`o4^LDD!paokWMy(m7_0 z4~6?ePbT{3okjLmk0srR3={3)WmZZWp`6gSWs?QoNZ~DgyPLe+)C5a65_^LJrg3&> zE%!Q}M|0h;?nh-|-S7aQC=nxd&Hky0f^HH`e95m=75GtV%bUfJF`rY(@4JZf4~-PF z!2}AOGyOHfswimp&Ra;5f(|J3v2B}-XECXNwN z6HLLu`$fFGobK``derjVU}M4mE!o?W6eNbH?qV#9UdzA6?*>`uH08%bj@O?}y$z7O zG(+~s>KKeg2{U4UPlqh^fWWMot3F3uaz@$ zoVF7jvCQmVe^eWzmhN=IgSscTVnr?uM-szUy>q>s5vR#XWS2MhQhR`Us6UaABB^t_ zhf%hY7&`z^2$9{i%v|q%Df{3*FlBD6v7Dc5%Zcc!im)JfsGijw#}Qvw0vllvdbAK< zWmrS;Bbl#7f>U~&*NJyW$`See#D-cJ3Ke;bQ2OzriF+Q?BXl$1`Y7)BkhmQH6LM%J zaZ=#>5@x`Oumz1Ta`*USuXY=(@s4LLfRcFh&FDT(3`8!9DdszYlVYx{i%EJ?&y8#@N# zcg}Nyh`CPOzsl*42d>bLj}&-!@pr16|K29)^$$P9$43Uh61Svy@(KSB#g6}sAr7#e z;Yims+y86W&QdeTr$WyY1#h~<{BKmP_pJq3a4Jx5p>89oDVPCm3N{HnqG8Vb^;O9w zpux<_P@#1T`A0?AIo*pyCD=CYb=wSs5xEcpF3NRDwlj~H)ph1SC z@;)Z#50mwxkl;eiymm-E#OFo+C=Zj=>hg*p+Chw|S3bQ)A;>63DVA--?fZ<*$eIX% zyKB$5!E~L;=CN76UWQ%2MJYkzfer;Bs#>k-L#b8g~Bnfrw zh4=DxCXl6jMYxb=l4nFHlSj{TcR{vhR$b`&w=Gca#6ZsFS_I*oUx;iOadNJgYl1TA zmtG;H=;L?-UQ7#j7ci|FfM_Y}&H=<~Oe-E8@2l;55CBRo#q1nT$YKEsYEPz`92DWQ z9vlUVuNQU?-0w1LDzBB%<&FaQnd)=*7~Q5Zr}=nA_*%nJT$Rgy+uE4R39rznn0V!A zNJ*gKw{9{?;<`gcm`k|N-3y6t%nvQLaf?{zEKtqA zpyjYJI@!1l^^{Z6H)>H#8V{d;erSELp|{Ft(dE55xb&Vo$6G=x8*g> zQOS#2(w>Mo zZB}G9qPaES#VS!00ig2$5?7*&EnOLaa`+)0IQN-Oj-rsm5u?_r(CAlG&AFiIT1$Y6 znEPf^w6nZnEN6Bv$2J4fSLMJpaNBGH=#EY9-s&Syt!L-~s7AcekQ{%vHURUhz7sz` z^CMa(3Sha>s$?iffvS)tegH=u^+-CZoE+sH;X;?d{`) zjXSk}byTKl=9jd@wcpfeRNaeh(9C6srTJtlAq!0y)w&{(7yR2 zo2J3rxrU$I5M#%Q$<4C<-sXhG0Q0$+f44WBl-4IX3;;~i0AwU8PzC!(y z?5XR4|GlXqVQgPyeTy?cn`t#d zh<`1cg;`6G8ep#dcAEbcOSe6TYUG*iWR-JS@cj@A+5RR2DIqq{weIcjarZ;Px!DeI zPiAr|);KEVEYkt$1WJFb$c+6quL-zFFnhLzGX?dy7+2A5zNw?#bH zgq#0BF|&&I7%o~IUNVaVcxjS4KGHrP906KFTkw2A1OT-jE;h+*TKyqS{6h;)!GcEy z(i+Ores9eR{lzcu^=`u4ZT^;5kjAAVQg#Ekz42ps1ien`z^0yAC={lat|-oH>!>;p ztvZrCT&wsnT#RZ?8%)L(!E3j)U@+YxC*Qxb>r75*DZV(o>%;(XfyVv(-gB7rFQLOe zKayVX!`tv9tTyh72DrzJyossh&&)@q0I*=jcI`V{&TFkC{)B+Kb-u?)wPDpEREd47h@f=tnE0023%DBl6VOIC|&5~$GKKhN(@ z-y8L>rPnH9+5%sXIXmY@+mGx{mV67RsCdJooCcff!5bOG7y|L$fH=QUV>IrsVpqFOI-(Y zSl`@YXKEj-sJSaD=DtyPTpne=oCnV^V4DUQ<^X~v;7#IIXM7@ip_ceeb8zhImBEF3 zQ$}dT$nE^D!=V%ck8^9rC-`5R1#)=-)H#U2mmYqF>QSEFI(^N-*xVC?A3!X>1GH)98_U~W4jeohBhz>^7(0^<6a9FSBPC|x`{RLgLCbaL zRfg?EM?KIAdj}`aCrdXs@wiB^cQ{5pSL}GKroIX223h}}qrOiXM^oSg zh|gtbEe^euaQq}ZoNwR%b+O0Ji;iedGAvRsb<;hx2WZl;V#7-03&Z(2Tse@=a z;K`J;;ZgRNQ{6(Fs7EJPJtpJIY0uN6LAmLC&Frrw0M1Og*T|(p>d0dllo(vt2Onux z5;^Qv28AE1<=h46azrNnZ(ZKYagX1F#aAD|8iY=gLj@5zg8qp2Qp|hL-t}S#&yZF? z01!_?h)2lDSb5a~rz|fm%TrfG@W&Vsg9kACZ8aWoGrwZhcDpiphjCGa&{oQACi4e^ zM=k|0>^T)cLz0_biz7lG6U@5eO8Rg?{>r3w?P=0&X#pGvyd+U*y^e+RUZS*Zn%IL1dNBD_N11GfYU8i zgbAdW@7yLqYh^*)9^Q;pOLAL(B7BEwvj4RJR|!1}Hy**G;UZNv%q?-hd+zSbG3?i!pg%FFrrMKxSnNdUl_^&E6tFvN<7fr0b z_$GVMgAbsjjZKof9+(Ns@(uYMQYdfQS#+S?Ff$=U$*s zmX7XpmQc*9xF!1W^ty(J!o1~PiSeQyWq%Anek%+>EIk8`wh99DKWk640#wM~;mC$v z3D63!lg$=NMS$`HfZ+XStKap#>;ZjqYOrJ$#s#PJou5A{8c*OY@+8rZo{$e}t@63;ODm zlI;(U@ON_lXOlVy+g)EK9|jiy|NMUf;{Ot$vtT0D>$Zd?`?hB*)U<4{NH)Y{9tmB(aJQ zDLje$ocqjL_f{GezVKb~AhiP%TvV}$2CYi@T0SH>`P=IRAJY6W0$>V|%DQ{v$&TON z)Bhn9Gk`qv{h5AS8AT6?`0TV_vudnLpn|>qrCe7BJdv(*N24$CD}R?o;L_6iFGpKG z_c86bb1Kgp$QV?fkh)v=i0v6V*rZKry!&hi?^ZlX^CWpqd?q}t;ic_6iBseIr^%w; zn3Id(OiqIr9Tq8VycJzp>`n<%mM2@gX;mQ1BsChDgZHZLj10 z9pK+l=1?#eVhU&5z=;3+0RH*T1cAuK1QGoA*56lu#@#>?uqn|d`TLoFzIDSZ0u^I{ zA>0c2?_~dbHHLr+X51OYNOSQ62Gyqm@TTEY+5g`9XBsxhC_5cP)`pkgLPAj_qJpKq zY{tC$7RGB?PtOD%t(>5Xc>$WVfj1*sxsk3-qXQEk!EW3hdHZSvDGl)EQxdw%d4Xy0 zfThowmOZ^TTLwU2CE96}Ytwj22Z40OF{?@ZyT*TJ`!CUA`1G_BL$hFli8Yzz?j>1RMuxCrMc2&1=nvU^?RXHToNSzQQ^~Hs`I1{xa;7K@|&f zVt|oMde-BSJDsb=3__b(%>DG;#)1cQj> z4arPP787kIAZ1;8cJTFbL>q?^Pt;a8fmGA8NP}?3_~Z-yLJWv^8~$0=YB1Me5ueB+ z*Gaq&0V_H0lyR+EAtcxB7W`Kh$S!5U5v+f@8@CtvN}`d#4Cno>G>9i82z>U*JM4`2 z7c2n;8!3L`+W#RxxdXUA?MWKeHTg!db-#H{pEODVK1yzeJ-+rEKH?DPnwG$)0oxTs z>YZ`zH!vBl|6fjq{e&z{x2Aff(uPr&0iZK~K0n*9sW#JNv|H|vgxbGd9ob!lXM*+- z)!Sybv_O-UGE+FzU?K;cw(S5--EHJOBe-3KK^?{(m1^|o>aqea0VBLBgABm_(*khI zNY!l3Hd($^kTdWs%%bL0HHuZ&ybVCiS*fu8a=O?gh%As?_EA^ThzaLq8C?cadyn&D z@9*EgH^K!=o2D@iEA8*lA_5OC6$xuu)F=}ik;aNAuS895YvHQ0lo9q}9sh$+9K$R}}>co}VZW*>u@ge|FwqWBl9U%0kN$nE8{SX^U0$FVLJXq5*e# z4UC$uQJCVoQCFdut0Ukr5XG$ZUDVIp@Yh$4wURv6Q2wXSarrm!^eSfF-$MHd3>MM- zM}_%X@EqWEhD!st+Ec$+gQ9`+f_5~%{cXLTc}uDb_Wslklmdq4dH^Gu^!eGT>!aZN zJTGWpepvv6IvuaZ6o9r^Xk6{LCGRr>?~h8^s=X+H4WCU;0wA|?VBd1y zSeyrurKh%SH)_&^60~UGY;VM`oj?wt{3?e?UL1|q z|LWzpp+$QyU7};yC#;>nvu>GhxlI6XUECx+>p{s-WUK|nW2F>+L$!9dCCZyel3orZ zeD-lcM;C=L@;T!!HymRo#GxVV8UC9+S)5?zb9E!IC)-Rs&Pc2x=UDlsgv+;0`(#mY&qd(0Gb0fxc-Q@?O`Z*Rfjym zSpi@i?=6m3#X@)8-X*`4vsW)2pvv;Vc5HD{v#qS!Fs~>Mi`LmfUnka$qZM$rC5|6z zVzH>=knR*Z7pc&kOx^RT*{I*{N%@siJ#D*Eb+%jwLU`*VYtZf(DD6u}`68Y1*#^9G zYU4PoCV_wJ5jL~)vap78^uXNAHCHi%92te0{kg(NKR?6|MVt4DYlJ=}7P1o@`2o}{_nuQ9i z`6(X%X--5NM?D)wH+70?%X!DuR!01Wp z2iTL5m1jqp)jc{Mr#SPIt|elpP}{5O>$p%{MpGm{9m)ySzT!)U~$rz=0xiz z%#p2qQ=*`-m8Tmjx68~WnvWmQMZ*Kr6ZAN9H6Cm`?nHdv9-SU{GA?0fe>qe>_QZU& zD(N@Luy}6vcC^~g`=mdVpo$!fN(&$39DUiBR&{8%9ED>O!?jM+J-!qAUrk4zTm zH(@zwZM3hu?`t`oSe$9stz>p!=P;kK%@U7GP&R1Bq%{J#4uCB6US^o6PJ_42Rn z{)o(atTP@DGzX>JSS8_HQ8jj7ryDZ^!pq4@vL*OsD03ja({a12Em&G;yQ9#Jb>rk=gsV~v4m5aP=1lMYL|%hUWH_d zc5gh{4YTc>1w_;z#1}G)`%~Cshq3#4->dQNJBGzbj=5|srY16+AGGkV(^g+zVVtP{ z(vt+VD_h>N?ApXRb_BY?5CJRTY4^5C$<@hj5W#(-ry*M4YgiFP=1?>0vaVk7SWk%^ zO|;TwgH@N;mRpKeW~+wnIi+?Vy85c3rUm(&;(+;Q@jyX`6n_40D4u&ah0|)xJ_|AQ znf$n`jjw}};snsvG@`zv3w)}-dP7hztfQY?K!Y?gX9z3|hno|-MOL9%R$!Cbeq=|T zJhboQA5F(|TC(nWPRBc4f4;JID+Cn}SG>EdACEUJIU*vWbRMN<)OneW=Wr(6HFh^R z`DjjI{i*W~bk0j*y#$;X!qo>;x7KMv{ivGGT8H5ooddMS2Rh&Yc^}z;w@z))d~i+( zX=z#Jb|SjeyA%J|d}$%V1NjT%vkS?gk>@AI`9nLsN^*ZYRg8^|YslH&Ya6lXvfW>d z@Z-gGJ3ZPpiWQ6)`reAWcDDFiH#(5Dy7w;?CZ9RWHu#FK zqT04;(u3ARhS5h9@A?cfc$prVmUbY%H30uTW8!n#EOXQU?pA>P!R0ly)NZ)wEe&hU ziU&2~6E&RMV&o*#sSI(v-bF}GoDWrv3;~`{fh>41@nj#u{IV;PdsPmF=$D4Y9M_6 zM#}E_e6b>P>=kdP0jpdgkZ-mMbo>MTbEV<0-3;al)wE|j_|`n~LuGRZQ@a+|td0x; z+_v?&(|q}eDQs=*SlQTpi+aueG->ci%aW%4**g;cf5_3E0zh7M!PBa!30xu0P)GlK@9R-va`?X0t344liC>sZCb#XC2m zG^XO2X&qlaU6vE%(eTA(CL^}!dOLB()mek}vIJNZ#RDnrkD{@+%%qJTaj!^r@$4XS zl311Wg)gjyzot{d2cp&CT{b$$=wH=ID%>XiDw>Vn{!eonGY<%r?t)HyF+R@CVeefZ_= z8Dqv996PtN(=1wC*Q*SXz1)|azx&dw|JM$*?X;;_xcO~wQhsc2)TS#iUZm5Z~ zrR(b1v9evIrbAEv9=yObYjOH%_oB>si>RB8xrF+^Yj`!dhZXjIK0V&Ip};1O%d=hI z38?c1(IF#bd&>%FBF{FnG0Se?%Db{I_AY+WoSHMuiM@{ml%D}mTsxfER6NzFcSw6j z7ilF)RE^hug{i5j$v*tBSC0Wt=;YHn-tDn(25ZOrLPC@Gmz+B+JX}0~OAE?^&b{9= z*PfaUODAzMU6Q35>+f6&T-JtU6Fl7Cy;;=z&4`BQx>ja9J5V#uUOJS8M`oYNzu6f6 z?btS1ureLb$~ju6N;XnXXgAbhe{J8L@`--w&WclzY}Y*FXRQ4e8Q1 zSz;qt#lidM2*gZ31E75^*c7fY>|^@pe~b#<8*fXts_8Ogjt!LWc5V%u6-ADtPWz^F(ro=L)=$!`RfBLB00=JY zNijR3+WlgXOp425oC%$Bv}s@Q(K^S@4=K<@yaE7wPgL-vuY*8n6*lR!L8rXE)9)ek zRF?`p8YnIe(<*Rw);m3sKYVqcvr0ejYuzHzsyq2`lBo6_W^kpV0@uD+3x}t(hq9Kc zwgD3H8Qm3wTuIJwry96fMMV%Phaw1e&W~wNI-CxmklR!POmM7F1G>xm3+rE}M#*=< z8z7Wf=vEk^{0xkeVbDCf+L1Wk0N0?z?ei0Bh^pEZykkz2>bvMz@ibV^rx;{>M?3$4L`P92-!w{GI|-nrlgS|%D0$khgVV?F?V`zFo4&DsuL zT;dObfz-866ta1`ScAN9?<9)Z;WN4Ypm6o+o>pqA>yN`;bVH3xFQ*7_>JjT_+H_s8 z=MCh1Lf~sCd7F0cVlkc&YQVC$^83n+FQ|CKYY_ZoF!D?p``@#hGEafv#tq7$=VHRj z;2{`3pz?>orBU{)kC=j=^36yeUz);H^8SEIBBpk0SAJKj67bU?Cl2A|iHA=w28;sg z65jnQPbt0@_{lWZH{d_{2E24P=>}32zE-@;m2cBO8*o;MjA+xvYLQT|6g)k3{Ifd+ zF6|$TMpba>9ZC77e?@^0^biPZqw0LZg(ZiCqR$AihklyqC-iq=G=baLx}AM(sq1P>I)L$v<9IpuU`(mnUSlL2Ji{|K3y*92nzvZwK?j z+zl_y0}z~uLN*yVqkr^BOJq69L14i-8u*!P&eZ63e24rmbRh@!b3s z-809bJt7cuB#!)wIW_L2y?H0D^`jDJfw%WZS{gMgO9At*OU>g6QAOQp5(D|0i>;Sh=eyXJJJ6ZrjOnv!)lF+{a#Umiss_f;XPO_kAFD!jmfq zO;7#O7lQ9E1`$0x+7(h6w#kWX731a_FzZe-eEYt0keQAWu^KD6-1i$@a@i;C~mE+5ZhXPIE?i{k@2FX~VibfoVXT`Uj2yf1(ulu>P6%R1jy8%lpP9j_cZ zk%KQP5(o2FtE->evQZK*wi=>``C9OG^aqShSy|B&9`e})?U`?I4=bm&|+4_V}ia&~2v z@aE^3_Mh!bYYsiYUeH{(-SLS=wX+dFf2V0xdQJ1M-8v908<*?zwi_zWa1U-1vtfgc zXl>EiIQM1Wx}53_X%X<(yAv zH&$~ck8;Pp=GLm?&gWmt`mVJ08$ttDYyT7Nf?hwg0n*<_19 zGZy*JM;KFk@^qp1W5m<_h$)~*FCMtV|t=~M&GqnZNmMMH|)G04wK0xUzQ}IW{3gn}; z)p?o=GA+kn#v3v}y8FQ(wLQe|Qdlj;l*SG!f(WeSweg(d}QV=;?(Aw$Z3J7$( z4lrIEi_wd(7=hl>D-L6!_+8&;aM^ePe2w3ocb7W9Zy)Za=ldI##9`WcM zM%$Ia1%dcg1EnpPS+$stxxiap2@WVWIx=BL9c3pe>49%?#IZ)+Rd|~!7MXX{aID-eOpSUODIQ&f z#=-{c($$AArAS4F7h=Q#TSi1BCHX$zvb@qvH;}t;Wof}Vd%m$~;4A?DzCptFf`>uG z)mi%Ky=P~5wO)ho-Oj-h(Ly4`t{Dt$z;Ma14d=Ck{WiwQ!E|U6UWi2gYi8I$hKlsk zKrUsIfFjzphejUeffji~l}_87P@17|@G+9{&!z-c_b;D;l%OWvpZi?w+1VQ~bQYr^ zc=eY8WChu>FU6iY(_MD=d2e0*;Rdo5F=BI`7gr$Qk;y;SlENsZ;q^0-$P3)~zt8eU zLVY}SV(^cz?WHB~OPyd}9cB3bVZhpz2o_ek_8S#!o9r^W1Nc({@aH`aG?gpm8<0!(0%elsw&#oe!eK&HI5hf`RY#@w14mxoP#@d zk|YPcWg)r4a$bd3B$=Z61V@6pblK?Vc~+pIjj>>L-l`yU^-W(O?g3>N$_tW zT!ADCTV&@^56fP>3#A2t>4S?=li=GStqObQ#o^-2vi>CT#P+GCz~9zTma72sCl6$& zy9jAYTpWHH(!jSwp!FO5{wVwKiSyYW-1u)McxR379S5H)@(_7#c;-aQuCqmB_?F@$ zes2Z-d2mG^4RB|atd+xaM)`Ty>*A%EkANfJ`@X!32n+}SiPuJ3V-6Fo`xED%Y-NCJ zgr0A0@Fg&If5Io+8Dlxka0TGN>!VoX?p6qzdf9=bWTI_omj#GlGU-;=$Lux>S-38I zhzst^REq|&)vwN=PNDyPior6lb&ac+OT-2;6q0?P0q0Rb0O?Pzi4(aZmXA?+ye31S z%evK?O*j*@yf+RcGDFir(p*w|=}2H;;4h~&wCYQddqVs-{{vFz2?87~)^(`!JYMif zEzmgBogq|U&xc8)pmA*OG>Li_AzC5TmC(XFS)N}ZeRBaMw$aH6od#v;){Kwk=0c$wxi!M}AU?vgR%-CWuszCX#20571ghp+f&XF2*P*asn^Iu@i$Ta|x4j`r z(r0g8?SaK=Q#k$+Cin_m^)?+PAcH<>l#+xuy*g?jTT4yhX2k*}p~va+@2yaej>6bc zIg5CU^0)pgpc8_1<88lKp=W}pJ4z%ROXfB!B*t-bf{x1x_qW8`oq%6obT1F{f>-=g zAqglu8=LblDEyodRY<46$0^+sLLN6h^8hHiLQo0PerlMdQ7GYyQ_;7RRzc=*m?W&# zkO=~&&~+K_3KkF@`!H%ZK(A|2&b1s2XzMoX*ni`@BcZO2Q8$Z3GCa0INbo~M$BN}=jyzC zaDMvGkSjzyZ}0GQ>Q_TMY*k-PMsFYB7nk7vc=1r{i4#S z=>h672&y(Y5CY#P&;5MQDC^9u<$V6yio&&{B$3a2oZj_vRoQT?=zaeA^{oB1Bv4uO z9oEdUzH7cJDn8c=j?(bH{hmLeIp}${+4A#x-+K{NUiB524>f>`-Gi!LUYd!9a6%$b zpQeAZthT_lkiK+M=FKFVx#dG&gaen!hSO{w~!}^^H5*H$xr)*!X$HyCNY$G0r=#+OW*TN_HW{8 zJ3Il2IB0@tL-#n z$yIkY{Z*!}evT0O-TAKhx;vF+*}CyC{{hCFSL!DvpU|*R07{nefa9eOiQ4NX$Ge@% zL4)5v6q~OdF;Fjaz3DaVenLzanwyRh2VSphQ&`z|PcdQe#LE7OG7t{{AYoN~ z^n&7~OjM=75TVm)6wK`kS?#Rnx#n7q5?UpJ*)FS2tN78(0*Ox0um%vmI92YC@O94; zLQi$aD+hQ-h^~hujxz?2*t&rJVe+JX8zgUNoGT-z4K)MK^E_|y7;j{_lYVh1~ET9 zX&bN~;E@Id4+vMpjM@FZ_dQ$X*NxkdXMK}D|b8Cl= zVA$~x!NK$SclUFvX8l)cLx}o7gJpsKMGCTD+e5sXpJv634j3H?_#OAhgF?#hD6jwQ zwSOUw6ea}LkSrGcpcFZl;z=xupfp4#$E!Bmm0xaP00z*Bd6ShKG|m8Sx*^k3JDQ?& zL&#Qe!BB(Bf?=P}mVLgzFxbcWiLKNG!+8?ae2t|*bI(3TYsfyR+wiPJjP##jQS7l- zjs;{`*D$D8&k~EonL*A4`-(!{}V`avfA*E{cA54%i_k|HH1c6s$f0hy5PJ6uu>g+z#4X!3whiG5O**Oh60;n$M- zm+U8IrKg~zZ5DZmaKdTnlmNQxwprXCXIaPH->eI*xwGC&a%5+@TY0ZXCHeQMT)OWQ z1JT}gG{HYO7MU~r(aUUVw--jUYr+$%?;M(s7F}%6ItaoX@dd6(F4u*mjctd5Aw3ba zo;(jl4)c8ale<|5)GKICO|tAJ>c#`)&DOu{xK@89(G`M4;aT~`r9g4izwxnV@NZE1 zElpXu1z$2zGLD30;_yzwINEe5H}Epa$9chXB17|Kf=@|@i39gXMqRdkm);e=KY4ES zD;V9!n%jH)W(D_S_j!gt7x_0nW00+Zm~M*aI2qCmkth%xeN-aQN}cKA=R3|aTC*TH zd)}U-+hN6GeLs3RV%=a_dreM}!LYg>~i;e?~IbVD>3Bsr{X z4S9Uo+XtzSVHx9Z&leWdiH|++Zlc6{I?gvoW{MGE>#a`izWS7G-)?pkpY47DJ&-xQ zZCv)brhH1QxyR}zU#VARf;xiwlTC@% zGt~`gT&|32Rc{{19r&^O!N~#e4jD&f#)JB+WgX}o-ZGPJ+o0=Arq+TSfk&@##pBzx zH0#*$Z|XDBFK;Nbsq=IZ|1$wP-+|I-SJ2SBLB^nldo&J*SeY9DXA{6&ns2-@2B}`# zTujM~Evo#XwVn{G`hgXnbWkwpH1-Q z1DloykO3Wms(#ugwj*9@wdG7I&+sm6-n{7x6y*rMe+GCMkT&I`^tH6adm^{}GkL|t zpLrHK9p&7`us7?x`jKm%9u8se4}ldkL$^9VMcgDu1HjW4K`^@F*>` z%KsjdA=wYSak>#(@;^%s)PgoaDqFA+|LR|~icH~w>YcF3{m-oce0l=tha=X%p8k7& z!Yl-o_NHGB>HnUjeIQq0>)qs94g0efgB1TAV4-Un^2+_!bCBJF=Qv5T6aVKV^BArO z5Ee>ViK+kVIikJ5b6m;R{rBU(2LyTL6vkWX$n6nDLA83dmwj6Ccj5N`{wv?~2L^av z%9Zo9(iPABh+!@c^b`7~+T9%=R}8Eg*XJ9Ulc=BfXoY{y?cCsDl5bGgw8loh{cNQA zYS0?bv*(7Z-MDJ*3Y*`T=qmj|La~b0|EPCbi103kgB|`)wfHl*QYw_y+o$GyHWAMd za+X-?O(ZrKE_Z2o?-q;ZeVw-Q2jf_Npw9^Nxxf~ElLN%`>T|W=@jmr>sqWKFgQ6kb z&IL`>n8Rh2#%-v{n`jbZwJmy?Lb?`bdB12K z`6svg(F~4Jy_Sn;CT&FqxzBEW#$`RaCg<(;{lD<0MWEXc9XWo$-+ezpMXWzeE7Wk; z+->~l@UBPukbJ1J$DeJh@QQ}x6)e@zg(Da>gi+dw&a9Hlwc}-kRFP3b#brG)l zUt@n$@|xm4X8t5|9h~s<5Bo5r06am*?pxK#xy0o-V!zlzbk2j|Ku@$$-rZbAU2g?S zb*IhCCEu(g>HEcBRV}7scmDr51oD7|Giakk^`vK$W_)H_ZRoVo@eP#G9HhlaO&L;SO4V_Jim*SWib z*6;x&lC*a}X9c};;^)4QmeRmv-wQ#VjWDAf3eJ-_!r zBY=LGhbCAY{tVbOC|zY}$+g{?&*6!0dGnH+$xf;#*7DwA7Ixx4sEhC4@{P2EU-OG; z2idKW?|RY^<<7soB*Z+;lWD99IqJ>VDBi%xlexV1Lj6;ahwK1wN7V$|8X{YLAp>_} z;MTQUd+LB%T7GV}pLO(VKVdMS#S-xkSW5OcgFYOs@Cz>B;aiAiagn*ZpLSF$d5wV+ zezkq|t^cVm@qb2anF@@Ui2I~2#ovG3JE7&OdBRZ8mV`AGy@$4!fY$To%!{U_Am>-2 zcg1e!A7WrMF&I0%SxX2S-nSPT3v^S1uHnX$v5~rr^R3@r%&I4rY-7(FP0)H*1I|5f zv1#mlqUC+wt6#qVi5bxx4`Y9#+o8^$ET3Na1I=5v$An{qIC}S6a6${<(EmCuQu1qCTO!*T;|IYbqWSKo?awv7j-mFfR9phM5PJ9e+OpD>BZt!?vuM_EFP(%mDtI^R>c%;X5!u5cEvN-@f7B3lBjc>uK;TB>pEBLwrG+h*I2E zr}FSr@{i&FjwbT#hmL0?6?yN&$fd&-&W7_TX{V%2hvf2_ zsuWGMDJiM)s=gKmh*eanguM;hks|zgRiN^8VKk zF?~BwA7h_%?D!r#h5q-wSP8+8`@94#i2v&WLRxi$9wA@pp0&C*{Ld{@K0ZQrGZM;* zuVQrGo6R-q@9i?q@_bosHJ2D`ZZs_p+#4vQ;<-fu$Ro0|&>}RF+H*#fkA%ypp`u~a zc9{$Dg;@rAZEW>wi>C`-*Sor52-ay2FKu%{2Jy>8%XBQ)6BlpugNJ1huvzrExZ0NW zU2$=udtXFD;%?FSBTFc&$ms57UF`l2cI6A}lA$~}vO=yEF5CR?!vHg!PIm(2f`_>u zzP)!ST-lULtP8E)X~$NZiYh;_Cy%T|cR_ zh~SXCvMw^-hCmvT;_2SMCGtEO@-@4=+GZ-ZoH=W?b(;BUdLB1-VC;?)4u(PRP)5p< zLLw3qq(w-hXtHXjTS=hN=u`^7Yi!|%-C@X6VE=#%aDk@LJZrSP&+h9n5+r!a+L~NY z)adDO#v)AaNaOX~a7OGwezsnvuJ%Bt(1yLOb;z+7kzUA0EE7cUM=)gxS|x0o3RyaNy*|q1fnh*xFR0dhBa5ceVEacve(Z^`TsG z@xUjm0sXGBUFmkqK+i3sBBGVY@v6k~?UB^tC3P*(%8ses%|VIh%{ zlm?wP55?*oo-GnxL5E(3nov+xpghTxgyK9Yur@3k(`s@{Sib?<(9Rz*pZHBv+{#Rb z!k7El22a?n*9Z2yzLqj#H8|fh-T~hz7RzbW!OI}Nx4z$ zR-#b{$G&NUtyyamb8)$z)xkygi->YV5e85HY)1yFi*hq0LHY!h;QP%%2gdSIuesr@ z_1hYzX$EAsst_tJZ#jx8o?Wll>l0P?d$at?`P+vG5Q~MVTYEm= zF!p}2(P`GU$F<}F0GvOfj?#RqBuMaI>DZe|(GWU}E>xM~DAw6g+5Vyp7OBX&0n}Ft zEf3qA1NYYYyL?$f>7Mu2V)4zM7~hrG%WIPTfCd63fnihCIOB6Qb*74#$NeqiApq4w zO z>Aa`2wtOPjyb2xAAUMhspaZ(ht0zx+1*7lU5Y6G))0t&!54(eY$!t`O$i=N8A+EBK zlIbw!QN<$=zvMjK(qsba43A6aOb-dW@ZA|_q){QD3pl*qZ*b&5o?D)`uKyBRd$Al2 zHx0sxRk`g7^>PQsM0i)YcES=phSYI^UamwGAOD1Sh>(~&5_J!eeMAJ3!}r>g;i9cM z{>{8xy}``6BjPFA=9{BehqLx5qu1CanQsOb9F<9Zlb4Vr!jkW*7i+TN72Vo-Ugj6= z+L#fu=p~yGWC~v%J=-=ys5Y7btKqZPgm2t9I&!{@9e-fVQMU6Hd}WceP3rMu2}TWbW>eH4foXtnXby7w;70^Fp}{?H zD9@6)ZDS{^OzkJl1AqB^=l+$%#MDA%_APYHDhS$}mFMB{S5xl@&7 z^d#UZIyI-n1yHVa7Aj&C>DgRa4dvGDm`jDv)rG##++!_v2wzQ_v7ll8-WZUzI2=tdw)u0e(qXfL!LBDM2o1C7tB<^FlvL;6;XO4`M<&pEsrqrY-lKo>ON$ zu-roOp!|M;<>2wCJCc}!v96Qv&G70XZpgsFl=1pjUVz0+b(1QH0>nj1j_;9-m*$)H zu{TDaF?!6$!JkLCV^DD|%)WlzzL~w;a=qHogNHs0AX}`Bla&}MX)P?EXnHO7J_5*q z`qD3}tmofV6O#_15sqJ0cL^Szj8t|WES*pN3}fd2W*;X2Lc*cy8bG?o##9*g54HJN#a^r(9w+R`ZW@*gjDV z-Fbo{i6+n)nrxEsivULLprQy(t{2!jiXO8Nt?oBgMrj}}85wJ#o>9wZl6#j%1rc9} zVvRJpbJ-sEe}hH8D3M~}cDcKJW{`E|1E!_D;bETdk9m7}p{Gt05!!n{DKQ|e2?0`tl0Tm$HS7`b>P=3}~h*48vUx+J;{E z(}}qWtvO~xo-=0yT1(32nIL)E>Auhp=V$~fU)kL4(Jx=;85&A@8NV_DVM?qm%{EAn zwmfQpj}XoEwpFGXs6Emp=w`VLp9lkktTEmvITsi|NShg4?nOfTv9kHwJpo_i?XqoD z!3HRQy%$=P{4Lyv6rJ6Js%ZcpCl1{nZ~72>%wzVOpoj`;Qe!eCWm=zClAK`14 z>1dIm@#P@#BCQ`RiH=416extiHh#+BbN*;_lZf z+x7TEGb}~bHc$bECabIvC?I8*mUEnJQf?&gHmoLcG9tm4sxa@=Z*P5RldWx}ak#(z zB=UOLcg?dspl5VZ$R>uF?|Jg9t;Aq7fu4tSSs{TD3I!Hw_e)tfDSjY#Xr7{YQI#y4 z%I}(6sB#FU4=Is(MRQ_HuTI0reC%s3M*f^K$NDtf1MlZ;@tBMNZlO-QR>!})ge#30GM-S4hF^ULH9;o2*&<@-WB+PE z?Fd0Yvx2I2SOFo6=TMF)^}^%aek=%-&vA=Bf&F-tKG^j!wgb+`i*rfnN)NLE8Wh5) z)%a$$jXh8LY-bARO}7NjG=|a+DN@zQ_PFOp`Y*2D&07FYO16)-PF>D8eu@asenu0m zEyvQ#_}%`}@w-{L={p%~eYfv2DXezCz8AMvHPHe~60Fk33Q){8TX?x~eZHTh7BQHY z(hu+J#++f2hOrsPjMawtkO7QJ`daeCc>>F}-pScVE&lq?#|r_Eq~MwOsG17cs<~U?fZW z;tk=NjA!ds!tVyvy-i^?E&}ute!QRUda8_oHxRxt{oNi)%U>||b)s;Aps#$#7+EQJ zyR>va#n(Sk76)NMAaxMI9COyycp-cHb*xTYWr7_ZQXXr3zUl;@^B%t;>+<=`$Yohz z{&A{#$+OmWDtRG+j^l=LS7x8K9h$ym4bP`l$7hvehPnvneQcEp$mwz;Gjk2+G{>Jo zU5PJ*`2|M%8VpL(Wbzb&!{Q;x{ao?FLxFC zb}#k(MFG(e<>RS#k6uGoUhg}NbqGo&R&@$Wa{;NxLG!!UtLPd7rCO*?8vZh~BLzok zp{mXk5$=U4m}wL`Ha^z0^IYn0pq66Gd@qHgFj@+wsDDYm)5gWX5Gn>)cF`9#2Lob0 zC(LBQ%GI^BnI|%$GkW(IHuK`p!%sa?3%EDWC89`H$~h2CgMJ2IE_EX|$)>6Io7A^p)6{_ItntqF!M z=@UL7leMZ^8I2Pj8J6}n!cNs;7JjZ<9!~Pdiwx223;j=gMV<7&HlXe zRxXR>QXG~v(TR+SJH1>k^S;~ZSXX8WWureV0_r<|7gVD|ejTv3fvRQQ&E}gDwaXKd zOXX58`QL+CpA}kRBtf7$oJ{qPUKHqBmddZP@(lM#8VA$z)_^y3`nQZWZgu_fngF%2 ziJ&rDBuF3QJ8!W)rz^X%31MpofhHIW|01aMT`y5pZfmQr|8G8l1tmPh12zJ#fv@Gj z?y-&)_AyV-KA}JB$qHWUFjUBRW0S%Sk%Yw|nS8xc6X*uS?3Bjz`{&7t zz82$Oo&C!!cNI%NrpQ8DtsM(>YGm1d_Fs(J>|aL z3`4!t@rdo!iL6?8l($R->3yvrszt|K)Buw9$0Tj7jW*=&ng7q{oi2w2|f{tItssDal+4SQc5XwQsBt(FlsS0_!LTfH0UxZv)zv*+z1;8H7fNNQj=jL=+~9VLKGJBF;!oJPCE`3GNm+9W^*z zDkt2!I;=zD?ZaD)&x0p6xjcHBF`{RK8n8l`{u(e$+)ojWQ&d7flM0_xgn@ItLPnU? zt7?;dP)UC2lSX@p?Z7<+5j~wU&Po|W*u4gkN)`!0eNcdFL9|i9v_MYNfTnp>_*5eH z5yQ(HM47fl7*c|0Z*`68(;q9r4bt`@NR%OBdMNBXWajxFkX&`@;g7>rs6O~*B3niU zW_P^6lUr`ZS$)x;`rYOXFg(qt<4&2*@ars?fhnX$A+ok;!y31Z0!RqHh%wH{GA1CA zS-$+>v;o!PS>L*O{^Q-(4-^~tGFgJ}(Vz~3eMB{;_LUx$8wldrFa`ko4h97 zWillWO`>;|ow7*XWjWXUeYDrGkG7?-Otle{no-MZ#l1Oa)A7;l*Q`auyfe>IBar5W z*=+C+S?E4fuQZaCj{#6kLGEK0?0ddPQ(eCj*DR3az{JXJqSw3%l5mGb%+HriLu6k+ zI-krhkT`1Y z^AuaJSbdh6pB6|A3hvR22;5IL_Dng`6Ep`VTOImSi$i2+0#x~uT>`K%`AoiR{w7+@ z7Ox?OZ*bb(3*8FzV60?M-U$p#2V9D#Vbo9XVXqF|y}SbO?MxG;YF0c9cRbi^5x$}rzA|>KNV5oIjQ+z&{=Dj| zlcC0w1&%p&Ih1mv zKdlC}!gs{dw~3r+u#Z+a;7k2(^^9X;>-fWmJgK&{RvcjW^|M2qjz=VMQD~K$8s|;9 zT%L2rI*BB1_#ph7P%Oo=DS6pY@c@zu}>6qa+n_JR*Ht{r4o&-Ru^kF@cxiN-QO-&wI>g| z)0-%WQj&y&ZYUp7fVcyyB2)(PAbMSijk_QmGwJ%g`+glp6teHN~K4iM7{8pT{O zvMd4VutkLFMvRv)fD`k{1-x#zVyUN(HP6nVY=e_>e7RA-6}CSj2C4=QA9HYLadcKI z?lAyn&eEOwb?UkOvVIm9u#$8>U_-N*ueF59k*@-uC1OaTDi^D4g;p=03)|jaXuuJV z%rmvzyoE{-I%9l9BpT33y8z%9t-6sAgVt{o!&L{Y6F?W?rBM_6fSj{DIjsii3<91J z=tkAG?exoD0C1@*5Nv^chAh?-k-VJKInLS^gF7gw_87nVQ=phgP|jw#WJY+lKHY4j zlnhGyU$@0wC}UR4G2+$2ji=${jx>P)$1K-IUF^M-btSFwO%2W zT|4ubTwyt=_ZsVA;7}$%Z{;D1v}4{6i}+jx+dUr;CGSg=ljA7hY{GctddBm zx7>{~qV)B~^C)$l1>s{GQD@`Y@Qi#a4$tnO-xM*;Gzi0QACsB526gy^m!7I>%6XzG zI%%Dg0eF|tteMFD=MjsUIJC-Is?r0A0$at{YK9lEi|&42cxy~C$#165SKJWIMr&on z1z4H*wWcdOP-)^@EpW~b@*&$+h>m5uXR>?_+&}fp3U)hl4C;>uyhzd<`lR%o2>ec8 zXL>qSyGma6o92|U;4C@A$I&XaH&Og>4`iBem9?pPz;! zrhJ;JZNhv5N4!|?7@RA+!GECFa@gH{rC_--l-MrjEsHNE)m&JG2Hc>xYe|2>%#Jk z*sZrA`s?%ch(fX4Fi?Vkx5am1FBHafhg4GG;BNFtQ?-$T;?d zf?oO{ZI?;2c z=4UB-ayFSAYC89=5s$)nGpRBunl_!rMEpFuHtI3|nRUbN2g&> zxvYU5e%jsS5CEg2{pmdYab4ojo+wgkvx(;6I411eUGg56>hgis&cC8rIkrQR!1s0G z8|Oz^h>iPek7lB>KOv>lmfKN=2pQ?LBeR!+%E#NU_E)R@n{dR_ZyM##vZn(P$$b}{ zO~b;oDRLu;=f~-BHk*6fX7@&Jw)~FufH9_lLy@ePs-9f%GGgbmuOh)XH13dLEc_>7 zWa>NDwpb4I%l;dp`L!X{t|ZrtdJEswqsW3yl3$Wbgx zP4jB=39XdKc8Mic3c8uz;T%GLWOWVC$A))*_6ZG{{WSB@V{ z+RcsZ$h^J!Zn_g}A4=A)I&pAzeuu=k-G}Nusk0F!$2Mpt6(9fhg|E5hubMI~Q|52&2$Gg=g1T?UI_~Px!N8 zq`S#H#z&y#q{@IJ=8P)yJi#&Ho%nX$s$cPFIj~KV9>xw~HxiHAt4-r&{3HSCZ$}Wb zVFNs3P$3q^oi6D*w*4wdZuwOLcz#xVc`vZL50)t2(VI^AJoiEx!gg3Rdy<>#qd-=K z^P_MxBGTje^VS?F6;DdGz9R2rQCfxTG1qWibJo!i%Sict1(Oq&1D}UhV+&R#F{59k zcw?Ckc08=gO)qY=O7xTgijlRB7QC_Yq~}cdHW|(1KFALD@3Y(5c-AD1x5BZ9_?ha- z0`8F!Xe5o~RVhCsZ6oag_-6astK8FBCwM+jlI_b=ZLC6UZi*XbI8OnKkyFq10`m>1 zt{o?xxiH5~<`Pi^e5u9e@aMRV@o!(Lr%Ej|Ww3~%vn3wAjjf2zrbbp#{?3z-op%1D z0$s$?JVqoikiECzOcTztFImDM?{TSRmFoD@j)_&IcsaklXQ~nl!Qb8s^WyomEmGp8 z@YvVi6uLe$8B+REas^p?uo?cs!mz}%OTNL_AWcsWABQN^M&Ad_2^M+KdR`W{6MX$U zK!9=NPHzGwAdO~*}?Te0G& ze0xruCtty?YQQOL+NsN$--Z6g^!0X|%qVbWA8q&NZRrh`%ChH~C8tBn9qD{Uxp7GT z+}#!XWU@TGJ}*2Q<2f@;UjIu*>|PAY7`faHD9}tX@fF}C$a1lZADjd+WJ_ZT=={QE zay_fuc1oxj0l5u2JKE|m;}Yh#W!rG3%%Vy;1K_9%&#)LP=NHNOf>S_mbjB~L$9}N? zl%CR;pRAFrx%^FUVt)c!o+=(`3IO^Xu8?Zy`QpKB_UOzZW)&T3n?kmQ3OR~(`*fR} z?WAOu85YhMj)b1P0kQjb{1MdANNVO2)du7JBl;7+kY|jh(^ci8zt9fT?XVn*i`;-| z)R#i4i*Nd2P0FS7baLMd4!jX6>Ai zM(AAg&$V%rN;LVxfdXYix)53!;`Eqb1302!z_d%~5bQv>e=8d8uRt@_;Zdss4ue}QLvt70vN;w7}UGa4r^_l{CKi>u~2 zLHI*T_H3vn3yckZgw zpEGPV86}7VOYGTpXAD;&=^JunUL@3fD_Lq12Tm1VJ0P%G+b#4=`ldyxbtL@sHVMp3 z?m$xrw_u8rS6N^dzrlm4>kC|VZ@oyv`x zM*Cfws{qMwt%0l$WIF*gl!6fTT|@Kp^{ zo5-L)(I#1!?4xmzbrS6>Wj)Q0XUzo0Y^CO;Yp)b?lPiEa^9#KRZdE?Qo2>}^5ugQh zz@I4ky0j;e^zHrjle+dp7tg|K<|N+_cjmoVc<1P-K7n}2X^Tx9*Os1g)|$->SLwZ| zs4Y|h5@$HcA9K>PYImU8iE^J6V5V+hq-sKOs9kU=$<{8KCp{hMZ#qgp%0!`qTy^6h z>=jpj&jBoZfxqGla@TAnpJTLih(+isV(c5g$g{~;BQMb87*&RFUJwbF0NZmK(EEap zgF=hYH2tgQHQiIrC#$(n)3QHR3L}O_5uRbi;ak$Y%?q*9=o)QdD7h&45eF9TI$A#> zT%HlA&PeG$cs=+~#PD7&w3v<c(fL|`6-?(g7-r@tRZn|v$>s6C+6jG1F&{|-jL zLth9PiBK&9eIbzhp7^OGWB*F;7bk}xeJIsp;MhYPElww{9w_D;^~(E=>PYFI-5@hu z27!WOX`a)uCcfVh-=%szga@O&ZsHC-Thj}!$>TCSVXo>@270cG=_hm}H?-e&4tldF@J3DLwu7#Tc!loMpz2&m|)+`j)_if6mVngy}J=uWm2lMGkp4$5LQM> zM-NtsP@TMvRMQA>3VxsGMhd=D4>;)ZbIS5K`a=FY8DHc=1;^PSB9F-_C1WF8;OGap zFMN)Lt*#$`gY$mOwy4I|S2PI{;7Pk`+~<}8%Rz)>fW<#RsxuJ%RC!j1))6^(-D z`Vt_EcG}USTo@I!wV$rN&FCPgn4Er#RZQDxkpie(UGQ9bfK%Do+lgyQnA z%sNCajZ?tnF>%Y4wyR-zdhY%Tf5t<|7Pwd}Bx6YZngjYXDCg5uJ9Q**X{4H$t z{O^?nmC1_CA;rcISaRRm&1%;e)%ov2=HnK=$*rN$>eiO8Bx|o-KY0lePCL{HsQE>@ zKiEV1#F4S#-( zg*KreZQ3tY4@FlRU^-M`3|9?703GZGW5MUJ+G>=C!0#HAp}1t z^L5L~(BO6bjDc?TK|BA8|>KYZEO$}6c?6YK4kpI#XM1g}6U>TMV_ zY5$$jU%S}M;`J${SpklCUAG{jtblRHW*#@$B7#KVbs$Cn-W=7C&e|1vTPIdCq?``D z=-n6k4k|&sLmv_>3mxnyHyYUex7qwv1J7Mr_sOw+bCGYehy}V!i+l4>DxJrQ#*kR~ zgozpN8S*5SzXo|=_5r~P*LbDEQV!eRz5V(?T=^g=>RZ&U*^+fRLWhrXb~Th6Kf5MW z`H;l21e-o*SQCFgsl0oXivv&VcBaboA`ApcRKLhHUj%fNb)TEbkw|Wgby=A&paGMX ztoKX5clAhDPnC((a1oud0By@%!5B_<9&`@;yt}p>?G(HDas!m|6wWfBW*zyHlv~Lp zSu882n=(AqYZzpip;?ehSR8m04qsTJM9l5y`B*CL#C}idK&nC$tl$AQqZ71-(DT3g zF`aX&w;~AQ!?4=VSX#cHlvfH5j4C!S$CwLp_zv>-l9`AQvfY^lM&sIngGSK}B}jWt zLXgseAN;XFeB=)#-YrJO+<@WyPhRRHq4mPa2Ln1}L_dd@>ziEGug+T}c!bj`8C=$v z*taBT99<_k3G5Q-{UV)my!YoC3e?8NH2U$^7aQ12hbcEPn8i&$057kPzkLG0st#eU zRa`}N#6KS?dLK@9 zj2iE2$$o{DY^j^i@Q&!rWKW_7aS%nZ2a~*354eU396>^T%qeJKj0AGAl-bJ_ZZQzF z_FG!$7G;V`--9)~xziv`8Z_6wgC>;>T9_erK_zrCg^FVy^^DlOG%P=eDnl~}3VFb} zk@9~ViWDdV2+PnLd0j|m!4T}>VNm5VMYzW>EQm{D!HH(R$Le6`TE(4Ps6d;^-RgTg z_n~EbNs~soq?lZ!6^rxEi{!$~k&>5~pu}{f(J5aAA1{vyyKNC?U*d4Npb*m#1mHxu z627q}@uI-6-@G|Ti*sU~FpJ?Kcx4h%Vyrp4F;yddpB7$B26n8GhA-`<a#hnHSF&yno5OdL+FCR1hE?F_e1 zaYgUZHjs?9KTm>l%G z6t$RkYS%!*g4bErlPV11HWJ*!`G>b#4yb)3d`|R|a23QbDjx?mtkf1Bv9HY3SSO_( zYQvr_U!~8tzr>YJvYxI|rM8v+hwV%G7{p#mpI>yLkbH6<8h)gaAo%db_@`fd(kbZE z7g&#C#ydRzeL@!iv3KZq5{Z%ZyzuFI2O2W%Xq1mOs+x>riCFJU+D@^uM!GW1Qp5ax zNwg-IYJ-gOVY`$t$gdyiP7m;I(*s7AU6C%37-bJQn2dtMGjQ-i*Kx$LaewZ~6}d+625L2lnj$u%a=2Q6V5d zfF*%R`_I*X28A8ar3sL&{)ZJE0zr7-BR|IQmHnURAcG+Qgo}@GHGeMt`<7&|55wdW z-1_q0$@JG>06@I{wV(Qb6R{tYM?VH{W85mLgY)Ns|Gvrxz<`<*Z4CeW>OUTVw_#g+ zQHK1#_k@5MQxdb7_`k1i@CdvO{sHDB-2dJ)8?1zhH#Yyyo4;=P|8ux`bky_SU_G!s z4?$DfFu?9+K%B+0_C=z^^KB1A2}fb%*2bk#fZUvn$m{hcep?1)P}v=E74=ReBHK=^ zT;Le32h`DeyVH(XN&2tJqeGE8r(1{|M-`WgD+gk|4LgBT`wOp&B?-Xi&gxz0YL;n~ zt)>+RV_AT-0W8tAa2ecU*Ui*xtZ)F~<}|O%4O%j1nQJ`ACk8mUoxm`WAqbtAac$6> zaeOO%HIirTxgy{)4%UJHD|rJfQ#08~Fnwi2vnAuYbM4n7mqC#Q-AoNI&2jG3k?WCg z{4i-$%Cc3;bTVnQ8f$safiHDv_ebj|hpHAZfZZH9uf6{|6L@KYAhd9)T6Elu4->h=|Ob7T`-{$IdNp}LJ=C*13 z`NBRn;8z^wQC&T{)%AtB6d2o^Jp4vL>4F{SVzZX=`KdLsBl1C>W`oz8=h{ykzsc}Q z_+{o60FE~si_PMr!Lfgs<7)JXJ;cuGD&=}#hM#O5L7!+jj&Urv`oi+k?lE}1d8iPL z9xwWT>H_;azbQW%OiI8%O!G8{+tbso32o~mfkB*~!r34_`usL0xWH~gXER<&4ofq`rKJ1S#>pWJeqDpcMo3AO1}Ml|B%mwE=PcZ8#)~WDY0`iTR&>d;c}^0+d?$ zO=C#Jj^)JEjEgVzcC`n%R~%SOhsA8KHVb%|ZnwTli$#$%rLSWrT(rWThXdlSYf%HJ z|8+I&mz?BL9qX+As_8+ykr zZPVWfbg|n#jV2fdOfBTTn-uVgVD+{}H;rOLf+AwF-Lrd>{nMqO`n%f9um|0QrJ!EY z63p&$pl}GN~Jg(VlV5PePTH(>QBF0N2Q6IMx*tO_*!OSNQyTzcg_irlWJM ze<8WRu1^rzEsVsF6`9v+DbxKbl+#iTanGnPxqSI2H8nycPPwRGCK9fy1Ra)2)rPq3 zT8gn7W1ao_In4Bzxd!iN-glP;$()u!>--qG5{rNUhX+!*Biv$@@~}>q8tQ(2AD&;! zT}&u_k3;|$QdzNJU<|O21&lbc9WV%{j>!tJPgJgx>K#k5^?M=@`DOZ?O4Uv?DKqxN z+t_;<>3ahz6tay?FbpgX%iywNM+2}=>u$dnp@xE06Q^(Ddy zh)1zb!4cQk0&C_qv@7GG#?oOAb%^Z>$?0ED1*+sd%+wRnILL1Nx4nQ4Moqw8+jjh;H-S$Z;+`(G zIrg={WT81@J$6D$izXTY7S`G!w^+FuZF-HX6vrvRGlHfF(7c`?y1z1!a!RPiRhqE1?;YiQ7WY*khSAa)D2hKjl zdrQCL!f7#X2L-P+c+$uL0$qD%0IcSY`-^`Lp|K!uNPtuJ-v&sPjRQ#3 z`mt8|Zk_fH`kHLBdY4%m)Ij>9{F1%EFoenT`yp)a!Oxb4eJ8CN1N^d*g=6= z9LJiDV`E3^-{)k)Oj|VS?4-7v05$)Gr=s4A4HL|(QZOYMfABN`dQ&F~Q{!``G`4S; zAYx{QkP0K#`Bwg*N-~Hss+6?xfvl4ZaPIbVX`^)FyuRcx7mSuupa1eIZ$=RvlKw!R z-ht{w89n*21Zd(gl3sAYk_SJw@C=7RofG3XhjaE*AJfNMN81;DH&ccS;zWQ|O}?8c zl$b+J9SUe@Gp?^x-V~Wn?3u+!!P{pex56kf3aij|Rz0}IXcYJlTQ%2x1Y#+Fau;Fh zd+FBWRC=E19V9grgK7m*%k2?>?vf)gq&i{i~S?= zgV-Ix3kBg4tI>rhfPp4PhF(Ftp5d$uZP+_+_LFo$ow>Rt!Lc%=p-kYq%1C@hinV9lsrxMN5D!IQv%QSEv!!`zs^S5F{vFz^1UFPdz_`rP(&C)^??bdV=1*^|1h6=5uB~LB3^Ki|)+k<3xu) zDD(vk2AG6~b2f{Nb(uNgo>ZHS9IPYiCH(-4r=?-or z5wejdX}9>gm>4x8Cs|}cN1FdudVjvDbGOF*6W-KmT2I0&?XB{zZXTNBz1shy?k(e@ z?ApFj>4pK6l$KDs8)gUrK~OR1?(UH8E&*vALP|kOKpN>DkdkhY?vA~<@8@~n%WHq# zU-sAeopZ*DW36Ky|H!E;>LhSnZgnLIr147Ic8WUGxP!KDZsrk;o`kcOM21d#V3T9W z0b6I!Rf1lwLFd;`=#7E5W%qcA_*?(z9?r%y`a*fn$-^5uP>qybMWutO45_lK z;N!czSwJOJhorQtEYhum_pixanN@l)1UI`Tu8-eK&e-~1PFY;~I zgh~SmdB*b{w*1+iAgc#Y&rWAWq4@QyEY|7;eY7LM0SU)kGlT#`;%9PL*lW13v`6c2 zN`sI02>qqJAbplQGj%GH{IeUBSk1Bs1}}{M&6<;?bKh)OmdX#+y*b}~G0~WgGbVjMt1ZW8Ptzi} z@-ba4o_)9A&(8eL-&==13n+dmxNGZg4Ayz}AxLfeg}Db&wJp(iF``&!7VJ!vj0n(N2O2Y?n~hCVw@= z2By^>Tx3TeM z^T}|4=R)bzhId*or@p>QaWclh6X9E{dK}$Ii2F1~nCZ)42Nb(PZZx+$^|A9t4gWe< zO0wuFIkT|bgu>TMOjXjp%HRIBNR3$D$o=O(g9anS+z;H!;Za=He!r&x=6gq7Qrc98 zCaQ5#1(;y7r1Faz%^IzhaUSr>p07m$X;3H+k^en!TR~u)K^eVoq4+S5$P#JZP4$ zGg)~Z$k^6FLRH(y_qI)={_G7>F{TLG1U^HFu+_`wejUU#3iVr6ZO;(S;x!yP>p%}r zk#b}3O+LPZ>E!)7B`qiS35tPFO;8sT))6^sfm9H|@l&fXy3G*qxHGU@a2iUkvTgXT z)E*vHxaSiDC3D%CCU<YSHqv|H8$sVjMy25JKkABEJ<>5J&0~Mf<|w*koB3qKW*eK(D5uK zVN2faj&UVO^|?-eiD^Ov;3>Ekyaz3_GbCy7&BM6*01?|qQ)=loT7!HksM>QFnMgNK zBS>VwRRi~zrcsWbUBHvK^c-EUjeO(`%9B?*Nvg~ETZ6-!rJ%PI>&g>sxuQMK! zX$`>W9M3iLQfho_fTh;2!>ON9tpYSAOm=y!uM1*%((Z+ICe$fj0faM-o{1i|RmlF7 zIw-}^lCL5s7d{5LD`3^2VBo)PvRBC#gX;PM-+5|PgbMKemN7q%!~f~t%P!daKzo;~ zA`F;G^t!?e&p>7@{znM(B~Iel@Rn_?jUlou+ST(b6Y5v82n^hscTYGq;9*Ga2i;*k zg3qSRm&kug+?Lc`pdRR9+&oGC;h?~F9Z|xp!Tj=QW>8X6m-L-x+mlW<>_%>l@cWOm zO_Y@8C?P&(?fc@@XeNa(c9LH;ddlifx$=IRleqe%Ct-?hGB{Or{K3UbLdQSa)pND) zPp!!J=amZZ{Db>=a2aT&oPUoj%3 zchMuD?WfI%nQ2`e`FQYU4t<68v84(VvD3K2O7naWDG6#n+r2{|6D7DVV6A%TX!pNb z0Q5n)Agg@aHZcGWFL=dxxrJin8AH_!aMHtcJonvK^b9i{<9u)-FxnTZN52Lkz`I^G zm27;&(*bn3`Is;=`_p64nuWHX4Kz<6fo1gL#Ok**$HPd_$V{3m$*LQ&Q9aEBwRMU z*S~_pDVA^5$RGS36z36E-?Yx7^J6+`zdui_LRx#KO|6-19!c%hm8F}%^t;)FY(>eh zd!*7_weOMe%56kCJ8-@VJV=klkfy3YE!E%owZ;iwtqCzDmXeAiG*BmL)0XLP;Ks;h=PbOZa1izOMsqWz!CP@XXsc)@lLp&8R$HE zYin79$(WH^y#J^NCHW_tM&%1}(|Vdcb~oVu2aXnetWDpb6oA5u+b}pfq34GlK6>iz zE5a=l0A%!^!;3K=&3|yi5@{?36r?Uy{`7tt?=wOb4Hq$Rv^%5Ret>#lnJPk3_Yfv0lH2t<`!VD_z_~a);pU!1cnw`$4e>jSz3SGUpL;8-h%cXxT zMD0l{e~7&F5=fDqV;0er!vVcfs-I&0Czm-e)O*_4Tg;$Akbqg$ zA^reWyZWUqH_K1kPJWyyF%D6CA;GjfrrHv<3sP+X4gZ}~YYNemmkRX(iCh;HaaP=x zzBdyI<;H_J6niOa3^Q^pGRaVShh%YIzRl1i_)^^wIEP4m^Taquaet*d0T2JGvD(3Z zOA>2qJutaS4iJK;McZNuDc)sCk7{5CLZ6D&D?vzMpG2Hf!x4+)5@vA8t34Ez&Q&>^ zCA#$zbK`eu0A^zZQO(L){%vad#r!3&idY8khTnF&wWaA8P4^9;_)7=-V808A=sWKZ zg>z^s1`(ib9q64H;(W~SRkSnkKjiI63|?-SPc$dNn61$ZE zG`Y4Hz|Px%pV)LYY>g7qyE{@}Wl7T${aBR=BWT;PpCj87MB7H2O4MtxcTeQqaCEl+ zKGWb4!^cR@&_w)A2m_MYCxKCwBiN`A3Qc@gHuomEX%go_kOhH>ESDKyyY0zXUp&=` z0z&mDK})8`7+YVkbIc9EtaAqdA4_CIx?!PB7D4!76GZqRwhel6JGVeXMVF6el0;R8 z4@{KrFkgZ9TxRZ|> z)Rlkfu zVXLIwNgrx>3)tQw5%doy0o2MU84)vLOT5bIo%*!SAIu-l_&j_rcdmBX;Qqr2jK=2Q z0OboKC+GjFMEX6>H8d0)Y$& zhdof}%`}?&SenqQkJcGliBDSB**IxLi`vZqRzEp@G`c*DMF5UB>+X9MK@hZs( z8P?f{W|9pXv2O7|Y2v=JAzUQ&qvR5$3Dffp^~)ydOV#q+XT0EIoC1+;vALCe^8Q&* zvnf*@&Rt3ikAMT`pJBoK88&0_DiVbEtB*e@KEaTs2@8SCiF^jI0nBU6khB*LQ`Xht zqPtt$-Tr&tp?Yx{j2b*ixc>NcGD?YQuNp2^EbNJS`)6Gn-jQnAmBq*U-ET(1FKgVl zk9eI;cQ>%(bSTfuQD6l58LsSmfFFUu!EuO@JLQkGe6YegVudSlk@bifAc56kkDfh9 zVwwbu8BX0N;SYK#CcGI)lj>F}sv9agr~{V4UdinzT8VCx&SYElhWX36YFu>rKVGtJuFqv|S1pr9Sv^AFB{-q!(b4VL{)a>)CNiwCiS^>6bvqkYbr- ztClpGwDDqt=mFF4%EO}G2^5#)`Zq~C-01gocWE$qX|&P}u@I-NFeu6=qjA2FjU$H8xjn~_C_ z8aY|wLFxRxzDGE$;=Dd~hbXzB*$DfkAG{bqbRVsg#RAs+{XUXl%`S{hTH4&q#~l8R z?~gsG^DWZM(pLJt(k2*&u^SmRpv&{IHsQ}J`yJoY473WARg)fA005sxsZvr42_bym zjr^Gw&SGvj+z`U2_;k_lxf4rE9iFL~sBRuWf>32S?6b=TKAg&%bGAj~0&&H60|j4Q zGd?nfCUuW`FryC08el)@N{45-VbxmhjRW#&%LW!i)@Hz#*JkOcRkp~;V{*l9lK67>n|7T5{V(dK z@Ek_1ZUlVFIlDLx_X_?vphF2qi5$B1yyfT;z`*?J8=GI^uM(7MhKvyi1l;9{PHOM_ zh>;fT=++sY;;QOnJ>R0&R^X$eaGFt8N^A8aK&d}i>HT8vBlndjXCQTdc#2yxP;2{0Z4dt zRH~x!ASnqURuOx7Z3BcU^ZIh_wwSrJzr5Q;H$9>bT$kNLX6MRi#npbosN>)0w%<$L zgw#hiG0uB@yZ^dh)Yk?YhYdM11f0go{PH+;(Ap z9?O(Ol65&%Hd{XA$WEXNfM4)5@B~C5PJ@aJ1f?}(mETGgWgj|;t_m0!0@_VG@u>88 z95GgH?=p&sJJ%o%quow$OfVRY(OjV?*yWg6VG^?{kO!76{_dH-TngUCo&tbvf$@U# zQ#KRF8Rz5UEXS#;?S7usYQeAc20IK6$s{s`Ej>|r%?Zd}$}F(7As5wGFobs2V-OWM z41EY(L^P^x=ai2&Mt@o5?OqU6fFy_~z%o zp*5PRnXx8<$m5!#bsmKAd_|mbL*vnUm=uqaIETNDrNq_~cuOEd++*(ni9ht~U^AWe z&|deC7An$qa0iApZ~idhN1Ut`cv#dMc?1ESsme=w{)bs@J)bZOO~SX$f*tMZxwrXS zi?z%|`Ap^fqigyBugg@5VX5v?ZU_1(3#69r^owvimq+WX&s&EesgKWSl80;TRX>~a z{VM%Lj3sgb{IF+_S>zFO`YYN^EFy?dPOUS4=2XHxKvx(a@l4{FG4lCwUpCzz%@w^X z$W^I~O4xqD1sb&UnEpu+{q0hRIK6b+826XALwtR*E6{al0bFdD$O1`x`SAyRmoveC8YVk{#r+r83|bw5N?iKZ!#SJ1G+ zI`3h{SzF0UDRbMlpwNSzu;m8*dd*RW>&crhXTSTKU-Rln#M9Enu#yN2gGp^~&89A? z=R4l<@DD^2CxXw@caJVy4zyX;TDW3l4EG|u6}6qjQ|)etSy>C%1>#1L%i}1&;|Mf_ z4yCVvTE%iglVDL0hp%iDL}wsjOCB+F14KI9t#-H_eJ93C-aOE@kAEr0M07O#SyAD` zTj|NN%z|_;ZgzZTTcyLgwg<3|K|Y`m0kkEavcFm^qBQ4VR(f|ml>Fg`lv~G=uNd%8 zE`&AoIN~Jpw-tp}rO=`CAFfGK=8DVdlfqns?Aw$`lt#GffDTJcR)*kG`O-}NR(WrL z=Lfx4p`#Jcv5Z$2d2E4Bm$NpP$CuZI*%Gg(y5sXhfy3;!!Y_`Zr7vr?bfWoZjKhwj@4xo*#~cLer$P(tWXuQ*bo<147O@MzTgEJFq zRai*+M-z%mJY!1vNr02_MfgBYdp#0Ze6hmIO7G|m)-BohLXn~cEbQ6OBOJX0h_pFA zu%}nU`@`hs|6GGptPU+%zBVLMh2SupjqUMo-=JDF`ozZ1ZCVCj_R#fydk zQUQK>r!HXa4*Eaxrf`A;E5tLQw$~1ppi)H?X*npM5!07>UE-4~SK88U5alI^I@M^G z{QNx)`0z&bFjs*7JVFW}NdA`W?{-2fxcXs1XqPmgK`}{rxZ}6w1-HdW0J5d{nSu-L zdXlgd`=U35^5H->u+}bl*tSYkiWaPDzS5JJUJVk^uF%Afy@{-wj}L*QQ7*a@Jj7@| z?H&z5UvkQ#se>v23HXt-$MUOM#Xm@A1vT*pyHqImRCk(u611Y6f>Ux&wC8w^F4a~h zo%*EH()jBh%P)OnRYHSRW2mifmd2)w-}9$OW?jo}r~>;eS2UD8M>Q9`s;lfXxQg$b zAAWp9%4<}+QjAXmOj*%>E7Anw5VC{?QAC*`DM2T9?-Z)n;i~QO>DCyOB-x6}#}mfS z1q;=cS%M`iY3{Li&X3u;^bUNYivI5oID=x#P5%_jFQ*3(sYgc4Ks%2Nx4Ha6sAvCj zQUGUI?gYsaK`sv^6F^l0ab7mbLS+v@5zoYLcE0^1-+SLb8e*WPOsVRf2kqtYxpBNh zJ`@Gi0l2~EL!}425tFBBZ$n(0o@0IlTx5$L-FVjO22RmF`ko)9#=Wb`#riHF*Pkmw z$J;#vFoi#1bOac@Q>#KCGVLJcJx5rjAmd#Of9_r3^->|M1u(`h$)kw9R3eMiY2!^C zb`m~UAfHsh6XEx9G+_&h7}9A&4=Mhlh=}onCi6b0T)x03rC{C2PN#u!YF2$s_w!`x zdW4Q289~bVvA6OTo_)(__ChzI^dVK&bfIpO-^35c{4eG|jqw8_*K_tSL0(bqNji{# z62X*d#?ysTYzh!;>DPQFu0XHIJtly)2MTYwbDuFj>oVA&8m3S_6t!o`kA3DRqHG*5 zL1RH_J~st08a&});}X=T!7vE=I}H4XuLEANO$2nYaCD>k|f6R{;3sIeK?mkQPZ8D> z_Zs4a3n^ux+?ofPHd5BvnOLY)UPL7Ki&XPn9#t=N2S5s?mp6tvTEd4<1Py`N>0;yM zj;nDDOaF?d9})%0fW#Fbrxm&flDAy80+wpGq8#l#SVFKr@| z(YQ@S2J^t6!k!SWP+Zyd7o)g=9w8~PDt7!oYgU3O#e5h23dg#atBGT6bN9~9tdW)W-H#(*!UbEBw6URF< zs*~E){PA9=WzBddBYSjHCE>AK>cDr1(K$McJ1DgAcO)4sGCJkEK z;3&8;wY|f(HQ_G9A((}k4Ox!X{lv8jps14>D5O_qd~FAk@|f_zm)}{nZLtb+i5uJjxO!GDtRiKE!F7 zveE`gP*S1`H!X-YV$jA7iXB?X8{-{J`jZPJ*Ee6aJlLdGY#&VF zm75&p41ZEfLLvwZ#WE;zQ@v136yFtVe75?dzliEn1g5&4pDQ5}j$Wg&<*z&X6BRzq zs|a>&d)epwZv6WoW|vF_sy{ob;8L$N7379=^kF2t=L*9U)QmbMtB{@)bJ&@7w`fKXf`teZ^fkC_U+9dTW*mKUQ>{P5S4x=10m!BV zJYod|?|Rlscf6c1E-V6hG5Sq&`4kRjRKL1u;!AW^EGc6xkfTze>u{wh*Fi^?LOpHlO>}ll^9Z!W<4{Rkbkld`#4D%Rb%US6ke%hubCf*mw{J1 z$H!c5y=j76et8Eb9H|hW4I)9TOvCwcyubd8z2%=ZShz#>7;h4~H z)D|Esgrf)Ep(z1+`P;X+rM}xor8&d~lhiN2s_pw2J|V9{WLX$D-^&jyk8mN;qyJwd zW!SyGI*YNdbQ$!VFIhPZemeDiQXOTHH7_6)^|H+E$YAUV5ku4d|*f-p>)u+)2QEGh4tigHi?BphAG9}=h5B= zS7#v>gu#o0M+pLB-c>PDy#wsF){zFj*t`(eabI_*btTKVd@r+U}68WDnJG z{@XgscBmll&X*dd8!;<<#VFhTf$@!&eOr`VvItvUqsz9&pudvvL!wz~aJhmM017EI zmuvj@Vc_xqQ7newfOjZ^ckuj;P^DD>*i1lBefuxesR0b!g=9o6_;2XyBdj|lGg7a` zzmT|W;4Yp16upqUzWHyTfT#LB0$}aTM|$f2g3E@YfxD=^FeLxy#Q<~r2%u==QQ5xy z3qo858iN|gg6)4s-v55Uhd|JSAAF6!|L+g~eJ(8txQihy%J~1h#(&-k`T@XyRftNz z{tJxT<`3?|R#1lf-Sw5}M`}01po^ zQPHo54P`DND~!N%-utkNbP3Cg1pPf6jYN=X*J%G#J<{-qzWDVNVb6<(Lv1_95c99$ z*+I8AWqa$W5xmUek3V9*`oVsen({ALyB-~6wjK@5!8Z)YhT&ZagY3-}TB+i{dYL?| zd1t060(_Fl)W;>h^_pHF7#i=>DPo%(_OC&hfw=_$C0jF>Nw&lek6@iMJj>a;ylYth z9Pxg9bdV>N**34D8P~a-yOTI2NjZj9QvX7t`&H8W2898gz-`OPY|11<06m37kgW73 z#XQoMwEi0qKkVO3=g=tk;Sfdt+b2A*73-EHsrBkav-xNlF?|zm z0nAySf6YvZr|U;iwOZL?2$|Ecjj)4%$vbNC9U-CURb`C`HSWJBM=9Y%o$I$d{KgH# z>_RIOH4`co*Yy|w=GJAjM^voQul_al$|2Bn$5=B0+ij=ev zw9ji>1v%2ym1+(bzBNDms~bWHkQcg~Y7PZnsh`_3@krT@FSw>7`$sFvDHbqv`>@2g z8^#gb>wEQos1*O1&0Xf0ZdjF#qCWH)iF1-MC1_J-hiS&G+omiqxe5llKNlzd-S6ik zZy#p_{oPeokx&wKml+wipBZl?JaxQ+)Oyy-7pfjJuA3cl?pqv?bKYo$z1C^KdenJ%Lu9XzR zo>jd~}vK(!M){=4#^IFksxSAewR_W(hc+N~1BG8o3`AyC#SJr$f z&tC&_E5g)evUHe6ai-&V?J5No8!=5B?{J(oCNV`QVjmW} z9`%U{ZzCX%f2~6hR%G>Dp;QVY6?nt8yyx}m%x6FN(m~irc3QRJuAIu)HietgKSNF| z6-1uL9RD@VgaQSNIpccGml5-C3S;pnBxMHw_|jZ7zvX!2>9p=!e5gljXu`G0Y7;-7dEaE`siQ15ehY-i^X@qM;%r|455B-f%_(E4Xpng(+y(%MUkjjuEbYwl zL%}3ERI2CuXY^L6uu+~As_s|G$=5|Wc;CA z+;WBB7;ZGYk8zzsgUI>sVNHv?PZ!(WrZuM?oLaNKnxaYMOpNyrD%IURqMZwoSnC>sW@XjfW*f`{N4iTQnTN+FJ zV{8C=i7c%LkppG_L(u2dPYwP>;0a+y{+(8^#^tZ<;O%yU=|29CkW)(7)%Zv}gwW}- zW!;d-_3t+6QpYsXrQbPyh)?Xl<9ey|zx=KL1RcQW2m%`s6LEs7zqVZSTynIUkfWR! z35`3N4L#5jU+iLtNr0_6&c5!@zo9-j`NvupON4rpSXKpgt}OTug=p_MEM-2oHwjvT zsS!qOu))MldHX)@&YmX2>>o6%{~Bd4>Gn?Nd?K1|XPFf)TMBv@SskAe9RVmt1Q4AT zP(ST^|Bokumxe-+FHg4bcszK|RGg*2AUEre5#@;CF;?J*)ZcAI|IsqOe|mL&u2bGx zzwdxJO(X&B`=pbVD{at!|MU6a+S~_76NR_HY_msMoC>cS(;vUzeYXBwe&E+W`d;ck zZbpj?!+c2p$748KVGz?l6UdRLen)K}QTpqN^32FwuD>fxReI85UHp|p5DAiwIw0)#w=7nqIyGQ^0 zvQT8CHicWT7G|>$>W))A+pKS`QC6xc1q6p%rG;7`^|I+ba zy+bccn@C3rwnX|q_@Yk#T2{N9Q1!siN3Z24G2erOCsli&dh~zZ`yQb@CNkLZX-aKi zy~Fxvp7g(MBM&y&=M?{XZ``}oBY+w`?XNfoy}K0u|NBcFgkZPt?z6dxed781-Ma)Z zuTG|JjWpw%5GERna6`ttr5I+|pnxp{m955zW zIDX{%vuIQn03xC9+1#x+F;MIz0+nV$kCUyiN($3PWHjthMb6@)0qcoU*w*xU1F!BA zV!)C%dkN0e));}5Dnpgk?`&_3s>0L?=)*9;3@8yg9#MUR2SjXC11jaeL>$eCEd&zF zBtA(Tt>{l=O`0e(47r2Fwgc@Y`i9rThuTg;n)WT6BMgR8TajX{LMLh3G~>&WLCg5Lp>bNG&TprCgK|zPkT-{d(o?xZCA+bvvl5kdGcanaraotCkx9X0z1TVaP=N zIpzNGcv>6CLy9WSZDK@sgu<*JALHNYu6W@f-q}o5iL=j{%mwG|1@1^6F~&dWW<;Yn zl9qJ4bp2$`#BsJ?Y3)(LqI&~5A8Fp)2JYF9NZ8zT-~p29D*z-2ah)F0hV237WLM1O zWMK2l;>pj8RZ}*2BSFe1cP=8GG@l^yDEcjMESeDD)QUb#{KF9}uc05=(^!!+SjS(& z-YiL18MI?_yY5^iV_2=T0lDOY4R3(LT?EI+7~0IESOAAg3g~=T?!Ub*PYV4u0KxN) z21~_bTgkkyrCDiK5?a9_YBQZ<0E7cCxV8j7xDvN*02yzV5Bl%U?pVB_JKp;4%#7M6#R38w*qz=w^hyfqs#hsnC-~0Xyz+A+EU}ACsX~yyX zUxeEMMls~PB33$(`9Hr*Q4jR(MjNlUH^|zI0qw=l@nisyW|@Fj0zC5+mD2fntjd&(;#<#`q2TzA-*J^0G7Tdpt0}sv1)#syOj)UUwDlJB(@T#=OQ3=86 zeC8dzSvy}fbL`ICVMvy=Xj5Xp4Hf8}VhjlAz4%>b=;4e%*K)^h?IYzN>?y&gn#3qE zU+olhS?yELY-s>Wg~mMzadVe8^eUNRCy)2rNp%5Juj3M5IRJYZjw%T2#6!OwTl!&5 z=i`vKiZ@Q%|M*4Uj%-R+lU;MsU7r z(>q$1TVB7hv_Be>>t4F{+d$}NEnNV65uoegiZ)FA9i`s|@Hmk*_(yPFVdJq@M$qnR z0PGa2f*DOzSf8;7>=y6?@%noRpIu@ie?z0G1O7augegPDQr4_*>t(!+G_emUx;}w` z4bz*ds%9w<_9NLr*?k54SWx+-V*!ga9AI zMZlu--aM`+|Mqy(HA!gmYsHB3em$JsSpf{Ma8P{HT%nZk3^diVC2~pt*5m5WBDRX; z^8Ku09tul&kvahZ&+%`%Dtu;k0X_b(0YDC;o3ev`N1MBk*~KMqFM@_*I8AW>H6jmq za`=p{{k9J0`=rg0(n+SJ-+V8sk)+QJ98TyCE0q@r?bHC15Z+QSPl#!J>R*~FPLWi& zwuTVANwuH%+HFAbzj$f(mHS075%Juon`?|NzXQ&f)#P(uZmxH+`s5eW(29jK`Ar@o zNV*OOn;=J*QX&U%PN?_`jd`l4K6hq0{F;7ZK*xcUKx{8|xM%6ij*#f+zPP#P{GMU+ zkr3+Ska6$Z0#X%~Q~jPA=gp5u$TZ5oVzcw|S9pNL3?dhngC0)+(M@`k20vXN(grqa zXdA-_d^W8b`BVwd&wML)RNAYWOh#Z*1<%8d!>V`;yjmUj`HeL4h>w87it42JArse| zxop`8-?y$HHhw_#2~+^a8j##ayP-X+S!B@2SGIOem-qJ`R$val+@Z{pSVg!1Momry=&}>Kd2>mFSu3D40(bLkMl}Vs#!N8* zSSQqTzPSZVA|!cWYA-I{4SrH;%ZZ78!1d_@s0NHeRaq%wgHxpXkfB_qKku<-AZO#S z(RyREm=#)Hn<5M9|CBM`s20h1{uXr~5J`*He1M1A=l)Kp@}SXtU33Z(?pqiaH?O~+ z5mPd;fyrkejgBqZm#c@~lR(0rs-T)J?L}*%zIPcd3oi`mpgsUIu%{^rd9+!k7%YN- zWhc$V3F5ZubtVe=GJcmh`V#F*&QtM%`yVgr&j*x%j8ra(PExmm=3NK(TYhVJ3Ovf? zwej-MX|+<5)1EiWS>F}xy2i)U=xFjjRBrR}#a6)$JGvhD4;6e87vH7Em+d&4K!G_~nRlvOMdXqTI@;E7&#d^+sec+)!f+@MsH%j=}P>RlkOe z22T-}vM{1~n{-!oza#XIHriA-4g#D=C?GFt{w6!w@sbaSz8wBF+&nP$vvzlBj<)WN z<1@lZF{Pk7B`SmtRI|bNj6C-#SskD3Kq8kh*^Vx)ftOjl$~hSY=1B3w=5;i7oGDh z(h1kO+PZ_8uAv}x(QTw`>LyQZ95{WGj1bSa_P1#a`49goIZwQqKJ8ecG5J`hP_sN;E@D6zKxQ`43DyXkn9Y^4a z6i$=`ArAolzbdTK+Mc?F+xab`8L&R+o6FZ85bLO(JZ49@;~(3jCB{VWU>w;}@H$ud zAWz1S1A~`k8XlwMSD4w2zf^7|J=TzHW$jNEUT$TR@so_mJhF)74%0?59G{?k0ucV# zE`+d`WrpqeC)g*mFHyz_Ja!Ef4X_N}9Zi{*IPPqv3$JYnpH_P8`gk{a41WBb^4rwa z^!9K-w4zC|q+PE!Rfq0q>W%AIg!ocDt=quG6z$Yd4AnW&y6i)<>J- z>Y~H|EP)P-*b(hnrQns z)b~^zygzN*LRE{`^S-RsECsL4w0Uz^O_zUDw{7s5c-|WFNv|$q+S^C>_NHznjIh@5 z&qv02m8Yj=G!O?$>&m#6Z@)-qDs>7ycj^yI>iN9B1b=#46G<=&)Xd|jwt9N>;*e1A z`_2nq>PJy|1oX3#3ajnuN(6Z#${<{45lJ~XuPM?oX3V{pmg^6nu2Kkalw3MD7OPRp z^O6(@6+kgxhnr>q2&IMvWwyznxMuDCOmqN&1fo`C5BZ_U(Ry|OF<}7+*{@$ID4Tj= z0wX=>*PYTzkEwDf+9-qPWqt-Csd#O>vriuEo7o(5_=wMV5|T9|={&sS{>>fkz36aDsmWq0KV%>23)};NxyV6ti^H}^6pChd}A2O|( zmJ^3L7;fo9zID6JsOw( zD5pozcx;tvxl){0zJc%7THa3MGNyNeVQj>zJrK7C^iCe(CB(U;_^1J$m3C{VxAZ+f zajZ6rtCc7?zN}0T54MvF+Gr`mjUKFrwtJnJmleg5biTwd;VfZyT1&*nv@*4qDyZeK zie{jyZ7IB`J?{+*-2Y&Vi&DZ9h{GXIK;%4*K4b@EY*uB0MQ1;EMnr5<;M7lC|K^6! z3=}C`O_Zsl)mpNB$2>w3o|D#vFFkAS^+TsQy(gySwum+D&k-F?vUrBvkjlXkLjB%u z`0_xG)hZZYyyF4$@n)S?U+w;{f28^{e*OaY%u=@@h(pUtucE_zbAZEQ z^Y*ESjTCEX1o6#*RNlh4fw-g?A+_pH7PRpS>WF#h1Q!ZcKsQhrGNIJMe2PrM%Vw&- zhbA&}3h1c=$6xITE|D`@EOR>}As|GVk?5SAzCAMdv`R>g1ZQg#YDl- zZ?eGU0?F%$WSOs}=Yo&WS zM9@a?Qx`CEkCDosFIJ}KOIIDg-N$k4=QrJ%=}E>qogH|B0F-?9 zmp-CNLSxq#DVLd*5m-*qf2LdyWtP7UWWK4e@vxiD6*VjI7J4q(%U@c3E(41m)!l^{P&ua?`wjguzRZt*RGr$83efbIUIF z8oUR$V{Wl#jyO(vwbCz$2BOuz_hxN8c^Lh;+F|R{*`tH(1*8^=$S-)Dn6;NK6Z#mN zW3bx#d0^PrmyP#&qCW7a@9{@$>Y*TA&TK#IS+u6FR;{%+BdRKlGvS|p^R($G?@Snw zINi3lt~=>S)El|~2Ab)?Vc+a~;e{a1jn*IZeBn^I++=&!m&^VBh_TSirro*UP&*8d zh>_+=yIQm9z_E8AXM3hN`O(<$iyQ|$FJ!|%+vUB=-MwF9W`b7m2RQVC+L0B=B)$C~ zv^hC0Nd-3XkG<=8#_|a9yYt!?Z55o@R?kdDuveM=v|pOOhIqK^$E~70g*tILYbYAp z4#;fT>KAwADl#k|k89TPRbV>l&<1H~dHT)1+L8N^LcLR_Jz5WSnJV_N(VOA!#8pH$ zY_#nqyZMp`bzQ_pDxLGjSXTFbEZ5|%ndUsEK1K5Q=sK4$#5uxT(B8iFNykW}mR!ji zwa1nTd#}=_%SK`TiZYI0Z7+xDlry?&!-d5~qpN?)Q-+T+I!Eou9|cR0&JU)C89wkQ zc(9GRT-E=1oISMA@n_y8@bV?w8FI$87^&d2UHta}eRd~_pIeR}pQEoDcscnecxf>Q zUb?So$EK0QZR`66Sjr>JBmpGAI%jM&Uk%;xt^BY(a?nNe()x4RhrdMI*%-a&XC;qE z;)@X;>scWm4&4O{*ECBke;{X=>aQfet9lv?3y40lAD-4KxSaZ-s)W9aUt^Q-;ca98HI%o^Rjqv#WnnCC=+EARiO$ zRW@{J_h!*x9^+)mq`l#(tQUYcuDO7BdMF4`eQHUlg0gC63;Spn08*WNB%hx0qSy-1_6>nz41CB1q;}-+)1YQ?WyA6b_h8k>!?d~7Z2V|BoQU&TK zR*cU(F~&*S0)Lz>?FY$umd!Lfo}t$6o>JCQJ2Z~GnGOj|#-SU$-dl(yNM^K!=Iee- zy2LLhXS%(550q-=%2)JttqcOIM!;w^Y^dUMd#6=qOv@gX3~Z09S+k2J?Ku}k&VNO$ z(pTEIe0m!H9yuqD#;jn8D6oK<$H=V6PqzO0#4;r=a>W2l!oK#H&=cvxOg>$BXQZ~b zh8RY@>*euOPvh;CSET9BgXe}{(-FXOu1(FprUAonM{*^1RA=cKe0-s2yZ%u5B!IZS z;B?Y*R|b(+{I1@~b*|y_=Z7RAB+Trlq*vJa!#zWvS8gu|?7q?;E|u5Y52N)eCfW_j z=6uD8(B8i}H*R-m3rOX^PrUA(L^q>zCqw@I$Vj2?Epi4aMWc5O!2+wCYjp)zje~yw z&mvhC{`Fr}6#x&glBYJ1KOBG=S zfDL=?up@z)m=i;7QPC=y+)|C^N1Mmb=3vvEBS`~I znOChH^{lFz8?t{`#F_lYea60-fTZ&juMI(l|-W z!TgDPl_-OJmMN%Mj=4e~`wcWGODA5$`NoyRMkKO^60eUi2X*|aslojKOw*2wUv^kK zHZ326BZ#TrJ!H6ksG6=+yTB3kxy{@zwRXsSZmWC31gc%47R zyYG?IwrKCMraxnqt4$!p!Tp+3w^iMgF%|v6#a)O-v6}kkW`$GncMRq}GN*uB-fQ(% zpigLkOr;;-oD?^M>Ur%(xPT2Emn1P}R=(m>FA0L?^RzoCj|&?(Oq3d`ek6N`jt=F9 zghMJUez@Iy+YMNs6IEj^?IXl?_PXT!1nwl5skX94vrF*y#Dhx%ovvDAR{J;MRAd7! z?L7!`;0yRvRGbg-2kOw?4>0xDJKkV}$3d;N%av~5VeSH@S)w)*>yRo&6>;Yt^V_lC z3E@H{0t>QyO}`E=VvX||KKR2B6$>`5R>;TxQlv#m-WxW$foJlDn2LH?rmZV06j+IB zgRH_I-v@GwggQw^Qt(gK+MG{KmvbUopGHT-ACI3GsKy{5c)P-qROr76XuLg@*Nsws ziB-bmsT(vyRp)le-n9ZP%mIPO^r0Lrzv#34=oZGf-@@w;Ffk@RG>Mvi#F+u=3+qGK zNXpXFL9dQQc0U>rKd5nXldz+t*F%L1-Y0F~s{Guz-&+e-x%~I!-661WE@s*f*O|ue z$=1!`%4>}*$I}xsJXg|A!$Mgc>3rs|KHTn!<;?iwaKzTjMVA%+@Ssyl)v1VM&_wr0 zB3jS7l`z*Y<6K_t_GU)l@TZ4L!<8lGeXp$y12S1UOcBj_q)8o%9bw!AtvEJjWF-ct zhKkSFZ|(g=ju6sTIjI*!qy+>L@`7Kl&ZykgksI*ejqeWN=yn;!@E3cWo;xz8h?B?q z`Owm(zZ>~x*YjW<*C5NFV@!ZunF6QG>aN9cTP0#Z7T0Hj!Zuz7aJsWF1 zz2mR-VM6Qh0LPj1ftZw}4x75|xYI>Ci2y~#{>7i)*Ulz-J0)jbyMMb(eSCSj9LMg?-l2{mdBy=%2glj_W`GR z{4>3k1%eeXKZX@4JMpOR**H|wd8xElAbK(_BnoI@4XCB`HFCQ*s^!2ZJezL zI>S{p-;jG7HwJz^G%>8K`kg-p(-D_{X0rrhR*b4by&>~8JpOLuW>i)4*MI~;%4xNQ zj~rHf{sUsk^KZ}_9;_YT>KX{N5swvAFps(?391_{L`Sjtnqs_NxGg@@ zfq4#6Vb*lb)R>!u$)>3mJC9jLL~DL7PJn=hV2V&uZR9*|yYptjARH+}Y(w*u)+zjW zFx)vzaU}tjHJ_y>;d^z!VDpzq{Gu}L;2J1?=$qs``3=FDo-F&0l5_4$Piu(GL zS_1!mMSqLN&5@jr-t^V&ysdQAXYl)(o2hF{OU&)dOLY$?0~`Fn`5TQ3v79$z_unO2 z^q0dl6j@Fxwnh(#kKm@~(zNm4MS1f7JOtTP7ujA^4nG~=GP%_pVUd~=s>9hnoNxFI zA?Tqa>m?q5Uqz!wRQ~{`B|$^~C-;vSXdnG~^wIfMVF%Zy)@zSXp)GDKtvxHbV~0fu z_5B=7ym8{fQcQh#XoC#F)f(d(O9)G}wrXpLj2G!9v!dTzQ&kGb$n{rTh!}Ol&1u;o zI0*OS@~ED&Gyih$;$n)g^+~61$}E2(Z)d`g`)4y&))?K{{i-ZEXx-WjSBDkj+?UU!%ZNzy zsn2sLWnRpcx6`KH%=yw44VLI=pap(fw{SU7E5c{b=szGdkJPH5*&?Y61@6#7*sH!r zlx^gq554!08&9*-Z?h8OnL4-fb~UdJ&_5X3az63EWoGms*#xzjPK5E+K?5~0R>>`H zVu#I@EffWchnR=YuL&|_QOa~u5Nl?wLDVD-+%uY&13w)(;N|h`1ecKOnv2T?qlEjE z-+_rYASWL+Jhp*tW@to5h*oP=j;YTpph(#Ii+GHDQwx5ZShAIzg!}m9_{ems z>UIrsLYH2cA<^pMcz2Eyanh?AboR<^nJFU6oLWe^mhzyK1=vbw9$g&LF)W0%&V32H zdXFVQ^A}Nu0;=(n!cWOkY=lk1_gE7X-+XgnJbt4+G~;MD@~{;v*bLLkrBH05#-F#1 z0HOq~F6kSQGPahgX=#FN)=0gzXKJ`~b;z#=@{>Bn0*_x_^S@=2bTu1d^XMlf)tDh@h69gSgF3@`dA4?S zUw{4ZNB9^Y_xL1UV1gFBpS%0 zfUQo~u2J+31TnsF3zco-YsM;a%p4|fVX!soTNOPjs$QkOeu5aqNs4?OQy-M#5`ahO z5ccdiFzsFxcIuOmEBqh@v`CL6p3yg&lzNstXS(Mq(2VOfKF!}0M@=(6h{V`_@^4B% z@%7bVXy%jqYT~R&1)aXwnS|a;BbHn*8hqM~r}ujZFWRU5u?#`>*ll}s))hljoSs-loFoWKNqm5S5RU4hM#D-?9q}T zH23$fQ1RQhnBAfkaGg($MFIvvqty?`v;+!BvvC=C)!O{A*LR~)GJYce7B`sHg3Zs; zxwrAr+k&5Fy;+&HI;s&U6p zE%s0&mkYgt`{YHb8_60w>(JDmCsfOKC0f|Jq)>mbEW<0R)_#6vVGD+dP%vPImi5@Qt)g+duYZZ=aAD3x2_lJfZ=i z`7b;c8Lde-VV1%;OZ!4i&+Ya1Lt!+Ssj&tZ$l{-CyiX zGfC9mW^R<)zzV)A=e=)aCdygpHQOHMmV32~b}tA$!?q4EoqwJW9KxNpf8`@7lk6Ii z)0vSk9w0TpIXVYUgvI)8-;WiKQ>T1Yl#od&$!z-kcyvvMQR#J8B&HCZZS@mdU#*^S z&RC{0u&=UFatc!b6bclbfcO~I33{o6n132L_csClt4^n-Y%ZVO|!KwB8BNo^Z6^YV6kB`_y(O3+#{dU z3Lff@I2KZ9obSG+f!+nuFFuv`f?j}jB|DMPD2vvhW9RtU&}s(~JnawPr;Quf?0tS; zxqV_p U5Ek*1EL_s__STL|VRj$Cy4Yah7O38LY&K!{o;s3tD5u)rzMq*q9Oy1S zb6m_PL!jH-r?8}gzdVQooUJXBqUGY4%&LBmfw;!bC5J@znsJgQo3i=|m zmeMjMY(RFr%h=^713$ioI~DE;3^?%{wi;JrlV$CkjO#$mT8NJpC$+vNO0n6%Zu1FM z^E$qr-T}L{nG)&p>5Kc=!ds^@7TA29&S|DKK%kOAROuY*=*uT-oHX) zW09?~Uf$;X51j|z+CMBDgkHDKYTff1D!F#oTL5{ASyq_zzUGFHa&`(r=;*!inZYdP zZIRRAcj36sQ4+R7?3j{kr-6G{lxdd2ky30D*NmnHlE#`OC_#duN8*0eWjIS-VPyik z0tjX_2?5*L$9425gsYL#vhE&wr|1v-llz|C2Z4mQSz+?*vHDpe!cv~H$&H7hOuo+D zkLK(g{FNOF?vJnxk$s$v65IZ+yW1uZynCA~@l3^dI2@~~>=0pW*x_RWhFY37cjh=vp++S41eUbi{Z>lP4jtbA&RLfq#aS{jX>ZSi#;=WpfF=BVF=+SV4LF?Pn z^n;;bVfIEhU_Fd{8OcuQtGW9gNByx9bQ9WVJ$P^Exto^JT5fDgkmM}z2t>fN!;YNxI??nL&45G}% z_TkVa>h^H&Dpu)Yqjq!S5J~)N_^5$#gyyxx(~RJGhdtw6Ztq{eUmpiTrDhiN%v1Dk zIY;7yoRph#)tLm!w|4X4gn*pK(5-F*SOAIUo4x>VwU)& zx5i%wJy2#jKU-0mw208+q5OI`f7YVrzLB}MF|xI+UlWNV-poC^Sn=hlUf;*k9*%~1 zY+t#$57-+^p-jq+cU%KA+!CTc0ja*7@)7S7$-~zoag1}XygQt4jur~S8F%=1fF@iU zW3M7Qt$CN@F#1BcLch>C;Jr_nG}qg+F(gFP4Myp&3@fw>!wI4#eq{U5jP>X}S)yL; z{*Pp#07S`qDK6|_m5m6j?6RB`q&O7_uTCx@j7Z08{^#Gi;Z6< z-XG%3w^L{cRH&)0cDyI_o92sNYuOI^iNFb$MDwhC>7wau#LiI_m?)G5{ICyB^)=q! zu(jg-yZ}P-2usu8HFf`)S8p`!G*}|DuH4*QJ>LO$7hJDY+66*`;gW1!`$VkT_pPo(M z+H2piKIz36gkMe8Cf4t98`qh5w1OB)jv8SGj0u@`7cSxbIF~NJ!|tw>I^#L{NP8w4 z-bHwvz|KdV;#2ypB!r!xSk+Dl0tvdY8izz2dDe!raudSG zKlhccjz?o%>9s}n=J#RKWkjI>X*2QWo6nYm&PZWr>Bqr(M2x= zD!(O13+FS&IpJ92)U>1Een#jDg2=bN#gY44lE4k$sYn!=6cYQ|J<}PD#XYXf&0k3i zywzZNrf+l$?nZEJghfi?e=7TKgQ{wj#w?xr1dYXwvbt&U&+~^unzfN73#al@=na>; z0ts4}(@Nmaew;KOG*el_ix$zXLK8E`&t0KBTaKPzQg^?o-zDArf?2t6l@*R!{8Q;h zk9ZBcw1*l-HS5Qfc&r!&u`s!{gWM|IRH8nE-0xL-C8p;q*lh}F%s-0Y&W-g}8FaR{ zmDs}4?)Vq$blwUIEVI-l%7LKYQ)NJ}=H^etbW^9YcWRet!y1>5u6;m*b5%I=Wr64^ z_-71VrHlxiw=C~YO!^;bRt={FluY>?lx1p~MR%$Di0%9c%y<%-FTvzV{(W`5CqgOZzj!RcqX9;wVBlyH7PbOkt5^H-k{gmy2`0HWDxQ4&O3HzUqR5osP zOKD%!9c8B3%`*1uX_EI+C4`ze9O(D%{^vtM3ckfjBf5h|O7hRg|Nl$Z>evv`PL(8i zn2wmOFCUbQu?F7B=eQo|Z))H9H22R`xZJzzug5l&Q#MtBSkCo3l&4O>IrfZnUR$U^ zCe=bK^f8}G{q=$SVuBz+SFO2nEJLk>?R7f>`UnLRW3JMR#k#q8VukS)<3G2Z!g&Ta zTTvg?YCM@X`7v0r(hsh8DtL7H`l@K$3A{yU%z|Te;#v!nf3jag{uO7@?%*#|fD;-#(FtV=pG`ITjO(?O#t~2JahcRob_=&VT7u(KjUR+IwNU8{sJXy-sz&IjX10>BtQc z5*NTlqQxZ8I zm!o-=k>=M;_muR1r%wtqHRjz7BI`N#Q%B0J8nH)f`aU1#GtcT!QceHdXD9IHnvzlQ zD2`L8TZeUT^UIs3)pUTm_riI7H!Hx?)}h54@Q9 zXYi?^;C>jzvMl#Jew|J9b#&`L3OI!5e{p+oHC7$^G2|be*#Xl#5o6Qxk@El-(zQ`z z(Al)BdbNhSxiV*$c!%n59Wmzu({X#hq&-0Qh5y%!-YPh_g0OlmA?Kfa(STLxefPTP zYXZ)yw|@dfYr*jbrs%d?c2N5JAnJ9z8D5r2Iy7 zAg*@iS^vz06WDs}Vz%IF|GPE)@5=*WDW-e!x77Y6XsKafp~!RzC}jWZ>jy(F#Q*ib zQeGOYm{SLEs_wRZ5AC)n`2WI1iGoL#7-%9q^@9(81B>uGv0>OK6voVMB zghbr?`%VA){my1B_CGUq^9MW}yua{phw97!`dSKI7xDL+{?CvENx{mp)>3ms{5=nU z{r(KT1=0``7(g zBcxRp&ab#;K+>_Q1pxP+<%$VCl_IMgZ}b~D0EoDc?f8R&VZl=#8&~U~sTwEr(>;0n zxoThEGte5M&+i(g?-!q_2;>fe_N?w^AArNqv*mQ(dLnic#I^zWUkD)042_=qL8^+1 z@K1hb7n%GzxTnhQPp15M-nw!sH@_`OYk6=TH2-;SGpgWNkn&THBF`46P(}+x52kZ=G8)K8&-?;*S*x+i30`T|v>dyMqY0Bb{@$&A4 ze!T$4FD3XN=u#d3Q)L8e>L{<)Xk>bw?5CeSyB-32E_z%a5v+!{YTc4e;fILqR5Cy9N=ykxXXZ82v5kG;;bDNB5?}Lu)e$fBv!?X~nU6Oo1 z<}p{rPNI&jz}fJf^yIE(d;{YScx8In#+W4 z*I(fWD=D|5wWN5PR1p44L{2nanaq1`?ZkE8Q29)Onk#i=j}5>ZGbO0_E>U}NA3dH6 z09i@}I@Ge=fN0FGPAGmaR8GiM_VeC&kzt~?DIXBN{1icpxFu2W@TNXM@m23XEWdk_Hvc8 zA{Il}fve633d}tM5g=WTOX$TCv1yu3rSk4XN1ymnU;M|l`(Asq-bY2lEwNWEIyPey zTy@)JH7`I*$s&>S&BT{iTJMFY%`v>7+%>CN+x7J~S>BD!ob-ggQAO>lNh1L-Jx~@# zWmYlD17LXL4;w8qJ=STC+R0Sbd+z8=8b$W+_zX0@5Sn@n>EW)LO`SOfy%#pLLt2km z4h=&YK8S?`gJ9}p-=hhbD~HIsB5`0Awg7h!#;fvG&|49$+u7_WCr3n1oFePSmIci(Z~TGS0#LFHg!Msjvx{X>#rO{w88x426bMLXDVlCp7jJKv zfOZCgeYFR9&`b92x;oI`rJ$(GLoeAE(hF~NW$y3g44BY@inpYI>(WIRI zcz9nD1@fGDlnx-!uF&85v>kwf2gFg^dfk-Oy88P+bSR zAA}#1I4K1hR0qk7T$lnCnl26%>$1)bHiwM2%dTTL)GdDH+!I&+3SR4 zf`P}toxXEj5*(QeI>7Cv0{msa_}VmS5hY@A z)y-A|L{cgi`%c4fsy>ojE()^jO+LEFCQdc@^S2DNlF0`dv2N__xdGS za(tYV4A*HEi?`ke*rJS%KU=!JYYx03w*)MIZN61qoeEjg!qKl3Ox1vuCLvdts8r-m zvl0aRD5Drmua2^=lVylR3ctWzu}71aQtkCA@WnN|7`@VwtMPvF*@SeiN+Xk7baPa; z^&s%x?~BR_)^~5DCsQVM8zzo4IPJ101TuB=FpLl@1uSAc)uCV6frj%_=;Ha zOw|bxaK4NjY9=?i&sIA(9378dn*r`AHuQ~c&6_?a+{Bt@ACG1FR6frKCo@m5 z87zIlnaL_yC7iQN58&(TA#}D%HbpB}~;3KCH8q=R2NsY{|FR{tV ze}CHlRv~pgw@1kjg4;gbW!DSWFO;6PWUd11+1KW^F)Q!EZO8ss}0e2arh_ z$8taN==ALipb=ytflibMS{M70PvE0grK8FYEo&o-TS;`*-#>_e2Pt%}C4;i%?4_x& zT_Tms5Qq-uIY_*G!0FKG1Ko2|Bj}0^p5!?;9SzjA>gJy~mf%8Ov`5)VIO4jJ`^UVd z>-4Qg?Rwo&JoLZH{dEYvu8Fp}drnsxH!MRLV#!ZDI#8x8lX#ej*H<4%-E`2&m;V(+ z>NG5Ay#xluo&F>narV`>5r~(P6l9I-`^gBnZl8qcRT(XX-H#CjJp|oHoLnO-?5QGA zdw$n512s%!!Ml$=o6iggDc8BsR(gSn37haJY!eN142gy{Z6CkiclZvyw7~Uq8eZ#S z^1Ej-OZcOq(D&*5^P57>DPT`@O#4j%8h>g+Cd(PT#y8Q#H{mjl7S+LW2PH{TW)a%C z{wHnz*o?3;BE*W-6g9w`&0$ps!+eoB9yQEHq~oCLSE+7Pwc;6?;xY89)Zc||zp9)b zujCD$a}bLLRuBUkf-Z<`uBh~#3p&2Zr|;nG*IJ^Vxjx@2nW56?`xbH56-R~AlHJA% zJ1NvG(es%4Aq!uz1uYqb<@G<>f4bN8W<#r{Z^{j*ksKDYgZ%+8!A5nDXCY1lqKbgZ z#huJH{~VEZJ=+Km=B!sSCM+NW9#Z6uA>4h}6? zhRC&~URe_zX1?}Dz$Iy~U0fyFr*s#gx&zVbMjA1`VhP!JB7^qf7;OGt`6*w_j8sS7 zO}5)+_d*GL5s!5nwUC!2nGlq;1K87z38Uw=&f5`3pnL%7xR3u1&)e?6YT*U%?45l3 zE{6<_H~DT)G{c6oAqo-#;u}8ag{f>t-}+}0AX^Z0(e$2vhF*adrxiMxuWjeYzjr=Q zE=Z#@Xubmmt5~V!U}D5z4`}dgEC~#~_7@Jn>rvsJ79|a*FFfydt}##*WS#x;>}y~b zr*Xe(mUMH-lo)sOs{B9o@+v2`NMf zPaSZhVHzr>A8i9d(RFDt&lQ3I#^-=+gOlI(q>>I)Z}Pq7+FUQ|Vyt76OLkV724+dT z8$>Y9kJ3LzhlTK!bbc-FT-o^_tKiMJT3cMF(HF+AW)L%WQY~)!9G^8Dfp6yY(6VmP zPcJFm-JgI~aPs^P$`l)5PK%(yOK zV-wD8?vA$bFm6ngEL4t9%m6fG6SCi~F!`{Eti9_z$Ys!nD7pBk0Wm*%eo|wMG#l!Fh05C;FPtKZ155$Pwc+Do#<31>LOU*C(8-m)Shs4#2&dvYv9A_sCNhpVbAP zOJKe2Ywr(x)hil-y!#k|mdVg@ z_-tJt82Ob+o1l7L6`^FUmP0;n2Pt9}Oe_Pd4V|>Jd}y)U$Ca{Pp57YD8posMlVDF~ z&ZOS2aZf&%9uZ>IDmIO1!^+l&o343q2LoZQr*2hqr{9h5tI@?%?9OyCqBOrgia0Kip-Eg}DJGDA@A{sYo-7xdEF3@L)1RWBG? z=?Bi-SG<((+Fhg{Odv4k&X(LUPN}|SnbXHmJ9zSU8q_x=S$tjLjKzOS%{!UyGA`0x zvydiur}5dv^7TjYD(rP1@<=)U@p-LD@Zw}LEx!4>WNebgbMw>_ttcFa80ZD?Hj=-^ z^O9Tt7-k*zWKA%j&?uWLS?8v@{s<+^twhXaVT@K`D6&wiN%9!F7&w!;-&bup*TEd#}I9ULNYkB{IZ_LyJi- zai3GKca>pSgLSwQFw?Sq>$DsO9^b#bw<@V^Q}Kw*N^9DVp7Vl26PDO>r)l|ywlOd$ zJ84e-l|e&7Cme%DCjw?77P83y;Idxh!l z28B+H#MUo-LA6q$P&Bt66%zwh$Ka%D&2->9HeFT`N6b3uP?aSYpd(?;aE z&Hj4IFf`*cQ#j}(BC-0TD$K?0y zBhv_WQ<~bVTyUk{m z)P@R*p7kn4iv#DeyivmpG(qkYBYt7Bio}UK2TvdbF~w$+abJ4dMCYs36wA-N&o#Ne zk54C8;#=f3QEAq(qhJS1n2{qUke=U5>Djq(L8D@6@^8B}0YG}tDAS3VI;o8ZJSwwW z=CIm#!7c!n`;+X!eYteYXbc`k^gEn)1LrQJAo|=XD36ZBL8#wb$7oH(9RM0`i+=*I z%BifO@MO1bx}+3Cy`Sl{Q-Y&V+H$vyu($>H8SqbS>rPY{I-5lRT+y}t51VNPoSEkK z>|Nj}{#GZZKs?eoP<`siMYv|KgsWdC>y2V&Ri-ghvra7hE{xXJG9Z>WI5C+0rngk| zKI;(8W=zfkF~L_;1D8)ER^Rzr(DziKH$+TR;Ncz!Pjym7^Fn#WfTrb@+`s*pz`@sC z@Y)mC*|W)G@62Cr5j1&Pvm0^51%V2dTd%F$wu1wt44ow#t4kHC)aQY{nIq)~c(p}V za;5xB=cEIf{tLXLE;Y>tFEDGFjOHS*d=nk6n+e;3lPeydq7%q}ty|%|yqsuad`?I& z-ON=5o1SA)qT@`5W;b772~VBp*SQPY+BP+~OiNZKS^gl|02@BPQurEr^g~m*7RV5A zXrw0~~=I%qQ~90w%Ao-LO*ZgVGORpkh^ zVdIlmr57?=HlNHQm5eaFj0bHdZ^;~&l=WEVJBDx?+G+41QuZe+3%mYAB}?VyMf0D3 zQqRtIdz+Y;yddc!+(`!It(yiA*vl6l4G)infK>uL-0hM(0+wT*{L%+`Mg_iU(=qH zW2&^G-YAH=#-Bw@t%n;SVm1NZgh{tsFfe?`G*Z^f~A+v8-!!3N|^m&(w zZm!qil-Z~>#eyqGW+f)fz&`i@!<6Z*H+JMXd*LbItiXHAs8ZXS7-gZ(QSE-Lk{}!ZkGtCrrTbCn9@P^T4Fh#vu8bC ze>c;qAV0N7NyErEEQxu+5AHTd%;)br=Q2V4M-BSXQ=`^3!2_D+GaGZX5QqsGM^hKF`Har=UAwEm9&S)vLFvLj-c9A4}LtEKM%IaMSOEr9B zUBU)5=~!d~G_n`-{FPC8xijO&X$2yqzZ6~qeUd#;cVnaE;?mAR-z5aic&s-VAa83P zL^}pi9neg=DFh$EZvfjYd6UaBbbU12p+gEiceR2{blS4JyZlHNe8X^$jUZCjlU%(~ z%m!TkOv#=+r=M;^mGjq`|R7*1B2qt5UN( zEr?T2;8Ww>*c<|WkMBR8jB<^m7!CG`1vrLUxhU+t4B@zq&acP{q^NsH_2_3P{TYwa zhK79r|AkYfDd(I||3qGh+Ynnq)BXG`fGxm}_6q*maD0u4EqiyEDkg znxnvRHy&(wLCA%xN^3nTd-s@6cD|dLWOb~DwAvF$bAspRHvdYgG${dAJJ1a%UG5kQ0jVF3&W@8is^kxIlXnRs))53Yt_e>s5vK zHxFP9l@6tj?u zoe1K2AysW? zLe(I6@LQWQ%@cp!a8b*uG6+Lprf#y0j#w6VtOVjF-nEjLGHKaE+Z{wKsAO1ijMDo z0^!yaqqBe`1lofo{-W=hudJn;V(&ur%RH^`@{gNQ(^Q z80vWZ9_k^w#5Bg>N^Trv+U%U5{GFQ@7ZzOF&6d-qB4$Rh`K95{w*t0Tp*dza4#=UO z%?vFN;khQxl3BJ#bJR@BEqE{RXM!gIH%MQk2{;`eS?E^->D00${RWZuL)O;B4^)7a z&1C#}q8W=Tb)^fMO8Yh_#}*LVxi-NwpBp&800x*t_pPxXR!_k}b-SBiYn-^jt3>Vl)#1vRmq>vW^lTBMzqsyHg(5az zFXga8b@9Hs64UR{N%CS_zh2l@Z0?@}fF!z0`kQl##u-*G9k@Do1?E0a3V=TrdT!Es z13X6`B)oXyaPpeijQ&))3f+>#7~IBnPUviHUUh2m7Mdh3ZHY0gqB}tHq6Y{QfV9k; z!&V6~6N?AR8ve?&Mxzr9u9Kg-XRF2Ta8u#+C($LM7P>>tKo&*+nC##|2zAG!jWoN) zZlC&aNI)af)RRP60tlKueZeju^HWfade`h0mXG*0d7Hc^#zGpd{wya`yr2cUCDQ@3 z+IEgJNcBz`tA#({1oD=WAC`Zm=e2Y4{b%JTH;_pEQX3Oao_3un^3{h5gZ70uq+@-y z!>G@i{_MvM&@4Q1EDdWV6hL4TMA{>R3zq`~le1CXY)pzQp{Q{{Wl#Jo%^502xh2fR zeTY5AcMDX{9MwhT)Mi_O@KM!}o%Ne1v|kCH8rxe@8x@9;k!>!eACR$%n?k86bAOK` zrJ|v2|X{4w$oS$By)0tjkNR(GO8P@YKZr+*1DAPy(>5~H|fQ!Crh7WL0MlP z6jx4v>z3D(%e_E`>1<*Mm-4*55UHB6?W%v-s|Ckq2~=nsv<)p5Sk)x-S5D-9s(&R;V}vo*t)){#)t2r=2vff>Hs)b%*F4>$W+qR zFVk-1Zu@T2D;0(hN_>yMu}JSjw-Zg>n6Itf%rzXIc<&wnon;*>2*Oz|NM7o)g`Hm{ z#)taBthWQ2nA%!^C%0wSqf`7p`q;NE6U%Ut#-!(SQn8AMcKOtC$+Vd3lfbR^JaHsrJ zT8damt;6wVq@%z*Z!dlW?UEY}>_V++ZFWI;{;?3!edbR717m%%b?p^h3g0X!mu^uXPhV1CWAb zlrr`n;_A{(W$cKj*cTu8-H^WAZ(g?ejj(5+-z<~2eYyt_!lFeThYpIO1xiXZ=we=E zlP$FoQ?-LbdWFYQuwNFLqxb_~VIc>w!vy7!oy`go#696PzK})K;JWBxP15aJ^!88ZIH`2&gKW8%17B##l4dg99zso?9U3lKJL{2Wb)i( z7JFyi&2s&=BP5O+S{x~J=KYT*lza$!GO(HMEC))Lk{n^I)7*V=QCRvOQf+`} zKWwnnQ^6wCm*i0U3FW`AWJSiG0yi~fcHxyxECr&7sfUz`-c56Pd_23WwOh>!P8#}i ziO~qJ1)PwdUCheVZ5ekLlUtg1R;si#o0v)x`!2olxRX-LC{{wDXPM`xC4QGy95u;O zUAh5`9MGX5nf+)cs3f2Ag*D;B8#c;_0cx}Zsq z=JSl&{2gZdt`1*P1i>=|v~Ru3Sn_C6{EshvqE!d9kF8R#SPE1tt;Via0TDET8AX0e z_4Di(t6q!#7>Ax~Wyg32A-}%=T??SIXEvqkIeg;x9|5c0uP>?AwDlBCpdN>BQOxN# zgn!yc+m&cOuw~vaF$ViC2KVtGR;e#C< z8L<7`P`)c7y~<{`dbxb-2!yRi=kCCg# zT^V2jzqBpx$izRH4VJc+vZ?Vnvl#7Q5*nY1RYY%a$@06ZVUnnYDXtF_+^73ZL*O-W zZ+M$+@AqXJ?RF?&xxBx+acfd{I-#tv&Ubh4PE3Je05zo{9OSIjvlc4Z4}3xoHEhMS z!i>myZK+d(Kq!mty!Sq-tk%&=W+Nn{y#j%3&1%kCMmqEDdxy+W)2i+}mMu`l#x>wU zMgVEQ3W$!QA`@oy^k|bJHa}CU2Lb!%7#2so-^L?vz(DAE({(p#^O*+9H?Q&60+|?y zCCbam@%gUpppqD3Al3 THv=1IhO$r*U>#3f|C$dP05tQl`is9)a}el3fgsfDLn& zMW@MqMR!r;>;?RZ{Io}!@d1dxb<-8xZtYp%)R9>-PyT)*mbJR4Io*8u$>yj9I82q5+U2Oi9 zRBU{3VROs@^RlV^(B%sornY9NEj;fE=^a~V%4O1lXu{)fOPp8hFOO5+_I#3(d{2-F zR0M6TB;D*9C)0h0ndY1kzp#?tXc|TG4YE8_WIpaOp8uZC_|K?*Vq<{{G?}`+1LznI{aT zXdHl?z@c+N017cDzdb(hdCoG)q2Vr7S`14+J5Wyj=;I3u>OSwj`=C~h#-8l99>JM` zz}?U!nN7d#t{dYFIU<1W27A@I`+Ax8R@{?1zH8+qxifsS3)7S;k#To_Gz9i<%Cy{} zoS8oKhMZn+C!Lg|!+nf~2ifxamL)!=Tf0nc{D_yJloE?Ar&W%m&7dS#J4nCl9jf{E z4cwIp$8z5j(y51BnbLcl3dbqJH&9WR|>|ue}Ybw8ts`rC-+&0%t#YQ%#q5^8$ zh&yJ(F5H(Ki;_c;nY;`5bfvZXe}H%Zrgg0|%QTmt2|G}JoH>k;!_^lH5J;$*j)Q>0>p_!Vr8o#=$)e`A;6+JauL+E}J((wP7{qn5`6v<8i91xSf zF1{{$o2G^31vbHF)Ujlz=C7dVD`A;_S6E_%+ zxA>Oe_S(8)0#55GiDgGU?S?WjtCJ~;SurqZEBbERAPqurmwER^)06eQDaNFlh1qgx zi3)7=5=^?*ZYeocx?frvKIEt--~UUXlK+C>vz7k4BB{uii0Vy&2EUvE_wv z$G0MxZg&X9JlByAVV`bO4-(osL$Afhcu$I?kvAA(v+9=I z(&HWz*^{Pil5bLg;6Ozo{v=4hS?Q`)PFtqEtsmeVR$Go2H|?u11y!y4ck+^AEDp*D z!ulD$0OAFJx{-mnrl`NI%G5J>RbIiEWDke`ykzk!FLoA}Um0%miL?Zd!HF5Jf5v`# z-{5MJ0rm={GTzq@wg|W%H)G%rrjP1reN6`dP=3!nY>n4|CJR&vF`~J?N5eTJK@%^aLfvux?5I=#*}48{_% z?PlDKjT9LSPRaav-*6?)Yvevs zr~T@XFbY^XtpmHQO5DJ0(b#We8haQxasveRx4gkFvcAaq2V(sf@Yv=7cssdwqOku0 zLVtS>P|B%-35oxODgN;R42ur!kNv-3#bCKu!E#xSsK5CyxbTo1m}(o$uWkQ;c=bKm3s!WF#H%O{+-ZME}6v|NjBs%)sBD|A#ZYxsTqUQ)LSZoaE-S3jANP z0ct+=LYk66w-)(P+k_uu!O5taD^TqYS5c@SG_q|jWpo;eq2=tLiJpT`o;IFkdy|)jFwkHET}Q zTOu^Sh60oigNru9oSxPO{FfjKilMcO+>;;}tIUk|ZNn608!eilUlIZE;D3YVQ)8M} zyRRcXL!2M_6S>sX2+lR+q5oU(FfkSCs_dn(?H!f`Yn@ZZ`-En;xj6m{=`Z!_PBQcADq8>78-KtA#e=<$09%}rOFEQ%GrcGm#^v5$A@i?6 z!JlA8yeQg?_+^MCTFj$cH;_wARl`~I4`1d+Pebl3wmsGNd6WaUisXcaQf#K*W#aw= zppj2&>!!~E6!;&xFvszybhvtbZy+zRuZaQAc_4ouwz))O{QPE~PlAU@qQ?KdD1W4H zy}ard)=&D8{wn!Rm{Zy=NYxB|hFiJzOkvfc4mbM*1nix2Qxl%yM*hVi_}`h3dbU`% z*C+rmt~({Ib;m!#GoHc&e^ZI!it|9ioEsm1`)eclNBb-8HH&YAITdbjf3ExSIFBns z0q)cquHQ&F`oK&QfGKC1Eb?}YHk8fM{(DhBD&D$wTo=4XZse~6WYrHp>-#?x`mEoS z&z@=bioR%o!5+RRo6Eu1?BUM+bu}XL@E=E_@|R>-6?JzmJLko)A%5{~zyM%`~;1Rdqt>yK-9XY7Q=q6}g4;rSc}V zpVo>sc$a3*ymC*9{QO@l&{5AX)z|qXE;kdZf zs;$KY{fE``6z)X&wc)2N#m4*oO#SgKRW`sx=OCTl6`Xb~RBXFcs298Quch@reGcFG zT>biOQkI5JOn+-#29C3G&TFkCyWqh9X@`Fcxu~eWhC_c!B4l9aWlftS{_746d4J`a z0z+Ioia$af$Cj^`9`gN1WB{*Gnu7>$vik#(_3wNdF!;J7F%mtsR%Y7Ng>e37l4v2OMz0SRmN^w{Gd6(noZV-BO_@q7xr z^1lWJips(OV+rq(&pt;MHjLUV*vm9TK^30V84lmgRH-#+evYpJtN&}|Lw%^9nGU8Y zKB;-e^9UEL46Uoual$RWhKTsDfBqY92y~~NyFg2ItF8|O6jI9=XS=>?f7&J*k0|c{ zT0aG-o9z8RMyPS>8zc!g{_BMS0$Bu{6x=m&T7y?zmH+{}_F-9*guhhqkA_)C)7D9J^0xxJ2E z`UuXO{2KCqf?a!yga@AS! z&F+6#*CP1juPKd05C}DhpB7WbEd-IOlZRu(#V2CVeGmbd7yrf&m;@#<>B=r@YHR1r z$9$NB2q}D#`D4K^Gbj8rtG|MKN-ER}>0v^PALe1By1)(f;MZTe<2^*%x*A%de@{nq z2G|ocFS!a7UD#}qeA0ifv3~h1Kb&JcMi@iC$huTv1?j($H7EvpL9#&!8op#5pA|u= z`>*E+0uBsU*awp1*>RW%$$~FCe?C2U4447PZ&J6s3wi(k=kzpa!(BK)t~4dv*Ka5# zav1hj4y&Xp3C|zYa|@sO6%PMNe1hulo-!ocT-;KJGzwJs#IF!>XTTh8E7n0MnfEhv zZ^%rKr}YjGV*pRQ%aicGM~@oWi~vB&se19neKSK(GJAx}v_GV(XAJnBIO70-1Nyk9@_|N9we1GjoW;b{1ojrTC7 z>tzp6lGi><+^YL`GXg(YK0>-2X}LbP*(#U|4d#6V?R0*!Rcgr4|G)|3k?LP}4iZIX zr@bn9`+O)>G7I>eYuU4V)x6>VGu;9)d1E2F97cY}TC))_$DlH#Y`2!R?q`2(rPOpm zGIuEK3Zb1x)CBg+&Y z-~F{n0x>JYz5|%5>1{KBKkviw!dooYx|&x_Ps5r1+>{n(iG1wpVwD6P9|?co+!x>S z*Cn9Z$j52U<;KXAH!hbjlD}ilQ^3qx2#BKc7L#m6^{%m>-E{Kr{yVvVq83ZOJY4D0 zk}uGtC4}c;TK#?HKumftH{BlmJ;fKVMbpE9e|3fC6!VT(*yGe|% zI-#1f{Ur+b4YP_8qK8fQ%@zj#OI`&ZIqBvK&`VRSgma-c?eymc$c6%Se-B#&EewQF zXFF-{bar?cw`wqIeS22G-|u=S6j}l;fK?G~5W;uh`Onn;&IInuW}#psNVkOK%p@FU z-sh$L{Yw_Q7*cqy+5=W^N_IFQ{NpUPu)<#xF^e42^?6X#aaxwHfu11z?=gp7PzOSp zDpgj7B-p@T?kuBgGXH($Ayn`@9!qH&AJN48epE63JxOLz)1U?M?Ai#tmlBCkhuu__ zJfeRi6cWKBrL0yg*XD3>=hlEgb)F1}A1weexqM5~n$JgE9RiLL z5o4o#IKz|HJHx4bW6xVct^VY{({#xlt&(Je&6g4m zZixxc5d~?^{}4o9_rR)0Z@E#I2hjnQVQHRAU2DhVMh+Um{$B6!#eX!Ot?4HZ12WfS zFNg;A%hA9>qYjV`xT#7)|DGp|1A=-b_@tnA{w#~Ldcwp!f}Nk|mc~_9zq!fZP$!pF zV*MxR1$7XF>cf~--L7B^Fq=oP62A-3W=$;|`ZL}^+hBw$DvAa3IXz7|IBvHA;~1tz z5Jb4=eUIK7W`I4Rm#w1LB(VjUV;zBZSgKV)`WON}*b2yb_+jn7v9khzzIXo`6QG^) zuHIjn0*BD`bb&6L{5JgS3i{pn=e)~_;~q}8{HbJ@{`n-pq=6+cxI5C2kwt-miB~V! zP3)UbmjcSAs+9kly43%$^QXU)HD*I)lc=13NtiFbAyaw!`}Z2ypag*Gd_McffSDK? zsXjnMvl}z?pk$o_d{}87lQwexxdi191_A$wWt68vo#qeeyCaz}9tu7t=#S9t zIRh`(?uGY8-b~*H&MGLcwA+5`VyyE6fDk}iofb6*`<4$Ise9=G;NN9db(n?$kl(O6 zio})gfz`Zo4}0lX4^m&9P@NZE?YCm6)!X)|oG?IjeKK4!-W~RR&l&`GSt->ZoH!;` zen5R{tSW4<`zt{JyJ}5VYc45@w9WSGxocG6T~|$L=n9U{j<^#xv8$39{p;L7&UPFd{>`b8ajUT{&%7R29t9f5yKV07Aezx8H8qw0LtQ>w|uzWXUjOQQSEuF z08}l1{~@P-cJoi{p44W)ny>Fs3|s+#4|S_7P7#XpX9WNnYzV2VBbdc!`TJ;`92~v) zQPZ7ZU@Y1X0Wz^K1S@)Vb(88hxFTc1E`i$oo(VEgi&o*O7?|q=9Lb8c?TP{U)gVsb zkb9*6<7Uq1^Dd)*^K*n#-hp`F%3jOy*mN(TNyRFTlfj?Qs0wear1eBagg}8&?(y~} z&|9&(E#}rJ{&g0CZGZyN_#){(8v8Ci>*vaxjp2gmzO!!DFWk4Ju}b1=CjkBiZK6fl zoP%&I1aR){&}%qw5C;U(&kWOK)8(jFzD`bF3qcqfgJ0)(#)VLxX97OxtFzJ>f1@nG z1Y{laW2`wEe?xAb^drq@S7nwZutGU0Kw(KI(`(@ z2?#?ZY(W7Ag0&;!g-Ou8*@l{p`G9o;*Jl23$Bt379=>b1@%~Ysgv90JJ3#3d&(`mF zbi5Y;_hYAba1elb^u4}j#oZf+DMN6keq0F<9Qi344fXz&TDTjea;rgsmpD(>=p#f9H+Z*$Pn~=tJ3IbVN~jm9;4Tb%1~s{d32|i{SCIv@f8EYW|M0x~7gt zM-W9Y9qKN97;RGm^{}cpGEhsBUc(Q7TM6I-?u#$*O?4MiY}N%>8j;AJ)Vlcrp>?)t z%i4pE)Lzg4T6Evg`4jJi#e!~SH_5MZvXj>(=1rq#`)(<~J(MmOU9|B+wK4eTX)gU% z1|-jT%;Y@L|36dLY2wX3W3^H!9d zJstutI5l*iY)2FhXwT}0T0_cqPe81CvGh8?gd6`nx@E1D>d)l88?=N>`DBy;WI!nR zUp@5U#oqu2I2kzK=@RtG`b9nQer|96kxerBDGre5JW$L2Ts;*l{h)S1$>kSu7-}

mpf+Hv6bR60e?5#m&ZYwaJVq`(yI} z_2g*i=}U;>57(H3Veju05*KC-6vwdx67=U=p-1X%OadCgN8*fqMdB}A{W>%qz?Q_O ztxYBoBrbDNRgbMMj*EpHU9Ddjhmq5;|J7AO|2@DcxMJ`beQoQ_LdciyHVmrPd;%tZ z0^}WFnBGN;8-}C2SEj?cn~9xI`2???zGZPgRPOI^G}I;k)tv9EG!RvU3KEZ9)u>zO zCdsMivEZF(t6!Z9 zj6%Z;O2|c?i_aN~_njiM2Z_uUfSGC$ax|z9aV+9^1b}fP!el;2#x1oX5~~Vs(jpj?7+C!hLHh zRoa4aTvH~U+jpLfrvkeq=igbh-UYuGokCp8ds^_2ZIr(H7OKU162+jcrndS32p}gg?%*sK{&H-#B!f3kuYgpJWRfofNzgQ4U2P6hc1HL(G%mB`<%o-cd9o&n6t_Q73v&h?i>#vGJIx9fp`*pl2{#}ms9 zTr5Qt;9hH`KVs(TqjA_^&P!d)K5)gQ_1xt?q!hHPOnIhkJrLJ@a$1{=(Ifb#eBcz( zT_UrHq3Rhl8{fT2`c`Cq;M}+#s+y}byre3xtm=#>YVHuuOMl~z9=hAld*;h~lqVZ4 z0Q=4+x%c*biMA|+_+Baf+Qt+TfmHqO zX$<5(yZs+k=lu?67rp!FM531{Awr1gy&Js?B8lkH2_Z@dhKb&Z-i_!YA$m7@?}<+I zUdE_{nR(8<-*cUFuJgnE0dwtV?|rYe*ZsM{XWWy0u9IPEFZMPh_Hb*nZPb+MwbS}L zqeSG_PJ2xJPiCmX?Tod9P;DePYDxK>Zz((`WsUNkSf*O8VVEGUZ77u^!nbqZ;hQ<<2xdJ^kLe{OgN~ zbUaF?Sb+PKvA@YasNuZ<_oI1aQQv$HSCO) z+~9%2U8e0?GVchd(hAdKn~uW+8@Bu?dDl%TFT!SMhKrzJR4(3<~o=jF03G@0#wYE4d96)=^t-Ui}!?yG@hLKr7Ta;csGA z#f__|*MU=)-7J(p z^NWSlkdq?Iq&w|aweL0RDAv!Z=&^Fm1#m|fW}J%5z#Mu-N{JNQKTO`P5Q7=1me#dH zE8aii|5`B$eMIwW$?_l4jI=w*U#z2Ff|ZqWgJ){&8H`RjFQDNTxQATCoc1JC<3@9X z5PA=>XzOAQ~_cbMC%$sPCYv$aKSbq9>1r)?SF|S29~elg z8}TSokNsOwdN+kxRCB}RG1P^pXdlMQV)nt>edle)!|kQm;xBmLEYUIH=`hJ-fjtlr zd90T&kNFRLZ}-e937gs2pJUrI7;#$p>ayc8Da^IO*@+)WLL+VNQ_V*@DvpF|%zg z+T{sm(Aw486huVZcEp53+jr$L0aQg*M`!{vmwS`kml$0o#8R_SMSK2{i_`F){=>tB zAJ*$!jrC^OfAGr#HADoh{90_aC9s3n5GsuJT-x-Y9Z|I`Cqudb%QH>{{WjCIHn?kV zbLUVj! zhBYpVj8|ETRi%#JUoYF(f*uk1P}%HINmd)h6uI8}$zt)1)4?Yr`Q8s1s)2e3Zui&j z+YVCyWPhrjMK?$3J^j~I^QR5*Or=v)l+pe{(ICY+jyxrU^u0gMth1xS2jy&QL^oZq zQ(x+FWehRvgJf~cb^`f>X)4Qp^WJY;Sl`?AUEF=>ZE5Vhzi&2UC5}&?qQQsstIhOA z*j6CAmuZe*Exqh_>e6n*xmo59+ChF?dxkV%rvwB<(S>AT{vf94IABAATH=rWGO3+1 zw;PQGiVf6LR0qS|D7V6IBS?daaJ_T<*kwDU_+S zqF*XCaERGoD2ztD-vYCZnnergCkMqlE*3FGxJjmH1QWev|0l=(ia0{wBjxZzeMpdn zBMPbJz{puL6_t=<&ZTLc@tw(jEn{i^%o)miZ-E zG$~S#SH#$XJ#Nb=bYcMSzB@=ip-O2Kw^`EJ`HVd`^-=Ie7pZeMA=6&C4yNqZL5@vM z6<`s022VD%@2pK*nWRYjVn;}AU3=pxlow^ZEv#$kib zDsE}f$KV72NRJ^rKPToZE-e;+Ah13Y_f$b1x!rWBlf}czbS4W989gtc(67nx_594x z-Eoh?#1%v|i{=h*j!6hJjgDtyvDSoMer5a}UUp%|i){QB?dJVEbyuHHNs{E^=iG+0 zhdTnVMev)YT{mT7;;(T0EW;~j!c0nKn&4M$)xFN_F<|`N`Uz!N3G&78qivEKuTlEd zSmA80`#D7xiDk%Bm7#&z2vMBc$jLZT%9>Z39`ep9IWItG?1GKo4XYKUIrIZrc&Q<} zC-0#zIHT)%go$m$WK&g<8gByF3+$6`U6;__czlH~Q{ZYH$M!bYsrXN|k<4l>CdtRk zEOXWd`2!C7b|R3^wf}N>A>!LL(KWcpRFkje?DsVSneiZ_8Z<)*8aD*OiCAexoS00N4F9+g=B%^;72VO_b03d?q8wvlIsFcA*Ll zghpPc3@hiu)mKk%6uI~{t;>x#IL`7M^Y45*Sq1OKyhjxOeFE~)W)OdH2Nro+0jZ~L z$iQX+A_@duR|bt1SJgin)dBs-0z4qmQ_wqrXk+Of_I;;8jku!=vWAHebVd!Wen4$Y zM`~B!6JLhRzVABwEfZn&otLE(Eyq;@qLRxa^pk*XruE~2U-QSpMz4HY0GCP(jOH%? zke@u{E1*+h(O3tub?IDXO)mWbvQ7LKg7F=z86G+4l{zNZ(<0i5dT>!T`>A^|ROqRh z)?jR`ecs?;9VvUSXRa!&?LPBV>}K=HQ0#zR>cN}SmVPrhgPkv0GYE+-5}d>`^<%$x zkCq2}QQ(?-(*jRD$GlrxsSbnSv<$ndY>bERJh`mi4Zq)lmrI_hJM*ovnDbM ze4p>h>SfXS&ek59FKMox##H!|M(ejAjxSZbED4XLa&TqXdp)XKUKxd^FPiUOj4t;L zI5pb%g_!>mJNX20Q3l%-3|<@&F5UN+F`vM=ckpk4W=JpQ?uXYoYfX9TEP zq`S_czqOu+s$w*T7s6}wYI(F;bH$|%WpJmBdv{*2CUARiDS}oRpbRAZ{jl)N6*8RN zcm0@p@%aui*@e&;t*)%}m;HblCaQo<7qSwPchRI+YgJ;UypDP)O`~(>2$jksK7Uv57~j#AKBB==V{- z%1gPJDE7@CaG3M`j%}L8{5Lc=hKOxbQY#_WM~IXn`cJPHNN$v66NXS*schxIkGO*- zLUlwBE%6hT8~OmbCEXK%=BYvuG9j1TS2)|^hBd;R|;#8m8kn~&%7rz zgrF@0*96uJz-SQ0eM%o+OMa}s!#9PQJ_M><0qoYhg3dr>$!J6|TiE!;_pc_A*&iVb zSB=l$z`|AfM+nm&Oj;*V?o|RW&m#2GoG8>oO(d=Gc}d6(`e6>ov1J?-Nhu#+)8`l= z$eMt3$a~&Y5Ss^5RFDA-q_h z?dUxsZ*fA)*BXC7i)*n#sD;Yys4pLSH|OTv=(kP}o>M^YD;v;AoWymc+A~j3Np_RV z??fT-1Cx}xZuR;~DVNvE(kd5Uz5}a!2?b+C6$IV^LGm?THHx`rU-2!w?lvm>#R5xh zeXa+Fn{u$f-!%1KgK1I%8&go(xR5EyC8o3_8eWiSs?l9KoyZIXb1YEa#fwpk1sS97 zFwEEIlb|yu>^D>Od=tBg90p*rN7#LI-pC9|>+B2j2_O*Z6fAOe1S&0IvrDkLhBh>J z56Q76jSKVrt7maie%YZ@noGPt%pzY!>(LSA-Rp;l)HPSJQ=O`Zh`swID*ULo!jUaX zN{%}wT712yTd1iiAFH4<=&FlQ9p5w-rB)x<_HuD*BAe8u=`DFzv*IJAK=X` zEl(1ZNOMCP1DALjH{Toe1!3ru1f}dgZ62)gz)3vQrr5CQ0e)<+yevIQASgurtkw&m zddp{aGRtdm@&f)KBoMgc-B`Kww=dLuu(b! zC1K?yoY90VdJy#L3VG}N0XE!sLM%DJVkcN&!EHpn#~UeM{vRk~aNWgEOpF-Db_uGc z8Be`{iKyn1!PpM09-&Jeuhcg%+Vu39YLE0B9k%R%oywj{x*FvR>QSLuqjxD&#P)!b z?X{7{nq{u^)%T~^H}q{i)3}K*UVE3n?T@%SAJr^)9PY~+#mwmxQkLQu(c4dk1-Wp% z{iP)~QRMMF3Z&ZSz>xHJPUtgr^wUnkSA*nbjOIIP3TAOwFx}FdVR%Uok+B??Z9h5d zm?qAEs=;Z6cz5trk7*N?-H1Y9hdtsIReFq4I|@7^3@?PQph&EIh#c{Kfw^s??2xj| zLspWTJ;)H!$s+K8cUHyV0tyQJ3FsUP%tGiu6@bf~GS}3~Lxj8gDB%Me1KHMFJk_!Jw8ATSYmzwgXyYostx?%HyY~Xu}(fu(lNs8RMiqM z@l$1@2&7aucfZqOCdjUYyvUXf;@=hsdN!SdqXYq=x-&Njp(=L`^0oQf{|=^O$O1yW=lRUH$B^Sdb@Nm4 zL^??e!aE*5lJteUiJcB$nke_yK~SVW_QT4!Q}-I{VPtF5J5I>yWqFdImgoUHXyWy- z#_(JAxE$&FM!USoe7j5KXB*89)r`0kRu>#P{qNPQn}~}^iVh=yP&4el3WETTB$Bd;8*N+awDg~Z_K`88b#$FdO7t} z^qPnZV6v{%#q1DM_iJvAAVUoxCh}S|HfcsB;YT(C1APpsy@tj$1H(kQ$J8p0C!f;H z20nq#2R>ty0e(Y#2h`;`7sgiOYt92$t^!|OG{BBGx>1@3L)l?eRD*eO#47ly{56ph zoP$z|9QP7fLPdshKL2{#p7k_f%6c=#ZJLhP0X(KY)7vY6pZ>j4mNWBo>4-+}cUE|3 zMQTmoo0ML1+N7TGKiga#slqqONS*Zx4&7Kh=q^~pcwzx(e5>Y((kGnzrUq0!SH*}F zYNUlh#}hIQ!_Mj#sPPK1mD$uv{c*IoTe;~y_KS(siZ|rocxritOQB-?j(S23(wnF; z$Paa)NY6>KHp*}1Y6)#z#)4>(@ElJvV+O}&5kZlSP(yt1H)WwJ(gcB5*1@65g5V0! zW-xi^v#%4=nyBLBK>Z^3&^mmz7Sz5Iuj2(+YKoAguFw{(P1-r}7o&uBKm@GVUXrW6 zW146HT`?bYUnCwwUaKyPm(g1gT%M-vE+DWcm^~a6Rttzp#mbj&Vr`v3| zNoCU99{H^2P+#>gwaQMjQFa20Ux_>kZVvwTiN{!_nULh%+S;Qgo1S2y{yLu8JxafK zZQ&W~Y8G+r_l6K0@m5mR#kS*FZ_2gs9&?H2Jq6nci*zsqY>e`Rs+o|G@P-@2N+K`! zy*mZmGt}Y`@bwwUFRp{~OZo z(u}D?9lDEKqouC;y+X7*6Z>kgPIZz<2r8`CGB`o(UxIIMZt^;Gp97TZ+4D~T+^>(5a{m~4&{)Gsx3cxz4sIwcdPvi ztP7ZH*b0!wYtFyPKcC(uY}ZbBmyCCQ`&sat6B*m!3t>DuUt1@3s_Ht3m3DZPg?25j zR6XMR(^Ng%*n29o$ycFLGS0OnX^yUJd5^d$iGOAsYvJ_`V*%=-#Y3d*71o5gwQ#zT zri`hA^;*aG<4D2Y(7bPLEd72Yrw&J3Eie3!^zX@+KX0UbNU?v$BgSF!7G+|mU#;=f ze;+xT2tySqwLJJ62eL&NE*Ck|HV~l!BAS}T&a_tS7BF6 z%#98DpUP`M)7qdW{#&f%$B@Px^d;;cu(d(uswaFl5B&t~ewR`Q@pQ^(A2fefv#G=a zu?-i!OXrT>iHI)aweZL>l-GX6`_O}NJ!^QbnaVKm=_5IkCz`!&pS21fh58oX3-o#e+{=LyFJ#Q4cH6EtDA2Mz*osiDV_gP>r zE0>J^My&zdF#CocyM z`FC#<*`-5-lznfMwS>Y2;D&q;Ut_J4^3c+Pir3hA0my3&E@RYBOzknbx#DBCC168H zJXZIA&dvhQe1_hSJw9oBZ>cOD;GjK;HUv9X{u%#3Yk7{s-#j{$gku`L_Js|M5>MIn zEd(Fo9X6Yb6PL`x2C0ySZ_PYW=~3%9WF<8|?vzTs`IWDO`+RAisqRkwd_e3Go`d@G zB8rMvLq&T^H9h5A$u#hrP9L!gpnT zpZ`SV6_JJY(R1BX#_-CUs=q>X)VtWD1ptp(x{r__Uj_#mUT9T)d)>2>Vu?;Y7Kr(u z-D7uW>5UqShfOM6Vc4^EK0IH;v_2Bq8!c_qY`>Az?xL~gZ!o@yrq$d@<%@PtzqTxL zSEr9re(6?3=uF$%gsm6eK2^3AJPRhUx@I5W+;prBI+M9hEQkOz@A$f=JjfvY+Q&mr zm8iuZWK@rxL+z_Jr>>Snvgr5qkl&Q_$Qf+<+LaKNc$yWLEZrP||GwwPueO#I5it5& zN%YwA{=ma+qk`dr-!x+(1L`zB)Uhn~xX%uoRcC}u#F+$CORb&o)LH;Jl0Hzbl+?Yiu+G8$5c$i$p1WjARV-uq752E2+Bp)`d^^7>S zf5!QmYC?ish5S|m^&U5=Qjh%T`S6AfN)i&A5X|%!v@MWW2AL*#NGaO+e%!AvzN|9p zC3tg%|BKzWHA;abWR?Qj4A8583SC8nMWpB)TNWaJvg@7%~mAKDE9t%@c|;M!^~}=S%<) zeRaJWZ`ol@aDC?nv*N7|Y%0H7g|wow{ZT{1&>vRy0`WJHDI`qlVzuS7vxNQV^OffR za#pVQxu{Pby&Xian6D?1@RblCD6xZN5kdz= z_g^neew;~lIemaPy=o2wehQMFAOHU3;ro)73xv-d;Y0J79bNN3CA#MO)5R-WLxvZS zozcwaj^710Ef;t$|8a9V)A^vr{iAWIIi|f9t;Z1d z?X4-G;Wc0xj)g%Y={diMEWo_nNlMB^qwb&D3&%H|dT^6(tLMb}sO2lX%w3$fH{hqt z>8R77eT9cewc&PJ$#eSW%Ql2Fg7be-NoPjo;UDQ#agSW^JBoyukVO9XLB5+6!iik!dc3^UhnBTJ zD6Q?mo8$k%kK^T8S+W;; zH_UCU=g>e*U6UO@C(N@y3)P`nIBtWce+}?-K$A;RA7m9dALEs*q4i=}u~2iR23Xsc zgq2Mc=)m{qY1#TvEnQ2zUi`#{Hl8s$;tD3U1f7bf055H_%|eEfo|#qU$+;KG$t1=L z?~yV?24Y!`U0J*;`WaJ|!GXsxlX}LJLIi8k^jRdE$IOqJ6ZG|}XS@IP=L(~$n!jU{ z!2Kl1#hyW>ZgzVpMBE;iD=<1!AvCxjirNC)7$NtQRu>hmQLDY1tAGP)&Jwa9RU$>XdHk_LM&!|ZYg`TeJH6c>!*TL=WL&jKeaSj>s0ag=g(DhlDkDfX0rWph`> za!-g%c%4hb?ig*g5t(IV#1qK+X~5&+wQM?# z7>AZ_RjUJt4FVDo^pf!b4#ee!lxSw9c{GR1lJP`NpN$r19lPqld{dY&to}%vR*I_6nS5 z-#VDZU=RTlL{|x(!AY81y;`ROfMcJNekP)gz$UsgIxw*C8kt>-rdPx81|kNaLx!Bq zzZw>Y$8sfB`HWp`q?!EAFd{xDvUBA&4y%}{gG7rOj@#wI2(!aku%MUgc$@FZp9GM5 zEBxR5aoc(PK}7T6T(h>o;hsElO?mm6TDD+)=9lR}oYKuPlc@d;bkdFXZfn$)x{#RBM!JW@a%V+6QIoj%pr_b4XvV%ErH#5sn%<7K$>idoiS(g+^JHb=$ zzNH4+G`zC3Na-6ZC9sU0lYLX6WWh`j{5)92Nt%*jYv}U~65BBB(j(?Z>huAz$k;hc z-l7_;m+qpQ4VI|jtM__V?}hftT&Z2C0VHzp=ToE0%$Hoa#&PCO(G_< zpDR-5ECd7pv!fZxL9!mwahm$#`(LtGOQ6k5hcQyYmY3O-oi69FY z4h(PElt0v8y9UtBx~VusRwdLRjnNfhH8RijS+kqaH)^@lm?SjxSC$%bZ;HLId(WV7 zWz96g8gAJ(tE#gvT)gtQk^J-VV!h#Q;74+=m_YM)@9(M%+OwEI7|;t5Dp9v)f?9ag zo!+tZXET`dZBq}K+-qMJ|05Eg&96A7Dj2?B0B=XuSGONd*R10D+>uhG@tju$@6FBpcM)NIp!lMmEQinq$Un?W#yyuu!zx<1 zc8dQSQ_+wa=@6|^B=9`V;iVeo*5HJp{{2!fRUV8Y zA^bjNZPMm2+|1PY!fQYCo7}*BCw0sL?yGNb@ag(9T<~cEyIlzfoi(_DM@?IuW00a| z9g9v%3qopKUK|(7m4W?xf|G0?(9?AOp+0PhMI@hTKPeJ{tVvLJI4tbZJptX2A~}9} zl05u}A8%=gGb6iIN-_QTM#)&i$NBm-megzn#YljNuwx@ukkio?(RU|_2}G&w6`jL4!$`M zF!(fMpK06myT6VJ!1Lxukw4~UcNrULv{zz%1#hy6*JA*1sf)Ezy_Z}~jk2jmv*bqj z%-d}7z_%ktm1Yc|nq9ZuU_Ew(n8x11tWQsK*Ro_1QahROPDX#z#PrSsFJ3=~H@q;i z*qkVMmO)_GoYL9R`fsL7Sv9xi^9t^0+IZJbM^3cSbIX@?@4zHTvjiczD9ds!yPK=z z4eQaSl55}v5@}hURLtyf+#T_nBa~HHyOXwD5q;d{sXE$%DQKkD3}ojO{-%f##83fM zkAUe*03d;+oBMd!SboXN^4`t!myf;F+ibD7mA{4T9!pG?G=4tc75H?##Jc{raN-#p zg1yeMNOd2w@}>&JY&2Ts_#UlMt>44z6MuOA<5VRWV<<*U?FLDG03@obN!>;YSXM7T z{tW~b2n3!r16&C9VCm{B*3%y3Qp;H0rvRp6<}L+tWb~*y1_-}ue9+qT8?a)TiuG{I z=-(`Th`+NF6PvTexk-FgGBI6lqK_W*!;XCIE}v!TQlfZ0;_=;mS51N;-$S4~z{j1wF3dmX{XAy= zD>>8;@ck(?;(VlL3N{vlhnv zN-Hh(D_CVxxFh2=sDC{fLVhRxA&PD`2JLLJcRFD;h)_rM2`d$gRPOhVeuTpL%ir2`hT z!MC4~>&GjpMrP}b;vb%ar%i(Tz~r*XZ%mhy8rK7hAok{$vg`Oh=X?@u5h4CvQm(jW zVX-MB7!>J5%Zm5Pn-pxQBe8_%j*9^Ot#B+n0mN8J^l&`V!d;bqLa}nG z)rV@UO7$5w2$X_P2n%0wz6{o;Vm}3{S^z437(%`6iQcO~^Zb0L5SnNRusV$-V)4pv zh3BZFP9e{Mgp)ZlWj5=|8J&)Wab% z{RD-}E}n(9SH(iEHy&oGFHS#G2~`uB^!3c~Rs>|AqNmg0j)gVo^0Bj1UfCt*a@xPE)zC*WT>7$s(CX)*D z7}NEvTVg(1`j+@xR>Qw-8yIzzrpP|b@!0L`sBbTC$`A;J*M^0UGLmVw}-; z_$v*3wQwqy`!!Q3F4Ltda{$Jep~x!1BCKNi??rw4Pc495v9agFsKQLqfB z631M1^KRU{1JiXEsA`+VFLV<6-12()T;Pc%nfLzuiX3thZ(c0!+H{wW-(;&P^0#8h zao@nfjPvr%uFof^Zr+1m`aU zj);An{+k+PI?r{=1r?cttzTZUE&}DH(2ZM5pWLh)V~5;hPTgDHLNua#es`s^^=N~R z-)wKunof4!?i%z-z`pO=#|?&VIGjgl)v@j}O1K^|9?uV=Ti$=i`Y|+JAO3q%O>6r5 z3X3?gqrS4l=9K43dwb+cn-eBA``L8fO=Jia61a~`?P?FJ_s33OMy~s`TJ=~J@whOe zp1>A;a5nX<7Fiu8L(l`mf~|B9YU5rpKF$|wVOf{;NLMr2b8wksZu_Fkotn5WS&T6z zBb1hZ9r}PSqx)USttXUVm1DhzsW{_00H#% zDHN_=Mq$84=cZI9I?S?O`t*l%Drb}&i?1!MLpK-qNh4W{3whG24M`|cL;qgd)_`hF z>Nf(`SIt7=eB2K$6Vqg7L5ME)b?%B&JXP|f;HuaH6>Lj-%idN&RJhHWY*qo^m1zniBY(qs%@F5Z)$tCHG(^ih z+Qs&fYB4kF;#mBS5w+HPGw1pI?=nBp-z%|p*cO(UU#osyeb4G(sM88hY@{jCL2J%4 zX3@y-y0A&PCjEGk;bj)r+l&2^44e3ve!z2FYUFZV8D|lj?gv`S`+{;m(x~p7S@C9? z`{iupb5uP~i-*n=@oA9c8_4}KP2##XCQ%NUPp&^5P1}4(J3zr2zVex9OG>A9_2UxD z*N=O%WffOgBt=-3;zZvAKaoL)+$P`Jop<;WR3fu>D|hgAqD{<830l*&H$UDD<)S7a zEqU!NF=ysJE8EzZ0QrQZ!@S!$!%E|GPS@ex0+W{OR6f`0~o8qJo~E_3*p3OF%1uiVm>;d_|2tTwFTN$mOQX{;=>P+ zn#XOg97a(?=03*{JpzQrmfX_$jmns-79aaH-EHqe13Z3U)E}^hUnr-{)@h1da~(jh z`n3h(!%W|?U(eelSl#vSJ~sc`#P@+1^7H0T!09@XBeeZ@BgjWx>*0{JULLk3;(r_# zFtIM(v&0vXyDr!*W2Kh69Zn7#fF4fU|3y539zlX)IPA~bo`7`=IFDd)zaTB&D50D= zxcsAA3eL()^*f{^q~y0BAjtX%2IsV_<&viw1O%U>J+qHg>l~lRUn#CCn0*tq;VRzr z&9c?fc@#>tM)3a|V5goMl!UH{+-Z-zAqJl*^BRb0@KoR%u-o~G53uH9p{i(;=c$5J zx`j_vJ2ZpLa9I)k5*w;ie`PDUS-GuihQn;_u8@9jsj__E8It~`Aoi8D`ztjO`BHNF z)YSMO=O#0rHIGWbY%?Poe!i~o!H+0d_SvTh4)0LbJz;<1HD$d}E#<(YJcY|g&&hEw zk>2C4U)d$e@d-mU*}#)#3C_t-Sla5EX3t#M9MQny4?ytY&*T zQW;Yp{+T41C!WFQNy1S5LA&AIO^={wg`6BBXIo(jRBYTs)l>J)^q*?46b9=0Tsz$f zFGT1@z^>P-*Pd}})2*5)z6HLc`_Pa-4KS`e@Ti#E)YA_E=erX=63btb{da#gPWE7D z-6Ql^y-qf|#eXtfbbX0~-&txR^X677I}R7lU-+CV5|xAGujZ5AiTV@@YIlBuN;(De z5cMFd2Uyf)>6#UL^?~B``&ep0LKB^T-6v`;9WMuHKqZZW<(c~?CZSydXOgF4xL)sB zZqY7>=rV^cyKp4#!)POWTZ%+q7FxyrG|fp;3;vMN`)BOQqht?mNkyNe8w*57>Ppla z5fmYAMM#iK8eA*;CtlK*GXYSaUjgGcFW#j7&?^3;Ijeb)Bloj?7Mr8je&v7FI3d6L zNFN$-<=?V8E&h2O!nwl9M~gi2-Ia#7!~L<>(yr`;-6=>97$ck%qb_H-FxG9F?C~{# zi#ImwUT;HgwXRRqWowoyemxnugxrecRTc{+>|<-x3i^+3D{izmTU;Omaxpzb(s$F9 zGw+p?75W7L)o^f~Pb8OrH`@rCF*iLN6que4FZOR)A9`@@nlw5~ge zl0TWWYhAU1+pkH@eT$mF7?&Q4bJJus0SwgP1_2hHaQuVKYMzCAjbN4Ax7a z^1B2w^;T4R$5C>5b187go0*5MpF&Pj3}1Sq1zNol0$0B1T*Cka>)jQAqIWc& z>tWfkmiRMzXZNp4RxJ;KJkN0eX$x4&cY8HX2`JHHcFC799muc=FRnv21R6LGIRG`z zsqCknw63CEeYyyMsoZh~)MlMo+@>cK0Q<~tLd(2;_p{<4ph9}(_WFXwe;1Asy&Aq- z?3-az6}RYXetu(;#%=LsPEJq2P#&JBV*XmW&*p~ol0J;OtTleHj#gOFsoVUY{S*Or zDCrc4BxXfL!?`57;&ZpL9}WYUve-G#L{dwO%}&K)I?PKV_CbkjMY6yUhE*$u{XQ~u zbK1&0H4;Z{fCN{ACQQ_&_Q8#C1~gujbom!~^Dj(0*!I1`!gPewb^5BUvWR8Jh?Nn7 zVF}XB+w=;2{s&VTS`q%hj@?h{jF00b63LLqPpiP$XTwQsKdnH*GH;6h_@@jO_UaAG zvuu>z{AyCNyldRBb4;D;5;XFQ{wE&hk%Vr8UEi~z`=;NSGTkYb&mWHo#%)*~KHG}e zD%*G`&;7e$s;N8W&-5|*4=5(_Ps<$WsNrrE;AP=8-(-GAUk1qD=mknF31WV4rK6p! zKV*Nn_B44}-FmlGifQm4$p$(_Rzm)= ziCT6v8q0E7P=y_=;yULxV41DO%&UBj{UEQE-Jh)rs355I9r)=l>;haaTOnew%=)l#0--WgQ ztM@;4w&2baSrGsQw_~I26Ce{``rW(|Y@%Y0dLWnz=)Wv%yFCaG-%!z54r;tN`-E7=>5VDJ0c;dQ^ zi{*9V((P*3KS)D3Se@U_$*&jf(AsA?B_L}V`NOPlX>~lNj&Nm#`0)AOOPe~Ybf!Vw zeG?d~Zydk#ubPz2t&>N&FAbhaKJ-H$I!tOBv5km^888*((%~uxY5dWp7D5^V5z5n} zi%KavCDY(_d{Yu@!hi$)e;>A(YQ@zmy|TF*=U>O0uqmXc!1f=cHO0m&bFcCVc8c{E zVXP9vwwD5fvQ&T9q0`?0w8M?x<2`QD(M(Ugy_kpZCUl{5nEq?vGD{QKcizP-e3K+R z@*8#+lSMmrs}1hm%iVp^)^=riR&ByO(1QLLCiVf4sY~s`hSUM~2+5PDSUep%rI`C)m_;w)+PByekS?gTSu8K`o( zT#@i}rNsZT0#eo5^B6wgew$i#@()D>Siz`axPc|F0%0_mV#hFz)+D8`=f<3gfbKix*B) zypGbRQbY5Mtb!p4R@>cI#}1MU5^qWLTRqto>RhyUtJu2O2=Z|$zxWO1ZrB!n%jC&> z5m(9Y>NormC%;vlD#WC-Tjxm2JoDLhE0wOjMl$>oN1g18TKvUpYtMUItdOxkbl+h5 z=u7Mv>%e7c!5}?r@aT_`6lCC#;afmrkUrwK^Nu2|bLwbVhS!6eqE6eX+k`C}2($bm zuQ8CabW!`Y4rFo`y1XUe4ctW~CxU|?U3H#)S4es`Ahm61cxLbP%{mf%LSJ{dTMyzI zPX;x>q9cuDx-mQH`?{Ds_yNh6JQPnY+IS=pHL!X`xKilmqx{AXftg!kWv{y`&BheN z%_ilx&3E|%06UtP!{a|xzh}*i&JsS}MF0k-`hQG*0)MIt9@^dg*;YUUese(e$x7B6 zkb&u4E>M5odiM{GvjAeMb%fa57)_+B^mVlAEU|PP*$H_1m#%r%#RvRBWGNbL8BO>F zdsnJ)~)O!M{JGKEjabF<-A@!<23E9DF>%fU8-2cEv3-*1*%)3*b zZ`v1rL=M?2Ts*w>sWTm@w7{7B1DZtc5@55|TR{IcY|A;l^_S@dORv;HjL6EN#a+wE zXSXkfx>pY~cLl3jF3ET$q|UiyI&|(;2|%`4 zTQ70f=?@Gq8#~56&iu=dM>N*M)a6m@E1nm*IE%yPa1V)qpLMvqa^Wo(zfZ8O#A|+kns~&bud!a@0i!xl^rUWFVQ&A8>x&)-V8>L|> z=>{o*C8PzULy_(j=~|>yNLA+UNMHAk63T}GasYHEO)7~#Qv8c@}cbsRE=8(gM_A7Gq^|>zJ^j6xzi`D z+VmgIY(<7th-^(|mc04NNj2Uuy;Kk;daOOPdWp=P2S0=V)ZH75$VdIvdnOukD8K4JN8ZEv7@g`V~a>S+FYrm$SI$1O+BxL0^yj_eTr z+=!@KO24;RM%4h1%aMx8`xVUf3JCCA6$YW7zRj#}OiOD*Nb`D$fK$@t5-9a7c|DK&x#^E!ZGh74cL=Qh78|%*fUK>ag^*t9Q7(y0ATyt!bX-$mrn^X$6W)oj zuTs>G0I&xF20r91kEyKv_=eOt5x7t}3-Ltcb=ll{`=MTQ(*@LgnC?0aaOcj319HiK zmn4h2o^w2K58C=de`Nt8Wo1Hr_SH?6stdVx?zsGg7%xPU0tm^8anLyvO>1{r+n9NX z1qSdcaeX7v@6>-E7Esc4Tmo6{GQVlPNkYZ=Cc}*&A;?M8v367EZq!;^^*cKe#K`H*(vNT4EXhO7eo1%fL;K3&aOJp08!|vpadtKeiKesm z$GrA@xU7Nifa9$+flle%GbgJ#OOg5SWW3WT4KJKg;Og}S3WJG1a2N1zu0neIwd>zT ziFE&ZdnoOp;9`N4zDp*3ztFYzz8ySI<8}rH@NRB^F~~h3S|p2t12e0)Qnz_fU;^dW z+IP|+0x>4VX#k3zAdQflP~(=u^gnrY{uTr~u-Lp-PhM#^ixq|Dx7#SNlHgtqkZ^Xg zfHHlAJck!+*Usylp*&0ki6FFt^q2&p@h61zVF1FtToKskgm%T$hvkIL6aO2 zb&bfpe95Nli6ZV`MP9a$Z5E~i-GeN*1m3_4!p7RSygYH|dm$*A_A_TqIGP(9S+AtK z^2Xd3Lm73ncHZys=Fy`o`;1)}w=sV1isJmwQS314hSl}c@NHh!E4ue3!jBneV)BhZi7R=Uofnln{@Gd2rgWo z`gPb3v8^X3xx$>SWcoI@fF(G@7f5;l*PeCb`XcP=g}4%+SkK?+c3tkCfb3ev(;Q@e zm7a~C`dc^QgtzAyOD@iu>vtNkTEuiIx>`j`xLJE3Nz}A~PH($7D$elt!xBl!n-J^W z%%i-LT)}M$5FI$}2>5U|q~^mWMc!Xh3*`8O`%bQ%K_K8>(X{Ih9$Fs1V{`N0vXDxs zY^o|qk9B#D7HeNZZm3%NKyWI|t4aKP-WX|8ZN!%RyKYl2{QG#5cdJUUOv&w4u)=0w z%N<3Ti2hlIzf0=zz($Z{x zp4tX?`f`0K+Zp(`k!mDboB;a!Q93~z*CjqobYk}V#`8^L@kS=s)TCnr5v<=J!R1=c z63Pl&E}%7M0yGu*KvPu-l5)P`f#;B8msJ^S7j&yujv#) zkA-Ju*OcGGVMPb9Eo@=p&O{X{AvYkl#ZQTKgyffF+%}K|GR9 z1x{8q5TH7mqwZpw4dFw@nTteDP1ah{>Av11i!#4!x6}Hf7TQU{u%cC-khd!EKS0uYY12+icR~hDkaEYo znfkIqNL|Nl?%B-Po{bvmLfwPo%!%k2mcmB5G!>Env-2?`Rc!@I^TQqLsVTc@^J+e3=r2HoE8Q{ zA(y$}qf?e;P-%!@H!w-twd|49arE<;VLj#oggn!959ykZTGzc*yVViD41!YR`RFc5 zOAA77Ue!VC_*VY-CujLR-E5ssxWc%zknE{Mpf*fV<%llBZVrJ4B#;R-)O=|1wO;bP zBaxK2PkrLmWbT?JPVed;lL!PC4j>M_aRvrpK?Rl&M zx#GM8?<7!V7q;MbKKt60#D^G?eZGRKhdUE1IIO};Pbn}R+hsUHe@X2t7&%MYicWa) zKcs%H_%gkoQ4JR&RnP@r6}W49-M}Rh&`S}4YTp0RZy+ZSesZ|O67S?yn%uj0RA#8w2rR{imC6O^T4(fiJz3oNwI%ce5XZmOAIr)7-PJXYaqXFLds{ zCm4Ony8)mF*V<3bq1Nx3rKia=*C(D7sNda`If(a`NhmsdQi10@o%no(duJD-2T$rx@L9+DEcOm}d)YzQ$=yQ7x8>d+P1Uax$o)*LGGA_fv4d%6*rK0 z^o%z5Pc`K8>P@NLR}a{x@~&qiPU?i(8!qf0b=2BMb@nVC(Bp-ClVzK$+cx3N(^L5P z&WvNHHzXY0CQ9aGSCTh)7FrOT$wfUiV4R z&*WWarKtrIK;H#G<>hCiR7;QY9JvVxPu|T$9z$M010tAP5?t;{VuK7Zegz}OLbvO# zk$w*(%-S^jyJ7{Qb*(Z8!WOl{1(Px5n5AXwlgXU%RPdU6lue24n3sPnYH!ta?LCjJ z+iDs^VhZTyEIR%r(4vFzE*cyBv2ruiJ;L?VUxDW}-O}14ELhh;g8Qij0#Rp}x5Xy9 zRI=nxAy5YlNbTP_l{(zNzRUzpL$)SkO>ld;#7qTF*Sbsvqx_D157l#PkU)m-cYj!4 zQ@r96>DIsDr<9oUnqT~XzUioP*o9k>erWYGzL0r!2#EW-EZjtaciyo~HE3>A{F)(j z*DD7p9TMQ@A7MV1dLwikp+%SYkGEdsy!L$NJNVafOaj;Arfv6+_u`Xamwm_8^+a4bb<%!C8nNh&RL2ww8b5F~A^CmCv}1RbKC6sy zE+ab=yIGd9=s5lwc=*y+-~$h&^TRyguXW3Bn?TTFD&N-h7;OE|6`Pi7O?faTK#fzb z8p|Y`5OZu_seIkj6F3kCL1A6PlYxaH>Fqv{8(=E>Aij{-KSb{g43`e14eDoMDw4X8 zzl_@*4JefIe&3aLPmKvenlR8sd{3Q=x40+gt_mo#scMoYow~T5LS7RNit#c-nxv&1 zt`K!e(RYz|>sj75uZnA2?oCw@>lM7Q!hOtsqoIpQQ<<;!YvX5oKFcH6u<7&sL#M%) zgUF z8>IgEwJZlVMb3?CL8X5CX=_zp_>vS!bdX4M3i!`4eZ6J;NA-K#PIJ(vcDDtip!p@`N@{*r$VmgeT!i$)Y4!2Ol zdkepVQ*}9-+`S}e_l4tiZubDfJ!#|tWHI>7n9lB4S*GOHfypKmrW~(@$X{1MPkv!L z@dU7orB#0*rG1e{rc#0Dn}>T4*ud!kZ;Y^(d=BU7NY_v32j@3qbZ9#bp)FcVTq z`nszau~(N10U?v~T86F&7uTt-TOrU3zh^*1XR9`+JJ_`vRF1-4|EnEY%K?SU9rGT@ zLN&N07mJgeFA7f$yYJrCw4th{`~ciDP*OMHBA^v$btMvlTol8!yD!UDPGA}*VlgOuNM8`-1i}Xz=9%OZFX~)nzjyK@kzrb9C*Zd| z2V9<*W@CA;pHWw)QuTjLfDaHqC&ebA*3hv1-tRXiL*~Ays9CMit0~8gyFQVHCapQ?gtC=#*WX2%sTI$p?LK`S znoT`gzZ&2knlQ%$U%fTBUy^ya-(W`|Kry%c``M_>!ixBJ(TrN@Acm9sJ9XzZd{va$ zV{haaCHbzhqrBc!geCZD*0bl%=E-)no7K*HqjL9qdE}R zs7q_gnRWC}$ni3{ZQYTQPt_aq`_MNDdYiW+BawJ;d&k?1A+)z#HO#q((C`68-jKE6 zu)1$*w?j?|cUua5{KGUdU>YX2c9{y}$#GCCD#7lrOdi)io1nP?H#Vj>f$d`I-q#2= zrg_c;--@s6i$A_5yoE$AubYf0+mM)uoPbyFvQMvOwQ2C%0*3@L!2k*@3SNmIak{5y z*|`E-mzxjd<(IEEO5?kV`R6zBFUmvV>E+o3X0jyzLh7 zXo2jEuIKY^TkN$joOD-#e0k=O8~EyvTLIVgW^-Pmyn?P@yf@hE?=sEjTY#Nm>61oh zAMq=_Lp0eZdwUjGR+Jz;mJa!P!$c((cnU{KyAc2_kVvWI}{PeUG0di{TgwDrdouH0XZe>*pU7 zP_Dds zXUmOehOItem?&f{otG|SvSLKpt#mSVy*$GPpp)sqP4!>3EfFpVFAJBk1sFO~)N8hJIhi!&{>EZb z*$P4mI@*Fo#?V35@Pn}yP^6i#oM-K3SA%S`Zwl!iy=gH6It)DdSbGt&q{UAwy{v)Y0fnNAOo88@ zS@vT&6@_;9vgGdFnK%fbe+L4tir(_+!DBny>|bp>5X6lA=7}v^TtJla1{+kZSlO>A zWGdpW$jW>-*7>PML5h+6gwBDXK>Ks===a2$O`Rj1B~P}z{P#RAa}Cr`%%$;05N%RIh-2LBVB#sjzR(lOs^*dw;Q9fUfCb@Z|J11)&Y_zUy*$` z-n?6X#Fuu2Ml?~mXv+^zx-w+vEkb37EE9g$RhysY#KMyrEY`)QaCw|p6l zVWyB|r=L0+OjDPI5%$a&nnX6G0hNw!Au2xp(v?L02LO<-76$y#dOWYG3}iGxY`V)~k%yY9Qkj=Z+CUKzWoA{G?ZGj=>be#Z0L(=S2Nv!=3H|=RhyE-1BG;`*v2*2zK zip~r-aE4V;^Ih8g++E(wS#iCax*J2Jd&NcFJ!xY2_o{n$qr$ZuU#^yC9$IFPnzefd6NeJ_Q#H;T+;8vx(2W(>3g|<9f|6}wpnd$u&+QUC2|S@mbHIQmL@#AKy|HpzbE;94k`X>#y}I zp-(ZtXxUNVcko0YHwdQRAXB>ty+Om#;d^y^5}Op4XE*yN}pxocs0G8Wg|2?;~<_J0gD-r6$Dw3o~K6&X7?&<0exto~g)H7yW{CYjS5vSGz)yHjTiti2 zP`2u?@RrlO@D71OcElL&DRd511&m>BD84oX`Xc`--(BR@57j!}&nAJHc>(WZ7^qIx z?~8{ZS#_+`)=mD^uAx0Vh23(fi{l(`D}+eO^X>FE^v-VoXy{0OUwTUnXlk_$;Wo z{S>UkOIjm+;Xn3Ph)B-z85}o!!ZjA}=^Bw$WyB#t4E=VCv17?Kbi_{)-Rzui2*o60 z+)hr&5DmMj{|l|u-|m;<$?6-Sy!FI!C<8 z5^f(Z!fllD(){*YVdP6W>SV8|8#RGSOXsVj$qe!)X(pqVUjXqxp}yDSf<7B>_edi9 z6yzdhFnMigjp20~z5nqzK&Q~;Brb<~3=su!0Oj*tiU3A6 zBV9xvDlN8p)Tm*NmzGIT)x?2fa{%nDC z=Sz~?0VnbUgfi}{MZ}wuZhXy;250`RfmMGeC{X@oLfTZ1uI*I)P-WWSb$4$w=Z(G5 zj?KV13}eJdChAh=l%{JpHQ|%>ZxRU^FadCrEpwkm`c%DZ?$un~<;L)NKz<*XF>ccS z7YiC8{`^hn2xyPMbi<{I$Mb8T?#7;9wVA#5lXrDm-OqKBD(*mZP%_oW=5qni+{(^^gtqqD zSM4O%x9SWgo7UowcW+w65JxE8)t3m;>pfiF7G!1+-38xWUITa$vXp0Lj7Xl{^&c>)0nlsAp$vUFhHU!u8nhQPM+|oj6go zqw0sh{;E72K&F(3#ig)L$M(OrUb%f`r^q7t(a{$BV26umik)CzEa4H+KDn5&C;Oru ze{)z73rES>M?EJpIJ3q}GkvLCqx(XW3a?T7u9iHNr!o#t$SCnNYko1-ks5O8hp4zW zQR=g-mTcq2Qkltwq?v^v)kA3c-S!TTr5B5Kxal7`Jc{l@R#;7~XDp+p=qAe0a*IX) z9Z3J<&9b*Z@H{Bw6{;WhVdGak(J6hm3wMN+z#!zL17AjaD}ygTIPoHnO+1~QYvd4f zvb#cBZp_i{i_{xRvRrgRBF2r+%(VToN0G>8Uev48EG!=?XZ$AJVS0$BoH>=3z2Fh^ z@Jb<_PpE%!O0x-^(seZQ$ulxI!OM6Ti)OPj9QItx$0b$sg>~X2^-1^Rm-5jpKV=&2 zcH<9uLurnh(zzOByYUM*yO-ALWoxNFn1-Ylycg-z5Yv59C@+;Qra|#jN=xRW?IJ2| zdgHyPt1dbY)L<<_LMunKvS*u3$j58C9e4ImhBB z3Z*>~-LlUOx@BrsquW-GzIjpS-9X)4j$&>`n%nWiM}@vPM3ZIg8kTpPe30q}qC1f3 zL7lz#2yFt9&c|^rcKN3qYjLjT4(@ZOYOyn5KO`r?t^R(@AoJdl7dor2p z1YCedeCm@E_`Yyw*;S)jL{aR3x9uGhujc_0JA%kao>+>X-1W)5;866K4=v$!@N^m1QcZC75g{Uh-3HTPJBkBW>ap_yfGs3@S~In!G`ll|^2Z6tW!^V{o20L?;QNt7d57qBMGoM{-38Rj{eZc!TB;V4Fasz&4@AydgxA8S6CN9}M$+IYu-*0s ze>`7S8$|xo^W65QS-_SoM@MU8-+;chq0GZ#PlYE-oI)jEyu%&xeTKzK{j-fEI;Y-H z{J`v0jx2oMxkw>tO!D505PmM>x60l{JBo9C-)Bv#h$M?Y$hjXl{djcCG zr^$-jfRPWA=8JbkM4!;LxMsFK4JW@h?!>e%4UZFB3+gJk?_Da=*B{# zY?}UGmsOtu1zTm@JGDb2sX!Nu;j(7ur|VxEP=sTouOve6FqM`b`@$WoIGa$@Qk#QJ zpO6D=%hqcS3_e<>ZyUZkj3BhbzSBGF08~wo|M-BGQdHgDI>8_WD*f*-a4iG(I)eLI zV=ow%xo4S`F@kG@~jFpEZFIZz&y5}Zuw$u*m43hvK~ZdRq|VVQU4PJL;bR-xK{ z!p-lXcBD2K1n2uZplcX@XJdI7IvPi~jafQ$4RVI>ulTAOCn62mKjg|S*=O;;b2BwGwacDMXAEz>qtg5c$F*I`7MwFX-9!>K;HpS zE}-j!7Y#AFh^tQ$7!E)@FxvHzFBZ@gm7ko%x1+XU##@r`PBvWMLK_|$22CA5rV z71E%APsV{%D*WB!nWXq`jtQTc9Yxp@j(A^iW+cssQKw1cyHm=3C>}A~=}oiBe~IW& zLb~>}lF==StGE=D9Mze*Em%2%7q!$v&|zzRW^3}<1uzF3GmN1hQP~{SSJtdOnV{bELHX5>nBphqY)rO}ea?x>6gH|E)P;=jOm>%<&SlPZ20pf3nRV zoHw4&`cN(XY@wt~xFUKxMrFxmtxoslw0b}qM#4#5rtQX%Cck+q?ShMNq2s~+@LlB#Cd>(xCxC|#fv1H*mWUe_$QIYZ z%xdy*i(hik^v4EsO^Yh;0^vWcKSK;|nc7ZNcI2&CGte&98JI(rBDJp}O?2R#vkeo} zP=qoZ)D+2>>U?jC15|ebv6%|kybpHCNea}xc(?EAQFDeeR5XE`YoBYpxsrd;`cLGW z?L3Zp&=}j=?96o4*~LQw4y9OpIsGY?IP9q+j^Jk4y%~G&d1%)2=m@5(-J&Cdlg*i4 zvyn?o$(@Xsd3ZRVFz1C}lfj)E(}_2N9~}j9)kjDP(~(uk>(!Dw5S-~%6ciF+csvv* z^(aKJ@D=Je%oMg|)CY3;@#hZEgZcUT8u$>qvF*N*&2+_R#C&V6x@YT8qJx)z3zuuk z|L})j(2<69i~;6UnX0{nbGPUCEIzC!LdS4AE;=$MA~$GEFqu3cUuUrzHFS(M6+gQ8YeawK7MXxZdVghjlc`xh(2BI70sa9X z-mlReYH%hc(!lsHk=Qrw&AM<<$1FWqsB}v0&X-(LWsq)*)a%-COFKc@@aM$>dhQCL zre#HQI|eEjKmWrZ+j47;_Z9e%Qn4_bGtUB(w9dr=_JL>$)9yvM@!gyh_g27njjnu- z3=V8|yqA4>sbli0DVy`7WS5bH=y{b-hw)!tV?dQ5SSrOgS#Pq_9O0u(mxB7+mv1a3 zb2us}a9Ei*VeAM)1jAij4$f-vwd$SfwY2o-4c&j?rsjg}4pXXV5cGPumr37$G(TK+ zo4p^@(HKvNTt5>;&$c$UTL$Mo*58jwfAUab_d#HIEStNIvVypGNbqBM9QaasHGNsrbknn;?S*?OuPV9UkBBz5jW^B^U& zX?BDv-gc*n#THkAX%)?VO9rjla<|kl<+qFXsOC6j>5ceL6_~hEsd6I3D(=cjM zMtur@Q5x!Pw8BggVdt;*n<1LW+9c4Opq0M7!!nJ;<%!iS$4~e2O6tzmwt!2!bl0S> zRhgu9M&VOJN~Ko~Q=gfrM)}a1u6^~8l>@Y|SqA?%T<5sI6J-ZX(H9Gel-|a}!iiFM z*eJpQ^GA@N-ra);0IVruMFvy}3R8uO9EC%A#02a6xXp<#R`M02UFyv?mZ+hZ3ad!p z^CS|QaoD3M;rPlRU`EBk&bRb!Cz7l6-B?A+Gue=1nWxG&g@5C=l^2biup6XF8FIi|RTng(sqe6oRRl6H!$){i_nWh%*Q5(?CU>NO3RzMdW#y{+9a&X~4kE zBR|_sUJG(X?~GQM!<6R})H~vKB;*%=_K<(i`5#7EN+OM%EgYgq@K5rhOogGSaLnPg z*_~b&mcPj`mH;Ew%wwvzs*!ICnTjI>d%f%R*6bk9)wIOJonpB4yLY_8r4*u0fANWn zUXC8sA4t8B?@MvVzBZs=u0DoT-?*nLj>UT)iQAYOAgWM?sIq%^#J*~R^eYrKN;Ksn z)6Y|N_^^2;>OH_Wr1%SY6XXJjIeE*Q$d|t#6JN z8pp02m=h}qqw!!#Gc&*Z-Rt4pn4IYoi{Iiv94Jnr)cqU*X6H_1|C{XwLO^}ZN)XgunfIhM_r}MpyUM6wg8G0Z2 z(I_w-AT!y$PY?5R6Yhp%pdYM;rpI4C^eoaLN9+ms8mPRO?;keYWGYGuH9 z{LCRrl&@VnbgNM!mOmha=0S4QIL5`d#f9iNp$Mt>)q35KvsqeI3+LVW&XG)|S_-w| z`>ArOahGJ-wv@ZfAOp)y25gUUM=CGoxM-|qiItoKD@k5fA7*sJmvrHU%K^WV`WhwfG zG$N8a%@|XX%oIgxUR-v)UKl0p0jluYj}Fywn&BtGJ;^px@_`)RF++#lANKzTNr0}U z;aKogsI-85mbE7ULWvBf(t{=H1r8Tr&VQb%H#+ypMoK3N-#2+L)IQOsmmX!prOq9M z{0KY{c=W>mO&XLYs*Skjh~Oq1PkrQdppl0EP@?moK?0?p<7|J0r~Y_I%x|=)Q%iYW})1q62ye?prdA7zi_PSxfFe-=$PK;=$w(_Y3bjL*}rHrRyj38_N91^P(S zfaEXD&t?h^XAo0s5lL9s+44JJ=X*@K->|CF&}aMV#LiQhXc_2Uq%@z>lFGcO+z@C! z-9Z4S)kt8HOloK?A%Fu_lTwMqa<<3hrkD&h|zGU=fiWi-}?fO|4HW# zWEP9l{*w@i1s*Zf*u&HS<3_*`-~{whe*3Tgg+%dHdIB(GFwD8^M)ua6`qvI9f3Cm! zTlLeLBfBQtRhY4EQjHi~?Q6s9@0h5#38V1z*K&du5pJ(*UOgmImOu-t_HG_I@PArT zd(NFMWE0sYoFEa&D)lg4q$LJ7|74-A z^0+Cl+?u1FH~Aj>|)EPP73Rfp?Fwyd)!N4GOTwrbIf%5F)*NVF!* zVl2#?Akinx#_R~QmCGt znjn;3G+nrlOjMk&qA(#3-54_AN}*Ym%I~VQ*(Z+~gn0MnS&{BOz4cei$bNZM*L{Mg z3ZD*cvfZkhjT<+2i)Ljuf9@0)3Q*NibHEHrmTKt-I z8kg(4)0Gt7T?kRNEpaO}&Ua&((l(mJBM~#Pb30|EH-TrU-55E2)r=hOA9ML1UE)Xl2&$dPszhJ~= zD+EM4bGSb-^3%Y?4??k29 z|L0rKIVav0Fa`)Dej3cC2Rq$!-+R895=A&iC`w`5R8XOCj?FdW8zM+pQ zE5i^WjHP?SSsfZtZ}&wp(^>V`h>PU~l~#6+!Qr?42d(`v? z+4As*%F1yAE>o_Z)PQd_w1S`3aPGMp4sJBhJEuViuoCdE-bBgOG>@5J;nF1TytYD zuDVxP6Z(cF_snkWHLc5ICDjsRW7?N}nNvA9K=f`}s`klz9eQ}1{yse(|BO;RF7vyW z@Is@7ZMg&!{}A{3C+Wo9wug_nc`N1qfv{=I71|a0f8LQ3py(D4j5OcfM1d4`z}_o; zmj6TH$=6$IHV+tvvB=1w+2%&N7EvmPLO>IrfC>bJl75wH^t({Biia_KluIE#z?4 z!l#M3LER;+NW(c{t%6ZijM4e-1#yLr9*x#mB^b&9x6)^*L)(w`<8VCKA=v-hKYqmd z{vtn4eM)z$u38t?r@5)p3(mCga%{Pc>%yJ=%543h4@N|3Iz2E8Gux|A`(q6W*@-nK7>%BbwYljsxw* z9o`95{PX1hGJ}MI-e6g&feh#XS&IcdQy+dqQ*%Ea;rH_n7Mj|J;nP_@ z7229;$V7+x0EFwU;50yolL$(L3SlX37%~=8U7w*H{CDx8Nbd_!{CM`hV!R zZpiS}$6h97N|bfL7`mW-c#&)RCkal_#FtGB{A!peG!@@B7K$at_os{BbbYP9eR)F> zv{Cv4L>_5M8lJB572A%Ho%#1Pwoml$hEG27*4v8yPvnw$G_Q3eS|{H#T&3)flsR+^ zyc_i!s3Dobg{veum5j!I_OCyuP_0yaE1GlvCrUS)6>N<5sOu&H|H~f$-v4F~VI2E} z!~i8q^zM8?kp}czvr$l;0YLNU!#(?6Lh>Tnt`uuwn#45;%EXZLESSELn6P1N>vFP| z;PO>LVT^*3cRRI$&86%&EVKUliJVj_Ba7@&!gsnvuDpE)mWJj9%=tUcbq_xMSVGtS*8+gjA~(0JC97gGn(Ot2h(dt(_U+l_I; z`tNFt*zZ$anRS#|o~j9yLd2s_2`O3VFr)16rwdcHq!vxZOcKzYsMRmxsz@d=%kF~| zhCh7|Du>qpt#%%nG^L$ao&BTpap;HKL{QBIyt2OmVq)F|nI|{-q0?865`m#(?uONh z1})=p5*=qReIgbl|aT^FK2!AB<=><>?$rl z#wA;7&3~#Hryr9k8bwSkPf~2h6P_I_huc3DU9W@7K{9=nM55-s5tbMxFu&Ol(lh1yInumR89bA{pG+#Se^scDqhP`57AvVC9e$SnJk>t^A zb6!lkcZ3RvjfZ}b7vfbSx`?FNq4aK`NGq>;CiwGYX@He|LO7Oz)sarAK0+)2AxBTD zS{&b1x>P~*^%>!2>(g=D_Ny^7Gk*@2G%8-bq*<4{(ygR3VYlBTyv0{gs<+C`Di1!u zHC5iceND)8ej^fhlge~u#pQ&-svM;r;vR>N*672&yhp?DpN6~mmbb6Z-k@6kg_cMj z0&xG+CG0*A%4i1g$ttI12z+PNHZP+Qe^N{HFa0_JX*jr~*1TJ8a4nAOBiMLzCMwF{ zg;m2SajUTZGxB@RZ_mqn#&2Ag>~yjAcD;VBnFXZ~oX~ru|M7T47<0OUYe}JTd*r3} zMaonH^T42&i?ZQfg*3V6G|a9qig?xY&a|$C_vqSK3>-Q3kpU2o>qm z9ifuBr<;89IZWIg1tcf?OmE)cF7l~8eDS?ni7QO>?aU_abX1Q9)3&$ZeQ9m_+{*x= z3|7#KjrspN$y8HXIOV`7@R7F(qOop_%KZ7!=C^^<{m4%yw6A2CkTohfSKj26!3{ME zj><=2v=lv|EZ3rYD&bYg+N5Ja0fa4EVx@nu!Nu)fB#7XPA-eg?VvWq3!|p*rgxGYyJz3}|JIHhxf&-NM1b`_Vzb)HMDPF4|xidg`X zSZ3g*|ATdlPYqs5-N9>$pwlCGuoDeWJKjWUu!;4M&v z8lu%hvrwen!t`?Rb-w=5A*N&dV*6_9EHYATVeH}Q$si#Lrbj@9dz|o~w0~c)PpJMt zpU109ETEy?`ja#bdMkjybqy5&#K9{QehR`hIsdaN1qm^tuB#o{)bQ?}!t4~6N z%@rs%n>0Yx(2d68pLz9QLP?=yH#z?pwtVg>5?W!B7>I&OAAjv&k%H+aIa$Z5Z4B_B z>8C`k%{?8~NH_`nFi#&kjo+QI`EDLB5?pFQPNi*ww;<+2>iP2bIaA57Jf>lvr&e{_ zbM9{#PYKjG=6*Tji=b}3H&S+kR=Cq)JErc*c5`x> z)P|m0>_^ht-2y>~&#_#&g^2`WvW^vlpEKX(FHC2$aG9jq8xK+Oz-jHn5NMemA~s~M zrO3s74z+JCRtZEt{w>ohk`BZ^YY~ah<(nwJcmHRCGh_|!!?c6pr;LUr7b27{5Ue5I zZ)*B@BupZ`d9@m_PJdI+bMTw^08bS&#Ruk6c-nJDz&W+*cD&wGgTsdHu~3R;2Zg9H zV(5oj&2DJwE8~r%v`lrg!NZ>Cv6^v(TyC*VlC^JZFXnN&>nTLs-!N0f7ORx~3gOsT zG8C6{Os}{qCEhGJG$rU9urYcf2nr$B87vH@kEBV-Tf~nrd)H^|T||>ocSSk-gx&-h z>^@69RtFxL?0EAZ{lq^E1xnz3GU|Mv{FpC_h%BO^_TPQsSL32)?7*`y!B9|mr2;js z7hS3S10DV0$hTPibP@*v7`HM%pU+^GU7XcR&|6G}h6zfL0+>_W76%qQHopqS8iO1^ z2PWi*VVE;ye*)%C2GDs}ifdP`(A#u5RirG_eB+q9zjn=*bhQ5`rH=S2Vr z!*%PeX0nbWzkB@fPp}{_!4u)`qdJczryd%j|59!+t4zm2#1J4ghNY`Kkn+w9%PgAN zR<*T;>RkZVA}D0n(`x=nRPt}5BBk@*0_A?(268R@O9f4sG4^Lo6KK4i81Hj%!CgF$ z;s9;9oM&XND<2`Q4eD7)FPgXsxSxohri>z+?SGnv#w__9*4gh zL(QQo0rdM^{Qgf4(|7?%pm>EM`Mc?{nIt0^2Bz)>jqVv7;NNe3)@s}zE<6_VNOpIu ziZ6^4Y2Ch&*23T1o*LB{V{3ZI@2tR3MI1zi*3eK);47Qw+_S$P7D>%;fk)0$=pIDT`LNQ%+9fFI|1N6jhKFWgw(9GaJ#5t1R#~zt z2sfUYf)+lVc{CT{?0;7u^-EZCB>6|c~IpsVC%YN6~KD7uMN;1TX`-TxR`QsQ60jp+X}LUcW( zCtElC>z3Mi=J{?4OkIKk+_U<$6Altkg85-Yb0+hC+Z3tdjV&B@x=6yfqca%0%zUUq zJT|Q>Fh9bMq9L3?;A1W$L~m4Utg} z^~JS9T|;*MkJ(BFF}ZatKHEAy5)FlRk5q$q8@A(Fi5~opD5;&6Rc`1IrrveHQgpX0poW|JLmWm6w5wZ5EKZzRRj#NZ-D75ouaBj? z8zj2%C~|#-Q0j5+q^`nGgj&s?8;1Y|g;P)C@nrRXpGX>Zw$`dDmSB+Idp~%e5b+w8 zrR`4T?Cj*irp7+iqbf>QlHlTy``#;kDp(f2KLRQDB{&P90Cfc&l=brK7gT*D!p0#W zYrz?FZ%}o5@9mah8h{qf{n!6VIR78XOn4f@UvNGIJqnI0C0 zkRfC-RX1SsMiXOuo06n6l?_*C?YSf=P`fSAfT8XO`4oXk`1Y3UrMKQ zSAJw)FH3^G}1I|d;0=zoIDF#CWpy&-Zx>?WnO6sScTE8bZ7Q`dlR@2 znSMe2zx&QOxsx7k0CW(c_mJcwV%Qh9Ecmi2lUCk!2oQrL_svR`(FL?k+M$^A~yyg3$L;5f>B zbjiMP0jch#%t8*WDV<E1Avg1S$iPTuRLA5D^+*OB-PV%;hN|4_( zI*074=SRt^O3dkL5tcGXh{O=KnAY%Gw)39oPYB-1va*wGa5Y5tN2`}G1~T}Ij4%GJ zpmpKB4_t#Hy{6g*3?Ww6V>uE&{}}gfcwEnwVusXU3NDrS5=ekQ-hY=*D7w`5oDm_N z7G?u~x{0kHAvmG+;s|!9MNkZvf_N( z+GNh_&Pc20G2MX~`@Alf?s=&j(m<9Eu^%pTmLL&9A_!t^PBa@WPTKkQm46_rt2g^50(biU15#Lg64($u51D2Jih zd_fOoKaMYWlnf1=!oj9Sun*trba<4u1V&}JtDi$w{;@cCRFHK=>mDA<$X)cM3?qINtO3EEJ*rhX$KKdZnsv7e z^{kSke+3LCo=Q1U-DPCSkk{a_2cHQ1v!F}fk#PZ)-Iagsj1QQE>;!U=T6|Xlj_qrJ zo5kg!p-yrYNT;^`sbJk05*Q%yd+1dFtL(Hf3~1pSt47t36~$*f)O1-9z%2Ft#^*I{#^8QTI zKof7CM#4__PAkNR4b3^h?$hoZ>9&em@EN1QFbCI_AFv6fTJ&4C3LUEM>wYcdostK;-=} zJ5+$%Lq}39L-D}aB{qz3U>q+Qjy*HT9saN>p$mtth^6*-bjQOrA8BS(2MS7dTWZDv zaXuX>R7;+Qx}qI>!%Q%DTn-}_uUrj@|G>!{3T>i1BCH|??)ox}n+2{GS~QFWRszx2 z-!CvJ(U`LMR`URRVfEb;k=j~!AFgKzWaD_>Wr)Fqx9VWi6YFz(TQL9EfBO}(wws)9 zz=M0zLrH5HBz$4NP)|eH)Q-kJFopRF7Eoo<;$g*p{ysI)G#VI}wf~FnB9yz+?W)N| z#*y-dnFuwxzcw=ui{c`c##QRCpdR6PEX;K3-O?JheoMC{a^E~G2g>Pi`dGB?I&WOW zEzOxHZ0jkP*4V=U9Sdw;mUIyG2l&!ekTu!Wji6we9;=id5jsfk4;5r+k&Svu?>}W7 z=RJb2V1BR`B=@Wz>w4<|!LQ(fK46334#=^<6E(r)OQ$G4esD0Eotw27z;_-`K}Kjd zxPi*wBjKq4+~J*20q3`Pn(8=9EKX>wfo;xR417-ons^NA`qE`TwAPln^Z5l;r?_}Y z=|7Gx!lN!L`|W4yEYNipTSb%|H`G_B7{QYz1*}MY>f)Jah-dj>U9hh1nxWAffwa(J z)&Th*cM}5^?ym5i(9(DX@H`@mK^D~|s{_&_GzrvCMJj&jFRji%0pO~nq2VdyhBp0u zYe~D?jzKDe9|}h${j;z7_~2hDFA^=yc*xN!5yC>TUJzB@VFi>zmF_*Son;}9x@!w@ zTiJVm%ht9~pB!Km;zR}3;UY+4fi@~I@%b-eJ`x$}o@6PD&$I+2w-evEo*$6fe>SaF zST6ga*7RuS_Y-H~>$niYNnM~zex;s39g*x%(EJyuTqB_~k_^EuFNHlt`II!ell)&H zzLQ8fH#`=;Xujr^Y}s*XPDROUPE;r10gJqxst-8I%ms|N^dIV4Nldt|w$z+ePCz}D|;HtQGEk=XUqXi8QqvKd3_srrcrY$7jx5h zJh(7IvwFE$gaw;@ITlDa}?qbknd~%{3z1pRu_!BiyU>6B=1$? zS%PxB6A?foqWp8KA-5835?fE81p~2SYxNyT{83J;TDiyfDAkK3wo3m%vV|%L>(ESY zUEUf0C58{F#M|_mpZ*UM)CPEx75s-UZjXWb1c#m8ttEPEDgx#N# zKt)-EH$CtJPsD%fYS|m_UbWZJHvp^B_Y4;mC3X$n4;lGJ_HKMkx> z0}8479nsEQWoB?QD{fJd1pi!QNK7||GgbH;oJ6}1Bog%7WGR3&8b&F-A&M0hNR$rW za1uD29Nve9tsezEgzVoMTf8s0gng-+rCE>apw#CJ{VY;NVLfgyl+KsR9L(%P(2<0k zSXHvEM=z52a6~mp2UKkfuz(A2A>X^l$QQGEG$^XDwPWElKZw?Nifq#hl53uZN>687 z%4TS$o@`>-mb=DsbaOYHX!ram9QSqTp3cEBC*##BYyMnF12;N5Vzm7Gdh+<} z(7s5HE)7yrh&G~mb+YW%|Jd1#HpPLLRd`PHLojp+Zw4)JKpYYc@I;xJauY`b{OC%^ z40?Wh18PN8Vuw-1M-!=_g@I(rpHly5eT7Xq+h* zZeQy8mb>pVgF~wvk~-4BKg`g~noU0b)8=v6!d z8rDnT=I`>quJm}EZV)Hb<;w3%8;3_e6($lt?BFy|E!*5~U)FTs3YWP6NXz((iYbai zTH-&Y45Vc7$#TL)|2`gJODAQ4Lqzu~3Yb;lddLC*0!kZ+N(11=sHB)MkL}ahscv|E zKiP{GnoP70I28S3SU_A0>5{*N1i*cuc+#*B_O6!b%EOYB^c(%+gXFlSx>6092yqyr8}T}ao$FxTITAECuj?z@yGJP`DwJB$gAoQkPKF!*`tW-J;y6LeZcXvwe5n zaR~p$N}NtFY|TNYrDf%Znj~oZ@lgdv4qj<4ASOwL96QSj#*9vs-g4o~z}Ptbrs#kf zA?Zx;Tb6Rhb)r<#8>R>e7Jb3w|AgtdPp`5o{~;jzTbxOg!50;F9x)s$i0Mv<{e8_a zN3bA=@bmMbzoACwuaVR#XtD^&W05fyVGS=-6!dVU=~~&To>zC#j@bns%bX74STm%Xkfz#F3#J-*1^i*Xq zK?Uz27jU^yb63-qP<2Rk*IJ(Ek7)^?WzBE_?|S<&y*BipPT_iC<&Ae$<;ImqL~1)h z<+a1n!6Xw1ZIeY30Z_WX5YvUsS& zfJDuJ%zTfTUMy`k+tBv+SIWc$p|b~jJ`~mf_d1S|i^~VOjq-KVmt&U3zu*h5Gah?K(8ajk zS{{LbcyE)GJIq-$Cs#1^{@|w0eF0x9td}eC_WO2}#2(u8(fE-GT6}XEo0jdk5N)M6 z#nxzY{S<~J|NK=f|Eurhw-1sfa{`V(U5wj79q1e1Zcn>z&)}9=4x1vidb^Z=p*Zl} zkkGIjUSY06h=9a3gUzknQRXMD*1k``$Z@b9*d1^>_EiGQq~VED*5gfvE0%+^e!yMH z0h?0;H_mzkH}Lh1ix6tRApuB$b;00k9Kxq4{}}38M5kwr(8&w>b2SkQb<6~W!ge*S z*38dLIq<@{k)A(r%j9~?yVH|L4DGmY)tYVD$jULkpf+w*RFd9&ne7yTxLW~0<964j za;M!<^hIO^%SR;A#tJc4V!}x1)*o(Wo>!q=S#L=GTZfDm90@?e++K~pk~B~J_vM2y z??|Hnf6mSI^9_H4in85c{c!jDv4W|wJ}97zqo`PNEpF;EA6_D*BijUAAMV=4Jy9X1 zkR=En$X|SNM>IYQ-Lp+W8OIePHymq z*~bcfFc9C19wV#al_CUG_=_PQTX*Mu^aQ+>G$@4Bseuv7{BVhxEsa$fm}adn6?W4=U6e<~TI;f~tZMzHr(RlgpHhv0Y@R#)hN~e~CHhB5Y$4!L zMX6^822rTILw-MUdVjoK?GifREkWFDDZ7kwH2eoPDl_|Z*_*K-!0jYbFAX0S_62`jKfb#Saho-1ll8>y zKfUq~|A;2HG-msO7?Yc35$m5C!6;j}B%}G!yp#VNEM{%fou+MCDLABU&Woh`))qL%;AL$)AY(&Cv2LB9mK1K*G zCRLGxm?B(Bs-{GlQD6Sz%Luk^b^2!hJCgb&(EtzRJfF1jm@f{7rzwfylOQoA4fO8X zqD76G`A2}eR=248&9bS79YcueWM&S-SDd=bwpN9Tw{?*FqoH8^G+PS}c6w;W7=q?i5f zR?qHpmpa25D57$V?6dkmLp`WayIR*Bf|rdQwur9mO&YJyL|`o3WAXzK-o zwjE{rKP%9XA_v(szYIHEUZ7aFSn?5g>*IxZ`U+6dx`n_PfCXPzu>Da|5(>h4f2jNa ztoMr`zwqc2@}O*RF0ZqjC%KfkZUZRKM~cqbFt{krQE6)GwJJKqt6gmtGnvf15T>)OC`mwY8@sBNjRS=6Yc=# znEC^`Qg7j(;!oZ8OUUE)t^5G9#+-MX!Fo{XfJ!)jg%ezPG581#n3TVHII1@7X7ZB(emE_kr2z z)sQxHNhsQDc`F*A8d7rUM0wm)<>;z`d?V9%{9w1t!M@)kWsksLxr29Lr#~!N{rMou z9PKD1KaTkusEx9;6XSiKJXlw9Yl7)lQHmCV&>yAcVSMzfQKPHzaLU)1WqB@($dJVx z&PBP2_!AXqC<2cL)XJuHFA!`SPysLZPgu|-s00yez{v)cXWjt+uR)U74;&)^eY4m! zWp`iY9W035-CPZ94vuvHVBSPJF3NawZgK^60EM*(iHQh%@bjyPc>%%iOCIv|`i;V~ z1e~cvkjPufRI*)JnEd+C&!(9oWK;<9G%yegZ8onxN%@xks5LE1_1@g*%<$}$B*tr9 zbymNDi8$F_~j)jb70{3nbpu8jc zg^rQE;Be{6ZK@&75CdTt8^r>x?{t&bXd+dwZPDdz!1xdglr_S5)YGDc@EI!Gbzg8P zHN8x(Wy1RDocSJF9!BzukB1UB0Reu)&$}R3q*K6^-8U;>dpo2925yOfIFWZ`7?>de zpl?+27WOt=Z0(EmjoF1_JS07BYs1re*t*=5i+V1O<-8(VUSnM$+O5!GNDT}I{%RYT z4-MdPd6nP}t_8~p@4FlQQ%b$Ul6h~tHne>uEV*eLlFCHS$HM8i7ez&oD0NJS8d0Ew zC**l*&7d9NVxann6rIo+6)+(?1~J@@!TejEBYr*(y#~J#rB#y3k%3Kr%c2Dp#3!aLoS0e%sfOe(!O zva3M!HHd5(5QQve1~*6jk7jI=g8T$x;Q6ms)&<(u4`g6S9g`Z3^2?IW?+3}$cEk=_ zMDZYfsFw}H$aVv|WkzAf<{81k>FLPAhc!l-@_eKwB_+)U3waWZ1SQzV96{$h9Xd<| z{jUMh*A7`XBYOXw*+h;nMrI!z0A$#t)YqsB7;70znt7A518+1G8K8QN>kz&x(AkKy&st_4a%4m|Xos+Z(P~ zW#0H7(i{C?S+P=B;+v2K_Z<3}oIJ3YGx~{2c?>DB+P3)JY-{ZQW&xOv!oP;<4_!ge z<8St!XGfd_A5oJ?TTLABmLTkeiNiZznH};CzhlweA%X4YSmcHh(?m@}rAKm}AilZ# z?qW5mD34)}%VJJ45>58>Wb~F~RHN%Yk0HI(|67fEBLVJo(j$?8_#h-yGBi*Z#6TWo zcTrn!flL?4xJ&HLyR{kE+)bw#LAJ*opP0a;8>OQKuVdhUpl#HL z>RM^acofu~%|Mu=U;$WC!A)d>TONW4gYBg+-{x11GL~YuY9N?1zZS;usT{1~CH#>a z(f4;$#vWl|4)Gr5BXOUnbm;!h=OVQE&`8PujDq!L8ROt+L@(KyO2f>|#~lCMd8N(u zU8fMf)nkkVBFXzm6fph6r%s8xnRv)sP<6tz$HM4(`qlWK@ zGM~;?tc#u3&Lhqo4_S_W=B;+;@F?kX%qV& zv<#UPEx015yE@`fIx96;Qzh|;8c9^!MPA0|zZW-};fWS&7o`+1B&#>T6Np|wQr30^ z(N8LErlQHF5WfxOc@U)j`DSSNP6}C8Sz)m2oGm8+3G?|^Eb)@vv9Uk+RCo+ykP{A$ zC%*rz&y<5c3H<8h6m(?^h92H6&tV7=mxLHI6)@|}3*m5C#jniD=XLYl=cyB^|6CRC zO9lUQ$ETn>DxIC+;5c{TxtXw-*}rx_%O%)uNc2DX@zI_Akw^1Cm}hzI`JcSy?U`x6 z7}E~z^Rgq%jBxMdancgjv}gJ4a&Y!h&s<7O)g&!hsCqwC61s4U(x zfGcvU+b4rSA2HS=ISuAtD;c)xW^p)QrQli-#7%LmA|z7%sP!z-_aYl*s(faZ%jS`* zRTTayMA*NEXk>3RJOPMkdQt-y$JM4TA^K#`a|xUYj_>3VEc&n9BL{K(+|q0BBJ{UE zyJG^5Jw9&dhhm(!R}hr=tAcdPXxc3 z($IK_BFgS%7b+;$R5^9XJjpEU!L;7RAW0xs^wS#q;7Jtj%D^R&ZYD1=gQ(D9l6L5p z3F4M;7+%Gr@p3tTqn`f%H}dxR!ujIbvQ?i)c&u8yr3lr)<*@Y&A(A%lnoQN$$kP1B@R2xPXzJx%o1={_jse>i&mF@XKYa8rKTPpio{LvI>Z*j+f?b^tVX)Tq zo6B?|E74>$!Byi6m1si%>?MP0xCfSdxDnmEsC{#kNL7h=*}Hx^EAXXlu|RJeL|_9-BOID_9Vr8c-QHVu-`h!#FV&KNxgWE}g_gMYI1yd{(Bi+vKg zS&m2V>kv0Hpp+J-FZnM7Uq|`yVPeD_e$jg%?R7GLn}V@+2mW_1 z%YTe`2|h&Dq^laov66yr$88QbFY0??M7GqM;(_v*91I9V0!)M;uMg2~`Hsaud5l`M*EKMEY_tH_|kMD@0_+= zpe@|KVWyi1ouSN!I16Hl6R`HC%2(4io)VPd|d(Y%<}OE53Q)!-&Bo-RAGb zV5qBa(MAH!tvt0tHHD;mv`cE~0szQB2T9$Vb`~WO7_du*LU^zA)#E%IWk99!B?i;0kJQ`F}+I4uGz|5Le z!Ttr_QnQyP8bK1q`uYO6n}wZEEH-|2Uu3q!5n;ybtM-u5(fy``8(dALuB656r2>VW z#_9zxZ6|<*b<6S&_8l%^n)A9vwzasHT}Io z&CN9UcXOTcOhc!&HhMP$%bX&3)Gl2oeUU~PO~Q3(mP5#^aCqHOEfs*oSM_h#jD1R) zpz{Jx1TCJP@EdRC-l#30$}{SASs|P$#d+VhW{%_8W=mf=n12`3QhEbyZXAW(G~LIo z+j7wNr7O%D>LTY6F{fMaV3T_YfE9&C5D(6RzwNQ!#njrqyOFP&RZf5fIHtWod5TMHF-gkFegYeFV~d(V2$+9gnCP`)Mw=fI^EQh z$!kIU@|L`o$*gEGQ2}j@9+J@5R}$@MUn!5z%DTd%{9MyKZswof_A~!-L z;ch5{$qI?@V*KDLY<_AY2|d6)$YOt#B*Y3=z++uRxs1{(4D~hvS55^9MypM^n#720 z^QV%&m@9m}xc^*je3G*rGzb#=IUE`jXnR?xZAtjC9Lca;(a=io2f8t_-zp5P71+q7 z2va~XV{#CrLd;lp2zmWyipoho!i__mp-A1^OPKJTcFv zQR;x+FPoR@gMVpy8KYUpd9(@s z$Dm|PXx~iwqYlnbY*aRrcnHAA8+b*~1YCf{(@&y-xz1ZD zfeVMr$ZR}J#u&}4^FXa2&*^#a{P-9#e=0pQo7-sk$p!aD1shx7~%n`4)a!` zN_TmN8oG)kVlSR{iM*T1PdmB#FVb^xQL8>l=!8N@mS&LM!Miz<8ucMpmmAdPf?r+< zgO)lxGU=poL!scULMSPh!r3x6TJiL7nMZE#-Z&SM)v##T1BwCzSTmih{+x zp39rJM#7i;{r?_n`98ZRz)d)j%vbx&g<>>r7U$6d>z5zDj)c3ifS`@*`t}YVC+C^_ z5pdOW-uUe9_ku(;l_Uwp;x}`n=@lkql6XulJq5p*^7K1m_l{5$+q`{pP~D*FLw@#^3QfGM z>^RqrdaC#9Bvj}hL(f{r3fGv8iEzrB1Lg6O@W=Ssh`o-!_CZ(SslGeIT{i3h!RucV z*8C*>K@d;FgjYC7$$TzF%g1vp9ZnX?!l~D?AR3}S)@b52Z@D$l6#ld;{3IxOooCDbCPZc47VKWYXmNVRGgVgj#B0%Tk;n- zOYR8`ImJQkh1qw6ZT$)HuK;Fni5>96)(?JghK})&p~dszD@1MX+3LuDOb0d>x55YAD=qDRgF};|y|o)MC`{C~R9u zSXSRyBy8uYlE^{tUqY$rw&`pV%nU+pK6>;z`Oga+qyO~{O;AT$L9Y;lOV^3jK$uJD z$>>$SPwH~yB0Sk4!KM(|nSL&S8Vc1j<W2Exn^~(`R<~rb8Cit*xx_jWC z?ON2p@|;u2GcUZ7H$iI*nN&x5#ZYHL4k^Q=N3;UQkv2%0?lvNuaH(35Gdubd*H6CKn)!q{`?C8Te_hqC4=!e5WK+X`2Bd&AskhK&lIE2ZYTE7(CWz? zu+O62lm3MGd$yNV2B-Tc>xSP+?eXOp1ulF`Ej&Fy?>Q3h#gq9(^|cG?v-#Ga^G%5E z(De6A)wQe~Em#C~W?s_lX| zkk!q4;Dt69WHM&X7WP4X1W4(vVguY~T8G9$(8yp$!}0mc25+krVM@OdK;@R79cdBl zxlzL~Z^5le>!;YjJo|9w0ENnhJP$sZY*C1vBW+r<+%_pwJpxoqo9xAN?K7@MS`wXo7&?X=T$i<>CB*>iIk@Vx(ML+Q)mg3VEbxKx2YyTv&s)lx!vm7}G zD;kOv@tRg4B8o{}^x|u0b9yGZ+ZCJDL7!B^(X?XBwB)AfUR;S}S#XitfFY{zW>)H- zJz2^>MJ1%IWzdthRV&jJcJ=S?)FOMHFK%{Xd7(|6&N)%nFY4ETEyOE*_H6owP7uRz zRkH>czC-nEq+^xw0w0Xv+F0?LBvCyE$jG6$vo}MOSN!E-NdCHGnpGy;=FCh=xgShb> z_S)*oSs9~qmU)=}aTknohGjvIwvn;RJbpK}m`g0X8ft*FR@|8wF2w&` znsYWPB1lhERpU1_OFiUT0@ELET7Du5(}pZK*&pL(J51n}9>lud<`Nxw8+%D|7_=`wt zl$HgGIlGFeez+E>>zE;~5|felFr=xA;-rD#8>TH?T|-;jy1ZsL9EHse3Tfe=SV;MBGY`|D6?(yY#Xg|xQKp7MKxXnQZ4t%jZLpq1-MXE0a zp#u#KEWr&jOCV7FT_3Yf3nKYge~BiAji-CU=*bS4W1hm}8IvU2q+GTCsBVBRz-pX{ zLu!-|Dgd^^Z9X2JR^>g;XI$b40bH{fZ!-ZOcC7cZBcWQR^A&5kcur^~{o$B}Ji!t0F8*Txn~LIYQiaJXFG zMMKp{dI#adEy`Yikol$^OsV5KnnXCL9@c$lY{j&!uC(mn7r20{4HxZrz5Rr*p^_Y2 zeDleFE0Vn5!iMV) z{!q@o-df?CqNa(VR30?l7BW@1l=1R02jg!E6BZnNfQ{zB|X|Ewq<^X$>Tc) zdED~rR}_HuY%W>f3EpkGj-4-s6E^Z!!C4iSSnAj<0`Q6>KJwx=4)8{izc_HiXtV2CBz=?TaS;<26-15;nmr7$i$cFZHZN!^0q?H z^ase0v@`191~@3&;tM%qq-C{pINHr`1yhH)OrKg^DEfWho21*039A9I>X{erPzIvc zH$<@s&-Z^nEoec()&bUu!18jl7a}CDad9+Dz;h(gNJhy4P@(&WCK5U8tf7;}P)_PP zLba+pkf|`hG@Bk+2|PSAD4pxABW3z)_T#_pmff2dsUyj(g?sQP%%*;W%tPReV?hV( zpb?M�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

g=cp&^tP__y{YQ8$t(z$E(T8F!`C#((E4U3jIW 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 An(=E2h3JdO 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遢aff6M5>)8);7^#=4%QQ&k@miQRdS-;aC>I zs+kWXLoxp`hc!$MFL;VqSPx2P3d?rf$Fzl5eRr6^?O8vQYhK4cspN%`ot4O>D5vmT z#f)lD`wFAQ8h)_q9}YZm1F&5H!zDp?9_@K}RRIBgW9uFPq$fgPPX8g*i%BxjJS3!} zR#CLqk85#iXS)KP@pUs)iWDxf_dvP+r&-QdW;N#5^OT(YZ^)mHpN)NAY8G-E#^kU1 zI?k*5Rw$%a<$%~;_Xxed*Ghut9x{-zr`a;s_hr90`&KQ&xS{qjhY}0<#ZkJ#!Z{u} zyr}=yIsBaBgkx~MqCCfyX&o2PB@UTl)u&}hb zlUs17>t@`;+d+xy(i7JK1U?2KO$Y&Ydb4E%4DCI;ahhOGMKo_KqWKwEbXvH5!}mB4 z@c4dfcNgY^$8}MZSADfG~wgx)Y;j8*jF~lODQyl4t2qdjRYWjLU!+s1)sXbI$l`bQ8p-nk}dD=mFZLpk1 zk#C+b*b>Z8UWmUN3c1LlKa&zolD#~RK^7=ma|d|1oO-k~%2Wl}5^SAT`-aRj?OmV7 zdlkb6UjZzgGuVdg`t?3VpT|0W-e%|89^2VZy*ZUzQnJ4Ay~NGde5!9Y?c}AdO6m%y z&sXec-ui97@R#B=5*AduhW^8hB3GNrn$<6#r+3&L$~24XKWPKz(4L7MLwc4&2m1*A zEUk{7bIG{ts*OA%dycZGwtl^FtI6&b!QBI0tvv=;owr(CVAl$Gh{E0*1V2vzw(qI( zcrcev_ogjEn-44XNN4*@jmPHRsb6WRDS0zF+JSiq;aJ9=8Hv%m`dC8ZtS-d!?z5vx zEEuLvyvOI>HR$yv5lOWWhcbH=1`hoe^G{QI=1W%_AX&c}7cgOe8YIe%_wJQeK};j} zaM4-v%BKAD+w-u~6Q&-4DjKlVBI`JTAWIoAc*?MlKH*uKY-hSM208!5G+gQ*uo33Ux&NsLl zdfjJcuc30e{Di&kARDy7N_?qLaZ71D<>J3HFaKYSuNhBj?cpw@DI4VhEyFlT{dL~+ zO%F4rLO8>~@bE8p|KDX@#E3Kjm7+ zmB4$RQs=ov?j5UtcxFqSJeFh9R>eDHtGO@C+b17*fAFn?u{fyU_yQ{#)o4Duf01SR z%FKIo5IwSSr8p#y`6tgXx-n&cjUKvMc7Tat`fhH4fZ#jtuj^hf+fZO&AF7BNJdRL; z3Jlo2+_?DAK@LW7f@{>R7k}wol#bbz=O7>w@Er}s%MaH+YiD13!IR6d)2pG4yE||N z)WK!PI<)eHU0d79HmKn>L3Nytqi;BRs4U?MJEj*!|EhH2%BtWtx=zsNsZVuuPIYqP zw%R#UhtJsNWK~XK#Cqye!Rgrgzk><$&6bm85oWZXEStV|i<#y3-(CH_CDv&RwaPG6_h1;irksg;*Whxd%Q6mNT=rpcuZRpMfch(n*~m(ITVDS3(@jRz0s09Q+uv%r_f<7%J&Vl~yk z8rQtXKTR=ox9<8YECK0UrPkwZM60*4(x~U#L^|FpwcI>hn(n4fPRxa#Ql|>`p#@fzqEd z!RSBF&#I-|zkQT)Z?uw>kB4}jiY=E6 zX;&*m27l1cLW&8Zrz}1nyuIpMEA+dz;!_i#rMp<4%&E2YI$cCu9F`HlT?NlA_aF?Vdi<^lTV>lK=Tvw(r zTT!DCYHXbn#7fC#-j-u#pG}QM)Czuh$)0`0jpCxUXFzEX<2p-*6E|HR6o9sM$ROV) z7rhRJ{`&u!diEO5U^a^zIQ_O9__P6`{>VMzfW)X{1k*9qdZkO$SVwu}nJV-u#0L#M zjX9M`(ub4Ey%u_Ok0Cb${p6rD{>=ZkR>z#43+1Qr`EOtEPUXjw(|){~MN|FW30!xU z+1r`9*qd56(qcP~7}JWnH;XYWl-(HOWxY)V1E|){?H%VnAVB)|oVRmPR?-f+l1hFn z-VTL%w}8r?_t=j+Y-yShmmrznq%^w^Dep*p$9Su-3eIX+53}AytwXo2)ShdPU%_;o^&5 zf9?n7ny?E}-+OT>$_`Ly04p#(v@TLq5KYbhk?8iWAxUn0?3ae(URS@whj;++f*&t7 zR%L(|hbGsA>ZGUh&U>o)<-sE$&sg~##{Q4j8 zx#Ig}oCyRb5A~X?Ub|3OmtAl~Q{<{u-d-?hGJT`wl6F$90G5%jQPEWV~Vf>Nh3GlgDSUr zuSL-!@owfE85BYnjx|^+>>08k6;Q`;Ux24gfvJBW;R9c%59#Ke7+r#OQ&1z|79m6a zq|t=8JYHQ`mnlEp<~yYj5dj-WK!Q$ZGP3&QnX`y_HoNJpR>f)la!ZwWqH2hg^29x2 zXY)z!+%|VBvhpv4vL!V4_~^o<6G(QizM%L9i>H~q>!hH zKI^t+b~3H)v2NKc;O6^LhOFnVtt24+=3x&+mHo>w&8?}@I{al~NJji(@`h<*l(G|R zL{S0qu<5kKy*97`os_3 zgC4ne_rBm%Oy{{=X8G787f;wOkYr}$h<&Ea)+pq@_?J@XeNY(cU~CIWeii}%_&r+C#;vZHtY_cuYmCGVE} z)lzb!hG3>Y7jPfmFhd#{LVSi}eERnBccwImBe5k0f*~+O*w%J5(2pYM#T_Dv%fnLR zOhc3%huByL7rKHxqTb3-jn&h9?ob{*KsEEBw(fGquT?3A;41^2ziRrxSk@-q+oUbQ zMy=j#!~>`Ye1AI6-WPGK3=D2EECJIqO z=KGjYVo|I3o&u5obSbGsrhpKp*{g`E23N(bskX+IY*$&Y*n_Vf zbAI1Fcx4l>1yeWo`4hz~)uJ(e8(k(o4VjBdMR#;LzM37+0 zwfF2>PFW_2y8-Zii|UoKL-+%tzh}D1VE2b+S1pEIVf!u-*RA{qd+_%I%hTkyV+BUW zh;p^f>V63K5bPnUOR`c!4g6ZUY|NR`I=qI}Ac55WkvkwcIYb zFCdQDU^0dwB0B-+SxB|xQ{fxZ?nBt)&iVdHZFZQB$wp{+YUc39r9}ZCl#VAxjT$by$ZrMiP9*y%ANX z;HUpD!aso-$e0d#6JogcfR+pB9QfXtR1|a+LW0)ifjq#Zq&-T^pPztPt~jB%cSNND z?hD>bu*M;bj9x^730#)1{` z(PX4=B{g)Lka}6hr-qUFQzhm|*H%Idzl;g-d!8^{yIWZ`86GA517=oJvjBcu?j=x1g!hNDyPF9cGG$JhTq7l8cy=VJFP-t!?a zx>SGrVGd1>WV=F9*RzuEs-K?M&^HFR=#SRMo1zJ^Ng(WX6AGuVX_se#91&tTo537f z%Q^LReW z-DBtd&zl26gLIsn9_5EHh*<9ih#wi}!M>jIeI=Vw;j~TB%f)^z``e0mtMciJV~6?a z&sEL$RrPm9^-ex(nsb`{rn#(jonqn-oYNa;Xr%DrbL0uvH4vnTd;H0RgMdu~sb5^i zF-5-7fybC1c21GH`rQ?uT76Xrgw+BTImS_Xaj*L2W^GSP|BP0`eDv>Ex!+cvIq8-a zXQ+j_B*JfGHJw9Z-bF!F5YsULVLCTFHBn+9A%#pjNl6ss@9?4-TX4Y1FS`dsi!jEs zNxvP2Aq0nj>(-gP_>sI4r-#@rFTCD+!gd!Oiy;B9K9dQ4M=%TFVi{D|rOuoNLy|C6 z5tc-^3q*yFxVKkeiT%AS%a9NOXxt@+szAl6$fQkRQ1A1M3x$G~h)9Gg1Nq>K{5Q_r zo5B)VR&Rty{2_en;|$TpgUFC9K1ClLy51NXUsd`_Zqy?BP3J;~6PYgW9v@X?? zq4y_7xRoE3c8(qJF@;T;(IfEhKd03IW?TLX!rDEtm~5(wEb#x?gD2zxlEo$82_txd zg5BRQ*0qUL9fk0i^?D>7!rZrF*t6fH$)gUEIsC7dUa%=eCo5jbyUfOga1hw#zx!-j zuFPa1qAAWvCT< zxN!`riQgShzzdN^D7YBW`*(IS4jADhId5yzP}*Y~0_g!%oZE|(w5 ze(JMbm1!A3GAK%yNHAxnv!bw(oW}9DW>(~V_gqJyp2JX8A4DV8b-sPV1-z*6wT#spMo&l!>Q_7hMd>-?)cm#ULVFKjn z*GCOLZiFPg_P`i1wcNinD1TdcucJiCYL>q`fQwkt8ZP&V{qJUgNf@V$fLXslnqvK^ z<%=~p+=qtBk{a()>ny}97(_(o?l}-4*h@wFw43>=kNeU*1pOFMddxD5T3L)0w)57R z&q_JdgT+7Vm!DTeb8GPAsIWu%`L@mlrY07eFVLVp+kr@gxuh_)5aN;jub|D-8>hRFm#I zHV8rc4GzxoGZglbN#Z0xK59?w+b76V=>7NSxjci)AJj2sx{a3JJ<8~WU- z#?a}+)G)+NKe5fBvW3UKcoye9@(270H=_{M)`AT6oyXYDvmxM zM*S$^+Bv4t2~DdH+}l`Y9heE)6SN5A-B=zotFa@<>wlm2Q7HE#+Z^;>;zF{<)OuN= zR?niK#dcRY+Cdf-Fb1ucVn(lALS@`FW5JKI3xS1mDs_=`Kvpd2f!hDV6e^S#)*q3) zOc3XM09!|oZ#ZH2?@&GWln#D;L}Zx9gmvn=E<(h+_RqN(oKmvAz9U~?TzlPG{1rZ; z)Nn=?M&c&h`nb!Y?;X0obdgq-1HU!thHlRbI2rXNEP=wNzQR= z+Uh>vcEI)#L(%q4fC>ZL?JdAC1ZY~JMiJx&Bj*m+7=umTO9O-`6GYlI5BtC}xZGdd zYH>guZxejTpT3_47e}#quodK{EW&h@0FlTPU3JgK4damMN?_hpcSyL+$V6;K+hR`~L7JSk#@PNrkfHt!6;x@p-cEy{@MLr(A&nZ+24+D=-J$X&CE&cykxe2Pd&IAB z98`XewzQR8Gb>5ZPwXe|GhN6u<+|p_0;!s%F%(ZY zN%oW_FkHW}Wlf8GI7WB3kx)khh$J7Gf%*HK*EDA8T@ZB8N-{g6^bTQPN?VohFZ4=S zM*PtrKQi=D+)9URscC$$^AU=F-G6z<$G-Qk_}hxjy%$^TiRyGj+}S=JLXS#RxP-h?-%xw079PRKK8pC1(6%G*Z@&^I=28P$gkboTFY-B{Swx zkq_VY5-!9`z*&VFnu${D_SnPmK5~5*JzYco`C;U9YV$w*)w_I|+LMU=eo=?&(qn{Z zcc+c+zM2#cx1nR*hwB;MNeBM;kF#QvD zUff~SG1UO5>JNeJL}q6hjc*-3E4!5}CYZK%?ufItKGl#ncC;d#tPd=&?AUNILPEgJld!Y=HGt*%M2-$Fx7?;3^$Yahq-@Nge3Q(f1i@rhmUrdaR=I&*`b= zm#)sIUqTPeH9cuCd}^qlByNv!#9-81aWF+msdB5ni(sBG!VIQ^Y=f*edsaqR#8z&j zEj#I3aA&7!8~uH{j|Q_sfn+{S(*KlZ>Prc}{^RQi+!KJh?u^2)`5lVxsRG~4ylQ@g z6n*)$$H;*TUN5Tt-gq1o@O;(adM&x6sZvyJYiWqr`R8;+|1%J zClp;3gzF+9m1Y?%ErL`7`5(asabIO?0*kpSX7kgA#^Q>?rrfo0->oRMhIb#k5i?-L z?PLoEM;%0KsAne26aTTt<>~Gj5eb&<+0P*678gD#GnL3yY?j&v_b3~)6>Sd+JpxPQ z67*SVlW1wW+b!O27i@WHvyN&rpC74cR&^@S>A4qX;#NU!k5ob*O3WBP>Ui1R;yH~&9{l&&`r81r zucAlILW*H+1!iS@8!x|~lzHi>E#bss3@zBiRA8Y0tY&%sR)x!$&OI&9XW!9`>w>E+W6#&gkZ%)wNgpGzg2_m(5}>Z4E6R%2}H zV|u5W2zB`$Q3_yh_;99M;yFI{aj4{xuVPK}U*JtbY40{dWn>}GmAU>IOkBYN3L(|S zTBs^y(gLj%WdQzs@!cbKh8{N>Ni)MSky|9xuIiomSR4{uMJ=7AY3^&bt+(A<<*Pel zngFTN=X&(Kos+Ktf78rr&8n0+KGf+S3_s~H=21%^o4`S5$pvfOkGe!|O9IIJrj4D> z3%M5RzVKI12@G*FQCEk71EO1>?brTMWdtxQt2j`>@zQZ96kVf0Bftb=Y|CPpXD;h- z+qjl=f^gUbAqcf^RU!0$f{YszQVP43@}i*ir>-Ht%ox(jd59MQaG+A6!4PRWf3ZR6 zGst{B7mDGa1;DxMVV0`ti6f)$z5yeYX*nla=3quUnqIkffkrYBa7=>N?`R}7AmjF9 z_N4t-M8JX-1*$}CMj+04w_tZgJzaV-D?iL9h^56EZiSUFCOh5}??+AxJ2r&p5WfO@ zPS*bvNLhUK`|~{j6pm^hb?AqQ-C8u-53vRJM`fZy&}}m7EqhaogPkaTY>cDCEZKPP zw7=?#+XMsiWXzn|9ONvx5$zZU3xtg~-Y4reS~L{0#l1NkmB9{>?RxuMI)D%i?;tF1 zP-lI24Gk(o@m_~56{qzwzjY=?ULHXDBksDG+iJ_QjCV3n9bqfJGN7ryl8}O}KhuS- zVH3?ZI>^@MD@adZLU%Hq;L~Scfvp6ut=BV-6UyhiDC*)Sy-F4X>@W0aWtJ}TxVNkt*1a! z@Sp8R(b2KDc^Tr}TT*sv$}me3^Rb%zEUbnSCkYwnCjOcr9m7XmcaUZASaqoow!(ojY{Bi3^2a8i{y637ch7rM8vPM5UAh z(JR{EFE%x_jCr#AGK0K&jZH9hTa}l#Q`I^wl9;zsdqB!#qFB| z^`O#=b|H&zW@t4sV3PW0e^=R8;}5#&1kF1I8xHn9>@dR(&Os8x2OE88>V_SD-r9lK z)kXt|OwcK-IVXw}86zSJw#c%{SS}E9t-@h%TNU;97CgEM}t&%Z`6j)qI}u~?TcN% ze>%LSVl;h;=;|7>bqu?bQ^Gt3-biMGS~m>xw~InC1UH9O&=0Rrx%2?NuytoLoj@nI z?uX9&Ru|8A=T#!x{Vs46Y=mBTyQW8$(?z;F=0lS1cydGzPn#u%Bka33T&%8{2v9l-Kfgf2`f?IGzVluc=%NgMZID>q}n_2p~0C>hGPsW>Q_;Hyr3O+WNP zAr1@6=!=L@4Mcx8v8~%uj~=+y6KbK}!WO#>)1&JD7%m)&fu^k?yM;>2Z#Z@g(@?6B z8=a0zD(mEt>QbeD7e3JNo51z&U@COpnPwXMaUc5HhNWe5f2rQ4hfK6n*=m0}f9J!{ z>NN9sbnl$y7v7tr+Q#nXjbIZ5)c2^`>z8LceHhCpWP?slO@m5|9ziI(kg0C2Nb8?q z3>1%hr?SA?sQbJkffna+Co81T0KDGjxxf<**$4-GfsiXOpN%Zw7qcj}oSL}W-y8n+ z#?Np6oA5b;^LMPlT5B3my4hOH->OACCSvzJD<^+f@DPDDf*PgLcwvZ(>s+M+EW+#h z?~~}6_W19%42UX!*_F10=n2}t&zk$D; zE%*=c2r0P+bh#j(i)CKV|ERZbTm4o*<=&hNyE1t0?CJ|A zDyGZKF|=A~Xi0^|0=m+eU#j|rK7W|FBo8(~Xt7^>`jrp2(A zS9+@QW;t{8AptR(1-_fQvxaFOkAI9LBxh^9n<54;Zd#h1SCYhn`jUCmV;vZ#(w==` zApdRYXG#SLdx%+sPdI*h%DQH4zbAg%RF}$BVpyk8_AC*pzMCT|NA_^zHrAm}g7)(6 zt}A(qmf`WEP4B`JmW22wDhuKAl&Pnkoxx;sSu!tCiX&vRpr>5~em==$cS(hus5EKy zT=7)FB48!K{GoY{P6BAubqA&lYz-xJSLQ`7lA?NnfxA=eS=kgR1nZ4H>)it%Q^c%E z<%AB{G4}O0{tUqc==fvaP6P1WGh}iMlmhTmdNh0HyrtJ>9!K^Lq%N)XU=q22wd%S{eb;ks(ns48G6B z1aA*#Mr<@CV!ue&UGlAwXHw+OpP9IgKbtY@`K~L&%Z(fNWL&TRzTEXb-27Lu^ZEM3 znf7qCP0%{y!s@^P74?^J3jjpnq9-rtFRfq;(Mp|9F&PUGMB-M1xcSdY%xwybw2;g; zK-%=G!((O8vup3eX(A_Ou345H^5^cv>541Vkw_pr2iQS_BT%wG92UM}S?W)hY|eW=s>5A;=(3kc-&5-^WtwRp#TbPG7Hfx2h~SM(PgcXhd!YkX zPO_3n50^UR~06I8yh+qIcbGfw*TH z^heNcBMNhCn9%95qs9;L7j4r3YbBM1lt|LhU|bJwlh*=tdmZNSI+l4i^az)dZ&~~Y zawFV2V|tG}4TT8G@ZoCQ)XrfcRKM-npDT^xPjOOeKa7_vkWSWlC>1>u=oHgfIrcyS z$BK=A%SNCsM;I?cA7gFVeD0~c)QBp<&kj`}LIKYZbT!Yj_-HQ$E??lA3jD%>Y~b6~ z0nOU}=Mp!w)e0ldZDafz0Jd4>V7LYALqbIM~ryYvdNA*QZ~B@+PwrRYAWa5@;`5whd~ROFXGGw8}>}urbSj0|MZw z2s#bI%EvUkI@SXhWSg5a&u;sTC4(r150>mVjtt{!E1Z}0)=BGFr{e|5L-HOy0Fw6v zJKYu$&UX74#12(>e3!zga|$+j)hyPoVfPa7%Q&;GtP4n>q}`)J5x8Lu5~hPegp3E> zt)%q&s*c2HhrX~73rN;&15b9cm1Te>F0kXVlW~e?R%`C(xyt@G9ef&`1N(F2?xa!$ zm9-O(g4slJ9p;B$ZRk69F*XmP{;K?knVeCv61=2-i?i?$UeirC+b%&A_CEb4TC_vkao9#On_^P>`jb%tL*S}x8{?4-x0@uI1f?Nv&c!De6hn_4huPfgC zE^t#g9Yi>`N}M;^wemP=cwVI`vBxM#MY&Syzc1Eh3cqU|;Kk$!nER#`NC!&JB?vkX zPmXog*W{41qu@jcO|iLG>EKDO_W|5{c!>NdV95| z`d2hh#=FlzO_+NV&`e`42L5pY#L!;L!p^M?-|=L#&9sLM9GmP)zrMU4B9!*x2XoJ; z{vuZzb6GrEY~mn&5`Y35N^IDj?3qfVNMbHU9U5?VwG}PMG*>ia!JledqOPYOj6w0q zB)p_-UHN7vv;vNn78Q^~2H>QkK3c4fh_%0iDZmhqwMnivfCcAqKA3u*>n0!mq$GT} z9digPe*~z$eJY#?VFvP3QnW-OUZj}injK`B3Z8M+K5SXB+G4*yZ_JJ8kGFnJjbo5n z8$(5BB$zorE=x$Ip8I~VG@Z~p=xbbCGTq^1984RE#@R5=>^@=C)tY%R_=(tY3io$$9`8xCa zQ~_BmFGE9rdA7Mtqv~!sySE*k$l?`AfL@rXo53z?_)tjYatKe?gEj&>)(LfO=`s8GQZCbcp4NrZ;UC?9 zhe?+F>@Wc9U5620R$VB&fA<+MiD2}$tUm9AJ(L1Cw?W}nSO@J@poTo4lB(^v49C6k)R&-jLGOftJ+5edS zqY_#sXfH?2wCED__!X9T+F{M0N!53%+-4ms`?Gib(~)W{7w5wsviEW-{O+WKKuQFV zn{8C;>>T$b64lE?tVqWnN!4^YW;`)}T#tW4qC1{RbF*68*yRenllkbJWn78+Ma~i> zAE>b6nV~oE$Z!SeHQ8}`imm<$m@WO%rEI3u-C!^icowC(h(JkAPam z-oF{JU&n?|?(x! z>kybf4^05y4sA;MgnOW5JbsK9Mk}qp-e)W6&2%7#ETJzKW;!##NcG3$@Pz%B0aT(9 zI4++s4|sm>Dq#*BE8?JR?Hf1>vpA0JT^ZZS|Cnz^7#yN_L4FJUQ>4ups>_aG6z?{b9=LkGj!EuWxhPcN@M{gOHw#K^sAuy^yze z+Gh*uT+o+aJn1>>d&_j96~rR-+x{c3-pAN|g_}l*BJs{3>oPKR!7jX4tReo z^hcCFxND{-bBu523#vb%Vp4PX?{2Q~;9d^ooZxt9*OvownKpQZ1 zXiU+|8E%#&u=}j{IBZ%MZ~XM()U-W`7{npMfea?$lI$MNbj|`8k!XiCRBjsZa*=d6 z%yO2gDj3Rm0e9o?jn!=KQIYI>MYjoDl3wnPf%Sc&Qpn;6@Q$|Y6>$_z@tGXclqGmW ztksD5)M*rOk{Kt5hy{i|$59M|mG}>Y@88@ruCiyV&`N82SrKm_mjCEehyLd;kri@T z`HEp4G|qP|LpQX<2o{0C*qB1|52?uuAMcltSgx%NEikU|axi-{;vioQkNDx-0#D#m z1JMzyc<8Ndnm(?{w~7ihJQNUlmvfcQ&N@4uW zHbB#yL#&VnD7?}?>5QZ$Yd_G*+85G7AcrSTO*~PJuv_L2wdY>K!QXB^{$eOlp8=nR zU262PC=x0iY$&UAj1Cg9k;+LYNj%GY6LYtlHM6q7rc^{-7(m7Xkz(Jz{GxWY>2gQJ6mtzt(#Nla9yh&+ z(QI&lDK*g7P5s;d?#HQ>_P#>U4c|*HKyHOC0zp0QiR!pNDKBHrMDTBYO0;jAJ@{ZC z5eWPhAoDfYES~O3BJLl%uWkg{ADNm;(;vRRpLIq^#r)U0-D6AX4&`ShlSGAlakAQ$ z{=tYW#A|z4`xItaj9nX+ZA0>ha=q$vz@{eC*wienFaF0i%YpR zbIO}42wQ66OUOAgcTFurfprdw&{Y{b8r9wsngm-)H;4LcL z;B@dp;LjJKeAl^08cC=bI!faE7C6c9Y*0ibfnWYFY$jYgLqwnVV`5TRAyF1qGfi8U zD&8DOF^>bWNIfWIk<$GWi;Ne!J>SuGoLj^3Vl8z1!7b#tzCAjJ&5=2L5aZD1LRXhH zWm~_xsjIM18nQ54u&!k|kB1tFA$k?#wl|rh7#mjqEOW!_>xuNu#2A#B?cLiSMp{P| zADC87M^b<{bny2U^*VIlV7g+24SjEEX{{#hjv-g(;h-&Tzga*4|z}w z4sYkq3A*gRzCBG_-thk~E60M5S0WPFel(8a@zv8YzLF~Dq#Nn7e6%^mZIN>DVYJ_u z?u92TWL|F@*mnpc;Wa*?;#9sO#vmE&8P7LPdrm01FIC|zxAfyCBIZN<=5!Co5`h^o zK)#yhAMzz~>=vdFTl~Z2IYkVrh7CItHrj6nAXQkt+PM7T#fp#oP9xPq@%efgDRV1Vt6eo~ph$ z{w;LAy38Gd*viDT;Yt+Nn(l%FrzL~=KcNs#KO7a=Kk^WSrwFexKp{tNKk5iVmW{7k zPL@*{4tI~ z;Hjud4O)mN+sX#Dvws0SWC1t>!Y`nUr)zIKX+~(SMPc0~o#4N-frdKr)$7u(;j#cX2&0b24brXl*41TVTm4cHNxLS&`rp4lHk zyhuaO3WMsH={1_>M<0%)fjwzFLy12?a=S5TqCr(f`Ujo_mK`8J0CV&2HGIm9Z+|qM zy}pqgb_=x-7e{Y@KlE*YpHUDLX1$1n^keQ`lBMEGF3rillEg13`KbW3B7+8`Ms0`P?-9dpYLL%`49a< z{U~EQD)a7~pReRe!=&iC>c*mJCbdh*gb(`pFCn>pGXZy?P7v+8upj`Bs`ExXU)1h4 z!TnzC@d{jK-Q}03=@ea)xkzlzlX1XW%B>57cejNlj}?lTT3-ix$HLPY3Q6fErv!c; zW}ECr|2ye0+58|y==oxE*j`^};J`o+WT^abUCcmrNKQ{q-j{%FJ<$k zWbkZ`*97Q~((?-K(!Z!>0#pkqI7aLgwgE@rIkVtoNX{rcU@7fT*$S&Gz4T3q)anPE z_;$6}*NYxd+9xk}6M@3U(Kka>>+^epcJ6#Ju7%W4*n$U7kh=_JxzA?#3Ptba<(a<)L~_1}mA zGL)gWil_(5jucBfSr}vv4mgX*q~%p=5{=*5OVMifW&KUaK;3OQd$d-w_~CRrMRb;D zHedE_pfXH_@aGUOu>NLU*5ZL^-r4iLKyK{-_T6@N7 zRN!%7gIg&2YIzOY$0UT-;>b{=>FAchrh|U~ygBH8;1eyY(XF_<+Qz=YDZ7v$G{ufx z+vMVU0tmgl?!WM@PG6-hl=-xW>gL2>MS=D^2=XSwAcCe=Zew7i3dh`%GWt_LS#2)h z-Ah1rTNtE;@N@R-@5gDdUKH3I8riHOYG#JV31%=%DF$vV7E}%S@PMJO z`#;9^lP%VFsHs%3I*kY2ok8w7^{*5|p4{;4?zhe;?EjgLLDkutn4bmaCCCCBVN;%` zYU2ha1Es`7j*AyUUM^bk7)zB#6Ss@j*GX5ulKGSi(<_zN zTe+O$rhSy|41Yu)(LI27&W>8M-sz6^Sy7&cN%;-UgM_)@$6 zkBjs^Zk=WOfe)JQ=Ywvt^n<6U*_>#g4c<-q(K@7d$)G z+u`o^d-3Eh?vonl>A-5l>$Mzz2_iD+J38(b6=J6SNIMsZ+ z%GCh<L;i;;6gkb1r8!DJz~Mvc}U#Ly;Zdq-_Qi zNj@0&Z|i>lYI#H%MJmUumB+PdK}FWh#dtKf;qpdzGk!>_*5XAq;7NOqufmZ*v@0Gp zEwdG$^rkT?hi-yZcZ}Wdi~M={1E)0D`Dj6tubM8;FOMz6PDUI|0ChB{REUVo6}ku( z@Q0dyBxvbzm|0c6x zT)5@BY!?);wxNvj?%dM6nW*Zkf0aS&f4h&@tOY6*l3^6ovb}imM8QDBg=^|wFW0x| zQa#iPmMuyaM}$_3gP-WK3+L1sO7yP#XxvahkoZe66|-#T_&Ea!7}g~L@q(reun z_fZB4=juVz;#xSQ$ST+<;|pJB=P6+u6(;XEGwv`v96?Om$^@t47vuy6#<%W1E1nF723gL@5 z`p%Z2Kp#hb=gF{74tf|exG0Xp8KHB*!F+VY%{pKTmMB$Ac+f2I=CQzJ&~h3KN3_U+ z&!Hb^;-m~JELQ#(BApKXyX;+jL8EjN_pFn%^dzkBn!IhA}s@I@XCfd!a0molCNT@eA}=aZCd!R zp2{AlN)7|)yBApptb7Od7%{aj-|QHfqlz5{53ldvzFG@Du7e8K#WE}l5>W-}6-dpI zyigSR`mA@%e-I@5>b||LHJti1eP>N(BP=GG9}$Ilfg0I^sytU~B^u1QfxWv3ZdRAZ zm=rR>8KN?9QSfMsFBq20MpL*Sv(&J7ieV>`ry~AybIHioM+(o%5QFmBC#f$P?lHC2 zlo{E-&VcVwTr9^+=_D)Wx!G-2&1!!AZ0IfMK`_wdHCmzcwi7l|2?5c zy%>;#LsA7gg`WUS=)$Qu=i1kjmg5omgaqMvHMK;0eu$=8r_7y;KZ(?`w=~}Vcaub4 zYj0V5%s+a6B^KKUnXG1Sui;%?Cm)S09AEd=)OileqymM3t4z8}O~ssNSXgMsevGH} z8A`i1JNlH>LFjF%=Nd>^_sUY}4ugfpBJ(LBlI2uvzT7NC++IxuQO+CBkbb+Fe@Oc? zMC^P?R;kOt!fzEu;>>d}axR&Igu}vv_mvLt#6mnvCOSiJPMg0~9}s1L4?EdxMIwfc z#X@+;Vd-CJ@RV|#*;>cD9pMBT>rBTcyDMHjC&gS>rUqbA*pL0q6!wD+Je{G2o>OuH z8dM5h@iV0EUXv0kR2$$nT>H{R3ID|w!H5bn@JV418BHGDdu1|!+`pI-U8uRY&cM^3 z7FDl9pj5E{-kec*_yPwBQ?ysW{u^!-DBMHB{7q!S7)&i8z2%mAyjVqTHfX_!>;)q_ z=vTN*(8LJCVaPm}*EUA@%0{(Y-pZ zxO32^>kt&~=eLDRq$?tPFw{$6ckf5LKZ=S|uQ_^93{mrF75-@gGDw2mNdj*T?`*b0 z6m<4_s2PL67k=k}#Q*ek77k5*Z`h~1yJU1DB1kB1bV-MVq=1ApC@EvqBxE!w zF+xP81r$)a8`|c0e*>lc$&dz<`*ZsNfyQn)ao2NTbw&6tm zXT)YFx~0#%FX$8>mKtj&#wC+5O>`Xl(G2Y<)f&hD=ASnvO3%U3{W zR9Ta@pHs;(!sXm-G#M=L?Fa3=%lWq4R7c8)t}Un9#<=I5Nla6p33x75-+@hFyTGz`z8O}Ze_B899@9>5_ zGD$cH-nL9;+j}@$mq^58E;}LcwH~Z}E&hHvV_*dUMt*>Xe$0hnA8&qma~T=9IT@Mv z7?JBuGY*4h^?KHRN~kEx<7|+Or}~u6^j59nmG8T70QIw7WeJ{`n#LKwP`5ivZi1-O zH@f4ou)_uwY`FFKfG4>c72Y;!TdBRV=FCNe_GQD<{G@iFwI#B(I>oEQ| z^{9Y@gSNPsfObShVR-Z!O7f)@POi600+YHmbEhY64Ia73gyqzKUHB9rw5BU7>sle7 zP_HocwZ}dkHJjZaunuRR+&JVfAow<7&&yEOjgRWZ0obW}#ux&& z@&iyO$q4J+arnx^<_x>9(jtf{tzx&38sqqm*Jje-I8pL*&3z<9UTj?E0p)n)Z&-NC zwH$HWoW|VN*1h7=d3WO}WbVO#Q|O;usgzTz4oj<3n4kdmV9;A=4fj za%8~ky08sf-_P78CEg-?ehR+t>nz%&c-M{)`K#x{y z{(KPm#u}}`1Bq?RchU9qn71K(ogQ=(l94#q-`)5ijCpaVKTw*;tO%EudZeptHSL!z zu_M%#a$1AeEBqP_)_SV zh8w#tT;Sr#CxiD*CNE+P6lJ-8DzQaBow-bME|X#lZELmSq}Qf~fj)>}^c#uDUl1f8 z-I6v)EuCtn0V}Mt+zHGF7RD%~%y<2vv~LRwCLRuYj|gtBvAz2EkfSH1#eV* z^?Z7{U6-hH;nQXlx<^5K_m{z@1}97;QSAquMRGVe5#YoWcs>5ofeO$07i_hT zUS+@yE}ISJEe8$lqXeTFlhJ6?&X?9x6e!g(3{vF#XIZvTUzQHCJg*e`623qV?3*@& zMw`P<)Ql6tr02;y;a`CCO$5j#Xs@zj|12KvzEJ0xs&|Rt3-upWyojF&W0!6vybwS3 zI~IQbD&T~grZR}n6Y8N~>(}ZHl{qM~d^|Cw&J=*qbr6Rl_6@I}*2`1;h;6$+W8%aH zK*42)!^8G`+EqC8F5Q*shR1Dw6X@YZ+5Ru|h-MB%nF5Y^`biVAye7PC3c~wFpriB) zwQixG>C#Mc4hFXYt#agX6usilQy)GWhCM%dFYk>aykbA+Xf-m_EoR$EKj zv&JQh!$VDxqTf}P0zLSjx@cgbT0!L&>ZFXr{=_!l6&T&6FE)-WknT50J{4`vd72H$U*uB4f?`o znSq=+t;(yn$%}{lOcLVsY)wHI%~9B7ae5hf%_8fZceAB*>Ki*63=7!y6>h*s4i zafomG&O3kl<>|>i8t%lq4^r@E-xd}7Qt4Gwnt!09W94ehz@fX;2UoERTX73P)hCW& zOYC)a4yVJJ)%^>BxkTF}sGW3kLI%HhJviSaXbqh_SK7Mz9*v*1oN6Cxd@aw5|KJ=% zCbFV-dByppcPnY$;LCCi4!kQVv5lZ@QKbNz7D|c{E^D8sJm~IvoS1UJH#{|;0q-f$ z=w-(7wSvD-Bo^8en1IsL=|>8pct-CZ6og=;NHd0q+Q@`B1v-`O_p9Zem0a6anO{w| zU^>|2?^Y{0@RAR&W}O_I$ez_jd1b9Bxm}?vm`-Nc!|9?euQWRWC2~fSad{w&?_#r# z0Ni4{(S9ta0(A1-0=Vv;QfB@P*6%(qgDEdL8CUmKU!g?Jl}aGKQw$Hy1{ziHf91-V zuislIy%MTi9DJ`9a+@a8CzpTL<rJ&~%nxS!^dngJ*nH_iNO4I2qYV9$@h}O`W zOP|i+vx&+!meun{R3tdD*zta3$5lcCY8x1!k08B~38sJ(O8_4g;6#eZ5A0F=maGRHCHTV|^He87(n!yD%nxD8%LCzJZm#M$NXtpWOSCDW$*@unLD zX`_S0HrkTM0y*SL8AadLK07!jGxhrgf0b8Y6HgGA*5=VuOeqrLaTdpTnaF9*^__7( z-A;rjDM$myh_bwf_rj}4P9V}m#48MAKkgl>Ylz<;jRkK_5}*ixnhEcdJ0eTgNfsfp z(R`|sK=R6@Ldp7$=Q8QCHSa3^hBtGp?Guv!zlQshwjY$M6bq%{kK3O?Oi`V^cwXBn z+*J=0MGa3n9`xMtaM{kN4qfII-)wYqwG+OL$&RbDbU4!K3sCQ45^~Z@h|Vf&XcV-p zGU-d|fsHTl$isWr$FhZQ4}q7S`!xunLgQwVhUZZ69Mj!kUlNoB0GXsGan$^VDLiM1 zdvSQUG@0??(R-t(XUircHBz`HS^KZNZOMm4ii!2<6c5hB&IcCzq&K zqckpt4SW1k`L3{20K*5RAa)2x=#wq}^e?5QP#gff5#TnG0Oz;~iwpT3IYx^6RMd11gdZ}ON8 z3hstbwucDjw<`OIDH;D*Cph$UsRtD%vU+grT2=HRkdqT%ET-+WAQwsTRo*=%Z zqMV@~h;EvtcxL`mtG6P1EhaI$TvGs$#&d@S7O|N2@<*6cl&l|C-r29Fd#5ODxr>@J z|0_bOBKC4Hy$Q()!lJqYZQ4Yo@s1(JHl6(x#wEr8PteEdVcOgiAn4G+s+kcfw`8i zRPs2h#)`l|8<`{DYzd_(ii;on-$I_Li5wrN&h}?YCn_|usJo?XY(1G+QFbOI;UV$+ z=%cPzO34HjLeO<1%xnH{+j~w%eb3I%eoNc5-+gsW?WZ{dwPZ4f0N<0{kYcv-mEUKly&K9x;K zA`t}8>0njEQu#O-_5-ddMd8#LC~ZoOaYj{^vQo}N@fnVqPUrK3+Y6TYn;GLIL`mt? zuUr7~=>acjYSJ!ZW5r09ACb!6YN*k@VQptf20z8@h6>UNJ)JSiMx_X4l)BuiO|?Kh zom*lEJhS zRsppECqA(N+dePdq8~c}H*cPY^(HacTI-L!x`Ef+VO-{%gcn0VLdgo3Nse_<4&jBn z;mblW(d;;nEl{4=H58^Vxjh5be~bzne5ZT4&T?z@*WT>l9|FPWK1Eflx_ryS0`g*K z7E!?JEy21{&n|Ma6AheadJ9)mcNxtU?&ny53ea=?c=goK3_a=hDMN4B#@}`PM>;&TbSpsi8G|t&t z54sY$SL^dA8VkEIHqzqMtj#;PI(ee8C1yT*cQT+^=k#NKW*PoNDFGB}v^#?gHnM-< zGB98_9<^WjjqyH~X;M7K;Pe)w!e_6UUPppEx%6^~8=I-G%ae6J1SOUll#N>!iKNI& z8Ub5PdrrKIo9uSZ>DIY(v9+$1DL9Zb)I)gU)lOb3%lKHKL}9UenpN4RgUkieD>|IcLWysvA-HxuV0B8DzR_2% z=&P1AS^H+PYY64hO2|~lLCb=ZOR4S>^YW z-DAKpatx*B&wE=%P1fgg!V?2Jej5B)TbFxlg9*rk-g8aB;U zc+dwTTDea9uTwEs<*)^p>?`uP8&Elcv~Ii#j*zW4C=B?Sg2!&L|NU`cJvX?fuuqWf zJ=8j#h}E#Mt9U^wX4LAmDjm)$m!bAWEd;xtcFnrXHKxwVd85gT$RTVx)HGTgQl%H9 zBh6TC;OiD^Dt$$7tFit;rn&TdAX)6YaE1oWUDF^9NR=xDo+j*QfLFmDg|{;oj(WeJ z{>|{sp&u=7Kqaj{8xNhL&+98)4jEr1h*%Ex!+xg^cF84Jk7S?b+VvKZ(cXQr7GVm; zQ7iwBWexn;dJe>NuV`KvxL^Q?W8d%+ic@;0KtJ;Dq=Shxk)HO`==yq)AI%r$XuAWn z=CC?Gyz|zR(XRV0X6;;19;V+!!_hpYB+>1yD1u<%oe@M1>ouz>^%k+jTEZOAl_xq3 z^3cmk%ov>V+7ox zZJ$Nkezk>*7tK{ER;LwEVr%bPRnqUa_sTi9-DV?H!z?Jr(p_2ehE|;l)=#G5$yXd4 zju7jbi+ePnlQHK+usMM#IiPw{n0XNkLz*e|2)HTX^u4nEA0CKdFe2>g?YH$9v$-j`fd>bBQJAK$56L6W4PG?Z!YZknzFUz8Gc zvykT1n%9a&FSG?on$jQ@rlx(KEE~EPy8e)LgzDGVyAt!?@6rXvg54kAVhXgLWHyo3I3@6wnuBLqIVK( z5=&PtwxLCVQ>)z?SD4Du$@RNpkIqf);9IuhM-+}}+NDPJ&wg-#3#b*R31qa z>ar&+h^80Fx(<$;A6if|m2%6^7TiQd<8fAOJK}iu!C$RG3uSq;*azpyGj6)OeF@l6 z$?L1yDXOwStN|#dAq~LvCV37<+%U^AkH2xRWIa9hDW|B&j#nb*f!Np!i@F0re@sj|&8-!#d;7u>w5_GE@m z_D*0KYe!G_OAze3i}iBBaVL%qaQdBXg#?)D6b6v$6o2`0vjwxwS?(-1P=eFFo! z=_>v9?dd3Ufbv@|K-I?yLI*K^c`b&zkmFNXb4Hn3^-DAe#CDtP>pJhz@y||sf0k>C z2iYb47SnRAOdO&54ZQx{<^k|H@(?4gh_)Q%~kO^D(uPirg_Cqh)4Pts;CV&_RJ4ntc>$%?=BXrp9kgAz1=c z!@4ynTYs3|yD^lu7B79+St(~UxHA>f1!dqae;%UsJKI$46?IhQ5fhYj7>W)76((><9{N5v1Hhk>HaUWgLT*KdwB-nx4ajUFSUU zVP)j^B}B*)x{YBDS%hCa-DaTJoQMpbF2!ATvw)sXx$RKFZ;E1p8sgK%$EK8s z)R8lCi>$qU;&iTC7jkKYv+R*8@;7D4gh@ej!4J=Gb9s;2W#wZ&TE`PpNP=T2>$v4< z#2=5FSwm_c9a1}Q(SCi3tH`<_ao7w$i}tYfhpAplgq_Uj@%myd46ryTpgTUc|FZz< zgs0?jA8VR_+;@Yg;>shnPEEQ38y0h)>2qWxjsu~kV`Mf0t%7enGY(t(&U(SJce|vW zo=ZMY?E^3Ee;$-_0z65GyJ~*;GaTT>-xcul_OtIJskU?L51tO|-=*(PVS(*!_)Lfc zz)5E>DiqejC{3(`2323wUI?Kn*iXJ5%wU9Z(SnCdUtsAkH^PyBBKceN@!sv^els80 zA0~3_Tv0ik?k&NqTAA9SUj<#3Hg!y?ow7wQmX&(G27ejy+4Kl(6OL||AzY}m4!&@A zl{xUI*Dc$-1!Nm5^?Y3SMNPO|pdZzv1RyU?6YbL7eQR7PG> zT#diCoV^&;%SjuPA&Z#Gz3boXSrWE-wpEHh<2@@@Tu@nxg3s%Z^q4o}gX_N?NgZ%! z@ZR!B@Jci;&*A=5`sm{n^P>GTO8W-i&lgaSIP91%coei3=zQ-AmOF@nOA00|Z-9SS zJdm~hLAdf<%5AC}U_jk4KNk8@QZ=dhjB=M8#r~fHPjr|VT0gqanz5v)tPk0EbM_;3 z`+McCeInpAz$Tcw|J!_`PQ;P;sgTQm#L?F|pS_(39q}s^n8b|!dd+R7>e1ktg+z?7 zsf*gGh%?!<BqqHcuba;e;^^|GofuK->YQ92ej!( zW3EnHR!+S>67rYSA|*p!8ix$z#kSj8I&e*mb4bu@EC2yjn{m-0dodl6LaR5nZ#Mrs zi76ek3S-Qp#rmgB^3-xX{mS#s(&1OLA2LrPxr3`vyAR`baDBd{$I7&4|5CKispE3= z_JrqrP&bZJQx!-XW^1?~A2RLwf?ge?QTpTVvlJBk&eL~5iCzMzYmKf%+(`ODPIh0;EqNg<)LgA8F(2%^l znqgWVDi&1RypM|5W8zRRSV#cBh$sr~c|Jbiu0oPBtBJ{ZN7B$AULn`o@sfEjxIySe zs<7~o_6Z}QTdXlNVDpGQSXRK?tGI?JjOFZ3tvOao1SalIbq!{5Fiby-ncwosme_=|e_p%6GY1lk?<+p3KepGij-gz3T_DPZ4?+Ne8*Ix5^0%?0m3{!2fbm)Y~9j~kfTffD9 z5K4;R1NSltcFU#V^5n?jQ)PGqye~?!N(D!y`+~b0BB#&V1N(lF7OrMl#)!#x$1cgI zN=P(y*-}|Iu~0oor8RD;cKJjeT&e+7AIN^jw%*sl(|;zM{`2Qu$G|alK|T_K^DySU zEqLB*R$t%}oeleyqEC`cepxEr&HQAn3O@N1-dn0jrTahj*dk# zRB)7hfke@jQyjSKz?3n*lJz(mMLTsI9}#CkdPDSlw?zx{gsb%$uhFM-!^SQ7C}%MF zm)B2+DqhQY-xN5}@MH|Cs7<%i&YF26w7k8#CgRJZ_VGSqvx43>4>~v!Lxr09N)*!) zb@<9Yu$@F~*E2$?mBr3RwebAPV=j*_}2HwE^>>=H0El=?g7 zO12s}k5@Cyh&lBYTTzi%;tDS-pWm5H56*p0rjwLu1l}iT#QR`I&$IpC#0FdWuEpaN z32f;jXLa*Vov}O=5;)=q{h>*>re=4lI`W%Txsd#rlj`9g#;Kaam#iUYB={rRrnewc zf`cmd_+Znexv_Zp>zKejxpDvA7f57m8*pmd;~hJml&yRc`Hh zV9W08JSGY=16?`B#}Ky=iQ%@h)SW~4^|&wL4_Ck9Bj8Iu139{C8>5id5QKFYW7j(N6ZKX7+kr6#m-ZH^(GQxcGj%Ov3FU*o9BJGckF zQ7cK2A$;VOpNTZInDAtNN}$3?evwzZSfPLz-@p~Gm)y4vTy9as08UEh~ol znicn85U@$pulbJ~T{sRZ;Lg6_+$A9+!LwXz*|R4LP8fW&EeB`vfc35ws)CU3Vm#6m zgdz(&_~S}sHKV&R+hXoVHskL<9YN{L?KspCY1Il;cJO*K&fSgAx1kua7)`L7a$_1g zUPs%PbHz4qTY0U^9c!MT{VB0G@taoC8u@uLmROL)Si43WCw6Rl8*gD1=pb?lO{Sza z8XXtVGET7wCPVXl(q3@KIm#Uej1CNh=`yVr&G&Y&5$=!b1wVOfDlz>gQ%BwjK{G4d*Bgl;WprjMwL-R z#Dh}5 z%X1x=H*EMYZuaehZy_hgJSG0bJ8y$N=548P*K?#4^Nj0bYamb{<$)l{y6a4E9S_U@ zmI}@(nM3`LZWnMH?;^6uHxglSTx(qU$xY_DTR2n5p7{~;#NPD*>ZhKKCnK+qj z=XZE>{6blRuuw44{jrh%;;oT1Lyu4Q2&CAC5<4eli~*vGSuP_f)Og!;E&G422gA-F zPp{vlp+<>u<{!AeA_?OKerLbmE0R5q|G&EqpM9Cn7MlLUMO<0q3D7u=QKNI~Bn0x1 z|49GqAY!to#wclnfGF|ce(M`f^dEb8V94M$?!BhS(U7|+nDt^zRrobn zLNx0l-wI`~Qx5(&Rkrw?RN57jzqEQ{WNlXE20i%EKe60#GnsJ{2Bdhuf`ohQ(~L;J z>NqdN@IcDuUuyDGY7zT!?}7Ch&j`d5S+yoD!4nlbAJO%bF5Ye=Aw1tVfm@oyfEQLE<6ZUD`O2qkK(fNY@B9J|ZuG zk4`tk9cO$3)5iZAKAkG6{qp-JcqB`7y0XI~i?j&IH(vZ)h!*Jv@d;D?W=dWp9;fJCrdm@=y_s=OO;O`l{~vgpBbP(Y#>y?22};Hq|2wM)-%Z!^en=bt>Ded! z8AaI;;aO0~+3H~_cBjiYtomVHui9|>s}G|Ed>60HsWpH9@JT$m<@tRbK%wtK?UYO0 zyhd%8H)$a=WR>>>6$Bjh`J+Vw&tb{cU;PKMj?lUDAM5eo?)0B-9=U)h<5Yc{7dA5g z&FjCjv4ddn{WT1ZC9nWSWgS1yZq_=cmQ5N==XlCd7**woG$;-}xT$Zb50sFWJ&3?~ zZW@zUQ5zB5bzW9(l+_g>at~80GV+xu`UJv>xV`_|zd_#+pdkvXPzmuoA^f)R?}&YlMSJ2*v;pd<>J zg!Ll@s_Xx8wiGWd5xLYW2VeW0PWf0@e=W*)j#0%|z<|%gR$ss#wTFIq)EL~76P!(U zd20Bq;p1^;Im??CMZeBmv)c3Ccpa7C0?L$*7k8{+M&=DgHIO@ka_r$9WQ!pxf6UpN z$UZH;`%WYbf&VwS2LJR+BIe9txB#z4nl>(r>VF$p!%m&pd!1N$O=+eJmw!5Cm@Cz` zd#AJ%jOwAhXnHd7FSYS8>Yxq$byGU8ZLWG=d*wa92V+xwM9k*Mzdf%3QDLW zsygGpWnfGq8PvIr7yCCKetegn12pW8xl-1I7DZ{tNj<=|GWg<%-Cr!{#Iq!F{+}C^ zKX-`@(l@kREAbY)@8{b{lV~s!urKp;qs;@g&?vxkl)u=HXWl@HJM{qY-mb{<3HBHyv(G bU9S?klH4#MZZOv)B76*VOtkAXUE=-^;rejx diff --git a/examples/xnft/explorer/published/Screen Shot 2022-11-16 at 7.07.18 PM.png b/examples/xnft/explorer/published/Screen Shot 2022-11-16 at 7.07.18 PM.png deleted file mode 100644 index 68ee0d44577db2828106e6d43ef07b652de4b2d5..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 168543 zcmeFYWmH^C(>6Q|5Fi8(5PWb#U?3s54Nf391oz-B!EJ!xk`P>iyCt|of(CbYg1b9> zn{!UieLvs(@BR0#^~~C{rf2W2mg=hRs;g=T%gah&JSKh&0)a5zNQx?gK;R7!2q_Qs z5pYL*Sg->GdLn2hA|n4rLrz0VN>}Y6#z{oe0_kJin)96on$!AJHK@&Z#zWE^s>E zT@NJOCv!Wm&GUltQWrzox$_=@YBRuZ-hLCLe$M?-$PL`pf|LeAoYvB5ipR&t$J8UT zyw{nZ0|gZ|Zb3$_Ozypz6Fr0kus}4AmtT7cun;aIf)-WyzGs0z8DX5MijY`+HFy=$ zBh*7MQNR2mBay7qBENl7%`=X+V$dg*TCF#aK<06j0}Q{7U>KDGK`Ejh>8PL&kJ>-Wqn)E6uU2p=bA&Aw7~Tf?s9_j%-t0`WX7|Nsyme|z3l}A( z4qX5*KZ7$&>ZV8H=Sce+M4uVeUiuxka~M75#*u0$g|Il)A}We!vAU%g*h1B1~Nc>8DtttvM5kP zNRC}*s<2LdB5wq{zSX1x5xItT zMUD`P>B992cE~U$U6;*p^~H@5{E(Yb!H*=` z97uoII@votf}MFPG&IeN_B4|OSQwnBDq@ui)T58df?p{R5C?Rm;|)G>e5K(Zn-)66ZpvPVZUvLeARO8@CAIdDl1l(eq$Z_F4sg#;I*5>@*}^Rj z-m_()!z&LO2@Va~4nA$eYr|ZoHV_OJ9j2f9((vXp4K&|JSxQ5CT8u}wPI!yX6H@p| zrmO!q#Qw3mD3nh1lXFz$=h9E9QG!aZ8DgKxNzr_iOAuEVo{}=l(aLaC5>R5#A6K?9 zCuI-iiK`3Hkl>eTl=jTb$S}xRPRA{#QclP$6E}+N=8i#Oq)@3;-c_C|SW(F?2vw;r z{3_p=eH9>{sXlaL`n&=>ZJ>d%`*c@e*N<4cPa!9sSZX+K+GdezrvT&nTji)#B;@)>9if9jkAnP)~NbY64%*N%|2HYRe&om zG-x$6D`d_1GYlOac#`@v2QqE4Q*)dx@G6Tdxu?~qSEuVMXDY89D;%{PaUFBEl($I7 zHiz3CiygV^xa*`H&o}1>Z(sMCKC_6|oBXN&p|#|Rdnu>ZfSg>KYL05Dv-bWM0TDrY zK~3)jugp7s#Mzd9$h2O_k4JtZj~ZJm1Kly!F<3~NY%Z)sMhE*@J8bKg2wFK>y{HW{ z^{BrOX=EyiH+Ix@cy*|Eyao#Tc zx~Yn}lk$X0^#=9t>Wx$U4h7sJd~+VzuA#1}AA{S~LWu|}396Z&$G+`(+cOqx!n~lV zu1TxWS8ZP5W?XF2_Z?bRQrTo7Qhr#OV5wx~&=+gkQ_)wYZR0+LS?N&OQ&Ct^|2}fM zehPheV#YZP5_a&6l30O1V?<~SzAC>VzkSf6F!6Hs`{ehb!&S-9&(Epj!ufcQlD-rw zMU1@5<;|=R{}{nYKE}6IS)Rf+P&<4%Z92V?HdHRb8Sb@euuo+>wP-&Qv&S?3p~)h2 zTb0w9Ggvc4GqV1pdx3k5JH1j8QM*Qco+MC`x z_+IG#+*0oB?O8C03Br}el*TXrf>pp)d+`=ho)(rioz|o`vAFqzUKo{9pRz}ohg+PK zJU3v3aEqLWt%Ch6I}?Yc_GGJVz3m&9V>L(1jY)jNeQ`DMASz;NAsTvnvEPjh+j+kf z0yBe$6oz7kZZsz>ff^S-OTxtsHwJtL_`E+$1?8^2Ea zin@02%RX-VmzD{aaTqraMD)&o<^S|0UMW?&U#5?rW*FBfRO2}8IA`rc&~AJ7a>=i+ zUsPrGzWBeXTBW|kJ4$+7u@vc%G%9`-dLooAr*E_r_#92?Ol~ZhF>#us&wBc&nOvxE zh*wgC+`5cSf7Zl8Q0+B zMCmZ8wP?O8+Kaep#Y)9DX6qiMmn4LX=>F)_gb_M5PD|CVyrw?d=N^R|v4pyWLT`As zCfJ)XnPhcmo7${?1!T8nXJm86UP5QSYdN?M9Z9_CC^1$0rKVnWv|I3|uwS)C*-}eJ zn^}9VlFmbBL?g6PdcsRRu6EBY+uO)9Mt|&Q!TI*(cB$pTjC}Qwso`aZT#|p1wKeAa zth|+q_V%5*HgE=?5V=bMg7j!naFtZe7*t)$6qhEzDF4%c7{frr(&mW@F&vE}xc^^*&(d+v3)4jczUSy^7|IMz=Nu1z}~I8Q8KRn=E=YS}lB zI!>+FJ9NfJ7^-@dCN~hr*J!? zIrr?D%@)?!xHMm3%?NJQ&(=iWkgp5g4Qn6ypJgrQ{~Ad&=^uzV zK|0m)64-M+M?VZ5Xw3FDzf(UQUR#AX-`tsROK)v^(Ymr9xDAoqa?UK&HCSy%ZZ+RS z&*#?9jVMk8cP_eaT+Wo1b8}O3Jt#fZkH^j|j;p`fIHTC3JZjTIQ@wlP^CKiD7xBQ2 z7gX^cv~l1ePL|7c{|h~XtGpZMLQc(2JerUbw6%Ee?#Oaezlo$b@XqDN_iAeeAt(a@ zdmUkLC^K+tQC-HXBpRQJ55+R%A~81U(VdJ!GPifo^*TY9vUbbBZZk+Y(L?-<9RC3D zC_;?X-WbcsfEa-?DhLUI7=#Rz5P+`$0?EH+aRdes;$Qc{AW)zg2WC(lA*nkk+p-VjpM$WFF$Yt z%~n#~0R$qTefT20QKSKeiZEfOtmddD^OncZ#tN$c-p0TP>SAU4&<=>tg$F2F89C}h zT&ygu9e7;$ss5_L1C$?bvrs|)s^VzDPo*X!4-v7kH-d0LS)r^{0*@gO2%r6XV;)6O z@qfsHfBaOYj*hlGEG*8>&QNDIsExe|%S&!3j-OF-cN zZ5trvd$`LZZ{}iTsV-_}1@H{$L*V60?pJ(&5&R#I{?p}uk*fWNl=JoL|EBz}C;xv+ z6$c}G5gRL@Pe+0Otk*xp|NZbELOzyjIPQ|93SIswfTu>Inn!lh?@qUG1Sk%>T3oko<3h|MKVm ziid3&@SPn?p0i2lXqA6ruH5*R=vWjoXy}DH^hc=jT#yP>OT|S3w50qVX(K7< z90n{{M2Z#3C7z%)p3h%bIPVLTx@NNDfcZ5f9_@nv&@qU?{4axWs7)^p3ZFAG7c28n z!C-h@0|U7eI_`cQkrWgT!en6WNU9PD2>kb@AhTFd7%-HlQ2kxdRb06mFFX_quC1*- zIT;xkOtO&;DhY5k!$7Jd=$HCj zi-__S>lp<56yM)w62{#o!s3AKQ%q{h!%FupPlRji--NT-S(%s?q%*db9_- z)eA#0sybHT5f^MoZf$`ejDIzI5Q){H66gm5*iKGSEe$yxZBZ@7Y;4;k~B{}{jP2=B;VtRYCwTvawanS5x>?IO7z$!L#Cucb9 z+^Y8z`X3sIDAN1XV+!x&km9F^i|BB25TCQcl<#-B)Fy@Ray&?Giz{g8|8|dneX&z6 zXN#%;y2)Zda`OSrwXd>fqO&wGaCLycfgh-!BL86!YFLYkDn@1?dC2^29^$t4g_KAd zO5`cPdzeiVH>Jy?9{uM~WH)1Dg4N%a%qW;o|79&IA$)7BaA;?$oPnB}T1%zFivK&! zp!?~T7@Kjgyx~x}iCm(9r<-!Pw6!&q%-e%=y53p0Z5rPh+~~aT6`i0ShkV76$gz7J z1Q%<67(6xu0<*?%3UnmwAPKPZ+z0wO#}SOf$;xl%Xkh-DE?t);TDP0SE@q907x0qy zTJj9DksJd$?ba52Bv{L5AJnCtovVmV9{q(TzUe9}5;6e~HHnWqJWe~$>UPQ~yYK4v zn_`!-Q>g&_{l|_v;a(H-{O2Kn>3=K{`OW6k~gltMg@FbJlEUIH6SDd~^ zg(<@A@qq7Q#Iqte2(^t29typ}YCQPqAaHImQKH?j()Ria&9!n_}$NtFeWWZ z8->@C9jeOCo9{hES_5?nU(c{2fj`p?7SEuatj48E)DhXKc)vzWr;@Q)@wn2Z84sjUi5R^=`Ffrki*PNF&b1KpH!qG@a=Z#y~Ijq^Oim> zEp38EwRN9Ba7v!V#7dr#^gu%MbETX?d{wPg1-ijNIvL^@coySDDykknum%$7j`WOIIA(Bbf;r-#FW0HurC$yRREd6>V9L7ox%ztEPg|58mm(}JJbG=6%+u!j zO;>0V5gsDl!Z=9(HeT|4-aVE2lfOTb+h#VQ*<#Bv|4|D@J0c1>AXcDRP12!gUdkx& z9N$PWFGQ0*B&`a)3Dxnr3H@+mU+>HqzNuE$td@adnn*IrRb4tCFslTgX0UcQ9Ua|p zTQJ^*+Qxi9zVp0m++N)_`3eyyAnVy^?@dfb7Q6!&jM5yXmtW9Dfwgb?`+g*G#d$P6 zcKl^QKb&H`M(fS+)2=fGmc(K8_@kLb(o6b5%6_s=Tr{ACRT_D6I8-IYeUF=_X_==B z`l4(mguCl`@G?PWs|@FyaC>|EXu1f>UGTlR`9c%_SiVw{bMjRnw8`aLzqlOV;WL$d zMKS*UsV~y@W!mcL#(jyeT@GkRzZ*)JPky5u%Tw@k+L;vE9xu*(uGFN;JJ2<*f9J0x z%dLJ|u8=7{nkK}tJ6o%?OGoXAzi_cTQ+;g-<>pRkJFn5McbeUIdN?uL4OTkB3&JTp zPhL6|93~j=7+2iY23LIzf{c0%*t4)z;l7XMN)*XLs{3#@8%JdAja0{4J&t3oN~n%V zQxduK7N6ea4lU&+%J+Z~3**$jRiKlej+`-5{cXYIz+vl=eqkQSXhm}?`~Vxc-TeR^Y}ZEHr<}_ z)*W>hei+lQ?eK>Ma$)t<`$)mke&PZH+@Gz*^E{usCz{6Oe8;rdC_^ED>Ea zZ!G@sQ&v-xte)rT{8{G$y+ka29CQmh}q{@EtP^ z)CgMeZ6_5K)isDs?UNgL&o^8agbUu^gceB5dWwhD#A7W6WHB7(id5DQ&zIz>6K!npeq&SU=MXgw%ihQ9ZRCV;Z?$Ltpj0w)~9x{N?0}C zIwkcIM}z4QSf{8GGCI~G@R#Gk5DBxHu6T~#Jun(pw$}}qf5w8_)hC&C8pv1U#WODA z*B%11rhXCv+kPzI+ekq#Hl*Tc@6BwxZu(hs>93JITMS=c-nX~*WocILHE=mJe)e2! zLGUO#mF_s^T)0Way(!BZgLVby0s>Ezot2gMo?GQZ*Qa!Hbt9bOn%<4UTsd8h2A5#3 zlbUW8gdz{Ro#`;d1>RhKG(i;BQ!@l zv4mIIZH?l_D}dyZuAY8>$|63I_)TN5_V zg3y|K#EW4Ay}cRpjn`Lm>3UCFnA}(yem+8N!$c^A#l`k)+O2(xjxKU~y*Zjstx~Kp zmYlU`Q*ZUu^J1wpd-*~CgWWXK@-d=m2ls0XpU&C$^zrZxctqv`M$f3r*}1s!57lCg zl3A^+oeZ(isr5451mmJz)495oPE00yjjUwid_T((F7we8^J;?J1lJV8i3=KRbKtD^ zc0wx7C@H#e;-Kl*}H?Az4%N`?qDL z*+>&-CAba(9F3k1J>_rPgo5mwZweO9-Z!%M005w z#&W9n-IBuIYFwu~-wc0+=}_|fI0CYM?sYx^f8z)*Wr3~cn^&!d2zfN!cROVpj%Pc~ zqfAXZ28chb^+LCkdr`b&EoT7M6 zN0lz6Z=R*HMpp}@hPnSjA|xc?a-t$*o8?HuMg~LVt--7K8&nk(9=1%L_qWQObt1Hb zf|tJyE0aP>)G#HZTK&37>YR4FQS7317q{JPYF9a~E>_-LDQLT&Z2V}J3{yp+ccqCZ z7yZ`r&KQ^yZRpul&ePcr61Y4IZpzD62VMa-!FnQ9o6A0S8bTzHUXyb7j4J+^ZMk<77;9d;g!y~~5ED~OU}UW78)WWTO7)h)c*!Kh zso|8a<~D!gyRSWss79LfmlUV!=Mv7Aq0tlTbK~(8pC^rn(3yf9S!_Qc0iFgnAiJro zLRAC}ERdu++dQNzz)<7UlJ+>Yn%FJVnW?rJ(B;W_HdODln^C`4*XeS0D(+;e-so0o z=rqN9TQTBxD6mBzwF4e$^5m70l46Xx&rQu4S^Oa))lN-yh9&6JW%XP zbw~>6*eZb(yrlWUv}%bIg;Y5!pI3`=n5+c?IED}i_&dX3s>||Az)`_PAlcYsNJ#i# z`oq`tkwm@caCjSJzRN7zB;^BLsdR~74i6;=qWri?~hY`VMho-ae-X~4riNxF1XaAw9_`5t$B%lYdl({t~6a^hbQy(rgF^x(2}3Q zY&c791278Mhwbnvkjl!-U2{{T&Y=Qs_?J4OQfbly#pN?U96x-o87W4@J?4J0cU@rRB&IUsd_X%II@=1GCDp! zZ&*~a+G67K`)gJ*9_KyL1y5D`i_clw9*27KUPC%>e~pK+8Q+L5t3rj&xZ+w9DLKi1q8LxKqGqG6TnWHWO&|Do!G=GbaAirv(Ys z5AO2wJd)!b9Mn>pvZh%*rj_{fM#2NfZDD5XskO~}%c$#{zB{?8?Uqoqn zx=6<7^66}6O5}8FY($~s6flOe0dFCrp@ENDc0oB`@#8u5eSk)#d46VC;SMqr2jF!X zBy$zu-QS+;-l5c0bN@=s4_hQZp{Y9{rxC46l2<3z6CsVQemm=$x!@a30(;uz?p zq0R}FfbsV+GIMb5rL# zIp&Bj$5g+#YIa|TBj=8ve39MiKW&l*?3wW_#et)2{n0$$hO2@&M*pCA8W3mPBBmzb zp(pIdCOFp1$I4Hzt&XcZSiSf(F2Q({){CJtJz42O!9I1*NZAnfK`N=$n)n`=G)%9RmW_OqDU2sFoJk-bbrF zamPEi(mOLcW!`n{sa~-OHvqHKC`BGAiHiqByi-lU*KGFk(^zCIUmJese?iY`|NDan zWUTRUVTkpVl^CgRuOOv9R2GjDA1(K*8)IKGx6)isAi;*X|1}-1HFF)t@;s-t)_W(? z5E3|)wV29tCp1*Fo zDZ^dS#*jYFe3K>}m@=z;16LR?su!%f>3i`7JB5b~?>k=jic}i<4FCim{&GxlS@R%~ zNjht6UV+~{z*~P^`c&A(fdn7(uZ4=~rh!Rnx%#`&nDl+9r}o4YnMHHNAW;1iCV+3y zLCQDEO$HcO&z{Z|NA!=26~ZPefNgZpnt3`~tiC}qu{S;`l@^Li$;la49kxsGeac}I zKq_g($v*(b=-;sb2C%9&dsy}SlY0)Q!vMi)WH+Y6s+m_Dv%7&XEKa*ols^FIqR?Xb zfBm#e= z9(@YNx=$=*aNHb5e%<{B<`lg(lFP!ZURIGz;H&xs%g=*Y@{I*PZ- z6mEdM0dGbG92NT1sRNFh44`KKM^{h%MN#gAWD(Pk1$yY9ItbvT^|k%))7Z%_0pT=>SV41?Kj7y# zY?tj~&W&ESfp2ZgI7q&7iva$*q7+|>*|Y>=7EVJ!#cqF)rN1s;IS||C50l5CUy(BG z*0idz!P;LQpvS+TLkdt^=mG4Rx`Y_dN?`q64fe)6DwjupdI};2m(}-tkrRkuewJx0 zYEVyE7PCy|Jd4j>U&%G(4|AsSbNP4S^B|DxtVptJ2qs%d$WYLnco(H809^7go^i8; zQX#pi`+vgxvufD*NF{aV&%%j6kQlvxFDm9f7&Hm_l$0bbCwTj$@p8?7(v-Ct7tC)Q z@EGG?&^J$~kvRO>OW$+p=0pJh1R)`jqWxZ99|3Sap_R_a+(!3v?zPYkB-9gAQv8a4 zSFPm*0?yVyp$AcBjf#Ur!eIQ+mhPAre;u4a{2`KCzeM8k|6~jun&Y+;_;i0EQkJ)v zu+8mlgx+E}fx_L0+=y9s^uF16ksu=HGktXI4IFZiGS#i3zAZCaJ zW&di`Lqo7UG+0_-BI^!dH~pt!9||B4ckA=9=wF?GC}5j|u{YA`o?QQryNf6YsE&eq zlrR2^9)#+j2>RdQ{x5g`7ODT|gaI~+egXtW6%-Ytu2^2a{EUl>E4hpf?2=$=+uvO{ zj8JG!Mg|ol6O;1&8&dEe!H2y^6D@|xy?vV&9j$!FLR;o9&x@)I0S97HFZZAxV>&NNX>;`$^ndjGN4>Pmnj zK-z@!$y?5-QB^?!zS0)=R+*lTuJA*g0$_;=sTAgjBwurMbRmQFX%}%fT_e2H{VQMM z6j?6Ecy3*oQV+TTQsgbpxnRU>fK7E>Zs(p9D z!iePN=EgItaYMxZ8yU`uhwU8K(9pm-LCil!wvYvtX(%YQ^2^XCAloe`BTl9MF<_#+ z+Rb2HNXAoD0L0N?5AJaD{nyO9nI_MAT@Iu0X&^9Tttq|(Rr}`iu1GE4DX*;W zX-5}eTYr9pNeTn7Ia+P++i?9NA{8+_geeyxq`GFxWiT1K@GaS^-ze}d?7S{?i4E!O}loOTwCp9Zf;Ywv8 zg0_nwz{0`<;)Ki%5o>7^4e3(RWE;Rh3OE`*HS=m#S+=s}1&XMU?T9~zAN3}0mxwB- zg<43vxv|d?JXnbt$uOPyrpN1B%T`V*SgJI0T7v@ok5}t`buVi!6$|uR15UCkveY8NPgzTlGVD7Lu+fXwOzECX*^X%{8 zcVs{XFVRETV4o8|KlZlKW_L@{9)Oh3ySVxw?uv@| z<+9t=)%HD6I}nkT0B{{NcC%sscf}fFxyi#LlE+Sl1RJG|XFTCVY~$4K@7@vc1CX@i zT7pU5MfJj0$@5uP!$V>dK3V%u|>fE=17}B6x0bR z&*#}dPIp^yAlrAu{|rTWmLT#Ci%s~t*YUO)MesfWS#fzn*F>@0xX<+Jgoy8phuL$b z2_4>K@yI6KcIVyca1QHPHO5Hx3??}AvV9%!G$`^^3S%oQr|f~TSC56c$;!%7C9IaJ zm(vxim%qF0&}5^dr&kImW>>B#YPCyD!zQucs`Vhk(RD#nlhyBLr?|pwgsz?`fO!h}{rTQp_7N%}x7l0?bVw8M)7}|n-8yXtx6$UR6uxWdkwl1W zrJJtCLf4cQI%A^}6#QltLQOZgnq91z9g;dH<^*6|l6ctn{YOkL!H)ICr#)3}o$UQ( za|!Kvx|I+oko38FDos$uLI*m31#N2&!+%}O_P5=`# z$Mtw^CgCvXSS(E%-bwE64{i3yOMGiOlG7LnBlzLg!^}DIO+W5M9Fg{qx)0lCJClJM z51A7RG|QL!&G*X7s#+@6^}9~gG7DYegv*31C`_^`SBMy7ZXczt&Sq>}^es(rRg;bf znqelKB_^q!1ao$s3_#Y(M;vRwzL&_8pX_qvwZT4-)g9O7S#U$HcCDn7kn9HemltxwysI?+^R#XIk-N<-NPpmDw*!NyQN#C6~69Tm)U$1q~Czp-`yc9ajtx78e6TnrUD8 z<=7HkPsdb`m@fUcE`bn1PB7kr0=i6jdHIy;t@S*?p$Gf6fbHVPhj=^VLYffa5Wtr0 zrhAs#o8y51{#qP6CMtE~W?rYAw`CTgNc3>8hjfAm*KewQuahEoC^J$(97ssX1d^O~ z9-rvCEh5AX+yFbC%mDv+LmBOLK8wyxq0M$lZxT&gW4x`6YOFf%t%8 zo2_=ojAlx(q=Xv}+=CcX}*mmevz*`4PO*|;M1}<)LZQVXD|r$ z>6Hwoa4SNo|3WP?NAFGWCBrjY0`W$Q?U25M!s~AGl(w{{vP8GJgL*re+hOx;W?z1J zl=?@HA1568v%zkqLu&DC*S)UHK!=7AO8P<-s`S(4r+={Hej}8!sPM}POVdSIofE%o z@G%0Smi6;j=@$cn$11fzY}aSTBNr;Xi~-rBwXdve;X*r!6ukR{?105C4gCOkMkHsy z*8m_o{WG-$11Eu<$1u7Y+>- zZeO^bGD$r@z;Q04JT!(w2S_+-X4!uWu(2uiU3EA5FL>XJT>7ooVyOc;D`W#|-lfCu z>C}y*i}inZZL2{RdUmIJ*bc11e;=;szGJ)Nb>7R8O{vRkPm5yk`fby2nAlBUzUO`O zvWLNte$dFk9(WNye!x*j{G@J%lq^ zZwxCd%XSE;uG4hgHuX-W>zMkZiS+B|-W0K`BiFHO3wmE|nwaNk)+b3e)WCyygOC!8 z=olMGR8n{n8oG|2#Yo)roxaJI<~KdlavW;!#t@&? ze+U(QP~6sbp8JKuF_$)LGhMm8xFlFg_;u^5ecuy^J#~+V5wYyt2Km{5!LlaAM=n9+0{>qx#p zIe_BY9Sdw=3G%(GwU?aw;TJe4Cn$5ydVJ7|^?m;upWJSqyqC8p=(=aN*87lB`om~Z zb+1>bU}LW^5Q&S?`8&^wp09Tbh)$BZZZpd{<31lHaplI0Xrb1Wi6RJueWjB9X-}+?Ls+1oqJX-w%P}9SU zFitOK*0^@hDPWa*jQvRgGgycYI}$)ik(Js${>%pLqVI@30xUt~`idHNCN);oU>&>i zjk%ds&b?yta#%IFGR+=2V3CziyK50>hqwpT_-)v>KeOSOVG8&1*kX(zDGj;8_1bN zrGmTQZ}>7i3uP0b>_0t7_e>PMELl_)u)d4MrF8p6OIT>2>&dRpY*|r$IAbHIG?F6| z6BF+pDF4k-4NgOptFP zy4dB`^gbcw@@an0w75$pO<-ki0SGgJPIrcky317;bz}jNdCEeZMI<@D>2Ma7%6MT( zop@h-4`D!mN~Fpjdznpr?@13_97x>=(E*Z7PHDwvKeTzz$3YCwPba>N71d1=q`D*B z1DMG5z!TaBhmQt(0L=dkolRu(IP?tp?8p~z)I6A(NrbwV_?L-~TCoI&jpDR*3i2#D zFZwuj3opz@ybMxLdZbpriv!_eT0konqCv4=xPj>G)FiSPK|zT|rPk#SO=qp4(;!`s z>RKBAW|j+znpud*^u!6skzCYa5Cm3lCLSpskqG57Hh2=isVS zN*CL_^kfGpQr+#%{&eLF3Mt2QjfTtBI9=DBC8(!bo#SWw!q2-nM(43|0+-RZy*8gS z7`vV{23e~6&!h<m)1mLinUh_C874^D4hT(>d|;#n~=z%yQcC($-r* ze-khi0VW8G0!7|Q`TjH%5xopg&qgdgqI~=WT_RJys0B}FsuV9b3VeF7$IXT6Xwz>X z>=!NFKIgoUE&DXCSQ7=K&cFKhcyEs~pc{81YJFVOW(hf?`d9H0I^n%7*>5BT?nWhF zOXiEKZJUDIW+P+GGhXkTLx~t4LT79{^zQ*A*3a_Kq$dtvDKYOs?I%C811B3fzpOs| zzQn%$vp^)#aoV)GB3H8QPqZEByN2mhElf<{{QlaZFE-s&Gu9;}!K39oCmE&t-0>Oz zl~)v*uHz@q-czqFo)YK%5oMC!>Q2M8*L&`hA57|xmIwte?N+pUlbgCsd24v^d|=MT zeop}l8XG6b1Wx`$a8>>>R|U(rIAUPmT9-3Zmw#TL+-3P)37cXcaP@+7-X<(Zw^Ppp zHcu#r5kaHV?zDN&59_%)_g?I6CGpB7s~P)?rvpz6L&XoT1=f>~$Dl8GBAdobbyJ-s zE=RaJ+h=;4zrYAJ*T1?)@OUaWJ(K*@tn@-fij}~E90>jpR_Mr#K0uWS7KAs4bKO_F>G5^A;j zjsAa%I0&x8(IQWlPyPh{yjbG8n_R?(n~_n_=Izd~DC)e&vCL@c!e&FMiv_y{)1~N5 z-@4W9SFbCg=Cg$}v9!?JhkP|4vi3XHS;jT#oTFJ62yz4&B)p;EaSYN(E5LidfBfqU zeL2N7b@ci?uXb)i=~W9PxV&E{>DU!-BT7!RuJF#9nf-GME~I-m7opZr$;~*)f+&8zMy;sbm=DyqJ!+F zzDKPQ9V`#sK2b>FjBkaXA&cYvfnk~ep*v5(e@Mka3WkY2-FQf0kjGkkp5ZpxfcCaR zPRYK>Hx6FuMxe|^{*vL{lLLL%C=#en$To({!Dj)i}JyATLg|a zL=)79v}`ZjAXPY&O7rKT%=U242*K5x_84tTB*l5nY|~Uu9-~~i?o`+(#J>zd>ZLrd^!SXkZcI@fJ!L?MG-Lqr@vzp%Wz;Kd|^~qKmxEh2+ZH{=t1BAcR4{I}ix};B8$0t(-nEEF87?zbS&y0i4?IW!MH1Y8wGSJW0$_ zLGV|M1JVF=+S)@>31mUD0?>cKo7x`u|WsQDJGF?W`Gi5Nu6=*wCV3 zP~)#42mAmR=#<4~6jj{5MD3pV_t`ri~a5CE4aYz>n2 zfmuGhCR2PUZ1MN>e@X*$ZfH;-0p=T?`Oe34hhZ#0rw2#kR=~u7X_1xwFT)-dfBFA;h6O7|Z7Wuu$SPOb zlN2P6$15srDcCDwNJ&a&O5F(hAK-8aOXSsXr9OUqKA7IBxuJKbG3{;pe78pv7KmQ; zv6M3JuPE5;gRn9J!s?#_6T{zl6HKIB|IWK0W+-&HumX+OS$RVc-he1=rn=`i{oUd* zKEdjh4d}rZf~AoHq&)~2V!$6Twfqo(Gsl{Y)y8j)llx2^w&{o;V%I^;j||VFl>dz6cH5gCo$>+M-*vRX6V5K`f0a{gGqRTK3}*9x zfT1CaAA$Y*?>BN#G2kJP!9rzgvG8&m_zP)Mo%A40{E4{Aq_3HXC~*=E%%%@PteXdI zYJMpe34?5*wbjD}3ygKmrw_<`6D4kwo~a=kad@5vNSLkf<->`D%^sBT8xRbu2K}H0 zh)q!+-h5(IvEP-&1#G>-eu%lU4e)Z$Pjh8lwPqu}>m0d|?y7VJU})cgeVm`86QlSM ze3G&y@kSD7fSur}VssRQ&yqp3Wh_Q2~vPJOHJ+ zVF#IjB|;+Q6=ReOrqXf7_Qs>ks|w`uiB!yvY7JLPW|qf?iv5i!2r$Zc=oKRs@m{KCtA60UaZVpTi)tND)s7m0~itcJ1IU(Qdwvl$eL`(o;1f+^# zZy+p*=wmZbrfKowP6mqHaD{~At06J!UaHzqMU+OzOGZb-Vra0?)$w%|`EvHNLM1Q> z70c84^V`$DNY1L$sC}#r`5ozkvtci6n#=KJaXJHqKvfK;rA@#@=8q?FC;-TJbP}*d z)()jZP@}Q2?Yy$mf}$b|#Mx)qvxu3ul~(JBqT6_5gSc3X58YgJ1;~1*M6SoJb3F^I zhtjRwqkZC1WN6~6DVe^L@;VonaHo{XZR@?Be3L940CXF^wIHfqi9+ldaUyda5wjUZ z$*#gC;AX?gtl`2sEK~69)MoAwxp?75_~Wi14-o0beg-hChPg|<& z+Bt_OB}q|n_38Y(Z9Ym* z>$Pv_j+ciUH|XYhSB;)U+79t+ecX%j+4ieQTVwPo#N;W$o14KERu%|-m)js_?c{y6 zj>N&Bo+`6A@#5*Mp*`)76_%Tn8Xc?WyD#h-%VN>i%6l^gG(E_H-Qm#)lO=GTDq{ny zivK=ssBaPP6VY+^RAt_FW}M=*!ltsz!8hCmD%qYy3{~N=Y?bG==8UUW^J4d5Ny6@T zI$~&i+fa1o6jAE~cSV8Fg3BARtf_4NyeaRx7j}Ea3p~t}+@A%u$*yN`#8~Q#~dqo#>t?~6#^a~D~OuO}1N%Ru}W~I%|IO05nxteqzOtLb<;c~ATxm1su z`q37Onaam=*LwU>tHfd-B}_M?JigvSGw|wEv!kEhA^sGabt12^K*v8^QXT&ktsJ~p zQwmM7HBgDEFmc8iNM2W3p?e;!GH|+{|7lm?@_^&&IP!LUS;)I10xBf&7)V0Y2kaQt z_;hgzKOvY`m2CdIk36$>0%PVWGVNuk(SFT8fn+YJqVly*L~G2=EV(Lp-WfM!*Id54 z$M+eu8&2bU)5#H@i-IM(m~GWRaC>zHFn6cqG>wbXL~5^HzgvQt-5f$_oh|vhmk0Z; z1cK|tB{b4{cFwi2-am(`VyH{ZI6U?=j_z8%im4`6m@A^;@wh+@Z?a%xwyUpD&QFAK z&MF4hrAC$PH1?M73mz~vu%GN{hFdoW1NiqJZGQ1*IIMUJ@-72`x1h$4VH8-dO6Yh=%0g(n^?<*5gFMOj`!#f zPpefa`+AfCGYWTJ(-GKa0zo1whA-iZik9$B4zaC{S~l?;2BZ$B-sRbc!-Coz>sA4c zSM8+Jv%Q|TP1hZ5i4kQ}`k>q>nm({_+`OtNCG+Hjpioe4cP)6i_#hCZu`=$&*VSE? zV-REiaTjO7A$mh(L+<)=t=3fyr;D`!yQDL7%{dX?D%O`iX7k^I_0pAi z;hBvrlMEMaX~pf^t%_&)8}3z3hbXN9y%@nLUQH+Kg@f$VNDmiPafL4k=JRv--dHVe zP9y2G%$#~51Y8eyRA*9bMkk{dmH>O5mlryhd9r#)-aG10=~YXY&+vyAxxR*<>n`7M zZsh@@6sULh392%@^aa&4kN0pG8tc)K&gGxWX7?aL7dlP=^7@;G(cY($w>*S1QQR%^ zY_CrMP(=fr&GWd>V{)seZ&m z!zJ>^vcNS>)k>Oo4S-2q4&PYT=?-qzaJ4|~VhLk{G-daN5>>C#8K-MRH!M|two{ye z!#-68ag9GEg#K>Y&!G75J&oULy7jzVaR>}^`oY~E44IGdojM~qaVqfK?LT4PeUe$# z1GJXE(s$ccu8jRjP^(<0*L62M+vHijIv!&IZAn(IWaBUY6N}6Gy5>;Ubp;Z%e!V|~ZS_4C- zPBV$&JV4w__KV%1LbXjtA?G!$`>;p<>J9b9TQGJVdf0ET;5GYLZ)-Yr2Q@`=y-)xA z*9$=RHbFMU%?@AOKu=Aqsyh?%OV6nSv&|93FWQwLEw)Cev?w^u4@SF8%c(L+~svM>MLF(cUs(k$A z{#4_Tyx;S{%-bjROI{8K3!CYweE~WbyBxzE)RGdvKdrBP%dKJtxGHOOB7}HHXy2eya6(6+d4yl906RN5ZvFG*!SH$@s!Ro_I>rRc&+N8{T)_^_H*kL z61$YA<((EpIHWS2swJGpRUW>+{Jk$fn>3a?%GCZ29zCqm(K2Lk*oZDS zI&amK2F2p~u+%S(pD7cs|Mj%nF3CCzKr~{bd@hm+D)*Jx)I?T;zg(@|R%-@R%H5F2&LWQk49ZkZWE_-MhHPqj^}5qHdV^M+tVn<) z0!@5CCc`(o0uC&lK#t=%k&_9)Nds7!TPnUcmGizyiutX&;46mti=WyizOTA$1_}9( z06(n`^|eSLTe@QH*(BD2IrUL_zash zC;PY03i+RkeDrmXAd)pV$LTs>pQ^M<5?qug?bc;wv$wDF@qf7JFu#yY@Vom;+V#g} zSPlW&{;0&(!WY#Ud)C#Z+AMO~5ARg$Ibz=`<*hv4i+T2WOo2j5Mcsh@T=&iO7DLCq zpP!@F=edt}|ES5_iTSCtI8(hsVt+sleuJ+DQuh^1F6AZtom=e_BwqghJb+`1D7%L- z&aG}yY{i4GP2az!(0IM8P-RyQ{{n#RfXAVrPASNX7JhJiH*0q6e!8svYng$095)fy z5*HDErk_^S{X-k(>6;3#u1}w~E>Ycn9Q*(p9|4zRWsy;I85s&fKHd8at?5VJcHuj& z-^g9Jm={nQ_ui3oaQ~5DtB`KG%WA7#^38Iqq63q^Kw9f3|Bz>%U=OAZw()oYpQ zx>io>8Uhm54`>x@m&hRbUYg;m+b+-gUT(2b|5~xF(zz1zdYTzvID!J54{J2tKMb1( zJf1u`9X6-QPP>#oU8Dtz1nEb~g&B6Q-yjvth&qM{W1^@pA_v^i{u5x&HsJKdbgncb zd98zzxF3|2!d3`^Ix~sk;-3D}gdw;wt z**N)my5rk{`Sy{Va11cc@dQ^#C9MNh1sjpS5~0#S_R(u)l_R+$vc)9{{^L^6V^z0m zrY;__me5IY35sgJW%VF{cBF;*FDa+J{`_EX#AD zTZt)Pw_T~8swvB%uY2-XEfL{OsYucLkMPh@)Q2E*#*Kq|yv78$&E$ySJkE#kdjp~b?SeW{Ie%$%kR*P3>^=()!sf*|Rd51WDY!uA)%#ohFlz|HZsgzXBF-g;(45=*hlfyd7Ff*6-~ zSoQR0Wab zfjkkJ`W}gnSaC~{A2soFLTu4d{-<|E}bldM$w*#5PWZ%^cz zo=Z`+hL)>_pYCmf>ABoXZj4?u6T1S;@}@O>9aDhy^KdnPk%YvKRQuu+*g|`^$6YwZ z-xpyIvcy09jlb^{KY2@FTApULr|3z=*QO;pu|9W@%BKe~p{!fqY{(j^w}~x;0m=&^ zSAC&0+wYY@G2Wi!2j{dJ>Z3%ajN&kG%$};);CfHU-k6{fpz@TDST$qd!m1F5q|+T8 z^3dTzlJcPs(-!nWEd4VI5?;7)2;PB?DRo(ya#a;Vi3X9TxurcLv(=3gzUk!Q*`$@W z1Y1qfwLBl)m=2Kd#EOJoD9>aUd#R=xE8 z$4;zmse6?%VLe;?&e1H&h2_}-GJY@iHuz!@)1XUr*E4K)ZQl?nw(U$vt%|tgMe^?a zFV|!JJkb^NC+Oj|*-13Sxf=aa>XVu&{>J_lVj;AWQRYH=QWw~6EFeVdKhbgi4Xrdh zEhPQSXEnXjf@->s4L0i*xu=tq#7OVB3ikbYvaTdepY`)<4IaTcWQV!OcL z^NW7U-!oOEKeKI#Kq~ap7UXq}6@RZTW8h z&BCHIC%lEJ%_Et$#EPifz%1+6M+mf0%Aq#$p#5Yd%0`adA>?Ml`Kf3Pw$KW$sUJPS zq6JrRO%#s1zf;o{9swac_|sf)o~fW>rwp1g&ZFEZb0Abep>W>GxAINT%y`l4Vdf~*Jg5rU8ea7cCA|vXi+eiuH$Vm@xj-M8ebFN4rOB64>uwM6ikZ3Mz8?n4Qm@E6Z=F?#lYG6Ltb7zamZ0IIMobGb^<83oWktxB3 z^SKD7AT{E#SBH;2Fh zJ&9Fa(`&!S8N(Tk+z9IR_Nj$NbG}wgiWhzuDmKNcb#QwZJKUjCh)LmKclyHn>U*Em z<^I7UH$E170tf4+?Q(N8FbvNyXe@aaoo(UVqlx$hm zPE$BZv5&oOeKM0E5kT~DZuJEA;_Lyt!ru|tqRZ-+BR?}#erReR0&4qEp87Jl^dsBSm&9&Y_lC{D`%{~r@nzWuOImG z!(MwTodSIF6UK_OHi&E_C}Y;juWKL$>ZDIHd=_tNv z;x#a`REBop}6+18~fBH=<|OcCBgl{P)O60PAZtv}a9| zIDgmQ77k$YO4&ByEEif7c8eKHZZ}%`(sGA8vP+oF@~(i`9W$0%#8(JCId9J8R!VI% z8s}L^wC0O5yB-CFVVAg^DLGVf>ta+7lhzIwGk1dd{w*3a`00_mLM>}n_cNC>@-?B` z;fj-CXcxtCwN7o_xyvi-RcDC_x}Rp1@)WtC+uFnQ(h@t@+Eh*d#N%L)@I)nB_{TY- zuLHQ#-Z1)tpOpvOaCg{miR&;Vl%m+Ck=JTmjM6!K+I`-62;7}-MP64)(h8Vs?IrPU zCrmp+?vGkzm19>64)N9aN%j-;rW?*e7&n^w6|2ye=(3s>+LTC1L5MB&M1t;>s=^<&y?Tv8+PWE{S;O^OwDnbo*yFR8?;id?d+5GdieT;#G zzO)jOVE{J{U?Ag(I(gWP5r^7$wM4AG9;YUgO9xW=HA+T?Uva6=W z=r66f*|2d>L@L#%%lPq7C;h03U1lRH^ABgNgdkuWe@G(FcDfit9cr%hGWSZOXI+W~ z6_Kbptw+0g0hGK4RMn927?^iot)E^*eIK`(wQEDl!u4-z07t~(sTd?wax|Tu;;htxv z`I$OhK+=b>UI^vRnVzrczf75EslTAHrqT~iKL&Q0{MO+edu*%S+z|Rz2*Fu8De;*_Xs)}XV&=<`Rxe~ z?MWt5{ehAAJ4I8*us{FSAlELiiMq>AzS7;;W|y&cT?RG5ptAK`!I7TS&|(dKf<8ZO zzwSG9-8FkMuUWC^V^~Sv={=;YYHMr)WWecY(_<~h&%?^Z$EtpAvuoVGy&gh)<4yg2 zO}BGPgyOmFAVl8M$Y=ceGpBC3{v9#m4|Q@MA{N^3pg~jH37AsprN>-&@JEKnNW8QXPSWf1*Uui;0zS+hm-oZVb}NfswLJpUq06ZV&G z?=LuK%|Adz6Z~+B z&%8$0wm)&vLV4~c8j!3P;yxd5@lJ!hoZ?n=83FyHsZK~7W^;f>b&=LGBiNY{>5)*5 z3~RM)(5V;7(@=aI^(3!@c>i8Bb~b=@nY_>pJkM<#9infMA3y$5am;t-WahZ<++%2# z4w9dLND%^t_!uoL(>u!oU%6U?R6FJ6&nYHLY_8bCRD!C%a(0QSiBtdGpjgg^DTtp4 z-eEj1I%FhA+DZK_{(xyBi;Dn8f<`h0v;JNB_OVr}p4P%0CN0U1G*6P~f{R;n-Z3|U z(>2aM%+}vl#B?P(X7f-S?RNe42OFA+Qh!b?qGzCGt=p1z9geZW%22RFnTy1eSuh;HN#SQZZHluZbC zT_HP3+>Ae#xqKvaKPN#-53>P`@7Th1(!9yOyIpi59;_SWRp!wNo-mZ{NVVJQ z@8xH+gY2Avu6!qVbGBT)GBoXp@(ckz)3c{8>}Kqc!oD4<^}3!RSX2nOmse%oe`%@Y zyS}y?V9zjK!`5+F7M7QF(KK2cO$}H_Za0eQJ1q3#c8qz4#LdCZJMg0Bp8yXsECM9` zC>Z;C;OXKN0ezkx;isxUb1zF_4p@%eIW0d}(Q$I=k4#_GGeA+W z7Lp{4wbS>46`aiy>N39{Zj%=0Wc&COYZwg?U#=@AHo6Q?4uNp%v;rf!$IRv5HR$Jb zlO;XB*NN7MOo~I&{<-G=kK*B6fo$)&M6K|jrTzM{!|i5MG1j5W{V>AhNjYd3 zLyk|U;3+EjXEimmhDa$VHb#rRfwd7=GFwsspno-d))cB3()W1qlL*g~KxGL}hFFe@ zZFn9iby53G?{xX3$?p1%>zQ^(oXjjJ9!mec&~2}?zrsCN-$*RI!+^D|-F}yV*7dkZ z##tQkPyxBq{%nBKZuDIW4l@f6I>y>}{2YFOgeFE9kdA*KlMM=&*`C2tOc4#gxWS@8 z?a^i)-?eyXR^6}4QPC@;{(;Sc{vOtaX}%lvrD&bF{LLBXHuDgG(wP*I?G`T79?l&6 z<8?iqz+QoDxdzmBCBu=~R@3jcOm{W2a#obgurhmKmBzq=OZ(0Jd?`ttM9nQ^V$U0d zUFP9TB6PN`osa&;(cS8KKl*Xq4h~sS)EXjbM&4PNm?I)7$>}JQup^rK{LJSqQekx< zbxFJ;{!KXo{qwkGR|l1J!YK<@VJkRw#Qte^lkKnp&6IN~OYy`Gpb&Y|B@+8dVUHSf z=VDBNjJSpZ@k5SdS)kYM2ldt+_Tg39HY_d=0dJ#x9l72e?U6RORu!|#oM&+*$LTBd@n9<%dfbRjYEa&( z2F>s?L~8`pj$AM{{w@=D`L^FZ&32$LK;2ypFRONO0C$z3%+!KQ>J+Y0Q%==lw;2P4 z7uM2zr$M0FO`!%(|FZ+R)`7P#GB`GxuI!GTN!TbuLj#3val*9&1UFY$tQYVdRh4;v zO1MCmEVK_=90!b-d+g%67B4g{5AN@*NxX^6>h{>Pyl-hc(h*8k7>FWw?q!-VMwvSb zBm+01Th~6QOK^YtCjkdW0C5eONOv|hOhHIs0Mq@Rl`4C8vJzwFQMn_#oIq~U%GZoU z7v{_T=jiToZjiU+P(=*IS-Z?Thig&O-4{oDBYV|&zgo-nKWJA*J*r>s(&6G+C^Fq*#}!6DtPYVZR98l-fi?JhXHjGF5JXx_Es- z!8ujoeio)-c`tb`WJBm%`%C(6s66Dwi5=uQ=N3btcpP&!m;LX{mTi39j)VDr#@*w| z=i9jaU)2bDE%2jEvSELU+5ZYgv>z41FTh2fe-#t5WThzWxNgkm;+OWfCMYKxTSeRi z0pvdwsBXyx^(2_`%u+0VGt*{r^6KAD-CnA`bK6qhD)x`4kRCxXfx%&i|G?|gAI{Z# z+9vw%^O$JV?S+)@OZvXhF~z+eJ4s%s+h#`fbnqmx;2Y?_hxQ#gJZki4eTZr7CfYk^ z-ylNyWMA!8y>#DT#>_a;oyxV(wz0BwiLW`{h^L;Pr94vY_5TZM&fzB?J2hx9K*#1v zUt80b&bPLF80c0-!`?X*1l`(LJ^d_c0y?}fAMO1?s{R+N(_m>L>7zSi)4yhNTX?9C zx5(-bTby=$u%+#D)fg@+!|&RixgBk{_U6s=o7ark_e!iPRffT0HEWp|h9!(-g;JC( zuydKBWOqHTgHY}<5T`cCt=FhYFVE%-41e3^vwFq?5@ ztoEF`chVXa0_=t-Y6xSXDr>b68TLGgTzk@M;=2A0+uigIHzHXmwhUhX zPJ<8&>g&71`%N;zPYk*d&K*F8Eu1E^`8UfQ_TE^jP6tTQM7vIPHXH>AJori4~gzGRp5@rw=cEGv~?(*rD`2KvhW0_2KPJgI!UR~4<0$vFbAy{EYdq0QSU zxl-LT5uF7X?@R>?*K2h8c*TIgef~4~bb8NryKRro(Wht4j{<0*ntgHj6v?i~f z7cz$lPSk?vAQ_-Y{OH?YhKBHzWfQ@A#;7-)9WlYi25-HNann>{@UJjh@YqNnLd3zv zdbhVs3&1y(#kZoi?Z+7=qwb{THBxCU*UM?wi~HLA*hp(KxD(Hb`tOzhy02E4bXgN# zfTXWYry-M{96iFHWsp?)r$C}&uIf+j!7$*(hz?zV#bE!2-o#tJpHqibv=gOsr1yG& z7DC#UuTlGtB)|KAINd0zG_zMuAJ9E-B4(-BXj-J@n^yYDsmeHbB)j`U4AtD2*Q9uy zH3w;e>VLko7mwNq5XJ;3YyHO{JDe7Yg=tc8-|-vqGUZDO19CtdmVn8=3}Xh189D8p zMxy#3rYbvWKNEBHeKj*Z6#ZWs3%ld_dwKexYOgOF>U9>`JM-7BUea0prHnmoKpiP) zRjsm~s@f-n0&OW313{ilgio{p`gQcP?rrW^CwZtWI(3nqw^r`J07PM*YaE{ zO*umK;SP#b{*9bOmYMU+nkKm(ca^m61a(Ea1f_Q3%H-m5a0TrZYsb-L zwEM2>5?#fLwXV})wWXJe4sCFi$a)rihuAI>S5x)l}8u4QF zS#b5AMCpO`3~JV|S+NiNLUFn_87zITXR-~Ky5@G7A$2lZfen_700v{nT&b7|{#2Dp zb~ELtdssm@onjr#0MJ|c+N^FIn@ z2K<0UyaUl{q_x6-X1Qgu-&L=#B2C~G&5RY!4Tl04sjs4o0sGperUMDE^CvYx91~6v z<*H_!n=~=6{;6v`H?fQNm|Z+Ol&zv`)~4A$f7L+k9S5}X1P#ZY5@El8e+6XrI8c=_ zT8J-yyW0G`uarE@x7_qR)`55MtWls%c24<19#c$H7mkE3P_`q_a52k;kuixtUI%3vo(aPnL za8PNgfWptsb#|2iQ&0gDDRlHyuQ37q&@6L%EUVE!S`p2+p2lyMt~C6(cureayP`92 zR}DkiK8mw*UZ*~L`Vf8e^;wMn??Y}S{>6@*LEaq}g8JKqA*E=XzCe1NAJW;~3zSyl zW!uNK3cD`)Zki1y78{uhI(Z6QgHUeY6!tbQ)Q)x+L1`N&1x*-Oa9;fu`G-j!G)F$D7M<@J4{x8G~M;1j3$8th{O=m&_0K@J(TI0{-MsJZN9YoA=?3i(N2-?7C+5X`eOg=NOjR z@U@@t=G7_+jn3&vY`F-6h$Fa=(8n%cNh(Grz3m63V1_u82L$U#z3-d&uS10(G|H{!lD-GIz{rM258)N{|4~VoK7vV6$+X zI?vHAjsu^0{=N3jl8lo>pZUf;-t6hV*krDbu^Tw9G{jcwk5yf*y`;cf*YX7GOjWwe}wS|U@K(&)xlYdJMI}Q{38$i{Zun^Qr z70MWA(ate`SIwO4>1v%9nKqq!Ish>e(l&dk3bAp;5rodQMr9+X_{GnXVo$mKMGDnb>E$OwClJ<9}r>KdYFQ_AD6sb zx&D?QQ|Z6}Tv0`SUXpXUf!nAiunx`TROe_<+v>J46G}TyR81cDPjKbQv3I$EU;q4`j2xTj$6gBq@GgA39D&+qKPDDuOl#}8FmUiUCDc**G zZP_gsym??N-}!T=6!zC{c9Xl+o-UoqGw^x-#68(>3=@S66;7A_SW>qB^zMj$GHJ@ z@tu1f!sabQG8j6dj^h9@)ZlZ`hT|cvAtA^87Z3br`nC*C?X~7Ya;)R4bwm!X-d_T&WRDqc5 zptLhU0zGEN`kO9G9D2KpMzJ5aCOsylXScSJ4y6j9vcabb-5D7xNw<`C-~a-UD`L zLJ-Dq84T(X!IqX}@tSwdC&j}~cVkpNEzSEiZ`_Rfeu7QJgBj^WJlg*|anF2)uKwyw zDc{eiX{TOmxj9GlRoOy^Dq+aXHIbg7omZQx^cB{Xkz7$OCxP*a zxe{!l-Ey}b*QxK-+C*VrXT8;Ub6D+L3z#8xNtv#KJmFR|4x^U)g;xpA{jdKCA#wL@ zX4_3RCvYIJ0BdV_X?u31ELh!HgGtJG{db-eICXzp-HKru9OG} zby-m()Yq_;K}M~RJ-%5XFw^m=gqSr8wAiK4q?C`ejmRWF)6E|*ZR@V3)80EzQg}ST zVOIS%suegXmCAp4Y`&7%*;{1#YkvA4X#EjOLO4sXW1B6L2R z*-NQ9g)Vj-TqCEFS23G#@|@Y2pUNSUCy{kmqoKKg$0 zhOc~GA8~$nsC$l<+3ZKf@cPPPLyv(ArFF$}u6mNqXKavqb54wTdZ zlZA>C<{ema8;NzCz^ z_M3u?h4ACQ`|c}gA1rp5_Yp1%J?Pd~Be9~isqqg_8o?uzq-<(7@n zx}mJ0Kv?RNzXtPzl>@PaJS}AfmlKOgZdpi7FN3_^QjUlcK7>&FhTiRr`dJbs1)wJK z<|gfjI5mkh`X2?e4%d|d@4LKKg2ubL|2wJAf5Oa2DGHMh;J0rh34=(`Ez#_gX@wh_xrQi+!a5N1lcS?DG<&^|+YZ*o2n3z!O*lGkD+|sM_}z zokqQ=6U)_!jY0dJAloTWk!S|f7rRBN!-vRke~H%DZ;y{J^EY2L^lj9=AG=$kCk&{# zByfIRQK&o;7sk++RI=|J{b<$DELw4u(ozQZICM?Qt*$C$>96@&bF$&cZ16{&C~5)d zw_z@jGBw<^i6|$r7qI+B%C-l+ zwmx|2k``601x%(u<-{$$*Stc)2@=dbUH*E%eEJ4?`RQ>Mxr=d69-;Q%wD9I{TIf*$ ziePG9P|W;xipKH!9J5QAIOwG%(eBDrwh-GLb?B4O_K+Ip50SQY=4CaC_W1&aY>+Cv$!yX~2?{>pgSoPf)eb z&q2kSx*BN5YWi!7m*I{6opFvC=wvuK>AkyV0O2I z3Gsi|wR%a+o;PC!MfYKDI+`|5a=vy?!lK!~6r;m2mX#>yns2){0w`KPzEQp|N4RKvUCP#;z5+NvK?5#8diG64M(}K}>Uq%w! zZKgR(&pzFyE!g`@H8oZKPuikG!U;H{IWW9_?WIgY=8Vc?G)pv`-^>5fRYln_e$Xdz zFww7(6)1xK{#w5;3?NXCjQJicz~znMYuxWu5u?E&YuD=Jg11&R8PDFlUUBDx(R4Lj%dHlYLmrn*>cHRf+eACwjx^#ad|5Z-+y zVjT$ek`jL;IyZ5;CcKu^PmM7~dzg$hvy5}I6wP7foWwBkJ5kKc#}#G9`&(e17jOVp zzzEGj)p0}H2lSrD48Z4{?{BWP5Lv6iB0BwFSnNy3RN~c48K>)ZxGD$l69!f8q&#YW zpi9Mua9#~=os>g$Zx?u38Gnfe&I=x+m!AE29G9!Lr4&KEYOyGNGUkbsx~B#yOT7SP})KL0<% zdJ!SqjO&sy@p(g7TWqpSZ@xm2GCBBl&L~8gE;{ebH#nA=E#MrA5eE(dAG#$w;=P!E56dH5~%vnH}RY z4LD%n$64>@_I`+qOFul5ziMmyL<()(`7k7!<(gcKrTB*$^CaCb8g-4rcq4w4cZF`3 z|MRPBQNr6vROQ(Ak$QA8ie-ktaLQG-A@VF6(5O2LGk}xWZ1}+ zS^56bwfSt$MiB|Dd}ypMQIX6nrP`X@BNNh;$_zTnNn1a@l-SJ#Q9m#;PmwOndXc99ZD4pnM}a;=p#ewW7BTb#P4Yir3%korXnzVY;&Iu^W^hhxZw$;-S>Bz zcTVX0M>iktf0%B8*|a?zzd@jDKCB6}hQIbU&zU=lA)gspI9lp6Wg!v3ACA0fib}C- zh`1%MOXyJ|0gv7l7--?&CV4sBx9w9M5a@mD=GpvSH~QO3AKUU{z_ZE6&uo|JVfmGc zfM*bMDff4t&O(v(YsXS5Mx}!V!w->VupXq^(%4f);{1x`qcL-jgB}tUg~WXh5)Q)b zVqc%szazP#$Ms!ee)F)OH&N|*aD5mQWlC{UZI>7;_BfT~XHnWE&_)vxrhu^okjO>2 zg8q!iw)w6UD3&?6u6tT1XWR^p{?hA9H6}7fay@X=W2cQ19Fmk?OIJvcyJqyAtCBUG zP4X+|-(j=AC;|8uB>Nnx0L*r#LLaFOM@DWEdA}Nd<%2y8=nGJa^cr@pjM@>_4+tR%~NY z*AXSYi8ah-gUTA1ES%GJRCQeAtc@BsWtgdEcPYG(WxPXzb2CHnE3VT<_-D0jm)*`S z+(r4`g_KKsUY3uk6qCdMR$(hmn&)+1S98$(OHvn+>Sh-sx;)%|sjn7yuo5!YmN(97 z<7b1)wy`NP{#ozbO}d%G7rI^sv2l}?A@yFCDNp*a{BZnoOheOeCAZlgzN@prB5=$_ z3Y*x6>=3M9aE0QBteD-SDd^+NR&Sec*+_8BYa%?0PHWu)V+Hn~KksLO2vEX|6h;nM zb3-JaO2=&$GKuGNk^e<@Y4Tn({H{N>5a}VBIwRFhD^hF=_7)M;bM_V};}TDEh7jZ| zJ>3!)+&3?C`Fu;4Hjf`5TTs9mcr4h@r%-5OQ>%Z$!IyijTEv^#n+B=q@j|NvwX|wK zCAZt2w6nI*9YH_+4_?4K$^3nq11%~lJiF$Q?5GHFYTx=|l9e3w)Dx~!g6+8|zNtY$ z7@qse5cQE#9PNTz^IERO5B=Nr-pqPTMaJ0%7pB+XIgT3$`|wI6V37rDTz? z&#d2)k>YKeXQa)8jlB|Sp#>afOroC3S$9mMM^JVa`S@3mz{t1^e zS#KF+=ysi$k#-`DMbTl&1=;ta`!*y4e!QF;gg`f&hfq(5hC%KQd!USu51_YpQ8xu7 zD|T~mw+|fFjw1*X*NJV%=E!e@vBWi!^ctqMl^GLeM}X}^5+T>f_7PryvF>} zq*~+)nxMxEz80mANg@2Ni}V04k4p~4K!Bnw(Ou+uwj7!zrk_1iKrB)IE;%`V;V&S47&HYz+4Xm z*&8)(gU^ik+ZhLVfRM?6(0!!$rgGk+kFg~oCWcF(UVVTYnSHQm{`ybIz*&LU`FxV= zw@ntfy+LF8`aKkvrDo)h3rZKOs``>Jhe+M=tkq_uuq;-&ePA~w&gHu7$%v@z4}6%= z#xL}Aj(6+hGzZ@%2Wv{XlFHe5!p`Cb6j+Pw{l{t>Cz!G2VGOK(2rX(N=EPoW6~&L} z7MqZ#8RQ%-%L=qUtVv{n(8!DT0qa43QE`G>YC2UY?(+xzJf-c3q=^6v@WbBAK_}Ze z+U#3iAK_OQe1J*d(PWXsP2j7Cp9348-VmSGe$SR>#?@HfS=pKHff55#6OHuN1_HrR zsBhyUs&2n0a$op;AiDJNSuZ0^1BD{v$!1Ihh~l$XowSq?8aW_Cwyt!{3>|ewM;CFT!fO?1aDcpNL0_EZN0=mKWuV8BTfY40YR z!L6q1kAsAZEJ7ph|2yBZWU%fNLc ztho>hrLX@MWHQ`K+mwkqV`GWd%82&lB8)elU$b~GUwYcQDvx}{J(3cd4r?;W*_%xQ zmnRi};%^eU#08TlaaN;xSsf$-p?|h3p6*|cv945Gh1Pa;x(X0Hb(}s#er~P~ubQ}) zE=bBHvKv@?3KVd2j8*@>(Il$d?CO>>auC*TsVW_-enb9>J_;NobKTE+9OgUf_tQj@ z>1U&BrsUukzU1gCIRRJe6mkDg&PTF$#fHiC(r>tc(tH@Hg4B7gA2|PHCCTa!b+zhk=sV7KG$u{*HeCA1h$tX7iAk9(=uVau zJUS-OHP{H8)1Pia&(Ie;m*V=vNi6m6JohlKqt_6?i?pSJy$C_V3^-9*0OPKuEJ7=* zbF!xergt{ebCEL)Cp>23@g9Yv*TRucqC0aOW>k)(d7ARs?gZs01&r@1(fY8TLo+tY z2`^whP}mjs@`NjVBH`hB&^M2j-pE)as9wJh^J>xjHJ^4|b3X0>&c)=r;oD~5Z>=v~ zg`CGCjSfwOz+IIv)<3L}>RlVpJRYH1P`+fxTJOmX+Tx`;cx*7WU#ul&r!h}&?2A$# z0Rz3?2Q|`XE%<{h@w^F(h(@1-sbm||Xdly+Sq>Ps%!7YJ_3roL^BwhPC7-sf)EH&k z|ISI3+-7FJrg{Sgz zDAg{lYkGp7PXOtNp0;8tU8zYEF(T`0&G($WY)`ijhShmvw7$2(Dt^CGO{5?4aiBu1 z_=j=kmxrdOCR{kexg-ALlzn=q6UnEub+9*?Z`Li(2~fxFOk&F@2EY6uG>oN@Y{1XK;V0RoD73S_r^O=GAC7C#!qb|`G-4^Ox5 zaeQ%3Z9-HP3(XXQ=4xwTUhCgizPuI2n^i_-JNM9YT+edGn1HJOOXOtigI4#EmWvxM>*eeASYU6<$@u_gK`cQ&=6 zLxKh#3Sw&qu{s@zhJCv4XV_fFj-ZPxA{PU$_!7N@9!MxJBr;~vc=0wXC3qq$*X>tI zneRTKCB66tEp3~buUU%ZMM5psZXfFGHy&{{7%#7tn=~xw$55RnkYFB z4-uXJ<#67;(w?{cw@2SB!iikoSsOqaU$QB?pthptk7I(7r7MmZr_o`7Vn*AY)JA6L z*jqYCmzUSA6#)%#RZh@KcE+eXx|qA)Pn3rq$p*z5u_3qk|6tk&gyA5aF1R(G9%o8H zj#F$`eqRMfeGie_sc&#vcJ34`K;w-DF&O*7mKGb6vs)acqkkPIKbR2BZ z^p&=gP@w)?GHU5h$~GA|9SO6U)nsEGn0*0JF1cz>a2d;BJO6XfISgN19n=xA&;6Fa39zklL}YMEN!6t3z|qoeyr%O8uF69B z@$9bc&%V;8LH;8(7YQTb`@7APIcwvHyYoNKv>Y3V%>5P@OvKlefu*4iyF<0r@t0AkYk-%F?y7R+40f32GU9_&V$l}OrL)+Aoy_t6X zA(j5+@`B)AO+S|1vs1cQ<7g(Q^-DvKQN`lL?jVQw!*{!?;?-|p>zG~oNj8ym9>@5rgNwoU_mCB8+OFOUKNn{b8NLGB zCD`WPn8N$?ITOdJcoq$7p}hhG(M{A}`X9XqQ+S@`4}A@Ksnh+%u_MqVNgrJA;_5zv z(%je|(3uG=&a=NW_IiQF_?btN-}-&`*+O#_@&gRyB+hZOcG(D$2dL2Gb*xfXylh^- zK0xgBaR*Xg}IYQSPpXol% zeVZzrhWc)s`%gt@JY;?1OZlL+0qyt~T<`bvufgdOXTytpM~R1!=V^{a5mIl_llH*B z#>Y!u^%K}C9H4xPsCd3KT(~8qd84&)xqQkN8TT-ZWRtMCc=>)7_x=W>N09 z;Uk;HC(Nw2O;_=nPSJq_h_dE!5WkV#TLh}A(1&0$NG0L*IZD+Y8#q}N=9;5zue*Ru zu~Z+sw;bf&qB!ZPHZL90{c@Q-UdqUzu6vDo((lOfv(MWbx(lNd5!$I6>j(B)Fvk#Z zTPl5Cm8U3x+WZX5nC@}&3ttObxXrIGk`rPyCA8tW!E!Q~Z=X4?my*QzM7G=>qH7aL z@_8cmaGmxj$tbXl2nAzym+sG1df2{*pkjBitP*rarTH8gCmW@&P74X1P*v?uCU2X&U(Aeim+$8Ho2`>Sib3q~16(|vfCF+m zi`ul+R!%N~1Vy&itr+&P#gT7Ww(GEPMmfV}LA|wUWR>DQIMffhzlpT8sp;r6+Uixdjj*R} z1PK{vI*!#OEb79oq}g z8dB&>7#}xdK4b-bHVr0-WG0ddiea(W1Q!J~@bEm9(hM%oeuE^G+pl7g&Yt~59gnVl z`<^8EEbP{PUw$^43Ud-BWY4df=_E=_Pxbk1ejA|zk{un?uz-e0GxkGd zNiJ44?Tj&&%73?`F}TJ?mhje*cifn8*N-h;g|;*HI3q2THY!(sTXj-35NPt3zZ}n6 z!*uS2TI-hbm97Q5RA_XgJ4-Y^OQ#^}ks=wV!z=rE@Z(Oi^;ZF@M-C~NzO2hX3@1Wj zwukp@_Xq1OL8M@g+@zR$beIQ$SRVU9#l5mpPi2+*Fdv18(3zAF$Gyk0zN^Us-)Xs#w;vehX&Wxtx@SmHJEsm!K6FEo4#<5L33AR>Br%12R}`I-zrJd?=S zeGO+tYiM-BAl}DEW68#z)R-%z(2X*3e4Zc~;8jEk>Gl|$f7_RWbr$6S?bm!vo&Q9q zoz!akiL;WtE}GD$*sSO7tojZPvX*Ate$oIGLpE#5W*b%0EOcpM0`hMCf+F~Gm$O>& zx}0sw5@kw_)^Wp9uz#G3;goE)n{!8j3vy(gPw6(AmsF8+mu*B{6>tQJ?Lp(Uq-&0W{(Il$0M$X( zNdEJ<8K&2G6*K8woJ?1dPgkuw-|A zNBe}mkt3R`&6xLYQmR@Xadr1`5eJR0Y^8Ztd)}Nc&ixe(2@7?a&S$Ce-d=EoqZ@mJ z*enQjO++wf%#1+o{hpge>mG_>vCk{Y!iJ;?>Mu4n2s;_g*lpD z8-G-eS*Vy6Hf2b!ONd^5;{7L+34ACF)8=O(rra+;l-!zm*{sBk z(!%b|Z9$fRm$@`-OXg+XtIrWJmcb4%51w}wvD_DG>R)X*K)o*CTx!`smBab-=Uap1 zU}Se&=`RGtFx#{74ZkPbUKn>B{G!sqKAkS6Q+xv#_`3!%JM;SVJIpsXQLK2!{;5)V zvjBmN;EGDPcx@-m(eC9Wij-ZH_1-(w5Wz1Ku#5n|u{RFoBByIwcewmg)!?733*zgnRj;`4Mk0&8L&p?n z3x%NiirVq!sGO5V88R!{ngZwBo2=!I5RHLp;^4Y`?LWcPAzWYOwEO;Q`sL|-EFN#TLn1dXV0!LxnOD*YFcSlRCTDBD-e6)Zl?ThQjVn`O)Zrt^Vrd-`U`FtDwod2Ci2nYk&Lnv5U0@ki%!h+S+r)e?!dUF-gx9o% zm?Vnh$4s5SvF3Bq&Z*r7pF2dI#f=@!kEh9BIx>emeJUfg7ik4ewS8}{4%J0WMY3-{ zfu%4G4S4w_!EYd6$1 zQ%cg@5qPV3dr0YD0=loef5&dvDOb7BdpUKn(6)EBp=}Z4$k2?OrE|P0^D#|xL$;i| zmfT+jQTcS>N+xDUa<^Mq#a<6m$q(~kTknGb1fLh{?;4czMh*kN_PbRJ`Hi}`!njjg z3C?F-kQi$CB{Lq8%rRu6Kh(+q*0Y8W02uUr=S0YOmmX2bFA8J&u}`9cv-A^5$-_Pt z*lO^ym(2Pg-=b>G9Q?H^AGu<$beV;$3TYA-(lzCv7>D?{KUGZ}K}tZmkcN#{NJChdpD^PdtbS@njl#2ag# zR^NQvn6C&kw$>`7O~;yLXbC30{OAb(a}Dj)HWz9@ZT_J4tKj*mG>V6$UxXaD%;UF% zSk9WVPmYby+$opFF(D(Ial!k;rOH0z`DF3y*)QGo8;dc{lwt_Tykuj%#_4Iv8Y;MR zB9#U?!P{cTIhcjmYyMrA1j(l#^GK1#TC*|u@tGL2CrwIw; zgQjv^tz#$xC@OO$qF+6`v^L5X2l7gGC^x0BPYD=$RZ%=JANV(1-Gl2)0@`xDvP4dX z9VT6)#ok<`4MCqEC^Y>07yRnZR08%-n}0dJ3BBI2yw|gnmG^`bxghuz%C;GRxK|W4 z<&Eom;QK&RDDDsBn(M$CAsAYT1S3x06dUj^tx#Qo&(f0N;2+gwNMOH^Nt%hw{&*f8 zGsaV;K;{A)F9T31gF(r5ACDumBTJzUC@mmi=XoD-SwtFpg+o5YDp;Eu+9MyBCa;sF zHim!6s>^yC&~>4xPpmS896XcJ6u6IKwTY)b-R;D_l$pQs9xm_~`DMvSjNX?hckFQX zKB$~2j`EI{|Kz7qfzC(l)13j$35rRSW()SbBZkK%5)THBEaIhdJ4>NX?AMOQkJ{;> zM+eVly@XW0O6nJy&W{V`HS;&4wH75kCBWYyN9L7oZQcT%7GyrDaf~9VbB;D0`gJbz zDZEN96{4(u-X^G_l5jVZ7rqWoD-Px~3%)B9OR~zw@Yw@T(u)xyjgoW6Gg-_P>(>LJ zQNG-QKn6KWHG}FFmP~zSB-2v;!+JJaif^Zq>8y2{Mz9Et*M3yx&9`?MXdW+dH|QTX zqdqJYaM>32=_30_UKNRqEkNJoF_Z)*k?DH)t!w$04zBO7zfq=zk3ZYEzqDEoHh7xX zT7sOR6i#KzG$T&_ZjNrXv}xzlF74|dh!m@k9juC82WJNQPpKL@av#U49lZu1qe~Qv z%kRQ`Zyq2c1woOnQmq`!jY9X(V;G;7YS-w@H%lK@l-?Fh+BrM58sg)oXwAQwrxXQ*qLg_iO*gqbNexF?CQ@Zv!M5*> z(j~mQQ#0XY{M&KPhkdVaMYv4B^+Nb5CFAUJ#Mmq{ZPs#mLFL^?^iuRzV+7sc(^2mn zZwfH_IW7_EegVii2Ic@!63UXoABnNA${~vjDGRy{;2gy_B0rRlCa^?i*d(!?GF|7( zozp{18nExLgK*SJOBvxmk}G?k7NdD=hN`7-{5oF`F z+4(K7GE5(jT3HSIY`Ft|%Q2$5Z0F&voNdZc0{<5xY>a)HJ1OcHQRWf#r9Re~rR2w$ z!mLWIw4^umMdAfmcQ{*t06d-dN)|~Q>21IUY*Gdwz!xP=iu5cyMWpF4Lj1mRmQEbT zOrmoU(zETzTaK9EI|B9YeBJoCD%}~~Y13%HH;lpxe0uVQrhRitws2a43lx3Ksv@wc zZYx;gb=q1~BAbQ<*R$n?^kuY>Ib~6ZIYd(i(5)Kzzf9-_Eu7J~s{Mv)EvLq53+3dQ z^!L-y%R(;Ql_UEYl6@%#l(WQ0;oLmJ{cJju9#>}?H4Ym~!fIo*SDFcU%l=fbG}Wb` zmG(WeA(eBc-M9q$K7iVQdlU<+x{`bLDaZCoVSKM{1QSvTB6jsBc(IQqveQzLZZ*%z zZy9`T-Z#w062_1{Y3&SPGqtHdNwE`Y-~uKL&g9>PlmG5_A3|9~}D8?|c4e80$ z6sJxcvkfJ{=oDjf0v^dLYPPH!QD5sP$+W)p94u24Wn@9yr%UkqOwQIFg6`aAHf=%= zF?RMS8R#)|>u@{8-Ocajb8Z%L)1%QaTJg*zxfYipHAJ7&ky_m-DMV;psbBt8Uw{>y zwly-edgh@+t$bP>R5osc_GGec+DL1%O2I72-iYZ34KB`|KtRlN_8>u%fyI_YU>TyR z0L|kaH-i!i=<&~t-8rE7xA2hJ=^9FKIkLTra^@*v1$a|L$A;AF((-g-$ta|Baj}Tp z8i!-$Q5I{U8lTEhkR#(a7hBNSZZFQX{J;nHO zQ^G3$FwSvGMW}MVz?J^}cxDRqZ8nMwfcYhC+M|>elQ?h3-o`}6;B>y;>Gb*?@4-d` zTn58gg)n(|iSOPscJl|w`Dt^^*r&n_V1bW2nU{YT?t4?X_DSQiv43RX7x4!(%fmA72`x^?C*$$HvU~c<;U3KTFMCQQpC{phkTSB%9f?=RyPlB8Z6-g=QVER|m4z5fwqPKKe1 z7h&P2;8vrCk_Escq=6Di--XLWGAhxKF-2ujG{pV#+?M*uHyWC;avHhAY1Z+hirt2M zpj`Q4(lJ!bfObihaGRJbZdge^TEd4HJE!kv^nJ$B`aXKcpRk7nXUZ=;p z20v0rk8@8&(A+^iri5GgkxyOhi9GuIGQlxxnV9k8`Z9dxVwzRP%4CPCig@R3iN6!< zIgUm6%(0OXHQQ4O2pB(ao*LoebVauO{oO4icGiN6}svlv}aupJJFIsf{W;K$vG&+0CGIZV6tB1^hXU=4TKJjKbKHKm{vPnc8|c zeJO2oOu-NbsG+xkVWyC&sbK-3Wq?$2xzm$!(rGR)Hs<5u(we?bChIS9J?Q(?ij%pz zhsI=P!S-LJVxZM)8X2nNu4bs($4aObx=Y7pr?gxC&a+cB{*~0oBc^+X{i+J1w?N1p z#h5)iWwX_MSse@_4qc;WZMihVT3!3VSxc{~BP&#LXClmNaUA zc^mbR{gVD&>S|aA$a~ztCPnKKwZ(B`!mtSgscEp4Cq!vRr>WL56h>+5nMaI?L4}OH z&@&cd@lT4$Cz=kRz5GE9BQ@(%^m`uA%5aZTCdwJ_dJrC=E=g>j1jXW8t#?I9v3ekm z<6**Ji))QgxPAxm%87X-qe$-N6{Az1h_B$DPgzDAI`^Ylq zhv+hJ#@Kt>R40dAgGoJrJepDST#Z-6mI-I4r0q>X&n$0~)P4raV{KL@L^E%mxY2^T z@p|{G0pP&H8OW3IZievRHjR)T{;PG>AEf@z9x$POu?$x#xHH~u9r>3RogUusj4%x6 zITdKHPti@a@ylv+95G6sTc_Yk<>K&lhnE9z*~U+kTDW4q=>S{m>u2>5t*anaU2$Rc zp^$+1@4^VlheYdF+kU_Oex$J#Td2``RRGftxe;#oHy2Rm5HI*xNj5zywmX3{E--gI zWP%zKs?T>SMH1Ja)9NNlRyn{ci?u%^Dbq}$BggC<>ecS_JGA5VPLOry>xe+FonY(Z zWcpl8O-zXJGYc2~)1Fb!LWqy*V2sB=+~}uCLqWDH&$94vdbJ4GF?p^;>)HjVgT3YN z1#I7IM9b1%ZMseBPFhvAGX3M!(1!%zV^jts{bPye+=d+z@AJ(HT#)w1JKf zqI{<#hjD8nnLS+N4ID`BrTv&=Sv74@wDUqer-ge2vd;y@N!b&(-NL7f#-p7Z&&`t| zm(}E^3>%dSEv%%*l`qeZt=$#Vi2L}js|h2NJ&H=UZuN0%CqDs-82BqTrI`R81fw9H z!LGoRPp(k>SW5Jw(aLZzv_Ok3c07+pOQ{H z=d>qlU5Wuy`CIhjeaFRc8xc2V?A3m*qc!DD?;N_oimK>4QM@2FbUal?g86x%>R==HuK90F&uorN^U( z!btrKXP@O|GYe`L|1*Aie6NIG(u7X*310cn^+hY?A-zhi@m`ww5vQ+60VT=VcBr*^ zdUs0U`WP@3p>-L^xXgHLg>n#IeI5<|X{nXs&*IVum(l8?Uv6STWIi4&f6Csat2?p6k1D$M~@ z_p9E-R;=Sn{+%ooqmh8x-OfCNu3`w9HXc#)VhZ z?%R3OQ-N|Yb`dxpE!f&X6sy-;@tf;bSfcxb2&V586tMKaO)2VcO30P|4BZP03TwJy zIKN9&`iBL3Enro7zcGVTT5$;^ej76Js?PG6(e=FT*fZpxq1~16knozt{lVHuP)50z zylr}{h5cPr3HF~+hj$<9F+l?j`PJ?jC-mWNJWx-L$Yk?)3*OPfciq*lDRhohN?P2a z06kvE>zGPqdpWHb^Etixyg02i1pW{HKxR5;Z&9+>vT3{B$K?%4DA5xcDeYp-0ns`D zw02H?n#64%nl~KnF#9bAl7-T9Fzn*6(zZLNUcah9$%;4Ks`)n9kcuB?Qer?OgAyrP zmA9Yx2W+rrc*4pz_8Wi0*BORJq{NLkG|-}gzZ23ffXP_4p*5aMQ77WX%Kodd!;KS5 z;=?wl$*!Bi9}C{{lh3hTW`1c>;#z+@i3g$8-}0K=F=ZTT^ax!lx#D-vdW^(=itom6 zd!uMH7R~(?9Q5b-A}Dr_bBpqf$;}Qe1~yD1M3c>LVfae>F$OglNR}dRrAfNL zFaP96zAlObsO)6yBQS=4yxzkNy?m(ILtp9gN>lCiymbk1xu|DaU_Q;+*OJq3B32S6 zLW!WY$l4H)7Q7MVtIDqC%=K;Gbtg)P4#yznOfm)tl!8mD4a;V_nP4+RgEolm2&Cv=*ZZ4Rvkit%d(MuS9 z+4il;Et}xb(YH!6p7>%?4?SB@RlQ!z>8qCE$5-F9CyvW_7r0=-^cEw*eO zlRSpNRIBO_=bKn$**$GF`)&F0cy_GB3$C8OZ|yPU5J_Oq{I8DeZ&FNs?mG92-7oe` zYG&kSW|3BHrld*v1T3+6MZf(fcs>#(pfiPWZEHtxlyDJ%vwy1!Ipg%f+xvHCWHglp zHmfw#P8W(x##wfyc5o+hm&}?|9p9eOCw@a;FU7jF7}&kGZBcDg4f@ZL$awDd5PVp6 zv7K6uO;Ka1p323O2+4@oO(q>@7+t&>j`z}uF*SI1LO??@h_j%XIacdzj?kCKTA>1+ zuNhSvnwN}yR6VxZejXGLC&P{CKnu{Bm0Epr{F5M;g^t^&VEp%1(sFjBc;tfeH$jmQ zSwKBB3X63sSYx{U39qD&O9_B3YxS;#LvOcM9YvQUKX!(3hIpa8J$Wh+wCs#sjSblj zM!Y%p+MY_)78ng)2RBwLz8@(Uzc=q+=8-vHRhz-=6UTJ12~$9mv)oT{_nZ>v7&-Y; zwt8*Dk4J_%HQS8pvh`W!3GHOg6R-s$atvjGGOz64<-+t3uM#vz_a{1{<_GNMK8Oc> zWpI3=j=#1Q?kC#(iL1xli-IETb4sR4m<0%R!J1EK4i9vxnnBp74Cu2DYNtTQ9QO6N}r_;f1FzeVu5L6k(C%y<%+W3mZgv= zk#`O-Gehtyns&L!F=UhQVB+MRVhYbK&>lBT`i(O9#TOr3n&u>|%~DaetQ9CeQNe?^ zWLF0G;nH=_t$0HcIl_xl^-17VwEsvK3q$}qQ3FW?m`*(8O-wK^ot3A}-49++ZXADH z29?iIxS#qg&bMqaF^CH>~Lmy{RId<0~Tp+upJ- z&DWwzW&;qOmx>Q8r-zh>4xk7!0H(=n72-stkF`9v9%O8>$q>ip+&il?v;-o^vv(&O zkK5LP)0(_l3%tF8j)Ta+)-Tgk`x5Syhb-5%+!s75KMOV4zY+Z26@9U-<*tJ#_J-^& zYtnj;$7Tf-Z)#1>-8?ULVwKfS^7d8g-m5QqSYl7HUK_b1BKCDGu4;(sWSOO2d-OO} ze$Jz`BnERQceupKB^{l^-w;Q?rz!tbxK- znW%e)Y){w>Oje2EUVuva&D*PQyT;sRI(;u#P&0_lyzMfRD1^Q%76?as=(#^?EJ35{ z8VRgakc~~@&Zj(GYF&d#uTgij#^|v*L{I}{|F!u4@u#5ry6w5zvVk|3`(#8qQb(&0 zXDd2l^_ctAMHDJ=K7z+%-O6^793IG<1k&kSGE1E5@iOv0c?p*rCUG>*_5_?~kO>XnbF>#@4V;R+% z!3k?hPP{@fvhZHG#)}*LtM6y%q;y|>o`w&< zx`NaCL`qb$-RX~GcSB_t$+~{4{F*Eolh@7_mL`h#<(>j%i}~B7foBJk1m?WBuby}S z?Y@6hy-FyL|2Dw)M&*RuW_s^a78k@xLsAN9m82qbqwgh;)4tkUy)^FBmZaTGZX!${ zd_N|5^G*KW%naBwP52>)`+9}?^Jy>$=Vh>beH?xfd#E!wC*(~+U~bsm_g;?%{g%T& zcSgF!Q@j4WNkdi}9BamNT);goY3QDHV(nBZ#z*ye6zI03hD+>htR3-28Cr#3|7w1u zf{b@Y8lWW=t8#UQZi`~#bP^sn$NOw}$)pwIpD{TrMQ;DtkkPFcL1W;%D+Rewdd>!TR5I<3o6;LsD%6AC zp$57~Z%s!2fN74>0HU91+S4T4KxiciGMa6&ur20BlKM;&Z#&pwCf<1(fM!giQ*O#% z?uX7A?-!`A)2;_2fx$9?E&5}7`#GHZ;!nvg(|ETbwI2(Mi6&J4H3gyvQ(#s0$NT(# zZnM=0Pg81u<5K*&VE6u$XifiqBaMVyF0ihncX!R*7q03jWX@n_Qe7smSJpEM*4VoJ zvyNVLvEuiqE8?XqKT@m-i1uUHYH(c&$Ew3dTdZhLwk%S@3&9fG7?LS*&}{da8oiW8U*t|sIt7~=ruwd;T&IH`VGNU zNczZG@{^sG-P{vGsE%yWVHaaI);{L_a6Vi&!8Uq!Ji^%GHdCyNFva|2MWH(?{CLiP zj2-wO2l~UQxqIXYRJo~lj;90L*QHjD&aK)k;?}uBBPyWtKur5 z0~OPTW>W5s<|&i7WH`ypawU7by2hAu`c%eZPPtpnq$+#A0qIY)Q6CaY`jq!%;=hZM zgiqobWaa+n(I{d1 zl1673e!WFraG}p8OU@m5GYso)k!KwK zcpAUsZ(~NfK8;s=M`MVQfqglOb4Fxda_ouCK69=W5cbIW0xZ2c(OVCPol&ycN>X6! zgIV%(mJJDK+vsK$meU{Rm!IkKNpgUep@G-2hKi5Q>Qh7CmpDWT3EXcch{4F%$4Kct z6>T*-bn6~WYf)HrYy*KWv2F}SI=gBPB~!t}yIQrF#u2yAyiXB*?#L{pxt=n!A8{%>s;(MPG{+eWMnd2YU#k7dcy zwz~YfiS4!ta#+X|S1D63+9MG&^{$+UYYjh5HwRO92RYKMZU0KOzDNSkOW1w>XOEW$ z2|mqh_z{{1wno9P|Je3Fh4ApkgDPP|HRI90EtY>GIU#_Vm};2G|JRZK?O)&yfUW{@ zOh5eBf8EXh$oyYEk{@OVRp)dl^MA3_|0jR@XQtW_z(Cr9Pv8E3z6Jgm^?(5e1y26oGi8 zvqE2Ss4k|D4`hwneG^U>g!He1LB{dgHg!qtrV&?mJE$h}bB6sXGgXCI#({4%+@d80 zq{tvq|<^ zpPq=O8kzv=1X2^^`Tp*uqsb5lqL~jkZJ2Q3$)i+8!yqQU`MsKZuKpM>ll3CRG^>99 zVk!}Btxm-cr z%r{MqiM7nWCI{N^{V-HglgTfp{!S`7H^2^Bm@SPA)|R=uuL<7k307T9VXzjJ)#!Zq zc74#?#(x-jAKJ?sI|E0UZ5zjPNRi&ReaN{NysfK0yJ(T0Yp$={fa<>IJ3wyW_|YR2 zIq}nd8j|>2ZFkb4wS78!u~ zS-j*;s^}6#O?<_*$iIK~9X!aj)(QIo^;FGm9QtV5-|>R6#Nb>2u4VG)DQdE!;8pj{ zN`r3lNVX0lth6Tb+4B^K$v_j|r+9KTX^A+$4GvQkN(tu?)(&nyF#xh_Jjiz|?muyIAQ^ra z0Z4uL4g111{>XXQW+mO3*Bta&@Uu;r;Q_HUS)#ZGDZnh!C1|zR^@;5OT*HSDnL-ip zOyHCSvB?AdkkruM24cZK*AxZ?RU7+WWwPS@eZ!<;^6uY-AHwlkof95FBpMWLKu4ON z8c#fZx6v?;BH*75JYc-SNe`mO`hIt#=tDo3bUlr012RXJqG{j@4znKsjpajd<^!OI zgmyA1#ggh{3m2co(SyX&N9Ub%DfgjF9794Ub%bZgB5DD5j(PI>{z}Td5r@8{+yp|K zXRqEG30^Kk*qwWEPF7Eb5~p;$D@t1yF6M{GpS_NF(YQ6JWpTO-(G1tnr>+_?(aPsU z$PwsT*b*}P*i?2v3rTDU+?UCG7k>~nTT-|HhKf4?LAru6y(;UA`7O;d0 z{MviMzB!=0>F%kfnN4K5Gw>sf?2I~|*aW)h-9>yof_lF_m^H{s^x>1H^{c9bAfo)w znD^IY+Z91YC9rr+?~acz7xP0w4T*dSH`<=gJ4eCyvB|OH8ftbC$6Ky}KIn5qWrENx zIiL5&m1h?X?wdVQeCsdm_XwBt)|f_lh>hmRW`>ICp-bwz9*Z|agWwU(DF+ODN-jYb zDuL^9LvzPGfvoe=x%(*S+-J@C1BedrX6BbRu%NKz<-q;LbIb+P)jm$0dCM_)@tLHL zREga1NxIZYKbdXA;46}8>&h#rNnM9kca%hbm&;3FxpGAEU$QhhQ(g1>vu&bWtQ0rx znD)1xBdjL-lg=TWf131d6Yml1igiP^m2S`rKG{JYBr&^(TA=`(v83{+W}o-@%GJ}$ z;@<>SzgIn%cHsRA zc{8>cB>yLG?*Sr5>iAQXmwOnZgyJQBu8Di2#t!fPgLwVoxoE=5oO zJclh{TFvZyDS_)Ws|=EGZ1XtMPtb8{f5#q^5b~6k@&l5>Z^(nUu3|T5Y>*wYPxjhuGmLPviCy8t zC1t6UE^v&N$vTZz4#U0c#Xe`nz2~fr+RXWh?uR)kS~9PJ=9{U-Pxl3sr?ApCBQ3GqjcsFSg1hMc&(qA+AhQ zsJI6{+TWdT!OBBt#_tZdwv_wZK6ti{Eg|aLmY+>fSe&}zL=*{hfqI81Z?sdqSKqi) z7;Cz=;(3P!1+2X&yFO#tGZ+MpHbBHRp9{6qIGhCkDh-!NpS!oSZgZT~IwP3?aULLS zS*~Z)w@z^C$U_=Wpi5H%nP7vEKU~){q)*?swuhJNRt94ipU-eOE)iw|7A9z!-ey;F zt@F~@tnY#lmR(xEx^+N^AuUNQa6Wvyc_6f~r*T=_VM@F$m@K_kRYAHUH3sB7$(`R- z2fdH85nBgC(G_y#p{fb@H~j3a%%yvgLPG&qpxE1aM^M*%nvb*HQonBj(6FH=VGibj@sGveq_a2z>Q$im^e-Jv(D!E_2j-vv52Z?d`)hQFWhV8cF$S^%PT*}XT|G3~c| zn8L-K3GZ&An$J2dt&WeZ)JX1Nl}o-RXB=x=LBW!jT7E4WmBc%fmWC5vE&eUmb`%Pl z4NHTV>I-JrgYT{?Dh1GxQGxgzQp7&r`RZvm`PLuh&)GCgl2=41XSZbAeF2=Pj~DWy z-!(#j`r?AH^La6I3!L9orT0%TSuBkXu=P-#pVL_xvq4p!)rPAY`?Q|#b|2@+{#1*P zyd3K@47R#I-Z}y5uL}TW{eTyAOez~ooLaH$KYIa$(xDQ2#EFb*1sw`Ftl6?e-n~vh zuv5WpVMo8To$n07fyd0!IRE^_`udJszC6?pFpe%O$-V*T>>zX2UTUx1ufgOK`On216fIsUwme^X|o4(ng zY%*_goX4D}w%J(~d0jRQuFc+4y)6F@t!_pUbckhIpf=yZxqZ_o)C;A7OFNuj&1UZP z@|(7t+7z7(V^FaKdtFbfkpak;L;+zd9${J$gSzd?liNrlK3?bGA0Lx$g2`6h*chOm zU%xITj@Tw@R+;ebAz+EK9p=7Y^k&s>?0$?6(j&bcy50V6K%hAC!lS4{YR}Ctt4TI!Vz72!hOG>CBjl-h zsePSWQ~3v%;ASB9@Ch;o-P=ehsJf5zI#Is1|5M+g*fU+xvbh%LFSuH*cN$VY(|8iC z=i%u4rl?SWMvrl`sciDGkylz&G!(ZVNW>iz!1y(DmgT*{`B2%0H7HTPYNUxe;~}Nj z!YfV(hUry`uE%-vDqLfC12S6MwaT}+svl5qXt4M9S=Qps>5Dg;_tu`(h!mcx zz1Erct{YLPjKA^kpe%PiNgPG@$B-Z(V-o7Kb0!YBS+>3wm@KpPQ8(Bn-%gAjw41Y> zzPq~0pIF%R`(Z`ZpHswqZ9eePgAm=}Q3}joLih`AmkW;9B!yzV^Gb)&rA^z}&JtuMlLwY^|}UKCRmo4xx( zu_A{2+2^BE_4B(>P8sRtzMjh4p>q6}Vz> zmZollbEz3~dQ$eik>ss37g71gVIQ+8Bkx6!Ykxs6{}Np#DUC4nxml4)2aZo`mmOu~ z)QnZLEww|ti9!%3UuSr2_zWc{mo{c?24|ek6p+%ik4IW-iTe3MHda194@*keGbi&N ziH&6Wb$xK_c#8g(SD(KErJ1r^ilSlaZb>iknHGI%!(Qur0$$+CmMG{?+tQ)=mQKnb zPlR3b>T0_9#X+#H$#faAtYu-~;3q>x0-=v;jve^vRbn5B>+Sbu+qDy;`X5Do%=}&Z zp^8Z|x!E>Y+Fdk@o<2-%Btn%(Ggr~K$r$wWq+d&TFa_*%3*xop!Cd&VnNHvSW$2)T)<}yiV3}%vpU>{0$6$?waJ| zGa@fjV&_)O{mCKfF}L>-$$RYRt^3h+qpo$@JwLX#49Q?O_ENO0AR>T)^M8nY=kGY< zwsEjY)7WWjCykplwrw?OY};xkY^=t%ZQHhu2`4so`h53&cc1+S_NO`LI&|HX zuJ6)z$TnuuFU1>RNnvXBra1#LDzo^zS-P;aT(6bNzfjLe{*+-eC!B9@g~0 z`<;ZFDmTvLavx)z0(C+YG}P@~khfY$cYN8-Xkr9(9d5X6g*C2WZ=0bAiP1qFtU0%@ z??>-1xn2S_(#(cIYU>k9B3M8BUne)6Lzymc3|t&OM35E4nhoIT&f}`9FyR=FGkNS> zysDNHDH&hDnUAX0G;8~tLv6dxL~W_y%GbOIAGE&-n0v&Ea-_ zt*OPyV@7MfEizm281BmIMPVpU{}{b^>64a@h*`F+dy_AL6|lVA6IY(`-bJ{|wj;8! z|BM5dq~d3mRgLRQs;t|Hh+(+g@w)4GZnB{#rn4>G%@NJHx%t}Y_-#lH*;*y`tM80R z@KE=j!{r@K1a)Gz8`S-f_lJb-7=&RTSPcVVvqs07uiUCZ{#%Y5tZ~?#b`EMsZPXd^ zH9fwITOW<=Jpjm8ACs+sb+fTHjKLOSPt7Y!1j3I1r*)*!`hi8VGqgxF-)5rsjd&-z zW3h+t&Z>Z@j=AO@`~EPxl!M@^ZN?_-jXsRb0bOU8G9V}v2h5r3;5Cp^{qWT4rXs5z z4}3@$5+pmy@03Sb26hxx9a@0?`(~BN!qOhMZWDpA)vxu>Jf(>2r_t;49eTK*)sr2{ z9jpnad!*06=`L}Xrf!$c4G}_qmR5$W^O8AeO#1e8`x7n;vd}4C?m^pog01QZ+h;gxKyVQHpkx_3<@SDVcRUgvXBa@3R5Drs!*= zTyr>opM4OL#wx{5X2tU2`sGdIOh8z#H{{624_E&h;0u;V6t6SD3ut29(XzRRerrly zrXX)@qkUEEk8GXdy^^d9H+{I+n>_+2hKw~Zp*aOq&I!+UO0a95M9~{QdbUP% zHr?p%G*h1b+2KQItSAWta9Q#iy(mzinZvea71G%@x zgynmuN4Ku5RKu5{ze(vD5AX<$GK3aYj8}uQzdFUq(0x-}RRNjM+O>c(pY|QZBEi?Q zb>ciN8IEf?iWo zrT3!9=#8Ithm`qx*`=+ED1z2Xx=}E0)qNZ7TF#L#!q8s)mNygJt8_@pB*2+T@Vt}q zO5{h=7Y*+H7ers%=0nGTvQ!hA^+v}XuA){Or5uLF_)#yzu*SZ?nr+nvaNd*EIms$S zLoZCdB@NselVN|2i=F&*{>Pc5-OkSdyP3bb>`5%JB3mNEKDEaT@fe&uDsQP3`e{c8 z9a{@tu|nD9xIyl(py==eSaN1^cwW%Qzz8NeUd=R5Rqs0Wt`s$vvRCo!a4Z< zGVfkRZ=4%e(PdE0GQ8`f7?t#TRu7qbG}ZTtUKq~ST)SvK=YIkkCG#J69<`78tuOnS zbjpXbTrZ~P@}Y0sCrgGJPNgBA;f`*4>-_ZZpPqAUyO{S$%JU7{RGOdn3nsdP;T$?- zGG=+uwc4|!z{^ICE~sc5`_S^uXOQsOKCEn+C_sKA zv&M*dfZJBZc%8OE`1=-R8HiMQnBgjazY+opt@FLyXcd4&1D#l{(2d_iTPvS^(@D;5 zx~}7s4fT6S8-v%F!ZpfM?wtDF*HVBYvR*L#%CMPx2Y0hi3(< zdT!{@A|S^_*zanf9%bXc$9?H?*g`4+n(mvT-(K3)4^zJw;~rvh#v*FmBzSJKgiGqC za=}4#z1NszqwS!4Niuez=Dgq9DL)Ou)|sa_BbJH6z^52McOFK0UYu#!N8v3m-5K#- z9=u)za!j~;jg*ZqetD8u$%GC{IhC=#e*2zw;kf?bYaag?gzdm<&Cqgr zredkSsvHpa7cA)i66tRRZ@MF!-+#PX4#}~}AZbr-76*C!8c&p2PIJ;IUZKXL0`44` z-9~e+$~f}xAZXBB?$8`VzVwv+I>>1guaeHUN^TqXU=Ml!3 zGns`zuxAb?Mjc2Tav~n1nPIHw@sH|_sw3+5nLLx#&;#$AH3d?cUr_j7lf7OlluQ#g z%EItdYcj}P;gOxwC<&IRqis8$p0}3&P88v_!f9|Ac?t5c3Jtji7Mz>W-+$VZwW&|~ zY1>S9pxZV`zi?lN@1k$Zeme)6}z?Y_B;zp|s z>v%iepnfxm3y;{qyayo64BazSc3*ie#4Rs}E;NR-M>Tl&d5BOc2HIC}RhI-4@ z+Wnc?mv?*FNfT)G6hQ*a>{@;KP8RJ1QxdAcjvkO=oD6|n9Uz_$QHYwpt+*eo&lu14!($^*N@!qq!e#j;#H#|$_ za!PoKczG^x<44f@tmjezeG9dp2p52$#tJ{bWnq`+XeKFa0mC6ju=+;!p5*8jAOueNUp5=I{DlR%P;7{4$eYkl_c&xl!ZxSh?}cyl z?PZ65CY$6tf5fXZMRz7(ee$@9i0@jy*&_A4I=)Fy8$?t1tr2#bM?0;KXIh=xHAg&sL3xREU^O^9(|nTnc?+Q= z9^ymn@LF<=7V~)L)AN(Mh;ELz+=y!u?vr)n3?O!Qda;xlT~5z>-v=N+ZrzH`iPvIjrp z(DU=&Qs&P&+s>~+`M*%w$&j`q_-|2WhErV+xtm*3geZ+dxtvKBFZQJ+P}0K0KUKZPNXwC!Z{Ew90%1CuI!>6{;cOe zP_;4%@d_U1&-ul5W}Q$1RePD156-W&%a#{-tmB2^P`z>q8smRiPH7=)Ed7ss3}S3b zl1IBH6p8dRD$GjMnV3-kIpyJp^bKXu;k=+7Lg>g4Kn0@wg&Ws>bsA=Eyb>D#z^P-gvC4N2H8sEBjQW0rtTjl{> z%}dM@HtB+hjwf8fqI2@UqOAe<=c=aKZ%;DfyPb_k@aa?suDyEIPIE&f`u)m$m$*^?x=bMuKZfB zh#Jf@7&8-XPD3eUR?XUv+5?oS7Mc!XC{SLVpS^Y3#Y^1V4^QwK3r#|V-;yyNhun=T zyLMQC3~tMw5@9wxd58rO1!s@;w+FO_^3{(wDs47D^8cB#9BC6!K+j*O*J+9!MQDP_ zY;alhmaqB|T_)A&e8!5RT+Z7q&6O_(5Z& zCtA&r*T;Wp4*PSk zMxr}Yyf%A;1kR~WKJ7T1%O@ZF>fvZg+dg&*Ss})G6r|pvzk+#pU`n%L>{y-^>3 zBHiMjB#f58jWP*jD4D_LyX*ZPK`lGY1Nri=R-lhULF+2cXHr4$ATVaCZFB1Tdt|70 z?+K0*q5bEo&(zzvc$!T{>Of;@zOWKp(_p{t`$aJnp&2iVR3(`q-PW65*U;-r)&th2 zGk9#~X!$oj5&q*K(s$#W7KQWpj59qs6HS!`K%u%bJsvqaW;Nk!f}gcNxOIzS~{UKHkK zWtn9`b9kV)g(mi$onY9(_o|p*u}MieR>s_B`JB|0xX&>(ftQC}E!0P%+*nn$=g&_} zlqlt+Q}x&Ut(ZpS$jxvbd^$d`9PYc~c+Lfn?-LGUPyq@3eca1USJa3H*Ei9R)`*`o ztU=U=SajYdwqKKcLIgy|tOY)0Qm;_p{=tUzF~VeM?Zk>?Drl{8L!oe^Jr1}XtTEP+`KVnb9M z@!25)c+_ju%tN-kNJc$ePu`BS#?3_t53aPw@c&r<=E7?wMA|xQ^iq`Z42FqpotZkT z8t0|9#{xDMT|0mwYdZdGhd(a{9h!eG}7f|iAP16H+kZ{W7k6sd5_0F9d@dQ0AeQ@)q<6cQYWz)&MhQ+J-#{5u z|7qBPg4DM^#!x#G&u3i~^)=;K*;v2p;naPf~UHZ)i zq5(dHeDHRs8b!6nDoplQ9a;bgoP?RlWQ*T83pY}!0T3xmPylyW>}ond-=oydI*4KZ zcnNrV0XEULluX`j`?>_ulU>J8l89g(bIpCm4GAe*-l+P@2VaC zJUYfFhaD%}OAhDs4f!AuLczzH2oO?B*aq;XRhKtm=j9Vh{w|jIJ`y;%HNQA+jl=>^ za18?32i=~grWknd(Xu?;@#y`M`wGqR<&v}aMj0x%v6S4Q?D9YuzjS)~K#v=tFLK~q zU_P>ssi@M~Mr;)wF!m>$LP;oJd9dj+q~qnz)&$=qXJYnVGA)H={+jQH_Dwn;K9~4T ze5XAkxwI&8?Bv*J8c$ zB!mw1PCzfONU+$oNV|aLPLE)gI~RM;UG4{t=L4zes)as6hiM78_AP${6~{D6=~o-u zwtjKRY}!do?`$A4nbE>Nu%!`@Zkv-gScS4HR|=ar_?&7_;EYK|moUlxEX#eTc_RZ3 zf84hbvz=8hm>CcY)MLZ&r|o|6nD=(MfsDwk>BT4DtTB)2RCVBtY__ch@CszTbuP=L zDwjyXKoqNV!3_l18If+#lo1LIdH6VdVXM?*c$6i%r|YB+^&lJ2vU8a`PrP(bcj?+Q$Gg4sclxQ&9%M?DZ9`n|yBx7I#MBFxNGEWP@Y_;o^J z6>-l4mMN5TxEQ~*`53rx>!`;RO(-Ox)l~xnAtvF^P5p)N5oODd{5@Cm;QGz+NGcl> z&aUQ_|8fnV)%tgVQ=g!?&H{#q;io2p^Qm26tjHjFt?Age(S$NlR&)+cEFWQB4^aVF ziD_R!?GnbA`hz8;TL!ZfQf!vuKvr7lA!U(JGa)$U3}~-wjvRggbST2nPvgI`TSv7XW> zJriyo%yCq9$PM9{`t@vIBB`FNi_OOkN*+0r^rY9U14^E>%aaigAj$$HufS`R8b0g@ z_)7Xsw()G`b0sMf^p|8;Xb4rYH>GE(X_xa3Z>svY>FOt1l0m-bPJL2w%lG7y-e`4c z&PaF0+Ny!GAZe`_V#!a#*uxV3{k>EyOI-yRLNF;_$!9P*O3Gi5P{$Rruhij)XZ7tL zNG;N)n~!%7y>^Lw6a$VrewcU*!sH&=xs_uWwp-=VX(#8LDRS)O2dbUVuR!hxS!r(K zMOHG}@_4@Scks$XZP=YDAqR?BI}P#qgQU9J^7Hv1?<6zO6HPuIJC51PzT%`RFPVs4a4Y4k-& z54?Ol?%Z)t5(5qp<$d>M)*kr|7uo93Co$WcDPAU%aVfq`9`>VTGF@8wG`#fGA3U%{HceyH%UtxY0bhPQ3+cQ( zY~5gW;iZ_a?26UzKG1uZ+io;29U=+2o^_JPMH9()%H`9;QF{JVuXvo??F+^^!Zp`{ z?hp{}rI>V`I+5IJH9oF&P3nKKlY@iJ^xrZss^lAo{c$aR>n9;86dNyV zy${mT{oK{_ZE`0#cFlyOKz& zG1HCv8AnI(lix=3Brl;Yxo)*RntzOO>EQIZ>WV)frRg^!_uJfnLJXlHn`y{R4^SUu zK&m3-5RWL2!?nrfb;ULih40=7}}Z->#7Jn9X6y1y0a{U zZ{Y4gUsB!1ET4p=Ee2D5+dThlyw$mjwH<=c7wjw_V=G7+5L}Z@(nH%yZf66@2d*d* z93@G_qYqDmfbQz4;*@1^N)QR3a7FL?dL+=qA4P`eB|xBl*dcX`EdG5p3Az>ab#?#fE%dc1c`04CWgm}GxH8Q(pBG!)R< zXzfIa`;>0Oyl!yl;UBV1m!sgZ%(S10PRD-A)1+6Pk12#z8)Eig<$mw*a>b+LF5Oqv zP11goIK~!|cyEP+7!MXlKDOaej5&}R!D2VBSlblCV-5SF@R^)8{BWX%bFMHSZRjDu zhYK3YQA>v(M#U20aI%ng3KV&23&(vCg7uXMXpdJv_dVP8wb6oap(Z+j`@Q8Uv$mZi zCYpaC9Ip#-osa|P5pYIvmx9IWKM{pND!%7=n(^>wmr@$P3&Ml$T32Fh$nRzWn=GY% zRDKt{Irhf>TXd@U#sh-a4+T+d3&Hz?>0+ZpL2T5YoH9)5JaiN((4@`f(sD+tzcNPu zdgL0(=59R?-gV&+5<(yN!a?UDrLz5C3;w=Xo9gB`tE+`$!m?88YnOUnvb69fiRS!- zNRQ^buux%*i4D8Ol_Wd+`=w8(l|?8i`>pA&F8cbpP3)~wYtPa0B{gMBjDcvCUzGA^ z=h^A+Vl_+dv!Z;Pr5kvc2v;Zx6fmRXg8;FSeNnR` z?}J9(M~H*T_@v&u1M&%5{=S4yIS)~2LJC$wzsxyXr5x}m$4-51{H287U-#|P;;mhx zlkZ!752C#<5toCpDe;@8e|$EA$M+tBl(q1NqV1D+mD_g5xrfd z?QG_gzS7q0brQWJrKl=$Q)zr$e`>+a>wXXDHoCd)Pc1j4%g(AoqJ(jMT_j4mk8 zm#<-jY&9TLbei%?Y|DT7h?&Wm+!acv1I0#u#;~A&#mNjYJ|zGqPGx?pXC6iRN6e7O zyqjS#Me?vOpZ~LXJ9+5Sjz~!Hn+&^YFJJ>7w3M7ZlnFH%--GP*ph^7yv3=mwo{!4%8GrcVwKZgDjYE-RVc75wu>V`Cw?8n~3()gYt z5BUGZFHfGgWZh7Fo?UXO35Yd~XinOrM72s{$rOpVA)hdAZy)5IB60lf(F6m@7KlF? zJfl`dQ#!(S%c2~HSyn^%m>eo9m;s33bCx?M!CAeo3?|AD8(iVe3{Ky5d)M|q);$KE z8f454*93 zO50f+^1C7ZbpzpAvFi=#7%*;^pLIKv)b-S4`AIxLMDShgEMhDvCc5pB@=(dy5=U-3 z$}Es2L4tBx^@r?az|!C83O+7uO>f_5_|J{}Gba@u;D?cn2}%DZDF@P5^+IjX8P>#S z!g-!~({0IwNn-j0N06c1)0=LFI&}D+TVAaUfzs$`Qn5X#bx6U4(D9M?#TD;nh5RNY z5m?wY+`l^)Z5G-GgW^6JZU-Cr$*@|_$;V1YSkwvf&`kU;4B^(8+=5lDYxUDZJ96k|za$`DFLAf1vl5 zh%e^%7f)jgrGKydrS~_{5t4<%kp-B_Y1-2O%*{weK-F)_v?FR0HLI0#yB6{fH%~w@ zFph71@fmT+yJ49jBR>6~A3=hDyo4;k-Sz#y;r};}AtgnCABqDZ{`>#@kRYS!1BgP1 zGxSpa8}9iJ-mw)dGx-0y`zLbL5LjlR=)UO5s`3AZcl?8I+VxQy{lD)18!c1>OtPUJ zi6afu|Ay=SBPFP5CywQR-~Hba`bi;Wr}r-NZs=J53ogn8hUY!3*^m4`@BZ%yyQpAx zc6gk5`iuL&XZi=v#RkJ?UTm6;{|7Vw2SE;@V3Fc{1-_2{H+&`>3GA1f|$Y_Uq5?i$XIkB{! zRIicF<2K2Am@!NiL#tw{l&vpxLrNW$g*p^P#2#(rP^7;@MkW%BC_Xcl!N+t@3Hmdz zwEZ27c0n9i`z&;5bN&sm>`;?%r2z#$MM^#Ji;VYDoNq7;cJVIr%7b{^HanpKE82)MQ4lk-?OH+W7)vF{lC7^AhC-ho?wPo z^_YM;!k-z{d@CouSozKIW|E~3X7KOqnD-UivH`eYpDnRRPN!B$Rr||R=mtLWbkM~r zwI8lJAFm4`-XS_tc;t(JEHdTBEUAAbguC@MB%|z~a1W zK&+ zr(}nGNweb+Ltu$YbbN%ijxgy5U&oL0|Gf@C#O~b4@m&a;tipOaC3{VMM3o1Zp`R0c zTFY*Um4M{zq79gTM_!g#h)>CuSU7@hV+Pj*gD3CBserQ6Hgw|f@}3ncwC<{5wvkwd z1Plj~Xvr+ztl$T|xPt@7BL#X%qM-)ScgP@7vh$Ysy~(T%^mjqh#b?oe9wwGy@8*&=xxxf)GO>W^adkv#g1z+MGf}V$^&VB z)jj4-M0XcI-%8MpTXZK+OzkhS1 zji9cr^vT6kQkV@;`r7VU;PD9R`Uv|8Qs9WbBjn`6WKfUWEaB|XhKps;W_NhJ6#9IF zv~L~en4g#*jO6LxFP!W8MnzVmPwIbUGMX?`j1rny>pBr_IMi5S&|$lBjVackUfO9~f(c?cO_LJ*pAJTBO6#kZq8+LoE{{ve^2yjx4d2Am1b zdB~NeO?-9t6J>&p<9G{tO zDcy_M_Xc7w*K@Y(Te|i_4J2;i@9Gsl(^dn~#d*@Re3?En1(>3UxQy#%%KRSri|Y*5 z?g?SHWS~yeQXDbm%4_l#$W>XG z7*{R%q^n*@koe1;`Z>_U_jW9nZ^ZOQVWAIWpRa;nGt#qqZ>nOqh`0-zT7jUcW2?&1 zcq&sQ;hXj*Fe&US9Thy*H);7z>d1R;iz(Zyy)cu0l&FbnpiI4$v&DcJ(Vld-E5aA!0MT1=f|ioL|V=J^Hj*tPZtB)#bSh`-0M291+Y7 zzv-&0{c;?kY_ynCDQdoMD-gBj$1GCN9zn5n-<~NF1v`w^AT#kmxgi_}bpTZ(1;kL4?+e#$_Kpqujs?F%P|*Z?@=+zi*#s2asci#1)L8 zN4bRy2ZfgwF}xJx15pK@%*Cf^$iQLQuFKYoJ@(kcmeA)(i})cpPB<^LjD*U!W06i?Z>xapt17 z%xR*sMX0{Hv!SeBg(~7}w_I3M5MtdjaP)9DIL$6;1hNtMb<58xOo#xI(UN+*J`4hF z^%HfE;BFn*qpHyMb&}qFZhs~e4*Dq?vUO6p23R!Vbw5qi8-M||8^}aKM_k-lyB-K-!c2afm(}4#A6)vxJ*|%b_^Cp zt!*EjSorBXb?wnGuDwp??_BF2v<3WGtSZ^jN(0f331#jn&2JYlVo?P5HeWK`?#FSj z-f9O7XI{A=ZLFmSqMxI`v$bAZS~6WQhu=I0D&^xmimWePNm!O}NQwl)FojJ?jJ@XYNnbl}uEq7Nm0Jh29Xr=;UHN*|d@Xfv?}xN^En# zoZpNdY=!FZG=^hPN8=wtCJ&ZK)^rwRV@M3M^}8+{46?h025bDX$plBVR}DdI?9-5a z=}`NH+$rRe{_NWa*w0Yr5G;f!FSh3N1;2lb^uahmvY978ix-ty_A{4eJ&eFyV>yM3 zKVA{NMI7sSpc|v&m2CNKNFK7AiQ>+NB~i;ImYTfYL~r${#SdzVFD8E*ON-Gr&Wl=f z5caw6I{Lt*D~5;%Kws7rdErwDT(9Q@z(iQoR0N`#VhWm{vNsFsOKZZj9b^3YEvif= zG+iSpvy}NJb^+dIm@6`dcrJ{-5K?!0exTa=jFc1fX~*%qHsJ7ehmnsyV|a!<#Nxz_ z3&}W6(kdy)^p|wlstf*4SYFBJz*rIM9~(Ka+?|BNMJ07aIBW)&`)nK5o%MZD^3vo& z(=5Y*aEQ=>#UPTcZcJmssVWZ-9|ZA7z9`~5VMP`AkR`MMnMC$Ifzz&VJ#+B7C1YCV z6cKM*T5hbz3TovPrh*^Pmm8=Z-u(Q|GuC*e#(;QU z?}@&30XF>udTUL1UEpDGCRSf3bB+9VE(_-{wqsjZZsybZJ6su^;QM#%XL;rcVOgi- zb~X#o$YF6)80E!}>-glS`>!76*7&+Jm z-kSU4DRapUWfFL(t8^-R1 zuo&8dKAkJ4t%1;7@Yq;DPP2^xsJxHMDp>KU3jE$+YxW|g*^QVF~&1eE|KxaeQ!a@aE&-t+nNGgh6z+}7!sBEVR04?;et4~{ory&mi-nB z$*^O!Cys+u#v8%_JGQq0PR;8H-LOIXgXFTTmsQiKEnx2Rqhk(n?h};Lq3ywpD;qb> zCEe3~atB9FPobjg)CSgV6tJ!I2%|6HO$pG+;@uy+Xk?+^b~eN_mhmwpMz#A^Jzaov zH8Ch}>Ge)0B-lq+e0E(g5Vho0-{Rqtf$hA_NhTzb;mL8n?OpJll9pGkb6=Z6kP(xPF71&q1@H|9sWz$LzI z9|wkX8b;ry=ved9_C;EKH0jrirc2&>58d7DJkZH%N7qjYmYe6r(>)}y1YKX6kZE-( z2qAB?6HyQI6;Fntfczc}A8gakw^q%MF-w_DPMV*s={e^~pTE%56n1iRljsy<#1?;W z3rXN+(|8Ar7Nvy&nzzJ0qc0@EcJaMJyFlnc*u@%p=h5y(^n`=aYU&K?{7{0pu0p_Y zCX5{>9O4xUVWqLIl}@Ck3rnK0k+tFBIu^nRn-mYrxTmVoN4x50eKSF?vFMvJ989Z9 z89G7c?$%y&L9Mn@*sL3~Cz@+0aNB&TE>^FL@>mm{Jz23hkNs5l3CEryK7cx%=YxW* zOx{f-Z$1x%AU%{uPlfU1H0#~_j-tije1VF{9*hDsIE^?A%3iYb{%h`I<>qk{Ow7sDB~>!KqhS?n`QD*plIi8FiJ(LCWJ z-f#D^$b&Y!PCWe+M~{tQ@r~GrUHm9Nk7`bFGq@!79Szy%l`<2J-)M&D|SIOzI+svL@usw0F#h)pqZiu7-=M%To z9M+POeURvL$2ps?6UnhICHkEnHPHN}P*EExC_SUQ9+8S&c^mul2aXzZjJxeNECdn7 z7kDumtaGR>44;(JTS0CrpsTsq;jeKF=c?*r0bS8xoF`#D87ywn&klGj`EJXr)Tr(; zEVQ)8G&`?zCxwmQ=|uKEO^7hh*bonO-nO6DcVPp3Jvzj97kNOe#4mIfz6RKYNV^D)5Ew0<-B<2A?%^lrdBKlMjb}vm~!OJc#6S zdw^t8Zf1B4@4`U)IW;b1KsoJSc7N&to^Q}kl*?%3GQo_<&dPYSfX>@8rv9WG0XQwP zZRFPiPK&txJ4Nj(W9cDC3K#PaBB6}VJE2$SS#ujwrysOH%`C#pI14<$Puy{IXbf}J zmrmwYwhEDa98Qy9@*LRKC0>_VgrdhEUuQ(HtH4bS=SCE(+*K~pLjxDfAYX*3OX-O7 zQOvV+U62IwIUVvGVhW?~*i6S1YPjEGK1*MJWd_f!_1xLA+}jddt8<*&H?{t7pKB!9N&7{nW(cBttcN1V3ci zS8$5-)d93%{6-NUqZWLb%vLs)^A(>S)VU*l-i~oJK-Y?MASP?{RZN@&H zW-gJ1CEibLexz1I4#XS|+!aq9h=HsFl*A9>&6w`DBv`xrBhSTPB3>t{o4{rA6E|}a z;HO&i?ms!Apgzak6Xzwqy;@T2PcHn*B@PemgflPIgShiKTDM$a%%ahfe?lt=U34$z zP(3*|jrn9(Rd?i7dsL%iq{kdmBx5-%IHi1Mp z9s(09`dT_7;49NMx-55&kOq0VEUrK=yJ*FdMEdv?!3%}#i%@Qzb?XSL4eJm z+q+z9zl!GkYpEfU6Gpf_o}i{tIi$;IjaXa+a9pPdIL@ce!bN443#8@athD~X@UUSi z+{q{mJYdz|1h~bbe}iV8HR)svNApzP+?&VsBn1v5kUK;Ss|gK%>q83}*KD+VQ8}YB z!|E@Vm%B>KemLV8M{oHuS8cm{$j_?ZJS@iYSfHP(wurrK$^W*l?=cc;eKRT(Fm6;t z*bnV{z2bjp!ZTZd;mldPScr>a5gn0ckc9MN-6cw05K9Jh&B3{I``y8RQk(GkC0=Te zRglPY)00w#8|!p2=J0uAJJreuHTnlkbtmAfsBQDXq}M@?fl8;tIo{2(1q{n<%_byN zSD#Qv=56`c?heZ#;&0<*vm)CO&>@?`Vqx(pV!p8FATgBbS#Z@q_6bwm^qJoUp){Z;HLSpB}F@EEG^>gtMs4<|COtc ziDCrE^m?mN&l)4w(k*Q%4*W1V|G8^T=_KPw5A z;nhA>iiGX7JACdzl2A#n6FW{)R|J=|J(nuuZv^zhXt#w7TCpCpa#1GEUIz2izLi*Q zvo}sM(=4p272zlC93h~jrZk9Ngr@JdO2^ku7b|^k+bV9fiq<;=w%*jiqm90p z4JSIVaIggc?W^$YJrDc9_Cm}GgIrP8*|8b{k19=x$-KuyS2Ts&+nlJkayJjw`tRJ^yfjOyc+0)`wLPxHz8Y3+`mW?y(Zsbis=C%w zleeh;#N&>K(_%X3-1lt|%&JMA4*=j7PU8$mPHxNx17nRgOZi{OY9dIR@23ZOe zRziAl7ot@#+|+g3y96M+j7p!TZVjSsGl@kA#DPtf4~0Wm`=N8GGZ-6hS-k@NMpQKfR^hyDQ`<`WcfJPxv`vk>%_yW-%#n0oCWq~% zgGt1_v1_{$b{FNfnrxcLE5HpAq=SOYs%^5U6@T)ATfZ;G9yqTCi%1)&R8)pygWa}= zAI%RcjWt^fjt0^lNroTMG0EgK)&~D9O;CUs4WM#JK;q1$t=b`H(*Z$@D9%(pXSQ@n z1kG90L$IFaN8@*2I-Wm)He1gj%Q8wO$Z;hz?>=5g1p!2OODKS-Yw=p21oy|8MUM)V z>lNK5+ViG%bmvD27vOE+adO19FiUXq1~bBj1fCTQ*EDs&*Hh#Tu%r41`^2oEbb+>3 z*2Bo>^Xw)aF2rhkHFpWZI<}ZMA0R?}Vt0mLqGGqO}E31c~4 z!I%3X$5GV4gP_h0$ld(12d@iWqN^ivO7IIlqUfWM z(Uz8k@fO+TRItb@y=xPG-8y+XYE{nQHKPyPIL#d=me_BDi*SCl_l50Q$fcWzjRgzwtSk@W;Es4fBpU6;|GI-bu zoPgX1V)EjBmIUDC5g$9~{iBT-Ae-C~h3rvMs997rK$=0RD@e>4kpzfll<~I&BvGmc(tcUpQG7r6tYrkBNG5iS?*ZkRbU|-Z0ln%%lb<5*C zbvx>Zrb~rYba>4z8a^@0WI?t{$ex_7){H#ZVuxl2hoaACOR$>B2@S|m6jVRp=z&P{gmAw$Il}MRk{;Qft?b~_w@;lg1l8wbCiBIhB z2Mju{k9F#z&Qt7_96_fbKCIx(^Y$gzF<--fER0@OdXXVjxA zqvGSR01ALIIBkDMbOOg|M-__)D6}LknBLsN1ar}E6+a`P)G$I|U z@nPz=tGK70bE>9Y{4x2D z{f!ok;nDDPa|V3Q48_a7ShIf9*WOiW;)>SXVz84Ps99fH-mRVeIuK)bWTfZ>W8j*P>NfhU%*)fFz*1vz3%ZX zQy;RkLVi}x_1d{}@EKE1f{hA1*r>=&&kX0)Bmt(4AN^P0V3B)GFzIwh+pQ(0?+T_h zs$QcEi#v@r^DamfVib}~1Y@>H99KmKLVyCWoOh8$n*A`t&{Oiae~DbqsWRu{GeZV7 z;m5`F*$t^LPyB92HjQt7jklL`)1`vbJ`NLV82Clb%@P^XgEd4=xJUWGG9EHSa@ZV3 zl3o`JxMyW6{ z3$N6g%XAw`Fs|t&J=|#UV$=S(>J$T``N~mqCk4~)r&Ltet!Xw(nV%!7J-;&uhfcaX zDgU0}#5#W5VmPMiZk2lrelX#i|+(AtIAHM`~A#D*Ia~I^AW&}%v zQVe(6R}5E{5GIU#sFk7K!c3RKPT$?io;VTJr(1T{R^Zf`g2jJI)AUlzt=NEVk&oa> z{WjwDV6Q;axoTabIfcS)^|sqYW|2uQnkPrEqWbut$$%YZvoz*!M~ z3n%shNvgOvw-N7`I|JwMyEf=9NW7Me7A zqkwe>;0SDuYI|JB6irM;rH7{k+rUEDQphTc%oO%ry9QY*ke2BUQmESP7opO z?_*TmV(p~@*&Vc%h(06&vKm5YAEH!Fp)4_8|DBTMvOObKe;jIMy*IGWxk+IiM?}SE zHR8zl#QKZXmN}%~rdZ^>ZiaP|yT7vimFi44?W<1_AuzTOGJ2!ch!dej^jilM3fjR+ zb-lFcf{QXLe#84lo^76sx|D)}tOc^Kl=-{S*7Q60la8bZ&BdZS-Iv9;opD0jbXV=1 z5_Mp{P<^#`tsjeoUT(Ka#b&CchjrU6_ZD}sBNQLk4^_oxoX=(ChE`K6HtuxW7l{!lL+l`1qHc_84pQ6(>R7^t9 z_!p#qkzKPgwOW%O`4&QRZQuo>4u8JjOHB*-4woO5_X_0#AZ+?K+y{$YG;;!&(o?4v zf<_blY=ThaEekmNQ*m9K@O?Gl-!S68nmm9QcwqCpg#ikO$2$VTnrMH-ng3woT&hT` z;I+&@ROshQZZ87`#5w2F&?mc;F3vh#u=~D+c=x%}bQfPbWw5&=4fP7nRP55lVIzNo z(7FCAis&-8aXk8Il&3~!qg5=*(>=}|7Wd_Ys~7E!$GZ5tAtOa=I-1S<2X_XWJkIK6 zhgfK%gd1*)hwaPMk{d==t|uVP)ElUm0BI6T{1hF)2wekXRf8P4azH|W3FdL#zyfkk zcP;RDF&tOwcWM+55vdxt?SL>{yJw16hecp)3^rt~qU59JPKj$^s z3w{W{2V(^Wzk3Uru}ERpV*3n=J7ZHl8}LJthRx0|q#t?J< zfFvjZPNhK;b`{V89Vkg7Jw<^Uzd67oC{}<}IfgOL$f$1#g;y+==Nxoet@XANo(s4U zuY1R;^~@~q(oE_06crE&_22>SxQUo!RP?+?&xf;foZ4rx5LP5rN< zm`v!p-j`*SAu75wDDHX!e*XTd;pl>5oaxgJCtd3Zdv;xEuidM~lxv5)%+HRR&rt9T z?TWbWgnh4(lYFGsQwHv|ddGn5Ow=0|ZS(MSaWM1?vyhJ+Utn5zd3%q$@-LMx>7ymV z{5g(GV9I&nUWs28-L+_#qX)ZddT9}C6PxU^-9VyItjafA%uDRAm)`p+rV&9dIQUs# z*K;y3b{WynIBf^>bk!ij0(f~r2LpdieEVP;+T1DA#UoBYDSpx6;4{$`j*Dj89nwbjHn#K78R2W@<}H5$I6)`UnAJ}{ zxu@qp*q@zdOWF*^PJT}7rsl5ZVWc?%Yg-C>=nSV1)*FUQv>*B&oZ%iI2!hEEhR}XI z)Y5*54vs)>k->6$lkjwjh#p9?Jb*w1v_{O*#LUh~Uo>5$T+DtUP7Bc!&oJBjeI1Jy zsGIiVsnh>nVIgGCG=y(}L>AG{3OibCS($YeN@hKZXH$&Wl!|i-wp$l@iC9UBNn;`2 z$H#Ae>g+#Yz@%RvU^Oyt7w^Hvw&%Kbom;B(JH(%x?Kd+5j2NlJlsus{g(0zGG_z{S zs~rMI_W)r!FH<`9TtoR6#*$yU<6|x1FNMUk$jMQ1XfWKH-)vkJ?MXw+2j2%dl)Zfs}yrZQLIDKYpX<2fXbv~9eD&)et3eDn|eqT{dDAgJXO)wa$Y){j3LltB4`=wA|tQpG_`9n5T3iyM(pYHg5*`KtO z9}7EUR}J}(eaT^3yoi?Wblsh$3@=695jCk{SU$75E=c!o3m{Dnfop%Gt9?EU$(2eK z@X>e83Wa7N#R96%jTJ*Qv+m0VBT#)vF7sxe1jkscp@jC7_1;6w&CI|ZW}JwMV-sjv zBqed7ot9ukh~sSc=+*mtEZh>z<)Kq`g6O6O$Q9T!q!@?wl2Ecb5rFb)3R~oa5(#y@1Rr>#MRiZ3JjD=)%~0~LUG0oyWf=UR!sW<*+>he$ zdhpY43=;jE44%bhP!(7TlJR#i*8QzLh&1GZ7n4CnGLzSJ;Flw>8}ah>=Qe|gmh3ow ze)Cz!8R9+hB`}=oNoU~r+v-ngsuWY_Ox>lP!}Zj1rFL1e?vKud*xmcN)Ro6}PjluL zf#!Mn%&SuE(xus}be6D*=xN~d#;_C7J)ruufviWBbjrHFaYUtri3vZxgru9c8UNoe{SSd{^3nb| zCj#!D+y4jWMn?L0iqPt@^Pzu})}KGx)4umZ82_87hWa3_dsX*bjsD$^^U*$5vK;{2 z-9ME0e@JVv57K&z?wb4mYKI5f4fho71^-P{Z-aaU?&8NI!N1!LAc1z4>$2wD|L3nW zgI@Xp@p5|@d5QUVJIhBLQy-PIr+(2?k*{zwkLUibWB>BNQp4n4&Ea(+ zz~w3Bt4sBPZHrCtd?-`jOz?$&Q|!^k1E{dHh-1m)>fvM!#I^KYy&)Suj z8o(^+6B6$tVojtmJY8Nf9M4Z1v%x)UgrN|_W=p<9NNqpiHYHZ&Z3oea5E~9e2J>AonruD1l~R05=I% z0Z2HhW#h@fkJrL1g6Em*uVoKP7Nl|=1{l)-O4(neUI)R08DyyTPPo1H+Yw~ZU`u2p z=q2AXhomYJHXkwI_ghL%-*eej-- z83V!La^^C(mr1@nD!eOuof`s@e428(ZXcQV838Sg)wB`)bZxmVgz|N9{8*gsC4EpRFC^vQ;-fi`XsN5UHjG)ogEuvbhN5y_F zn`P+x5`uMB!=#tHFW)m0M0R-4Zo;}o(ojD}Te)DH6A!cZ2b+%O58-GUX`4dN7F%Fk z0${M)1Da=Sk&Z#dUj$j%t<~rzvN_3W6I6IpF_+s|BwZCG+oo7#a#$yrb!$BPMOD9I zG1yv>u^Nv^-#vNuC0&wPhr4EQpJ6y3v45>gWpim>x?OYu?$=c^g@I|s`GDMEXXqQk z2FvB!&9K4h!qVqZNps%rdtg1e<@M}lPG#7zG3fBS+QKKR`7Y#ZWA&$No-xw=^`^w# zO)r`~-=~`OqOeTE074WsPDLT03uL~8rNmIFKywu%O+!nnU+wZ-&ST{a_oi+h^&NM; zc^d_waFBhn<|y_WO|B+qtX>?tN&NI_FopnyEcC{n?b;ub*VkX9#&PhgSX&Q?c}&{3 zWr(F;m~`r*Co7jFWTNsaJAT^-w>y9QU$=W*H=)I`PWs+<$nB5jHbEqM9`7z^WFh_f zsYoLPE)$CS$-eVgx(~d056|uS8l>LkZS+Dxfwyb*k8A^#9oV&kk@{i7exgommG9rI za$r3Aa-*N409aqi-|f)NAUJnZG$s#_BC~fY(Q^l-Gv%Ee^wF80+pxUtc1uQdX{VC& ztQEE9VWgLN1c0!iA`R(SuhPiOpI${Q01d*N04HBgH~9Kq>!8#i+D~xr zo>CI?ZFnO^WiL()#!HKhD^Yvr(f2fCHNlvioJ26QW>iE8xO;W499Qt3N-CRd^#5KK z!6$Qo2wb2M3f}XZQ7#S>O+n~A8q_@$QY`FsyUt`RvN~h?Tr&bCbD#%5&7Tr{D%$bvx<0HhL*HFSOoze$Fb8j~(k{H#aut#lDh?*nx#~>kUjAUq zQW4#e7&4XqLB#1K_aZ5evha2jcsf_3I4?whp5A~L0mui!LBoULXM+_>WO41wB_k+hG{Z>0NreI6cKCX$OW0xJAkN`MMe$-i z>z&|~^P~H%I!S0w@eh zGofg9Hf(ARek|v=?=gpC>l~WC7bqM#XO4Z7-#aT>b71!Zfzflj^?S+U>mXbHW zMj%)&x>cc-RyQ28qlDjZgUF__8nYc?kNGic{xV!uY0X!gAOV#d=fX18Q&HT>utrap z!QhSdQbi6KnYReXO(}TWp#qJQ!RPh}vbt`P2hZA73cV{`7IETV^Vn7@P4ao3GozBf zbHHFEJ2fK!^Q}KLQ)M1al0F^th!`R}uATMV8_poEGIy?X$Fas;`I;IvZ@m;m`l7{% zI>h;e`os>9^ai8Vc;od)vi`A~-&O*1f#+oQ*zqJBN(U2uCd%jaZv=CE)i- z8hJ>0@LAsWo9brv4}6#S4f`Xi1Hsy8W`oy=vUd0(%N^#}f+lkiEJ)s~WwC#`*NC>a zIR)zXNYU~acIYvB$w#Y&XOczlivn+uH=Tm!9Y7v)YQw*Z6@j_1xH#v?UC3 zM{XJ5@agS)=0&TN(qN5n?c?W$Jx?2T6SD3VYVQ{yz)wEBLo&~9EU&O9G7g|I$8-LM z)k#}6&2Nq~M)QP*U=yS;ih4IkAA$9McSW6pa$3moV(VS7SJ)^?8AMpP+K^iX2655I zJaACEGfUmO&0)%R{q)iiZWPXJHSL7s2wNTs==yomAm{(nm#c7|l2%1hk6d#G_UUr5f5AIO(qROg5+ z@e9uA)o*^QwVCOtIj?=4C8p}Fq>@!HzF8Hk%@Rq|S6$n?^9*d<|5c*<@Q7a%fetE5 zUTZgPkT2ELK?!d*>+|r2H|^iSVDS5Az(oeJSb45&0iz1M0#;s)_T#!jZQ|S9G&-1j zc`5;~hguZ&oRqgxSI1j4pW8k{&Dp+kveVHy9`?=oavC~Szeq{dBz7ROlmVB3ddYX6 zeka<_3JU}csy`t1hehhQg##>4^?-1xz~5yDi!%`QB<-zt%z-%j;TH%mL1$&!)L&VP zCZ<}qUm2b0CVVIl0$CJsi@TVDNXXFo^AWbYWqy?!DZe`U0csq(Sn$IyfW=nCJcGr$ z7KNUeSa>%mXIH6qS34HE5HCO{i%qL(!##)0f5BdmjOX~Z$qI`@j*gG^hHZwA|7oXA z5TMkd%6yzpn1ur?_>l&Q_mNPBnIzyCn=xJl_#Y3nS9dIWqrk& zF+sh*fgPMe=I9#57SFz^J>t!#`>cuV;Fo%5FxPxk8Y@KWd>drX6Jmdui$;oHn?@^xJJVYrU^ZYymupu_h>1&EO$Wh^{T&S&w&O}Oru+!VmAqLE<1R~UP3^IFc-@D6ep zmV$U)kt&82s>{OzqfQ*YFvX&bn{Aisvw3RDt-TK=lB_z8akO6^ zQM-GJG_^yv(=!Xx?f$(lhH*Ag%|>#~z&wQ;N&iO}BG;e%Bx^>;pYJ+&(w0@~3j(N*mvEay_}rCq-t@YI9ef5tFtoVn?_XX9d4{P^m5=tp`V#?V zWBF`=6$xYl{kIsd-I}#>45Hbx!B~RN^&CTvgE_v~v#XrulI8GeGY2c`so-sQBay6h zqm2@?mQff4yAsmzZ$kVXo90hMCZ9MR_t;3C=Ex9Qxmp^@a)*SebfEK6)Gh)^Dz6O?&2dQ7E~Ob)6cVMiB4{XC#bWUrgVci_{cuf?6dg{vc?@;}`KkF0 zjCSHDp5$KV98Wj*wDO3nJ41Q7>|wB6PSfw%g>>Nae0Rsj?t6TP%=KmF#n7P z9e?cA_E6&@Xj}cx&qy^cm@t$Od<2#@IajqhB=kpchAIl*K#%e|Vb$(e@_h)vb+lc? z5Z5>eGMH)Uhx9uLu(%u2~5{_3>b7XoM1SMPMqElc!sGn7qDr*EZzq ztZYHG0VV*rMz0va3n0hbv9q>wI@xu~+fJYTq+>qMUoNp)cEA=PT)7;_^Fe_!FH%nh zQK?p@5+Di2aPxhn@uG4<%SGmPjq9aCw^7Kw)MYzItJ!Yt7gf`C=gYL#XkenIV_W@E zuEZYceRQ5^uzO`oT|4JuzrAA*cAuWIh=x&io*3{HZr7w%AcEDvNHT&j_C6(wU)15t zjZmrw30pS-o1&b@l{x9a{nWGknaK`x6oTubHPhqG>x9rBz*(l^Tn-mj$&1~bfXulc>lJ$unM)>I@vD~L#VzvNj>`a3h+J*PR8a}V4uG%3!oAT6Xh znpivXAFNz}LYlm??O-+Gzj&@m{MxihcEo08pu_s~W3g11B%umcTA0x5geHeC+m}9#~#68)(A2 zOojXev*Up`DLnSkk$JtwNv+5We!l|mQ7D5$llSpRW zxo?$HSGednr2xAKv3Zruef|Z*Q9P21$4YO~59B-f2+in#<~ej9kKm#NW&K)p4B?&` z6O?IQF+&x5e9s(C@s!du9UnAneHZb3iys?_$ z$fo;Kg8n(H^_GNca(jT&>{}?3*MI{76xU_X(BthTQ>%kV-z%3(9wx1a%^#`aV(6XS zV4wB)=t?$gdjd`c3fy!XvnIirUJNGi*Q*wU{>oFX)L1U}?PiqPizQ##_`TqFmt5r@ zg$sq;8tk{1I*_{qntqKv+a_RKh7ABhF3<#nkZ%bnS|VgoEif|mT(fzbr77!70ab}D zfSO&_1kw-;x|SZPSXchNNKXZdAOf9(-T9nXgb??f-Ft*C<}xaeKuD|#b=P&%>r2-h z1%5z`2eWa{C?=J9onCzbQ(*$G{`!qa00>oP@7hR{REHCMZ<((Yd!*90{HzM~R>Ear zU2@jc27gik3jCvIgFC30nVBSn5lm`rB>>w7&}o4kubA|)+F0{9LT_E>FB4FARFT7M z55k@XRLhP#Y*rmL3!lJ^Tp#=h2TqF8b^7TQzzM9ofog!&xVOgo+=4-j%hL@Fi_60& z*nGQgb1jCSXTQQ-yk3U7EfT^`d*N>;Jc$~|3d@j$*9YO5AhEDH^pc5_3XPvZjUm0% z|3`cBFwVi*To5hB8z0cUFxFHuB<%Qefg*FQ-XBuVNZ00Gv)gJ)agx{eZd089^h*Rr zHH2!I2drmq94;R{WT z>~((L4EQ_>q-L3Vp)|%jQytsCL|2@)cX!CCucw*-9R}cyK;M{}H~^2<>T)(!cl){o zC%9;MkgqQch9!MNGtWuXPNq`*FySC2S<`4#OmNUA)q3I4dHks?Z*p>hy z*S_%`XnF_}&aku!Ne*!D57{m$!c7)<5WN0+q26T@ARZX*4YLCB-CE|BRjd*R?kv?G`e9LDuYx0GC$0z^7`HOB z9E6JdF+ZoK4kvAgT6bnRjO<@7aDxKq5Xy7?CR~AxrzzWk@DmS#-pV!xX8X3Vr?u%S z-E}Z8Ilgsah0bGEs_?Az7VJr1p5WljjzTWVwAdQgWx(Hj#W3cy*p^$#srd=C$F4%X ziO_T0pRHw&PwnT)xxH;gn{ko1AR1GG?K#j>28X+|G7*2Q!T`7IB!kMmqVtj@w=M3m z!b7VPwQi5)SKqV<-9{-y>wF^kKic zuSs3ip5En6tjk=-z<~u5Ci9%y%=n@~yGKlwl$SbFDuAy~#aT>ZlH@c1-TPW|2#2C7zamL>b4r#b;b+RVB?PX71j+NNG;-Adt5zR>kXq~ z@`{^ZxW0Kvn$s0^)MZMvn5aHhWQQ_slWF2+r)>+h4^-FG-ehtQ;b&SAdv&=XUZ=`F->HVmMZP4N+pJu%A|fAbK%!K856u zFPS?IG%-o3+G)~zGA)%~uk18km^767q(wbwewxX_t_~)NPx|!I$7>3q@I6+TLc*7% z9=q@4>3bBRvb7u5)*&s-dP(ZD1E-^<=2qoR2r3A-mM)?N<<1J9LC`UoBxFMJ=ybGu zg>0UZODDJ7c04@yJ0^R#%kfRvXQ-9_DsvViZLgez;mSAgDjlyqNb7C;=3L>Z7&De) z!qT%p+;+mYOltzXI^9noykm@BqI#R>DRpMvl3WzX%#`t5-t68$Zr`8u)_I}d~)>r{#)jPVTZY*BqCE769> ze|o42L4e1S1FTr7?Q6acG#4rIT)8WWmnOBf-xHxnNuZ@ocuIO~%lVJozZ-Pb9m!+p zD{7?lrS1kqh_!0SM}Q^)zoF%cw>xGX^~UZPEK~g%5EodS{TXET@|)k|FH(c@DjX8a_{C0^UgkpseZk65?yWIna z<5zfj^AP!F4)*+X4&v8lltB8JfdAyvr!xn}-2t?6r~)$qxvgbX9%)%I?OvW~p+K=yz6seK>jUipu56|Cqg zGaJ$TghiCOEijD~k%%`L#a8e5T|Yy|EJ)R`5BY}4(5`c9C0@Xp$*=vQ&ilGdm-D{; zH4@}m@OGghS`meoblY@=S=6-nMbSA1!NH^{UL>bRg4FJ@dh3BmP9nXD!D*lGsFkT4l2+NR;PI-U|vtOBF%j9_3nl8N%afdeFW#n+fy9C;iTf^bE{%i8O{g73v;>m9i_(6V_?f0o)&q<0$= z{!&8zWOXvNKy&IGHNVgHnjrX?gZ1%3X*g(Xtl*4S^farZOYs6??34+(c=cf z>Bw{*`DVBZrUiHuku^Cwxi^)wUMauh+TcPgWIE z>d_Yf;SXrjugXFC@}#CAD!9v|A|MY501+9*v;Fanr7^6fF*-lvbnUWa`n+J`Lm?q& zLb4qJkCB-U2myEN+t`TQgn(I-3wpZ_jFAyGXenFxi7$)PnqlgCB@Cb>xQ2sx57w5? zSGnqP;cEn@L3E@n(_=TBhKI45G2uxJ$tz(_=fT4foNZw5yR^ifKJII2L3K z-||7wPJS!fOF7JYuAP+x`1zHk~y5rlK`0Q$kFECYH4!1VSVQ@P{#7Y==phKz3?)>6HDd6<0x^z9LO4r zjVW`eYfEa<%u**|;Y;+QG=US`=80|QVT$zvyt-6OqF5lGimnJ$-ju^<^(`_p%OjQ}_%Mfg@ zKdAXSB{{2&X1)W9BKBEYFXtc14<_yWS(v68`YFysjvl>7g@R(D9^L{;aBNqypw=p? z8WWn)VXOe=&djaQ&oHcfZr_@N8nDqJOeJ6Rw7XY;{1tAiPRU-=C96;-LmE!~rBQu+ zq&9ZwTPkltK?en}5_B++4xoZhd4S1bh1BNbX|(Oi9nNEG2$Zf_{bCV%ogA=$6{t`|J!mGAuN}!rBiI(#kWC<6ViLvSWc*tC*hUBeUC%qQel=7pFL#*_XBr!_ivq9%KU2FRY*j*Zi8vLM z8yJ5DIMAR6T)Mg+m>&n{79@H}|3o4hPnATBx=UAE??&ePRNcnL{Aab9;&-;rNhiSK zIC1cPY2WjZdNDP+ALxrWz(PFo8lB<7)t1}%1J)dRb;Y40q z;_@@yfcWMBZ8A+C#y(MpDp&tp_A}E55g)U8i^pCB(X)~^8M^+IiUkE(K|2J#9yDY> zc-$l=3QVv=Xq1SteC{k24ET*D@r~1ErvhdJRlLtI)X2olmUy>9{BROTp@8TL!kSNL zOVVD$fnc%5Zn5C|9j03{`no#KzPzryZBZAZJ8Y#~`IGb?-1?!9>NQ(v{NXIOU}!a_ zNo-MWtX892-h;=M)?iwa*6(ZFEwCDek|agnck8i(G82i9{sCj4F3bRaa0x3&~>2DxB@Rj$Ltog0tZF8*McI5Y;0R$ zSOGCFn(JPzW?sgQ*YYLi%hqNpALil9LxwD+dkmVIkV0FNg@^=t9$e>)QFfN&RQfDG2zC+j*6y#Y;+6q1sh2bL`?|D~JQ3X1>>TVmUx#wKJRC&2 zCKe)J8ocSu-I!i<=AVI=bPX@u1@&=buCcvz@qqRO7qqtF;(8ghE^Foy&DujbVr{nk z);f99Kg)pG)yM-bQNq^gCKV*05Cqcb^Zw{(ngAu>eEcEeT*}6W@v&R;1T4}lAI)( z;3-fR>}vj@ROscNDZvC($efpm^jjoxjL=*|y}juCSSyOk7s7zGb)00OJVbgLl0+RW zYq=CTSGJ@`=^14-v`<*MKt{GScoVgGOraq~*!b70x4{vo4_lu2CYx)joX}H%O+mp6 zGn1J9Qhddeycn|gTP-}Hm{LjyY(i}pbs};rLNx#pbTORmApw1OzlU@GA}^5CF?kG= zp|UMzw?@Coj0(t?*4y(Y4*TeoJX((j#nIRSvy>0e2qa}anP3I)0r8*{BQ0;eM=;nd zFFI7>Z?N%iWkG@gTci~`WOrp|Jx|LK@FTPP(vorStlVKZH?arnoxE?nH=8IX2peA3 zQ4;Apyh{KDq6!n5;nr`lJnzkaH2m_NKYt#qQ=#t5UGL*vJh0J=J=ZCg?UsybM~5mW zJLli|JsbUTcnlF1MERHA%0mhi1jk0O)KvUEP!*e^O-7g>#D2zZBP&YsI zkrNw?#y=64L&3!+p%8|F1hJ&f=0=xOII*f-f9r@BE6fzRbwrp_llOLNb}fyK#!oKpTR3iWr!-FDt~8 z&>m}pLInWRCpYJ)w?9jYTeXpQrLu8;at1W6X85P%3Is?7UkrobK@Z6vrVWgn02)Aj z3=7aq)JQI^Bk|x0n8e{#z|xglic(#t`7&#m#au4#5`%Z>s?QWs?SOnNx}1KKG0simaUx_UR5@ZOF?KBu0Rk<0ue8>H<4zJM?*^iBuPlO zzsw_5s*XsZ7YB_x^w_0HbV2J}fm1-txj)65|M6w<9#QM<6#DWvLM5Pz%j^k72Em`m z=J$2SCz+PML7T{q>%sF*l!y-Y5J@SWQpW{rjy3S)t%Q;s#d4^Ly*ha z??i4Ts;@#SW3=NLREGfk$Kf=yDqm>MJQDs~SEHB{`{Wnn&6#$15brhTv~(}zaO){d z;7Ou$@DfABPbnMc;_-pT4cuA=avg^#x>Uq0x14I{gU>5}L7fD6EO<2P)_ah=fKBk? zjCmUOG|a~C3ox~tM|_aAb!Z>D=pm&t+}C1f1|BX$jyU}l?zt0b4OFK&!TI+-^P_bH zLY<>D8so#?k1tt4vRo1CtRmOpvfsHV=#up`>#dWO~V4 z45CfGPm>x=iN@YdeU1%`hsTrn3nPHaB44_o2<;N5yZYTB=6nzIAxjw_y zutLi)JzRSh>HK|6X+ghMS_*3M&QW3L#Tsykpi1~W3)BW~~kbST~B^LrUxB+EE zxf7{b^Jp_@FhFEqe1OV)enaa2#})g(*s~Ad?!C@L&Pntyz!*fd>w}zr{zPip{V&kE z3;H4W6Hxq!+wlT|_7AQ7-#6e|nWI`=U$_-001k`E zNXlw7q^AW~DYq@9v{5n3<7SyVU!Ugt6wpPNykESsvb-lE&6bkCsEHEa0s}MKL(S7i z0f5B&|MEVi-B)T~7d%|7m+jfppRYN;ljS=!XzbCoJ-pOyKhzZLv77^_e#j@b{q<*f zjNcCXEV|xjCus(|u2N%v-8Rja3e%b|leuNE`2g0Z#-hIou>Ql9OMj;^k0IbC744YH z_;QGu1d8+oPbeXo2&ZvWAcho)66gUzDH-_LgFlQk3h+`BUuoq=knD{$0#`r+-p#Vm zhJC6-1jTw(C$nCuBwE9cO#qbcf7@x_s{zgwaN<^a(BdJB<8;KFuG^H0kFM`iz#PvY z>v;6==ZSg-sJ@1As36#M)gNoT;@1q?{!TYb=K=jqA+C?(M-irPO+ff&M~AeM1AS}RLh zt@pQo*hOcGnC3>}E?E6-`C>5pq)RW6X*GpHTB))QnGd+lkRtW7Ok`4g4o>EgHeM!O zczI}NF}5D2?h^#)&<|7gLjpKBFa970>0;aTde@W(?`y~!*ZV4DPUyUa&<}Ik8K(Vk zDaPL-S}H}wrK`VSf_v!c8QX6ZE`bxawvU5zLdTfY0-|s}M*tPna0d(~G?>S$4`{Xz zaH@uf2kejIkIr$+CkOHCh5)m7t=S`!Yp#y1*iBzU!qwBRGR6;M{+WHp4XlzkK4U_| zlIb6+k$^NUZ6BzsX}>(5cjk-NB;*6;d->wisHCP?6$`~ z3UuSMp)KL<*v+qzUw*29_ph9(V;yOd$rINwdv}78D(*>dFU6A?0PL{=*ehbA?YhAq z6IZ4Q^--F>fZugOqU;II#a=}tq$DIcL)kzs6LTMF)MGkXm1VF#`7`RS?=bDjJ&2WF zxv`B}db3`<#vorWFW-pLVa5#aAJ%yf2kR9FsDt5Di{;(GVzyjp@;ce^H-vNdHS+sl zl|Cc0gRhU<=6dzh=9^?anXn`?=m@x-=DF}9c?V*m=hx)R6HO@S`iGH}$i7+^E4#j! z>CV0UBC;WnG|#{vgKP)Rvl8{C7>)2i9+`wTk4&Mr7MYK~CvoeVsqTmit!lF14rt*x zPecMeQ=Szm-&`O{*Jv&*tWGvwIDR=I>iF!VdDXJs2;?|UPpE%qY6`@La}1Ly(%v+M z`D5P*5zi0sel9d?kt28h4tg6;e@y<_xN_yk!7mQ@ei59`GuX1>UcieuWbTl=-;l8e z5T;AXRDV?p`}VR|$RY~m1Na{YD{h#%nMh}x(7IU7VpfWLCT#+QA1XwaXXi_Ip>DQM zM)84R668Jfdm}$I>wo{%k>9EhaU8t_lWtyPH z{7=BpXy-AWDjV$)7F{ke{ki!K0tJ&DQJ3@Gb1*`1iXE0)D&uxULOl&>@)kdh4Q6;^ArgCM_2KYpLwNP}{h*RpS;%SDFoE2It2M@0_D zF6aX@%-e>c4uIYO!9rQIt6==qN+0P7GFl4<-J1UkpE1&*Gn#P75tzPhGAO@1h#p_ z>wLWl>>7Xej^m4ibdBrz_~PQvT`4S&!`z`b{et>QGe@SO-J<9Ak%5>wv~vtq?c={B z0uvR7XfpD&KN@>a^(N_{N*!CA7c(f^g|dcJKn}k1H`1SNk5}=-Ma~4EfOh$izNj2H zTAE?K<}h`{Nf^tIZO=>?Zr_yo%#>_j;<;~nn-*x))C<1ek1~xHbWBxIv0Ic&{#{wC zeJ~Qlj5WP`v25}`u0Y`SfD_rCpc)4e}m_fus++bRh2 z&zhe6#(PM{Eu{cvhhV+Wx(0|b($A`Wm+uEAERsZeBy+8sw;Mlk_ZA}jc5_?Y5A5cJ z_E0m5lQ7JDkM0_rVwj58l-#N3S(eX!R%P@T_{?cUGo)>g`(7}e_E4_5&7HRh9-VAv z?HlWNKVHF2dK{LcC|vc=c319zhY(U z1@(7MHtWym{@s@#)#Go(Y#iLGTdJGIp@gZ`5QTRQy_XLR7g?VUGO^hWq~+Hn`fVU7 z4=_e?(f?3{t;M_z{)i1z^?OP6U-iE0@_!|@E(^mMli{Px`B_a=IB~Kvt_6#52tQ}9 zcE-W%vf zF-P#4+3Wzi6605OXn$JNk?ABfgwR+1PgDGEzL91~9)sv9^a7zwjOW|}&c{CL(rJQN ze>UfTW?!&zyAZl|jiC$ZviT;%_qZ-qFIUeY4Xr zZ(iyS``(`xi+9#IAO~&`hpwjrmtbd5`*Xbz2Zw~ZZem<+A6-niujMC805#lZe?`+t zQf_W8ti9Gx7fOhctb8ooQ~g*MR5 zzKS3>hy=bxE6!nAgGgXb*A)4on=pPcM$bFCIeV{`F`zy&x|0;1c{K+{LCPaN{DSslt(Ia^QG0?&TkqFHvI2TIg4e3L_Sj; zJN@zCcLa8cDU?EKwjFQjkf98kji>`>xiVC#%&uYNuR(VN?Js4ZPKbHU1-VKMHHbpp z>=z-o$H4KwP;1x%|fHtA?IyuCiJ6RL!a%p-By2 zJ-_ZwJUzJY%M8*u9?cqkI~au~Ik9q48RV26YYjQGYLfD{t~MH~<&f)<26>FwR;@3^ zhC*TryyB`s5*0zL?ETs;GQJdF6Vi3PRGnja+l0_)#P^x1J_SG%56L%`@D9EsNeXPOfs`tvQvslgr<~E5w zRSAkL5fpkN+L)1|5(p$(cy8c!BA>p`H$2^OWQ<>Hs^YJaa`|X{lFsuZzmYkLjUDkO z;`^sPg+S^0+_nmac}i}t(^VC{Dw`7RxKzQfA7eSE6%%`$u__P5S{b~TOCR#!kNlh{z(FC9ST-&y%M#mY*f+MsRSk7>Q} znX)Ib{pRCDXL-d>6cDD`KE&@9cfcthnVnMET4?#Do!hR)Qji&_{T3M+O)3fUkQ=`G zdk)URbfDD`=Q|{Q;w4#KN@_6Ba~H!z&f_Fs@L++>%y8_U+rRe_bih5k2sphBVV~!~ zm@(OT+aVLWy`&!#4v#h!{_~J~FRdO;i5cxEW*9sVv?9Ng6dgTs@nPINX>v4K92M`L zR?+eN9NCo58`$}a_Oujcw*cW(n9Lluf}tQ^oWGOTt`9-Z^k;4WJH&lFrb=oq<~;tA zCe*K=qpaTMW7&BHDJ*w2`{kO7UfFNz;FOfU>4Ih8BM~phh3xdtKUE;MK1rX<8Y)Qt zc!jUCRoBAK-&j`1nO`c)VQd(QjxyQTtj=gU3}TU5uy(_23nr~5?t>;lzZyICGBeFH z*B=VbVe9|$EftgJZnuhmVZT@?&ov=WzDsH8Czyqi9NN7}BQWyZr?TQTbr4}isE6~} zcfae7ZyI3JYw^v^l`W<<=c}z9AyC_5k2&{FdQ`7~p|D}_2mw1hyUjsVSTKSiLoj_& z`9$+tg6Vi)jaDL4lbK}*C1iEY-HkLd_al7K&fHGARh8LSJcDtxUsf+seL0@PlF06I zum~F$^v7AQ*T*OEVg?-^Oa@~OQ%>Pf`FcsoSOV;_DqKn!i%mmh_#~9W1j#!-{B+s- zB3o9m8Y4vB5l!HI_1PivX%frJ(EEgeD0Ry49 zrz>}_G#vNxdz3kyAs{ns$Z|Ud-3CqNZ(iF=e(H&riGO0Hb*TOdp-g6ne}wS`HU~u< z+f|YI=k+qF9glcY;kP*59Y(`^PODVgb^m0OM9IM^sn?@YT*QUyE&F{ZQ)^$h+X|Q- zry=cMA>q2tJFv^KYSzuLPUxoMs>P27Bep!ffgu=V6Qj51;&jXz_|>`yVs?HN++S#e z=02`^h#k#6w<#|6I;+~?A{s$>hzT>a@h(Q&LsCAl=#@R|%vN~$Y5ztWO^R3K^4lG) z8WIy&+w+jA=&HN1(HMU_JxQ&G#6g2qh-eQtK4pg+#lSj|a$ZRHeRoOhgueA|a!Js6 zD1{rTsJ_QMwCk9RTe5l6>0S0aFXA9 zCtR)mAbc&Kz@!`1)Z#RfN9C3_jO|V6T$dO{hFQp@+s9c6U9?p3i{l@sx8c0dIu)l# zB+Osxdw(vV%wtJ5S=c@Zq3}C>Cc)jVfJ6R(#J9h6!g=Bth0oAFU=pWlAW7GEao!Y- zKz~G*>fn{{7)l;J^xgZ?pm)lhWX>w8%YKx7z)9F-&1_;Edi1JZ!@7LB%Ks@*GK@ZX zm3Tj6Fv;R(ipX0U4Ee2hJoQJg;ORqx_Y;GA`S)?k?ALdd!+{K0jm@&}$OYy0jds@X z_mb*!rddEoF-73UqF48!BRn5g-3=%6xzgyR5!?@6yQaNhI1i);ovMB>@{{-`f()6z z4d#8aIz3WEjzKrrL5Hp29OEYWu?E&_s~?kSdN(=VX^T*s_|}g8y|-rv8IOnjXYL5@ zt69PP-FB2dQdDt4U8*4ia!Aae5;xOubu#%4hM#Hc!zv1wAcrl8kX@`G|iBx8!R68HS~``5t$Rr|ifw%8@K!Wx7ncIQ?xo-?j#uk)hkw z*LMb~$JUS!Ru~ZhsAmj!u2*~X1a|W&B9rjZ?zk6lbd6W`uQ|CDR9Te+n(sKqO1cH1*O~leo+@#%(_(Eet#kdJ zRO^mmSRR;k>TlHUX6BZo}VwurerJNb7hS~}E zA#h1}>N7$yoeuUO>}&i51Mv5Kj@cQh>Zw%OP{0~D=h<8mR8ao%3L%p zqgd}At4EscRiQGPgnxvMSS(<2jW8#yFc(dy!-B{=b_XdsnG?}G$C^%x;v4m z0EgAy;j`O4~$I@=4$Y>_PkQNn=xYv&Q@ z+IzGh*0c1|;iQf2bECDe2wXnT@s9u7nDL5#(zlLO)VFvtkV3UJXIr`&miHU3rU zJ|NkOAuyG9lM1)LN5I13-YU1FE29> z)_4E3ls*K(xW5;|?4sw1lNCG>idxPS75N+jpIw*qm}KJ%_&lPjzq#aRwk~86^|xkX{WmdelsK5hPeKBOQKr?fR zb974k6lxW^0hlMZ21%=>(X4?~`CL^vyQy0_-_6OsjqOiHdR(4?ziu$*Yffm$1{4|C z!f}^%hW#>F6G20l`1e`4VrbcHAU-$Y?zac# zom8?vdvb7Tx&tn2bYKeiHfe!zaW~Qd#m;a5m%$IM7hNSs1hI5(aHs2mz-!dQ zOlF+Y99GGUviIE3vb!5GY#aFL!k0R*JlLSX<}|K)bA%tLNWob5A{2L`NHYDtFJDL@};}g zGvzw59!*Z7J_15y9s#1S2~{9kfaXr)SrSgw^3$m`;PF1mh%|8C0oT(I?K1o&favyl zuMwthrNQx$Z3G}QBiYJ9>1 zZ8;f(w1S8u3)noJu6>!qQ|jX85pk0Hj6V{$$ibQE45s4dKXnsiK;R=ga<6(+rm|V} zW-c$`g`8fxhDv2Fl(Pj*AqR>CV+4ZSDo`|dj%LDOgt$mSw`0~EuD6+;oHRh=$S*j& z=Sk>PwmM+~PuHayRR(K#Qz(_H$IC6arD?Ou%qEMP`+SRolC0+U^;O3!N&v@_Va%rE zMKYYb7x7demONXB;GNm^|6vW4i=E8%ChyI@#);T5_ub{#hN0(XruMeOXu}v z3k#MPclFRnkhmJ^QDXT;Vp;{e#Z#hs^?#jTT2bh(M+<%V(wp_ ziI~@?FOx#4Or!O&jXuee&W&jU#D7xO8iUT}gqZ=+Vi~Bi`8>Wg*f^-5^PWz})?$c_ ztud*?p~Yk1O<-xdwpAsZJ^HtnWg>Z)8yAIB+ttu6Wtj(-YKIBVxoq_so?4zJ$KKjv z6-}c7loUDfI67)*g!gFfeVsfLCSuh_>dY_3YIi*+(@NilRJN~nc3V@p9PB8@MxWLz4i+sP%bS&0Skzhg(gTc8aL_c zGQo#dvRm8rVi$n=PF{x8iqX>}Ee7N(MT;L>s~hB!aJiEzy^Q?5AJ$TnbQE2Yu;{X~ zqT7fM&2nvRz*sVLbdfxB!atPDEeRN%y+g~l_pY`h`0HQt$s->4f2Tnel=O>@=R)>V zOmQ8CZaY2NLGT3<8K1!@({cN?I7v4en@tV}`C&MVB4y6Elo&c&rw+pm<^xrg!*i3* zwG?#Fu0+T5J`DlwL%3&qeI9iB`I7z6hmaR}mRA{Gy^nKz;>XRBX>=98}0lGj$cJdL z^B$K?&pS=7^nr11Vx+BPQGzN}3}A>%-5${vHP6=sXdTBm%-F5oJWUJNFW}iUZW~En zY#w%X46ASUm2lA}TyoTUXuFQuIv&?qhblVq?kqA^kH^RK=Bi2dC-1v1e%{&jJ2lFL z%_$UmLV+)~*(Uh0Ks;z$2*BuJ<*QXZvu}K!he7U~tY&kI)>d!mEuD!}X?daVAz2PS zVg?uw?LStUq|<0IuV`L7c267(;ro1hks5kF(@<+7H)0E?QR|%aAo6v=V&}8QWTdHc zH5!Qq2BBhKrG6WkP7nsDP($txzSJLr1t2|t)UCN=FUAiHmOPiVTlsx{_5P7YL z_{n66jpkoAbpx7EaKmBl_3m;Cr&N1#l>jzG;Q*o2{vI^a``A?mZefap|;#S+EL9>^Zb7ZyCfynJDk9@Om&U4k`LN`X}Mv&}kqOW@9 zh5|cpFfPWz&NPtC6l;pm3g2ubW2fT`)(fOfca^T?=P^0vs+*R-U2}9V4V!^I{lyFtC0OmRmO@(@aJ`5y2n$h7hUE|`96In`P00%|_8>^4@ z4-4om)XBNQMx!a)ZXC!Kc^WB%gubro;_h-F6NF>X%0Yxnn_|shl{5><| zK@2%L>t{KETNh^^@W0UPo3Pm9m1!5Zrg6V>L84FN!aX{OE0{^;f>?S^6` zbz*ia7Reu!n*%iiiaMFLy%Clgo3qio&wIjmk;QIm?+02AcL?))?_ZR0Q{^dBypH9dbW7&+4qfYsDK3P@br(eczeR!He%fVcPkvM2@ccOfTjmDnfH zpGhK>uBGN+Qt5n~+T>eAF^2siN;KuEk!39hQ$b&wS9wL*_(jn~ZuCs!&HI`P^&w23 zh=iGXrGdn$c-_(vbp{O~dTXQWVb$ArkqR00htY&lGoFHTEq1ByOq4*uHT4QUvEB$~ zD!&L!s?)s}(cUDO^{^hyv{k+p8ZH!Q8iL-JCsEIP&jhOMP@_-<^io*uSn?%-h=63`2iOssmSn0CvxtO1=8tQLwq=;Q$rfO`kwi$ z=RF1dBKYZUdn}Z4Rbg`YbFB`(j|_$}?fyf_SzY)&dP&uo4l?CzPEefM0jJRPm+7JS z*KL*;Z<1NJ>~g4(6q=BCTY0z)f!Ylu)5W5KrIGjaZ(dRvIMp}tbH2L!3m%l~HaS_u zTRq^Uk(39D|ZJOR-0~T8cTi_ahBo1&Xq)ZG?D_m zJ#~0PGP0RZ1R;d_0+EUCZEk=JYwGk9HLMzRXIGNM(xL{>#Bx^khq|sj{+?&;cHF%u zIok31Z_9Cpp*sV7#mf6g8imyA!?AB}Vj82I_uBggE>yQi>~-`!qox|C@(?MLt;8dULkQrjF2#z0Pd)T!_hVo9uBwf9 z26kRs%rFc+Clv9pAplBf^3{hI;1?U;a=CvkcR%Yh(H~2jwwlz$VKy_O(|NUjP1zxlWjCxO?mN zPe%ROUesGu%2NZkkd7O?SSUw^zy31j5l`_nTA%0bgYM0I9ZWvn3WB$==&QeKRDTmJ zQfqq6n)=3xyJ1Uh2;{o{dO1(SDiBkmCX8OEia(U}!x!>fo!`~?v3i=z00zuznT;n5BTT=@<9rJ z0~-ytex{jgb;-H53iPHeYK_YlBx&Vdz4_Wg(G76%40`=}{lpyh>T)~%aLD7hsE$75 z>L$>m^As1K@l@-g9tS-A&~`jI1Y(}XffCQuCv3Hao2Db}BGwPN)n&n~U#VwfuoEd&O2)HqIzGSKSCgI9L2#kZ=LhKM7m!etwpHpc<8dG~m>-_1imzM1bhq?(4AKR(fF=zo(M6 zx~dAn)orLh8;wJ8c6d?x+lTCL+K>Yl|1_Gah37+cplObcDJ6Twz}O!OxR$f+(FSkIoj2y z@22^ickd&7i}Qy8Y#L>JX85y)@JB&E=9<(eiHJ&kJ;LaU^KJUCb#XWgqwNe&O)q^B zrKw>`1Tt%^=Yt5KY>@F{=U5vANFf}9ui1UAYscm)+e}px!TxY&3~5*GJ>-mc)=ac<=_MHIvmp(eyxiEz?hqK@0bqm-JgdHJp+#TE3&0t z$(6g4M8jT6kWOFuQOqwfy2)QmH-Ce` zd0!5JemQ#%qmBDw2Uza!Qfp0UyW(FeYOfqehD$#g%EygRU!Me{e0EK0g5de&u$f6cHQ7#{ zH^n$l`0NbFS-i-*`T;EO|Jv8u)-ZkfRx2KD!8OR#p0q4qGc1h#=QMXBy^bOz_7ip6 zNJc5&i$*<1>PUVoI*S!v}d`+(r0 zF4Nqs=$e_|m^kSOn`1T!_w#yp4RRm)&UiwrYj)cLUZpt20Y_AgEaj-jdj))+ZY;#{SMp z!kMUAZkgl0<>eg)66$*utN#4)MixrxJ&UjSFlcrr0H%OD`nbm)wLQzQeSqw-BrS|N% zyth($@=q|UypHNxR+v*nsy@sOqlWSiepbAmZ3T*oxK=m8=47GgcL4($>MZSZK=Wax z7yk|IyA(Iu!QEB-{OrEWE6neU1Oel*RqIrie+Q5d4l>;h&{%El48}T=;g({i`&Pdd zq7xr=L}}O?aBLbUKZ>f^Ybye}oIR`&zZ75j839T;v*U#!L=7FXGWdyDnO9 zYyb0`LO3kXsa*wwqrp<h>!$S;7*ScnVD9uZ%?tP#;H^guDFyvymu!xSFHW5Q4l( z>D9RXFON@~GFv74CQ0bwnlbBY$d8N)nK0>$H-GP%AL6srtLV68+)vZG?No1-YYivV zlesQn+QM;gETVeJW`|WzCleufoQL0=i~seW{19ituZX!BXSK~(_F04zeihc9VGFP= z^Upd;(yVNW{QaC&LWuvO!QYfJ{9-A8#*M+02K) z4-)^whrhVdhLXvDgCL9{@Skn`z5X*Xzt1sY1dab+r2TtYZ>UEBZ-^y&EH&6amVE_x z8~6&k(Tlwb{Xgve50n3Q!~c=@|0{)g6JtIZQo#*GchcADJDhz+u=<%AlNn)pMCbxUd89QSLyM*gs+>N)*E{i*VUJlo9nd3wy|p<79_$ z^Zv?wyUKxFVY}p9HnwL_=`<^yN&g4fB7;)#lDFuw-FJJRhpWE7+uoo9{yMO-_-ngaeLnPS!=2+|QE|7BjlktD7 z$zS_#{(v$G(IRxPQ+vvc^z_h|@t5-lguhe!wOf@G3+yEiCcpUM_&mmSL6xKHMLW5+ zwI6+W9nN>EJPzLIS91(uBq$KLT*86d>^bZ})!2u|)0bA8qdp$PtWEC)#uR)a5-}O5 zJiSbT10i|hX&G!M@_c6wrn$3>m`F@T(pruK8X>a}nQH~xzPWTCY7Dvf(`0C)0C?PQ zB*vvq%lM+=Mf)z0=5|ZOZjST9qDfl*hlS7qRWh4-BWl3_-ZVDCUx2HkInyBky8|7i zkblEHm1;6T^*^=czCI+FWlyf}tK zVv`Z;KuhWa$?$+mMnpW*S^<8HY$n(0pCSvD_M79(ROC)4pL58%czoRVH{r1P_Mc2f zM_m_1@({#Qhjnq)e~o?mR$rp4JKi$$)$S@?Yr(J|lQ4B42~G@`L~8|`2$*BUIun?| zOJ=T2n|P`~v6+B+r8{RQ9?p3cZ!VS_3X3WL8;O6PzS!!~GZ={dmkh`%i;Akdw21Ka z#c?2D)UIvmt)zph+;&*6e%dI&7b~CXbxDZdzs(XxoojPSluT!rUMw;BtZE}F7~xNXGok_nkN9A|vWH0d!!KVq=gp0L>k4L=5YJF* zTc-Wq^nfltMwwO%6=7k5O@p!O&@oc=YGMX35?-QIZ1ap_K^&NqHt2xTra&G(^Srbz z&Js%^Wcxd}x7nvMs`)h6ux5MM`}w!g_^rK}G)->9(Sk4r=Q|tO9Df6k7|wIYxYpKLYPz>jD#ebrv4I$0#8{VGl9bN4IoUz_7aKJqYn3!+knSqp9NKIHapM{Y^Y>ma@scM_qoWpWO zljW^4F8e-$+Z0`jmNKKYc`K|U-S76Wcp~|%gRGW z(TY|I!O0FIWtRN~9?ie4{coeG?RsTNshFEYhugZ@d4D5Y#;t;PZK%T^hhhJQ#bSSk zN^dA(_nrC2QAB~XnE%-!|0*mgywCDxB}JYQD1bcgEC(hzT0SKHBiRwBzNN~ z2{ZzxLhH=Z73VJ~!ubOc5YM;2ReXXdKh`vmOflCt>OM6LgE zdH_xF`4IIH%JnyXa}8=rjw=CiGA7BDx*{J~YOt2Y?yX3V@r{T!5#%+9R~Rm#CB}Gp*{Vbq98|zAe=QMg-tQ48Do)n`>tO|DO&S>Oe&D>ycpkh4y_hcS|$ZS3m4AgU!t4evzlt!yyV?~(WgU2Hyku%D(09k8tfBu^ ztXmL&_PgEqAJcIOGJIALDa^WI2Fj3E+*8*=EyE~l!ruqY;zsMIOtJ#P-CwkdLWbj#`n3&#;}pA?0bQgF)u$WB~qLTE;Jg5&ijW^Y(Xg3`kB_EB73@ zz}uIPF@E^>$qiCOW3ZQRvrO^`zSSkX0Erd@MGzS^pR7XXt=$}n8c^H-iB+8RWV&zQ zQXvg#H=3Rkh}{1xGJq?W4TDO#lvsxQ>3ikJGEOBNIF$8wSp~~IxfOt}Kt@AB(Bl2ld{J$Q{B59Nf6lVlxj=$cdESB*8AWDiDfD)D@f`s%tMz2`R zW@Z*{j_1p`+_Q7YEcUYRAfitO59RcEU!48E)<~;dTTfuf7kt*Yvm=6bEvkB7W7S;A z^ft)PCtB~*FF*Pc0ortKPetj%mqdCk`;!h-VF+UMz#`d@dL>bz;-vxshE{8Os2m5LZHnKyKq?(u<2RLvW0tcc6K&B~ zFVB`VoRW4sw3#G>&BS}hi0*#jfI{wmyqA7K#=E{*SWG^jIqyOOdS8!r)B#95CsI@8 z@DxH%@sb-tL=S_?Uf59*Nuv~S-faB@Go9aL45T4>8%T|~{JTBTeJIp;{*lyjZ+n+& zry9FP{R8ql&vWCk=>o}kab!IM*=C#42PN19gMaJiI{DSg;pHR+EY`T1o zeNhZKt?NzlR&jIi@R$k9@co$8F!dQo@`=l3JxQ?c5gI|Fpp0k80dqJbwzBgcUVX*% zUp?oC7={BVigbfsLl8(cgHhbk1zAQgT%y%86CXu)Q~?*Qfzm-ne(>1cq`s;?(Y~~? z`rH!3>438}pv~W+vJ93QRku>jgyy`y_{DUTs~5lDO*cfz8J3R7N2}IZm1?sZ z9$s&?6mv$EGL$?~5T=AQq1QE)DFY&b@vxoE#E=HD(_s@?Dc7dYRF%b8k%wcR zW=8*yX?_LAP7zfI#fel2xQ;^+S>425x1aeq+{hPI?USYpm-th7pW`|?fANaEy-cDZ zB`xKiD2x3Xm7DaobWkUZkPMjh%NpC|&)+j3?%O?-_pOuMs7I|DLfR;TkcX7XD=GVN z6kns`NUY-^T0{d*Sh^NReQ!@sy< zJ{(4({UA#_T@G8Z`gFO4wP(f>FXVawG;$T%%}8b|G5|`CzQh*57Z>L6Dpmc#m6C1f z0hFu^9oZ0%hJ)S%6&ydNN~rS&lw!~+6>y5L(96h;J7xL;YF~Q$4ck)7=#hfcXwVgO zAaPhcG;KHg%{|Gy`CnE5mvXnAmkCBQNS*H{JMN>JbQ>v+&UrE5>z08*On>rt3=Y^X z!4t}ckres+aYn0Wh#2u;`3AQ%P6vV2PcgDIQYk2XF|?AvU`?tb`GSPgSPJ*D51dIx zBgq=UC!77qPbHcywsU)H0Y-x*IV}zI$INIdf1I4CWI)LBMTQ&sk1$7+NEa1|vyyiF zYf1jWHUNi8G#dzyVt0dgbpQ1YUcr${0--wGMRSGnpW7CT10pX}o-^)0q9Y<7KQV6z z9^G`z>5zXdlqgZ~?}uemqzC>HxsgUOz-h{56*G2+)hE!Xlr=B!TsxKziu@bf0Z$8# zYp*q**}S$q>6yslm&wI^gB<$j!k(~S(eDpt%H3M*{=X&}fDgV=ZP3;pW_tT`hO7# zK={3Tph_U{lgC0l52h_yT8=(7N>my2k-D6t17R_I7XJ+v2h)H5z#PKS=a@6^f);&u z7;H`Z-&+v^@Cj;*!7u;y`aS@bL4Z|8^M|{};<31OWkL&{U)PuN9pCm%P8}{J-S= zODg_XdjD3s|F_10KMhqhK{EGiU04jC`5O+my~aac7wK<{t!M=fqG4PEajdnP&5jDk zi!G^G$dNr?AUuhqsFcjKhKEww9_0xT-evLEYe8pWGf6BzLX*lYKgO_XxpLSX2H|np zib|(*(>Z-xsmt5e(?sh93iU$X(-%3pJwK`eb&F1#Dn1V%Uf09=`3Hy&WxLqVBdC-Q zoP$J``gf$VDX1`G)1{~-x}$mnN&AypzLj4lgZoq0lXeJv2qG0@FbQZV3rNa(2VyY? zd`?3R1R*>>L`k+NC6-@$51fBnY9vdf(~hb(9u@`i^K=tkHvs^4AT}^PvS&7Uf5tV} zXsYF|LMeBc0r9kK`gR~%BHbk`XLIoV9e-`ck_MYq|D%p)+>7#y>B_Gyc2d~}6C0Pa z_+y~WY`sNPk&YKZAOOFJwtGOZgls3!>$r;=&w3t~)TA)1JPi`$TIdwVU0TRYSLtL(`Y4YS1K~1yFZc4w&Qak=dpK!FqdERp*f_kT$(EOrmhV;`w!M z9VL#YAtb$ycaZqH5}$AFwLMX6U7aLwNRXrHm=HOL zZ^mml9rq%{V)O+F7J%|M#8FQJyn!s~)`~Li{zU7YfaAA?!=Yn{gaYLj;qe9+39aX! zF4dbOhM^F3<++O1F_^plAE$0a?!#78BWM1W(Boq;Z@lE^rnwPCH@-??l-(}b- z<#R{(o`0i-vZZ@94HQvPP_9b>k-dUa1T!cJbZHb`j|52=;|&FaJomo*ny{D6YM**f zct{AtRK6|7r3iZFu7GhV%Jn)9&pir6?EAg0K~YFLoL=An9j|x+4nwb7Xt*}#q41bw zKd42Dub8_E6kc>}-?Z5fdXp%tH~V8{LJ~ic-S#8<79UNPQ}hoXX$;!K>2{y;vb(IS z3KU9b7YYKea>Ut6*Cie|O<@Ogpg6xkR*2L0yo^vH8;DC}J!;yucMiqpttilJa%7Ry zgzB(ILEr7LuZwZi+7QT8p-ofBZ(bDjjSw>-KVo|Kw7c|vcgzm(c5WlRwK9>9X0*z* z!k}S$H|aT^FF~g z7bDeXy?S&Lw~rESuCkZum2>>c|+_1?S@Kzmxs2$-$u($umLYt;-! z1&nyM41=KrEr+1s(H@(}UE)CI?(ft-=|Hh-pH4-E0Z_mgh1tAxG?^;x@J4u9GUT-< z%FYOAs%LB8eM=cX$Yv-L8vn}2r*m8=ns#^E&SVl-fuTQvr+|0*lIq3(Vn>l;GspJW zqJaf_2Mx|=7RoibS&fXDG@N(77DhUSb_Kf1P`0!Vyt%k#UUj@m3AScwOcfu)OC}RB zQFqA{rQ6di4--4gE5}H^D89kRH1-ksR3PzT>mpDreGt3mpu6%S(cr1W`ZGc^wIJx+ z2x%(yCXJK6fL=Quy)RY_>^_$#zIIr3V(&*Y=csDs_Su0oY02wx=14D<7Yfv>pJRlvbRl$;74vNJmTz(-ocC z0BD%xH^SF;(j*Y^%o=V#oPBE{nrb3lYy5U1i@EiAg;9ulnICEkAQ>O2(+F0{Fak>f8mjFuHhC(`ok&7ocCl1<~QPNpw z*}L|fk<2A{bSjb}d68wS$RGOl-4N- z%WZWU?~Wue2+@D&b8y1`ejnYF9)ov7=lp@tQxw3W;xk%bsMM`2igz_%PFBu;LlEP| zRuU1K(QGGw-8tFsF=0`8_?$wEJ7b2K7W(epG!4=Pr9xhe5p8-xNPIDz=b*B$=(FYV z+qs5godYvF&(qzJOKxpgUK~b#Gd2@aU^*#==3+pH$V*1sbJTC_R9PrBn@XnpSGk?1{7<&=jOp2LhW^so6Z!7Mw2CKZw(pC@`{Rnj48F_C{4QDrpjXD3Ipg+B zupW>>heUFTKAxW{uG&6%|07H%dkIR%`OX1+^4wcacm1id`MGWCULwpv1E_I`;~Lc8 zt~Ijgbf~nvaPsAzzC;c^$`bNPo?9Hpq ziUl>zOARs6H1p{6)X3o}hGq2x1J!6=O7xgxI{Czd4}9ucX6OT@zoL?rM(}u?#2A-| zE?AG9fSPI3h0&cWyzEZqC+oWAlKmUorB6s>&ek*vDko9z5T-e4eW`sDf1gkybLOj} zwAPF-eY+j&gP_fhM&vzX+xyFC`bkj)!JLH^~~9J<>9ODvQBHqzs1sE!a+m$XjMm_qI=)4KL zO3Efiq$@di)-u$>r??Q)&UD(JSEx__ehmN@Cc0burOb6q-?azvIosYz9jaY?ew0o< z2m7AZgh&T*`Jskca6}H8V(vPl9gc1dVcqz$t0hZeO=kC zXchxM{?6qBw_Q}BIUmb1%qED{arC>+$=Xb#&1rBI>?`x%1tHUfhjOgf&; z)&sXSIH%RrK4%7IaOPPF&u$NH52lg7P-R)N9p212g0`N=-xL=3#}Vt-(tsrmI8_>bop_%*iUxyBztJo{u5;<{JMXyaR{ zc}5aH3Lx--Nu;$!#X=Renh%fl#g4r&7ddT78qoKJIx}KTDK`>GQ}Px`)IQ5D{irP~ zQHl}auX+QOZwq)q^gIMbBtrw3pF(Vtv{h((A|q0%MTR*7*alO0zZf}rD5CU_o0*gf zBh=`kOrFxWIWkp|Ew4cEXav-Js=fGNM4_eMHch!d=`jy~r`7Unc8F?}PpeU`t#Eb% zYaoMuAzLRi%uw1l!@B^YWygCB6(>cE@Yb(V@Dfv%+CRmCAcj1$wyG?ImC$qFPx8^k z?;9~I>rbv%Isv+)6br0Y46MltmmLRr+(-ffBwbatpP5*FjzhQGFRCT)dOs>L#S!>W zS50M-rEp*8g7-7p68f6eCV<=+ddrEY=?XYi+sXRn+ue#^<+kIcphfXwVku&n36Dr8 z?Yw`jT&<7U0VVpKoMI* z2QRThKgb?tqkYvaR0`##;4xZ}Q%MEDnPCKrJr>EeA<_;0nPga3v-wcFlv}njR1Riy zl@77PxcQo-oQ@tMs|h}A9c>A;3HS?a2)sI5)Uv8S6um~#eS6|ld%kSd={sGSOrM(; zJ%8oVBG|9LA2F;lo?-R)j3Eco!)5VUY*rl;2*=Pa#)iOmkjj6?S1w(8Db*$h<^v`G z!>z@a0#ih@NaRZ0uGu{B2sJ}jRRSAn)A%$TEf$E3J3Ac?UU?oOPnHxr!Leo2cSkZi zSsD5#MltUj`CtYE_8s919q$y2$z|cbD%xHM6eD-Zi^kaFy?UXYwi?K7c8+PS>f4Y` zmC{n2e39}M5FUufo7D~`z}KK=*0wV=)Dz)rY66|wa#UUlvL9%gX2dQ7Y@ficGA0{& zh{T0o*-zSv=;7U*PDU5jj>pf7>WrMJYB)2md=l7Uok>Q=zI&X_JKWiJu`c~cqmvSM zY1Wf7)nYkMe@!B|^Gv-`oS=xM9yyUGmZ!dI*Bew|w&(C5ts`66nA3^{YCyTFViT<$ zz=vIad`bt!A*pY>3U5~nB>2ePR9 zuibb)J{op#Hf*$)lny5K1p<0_H0y` zf(7;u+C8=h`tjb!=g-J^?Nx>I?kZj*Ha_ zbb_E+r9Ix?3IuDYx^~ehR{A2}Cl#0$3Ch1lkLfKt~VXP2qk(Jb`R;a`0 zD$q0>mq@%fjBipvVj9>W98rRl1+gV^pe;gizuQfYZ|Yz02-t-TaOTNmBb1W`3o~w)n6MVJarE8ha$zpTyT8uo zS&BCkGg|F#&vbbX!_%K?Gg!8bM{cF3%N*UU*T^FYDLqRnpxYjE)qN88T^>79KQ4>v zo;qaYy6=@{xKXF4jA3w84T z+;td9K2fDC$coORxZKq`kqUSSFO+M;WB-uL5l8m|7>nXR;&GPB&#iIPB2p~Aupf<# z9MrbVgy(fKEuCF_jc13lE6gzzALWk#_m;Mgwr50zjw&J}m{7KiHCD$gx9p}@(~|dP zh&VS>DKkf?;e}?ayVg<0KyN{(xX_=T!>@EIvehsz`%{gQ6w}P0*Nte~oEK11;F4?c z8T&zUbKoRB7IU*Qawlnl>7!5hYdm_XV$(7Oo&eNauac_0L1l7p9_s z%H#cH7$>EgXW$}m;8<&Vj&4zo*%!YzpF7{HkB#xeASme^xm`Z+dyNS{uR*$UHgph4 zg-(x1Y{8It)mv+6)#@=Sn}>>JKK$TVt$sfCes`}HCR`>bPKq0#{KV_qV^aEE|5N%* zPT=KO8KrO|oz-{@xdl_Q5{d*YzK|T+C<98e`5e?)x6Yh_7j$`Z~NT#hf7*o2;6guZgq?5uIs)oFHhGEC4qXhyoacLI2SvHx&ib*_mx2%P{ZTbhJ5W* z@l1(UnPKnqN9sbYmRi0mW5Sk5RD69e_W4EJg~)^iTVnN6_+gM|`$`j#x@xQ!KlgP( zZ#@DztLDUh9bY(PVV!>57;5k+z4O2kuvx=O1TZAKr3P0=5!kFH3l}l*2!1H zgq|(8)Ce9I8qMMK6`YeEE=zkaJ;3;07dZ_8$p>Ti`CwGR5_cfy93|s9!>fw^jvtxu zp7!}-$5N~nxt-K|G}U*|TNCEabjspvZv;1K;gCa35h=r^-c$qSnA!KrU1>a5E?2#7 zPbg^fzghr~URiU(<5D5hd%ja-!mQQI>O`zlvzx4+cq6LhlIB$5=C@kXCoRr?E4$Wj z$TXKj^4D0}-&Tz%2PDE=x+$!CwOR}MOlR3@2p!yBsHg18WoY=w+%7%WzEi?Bn4=$E z>#XklWnLv;SWbIV7iulknHb#RL?n2YL!@Po`2z{eXSBL+p#i%!{Dr}lq!eQ`09Ew4 z%%YYxV*2go)lQlsZr=aN=9jC_Z6s(@&U*{qa-0|QV~Vzm^ofkF4?OO6v=DoB7-8-{ zjS{J;Z^lTXj_VI7vUn9r`tr}N>zft(=rLV1*C?Vp|HShQy*@9R*h$Lrc7FZPG4Q_5 z6>i_8ell9Ab9wn=Ako{5pBNGw2(z<4&=|FxiyW_g$o$8_Gg3o=6 zk$Ql<##m1P%@J$c{DErCI1b~DHDU@)o;fRbuNzF?G;!~zS5FIj}80JoXP zsFTEB>z;}VB`Rd6+{l(Wk41JX4Gbpt?|f{+Wiv(F%hYe9##jlX(us#M7G_C7?|j_t zPDyemvMYcC?b;J055Br7&Mu43WmCKFvMo|$or0n|#Ys7e#1o^MD-q?%Ef6>N49Wmh^MGS*_cJMyFj%Hm5 zgVc_P$>lb|^U<_EX=HV>5l#l(=?fr*}jT!aYr`4OiU`3O_|y~f5kox z&7xz>5?Cl+0S6_m9;>D@1ST_p|S`^&J9$~1NdR}i}msvaf_GX}^fPK0W zl6-WHM({2j?H)KiO6Qj+YPjyPu9SF@6HI}A-}>P?R>u>X!h>%L)OSfQKd{vr?H>;W zaiQ%51_IZsrEkSl(Ubdz5nD;=M-r3V_cK;OoMQ3#7bv0(PpAGTNtAgTR&QS)eS{~1 z;L$5?0L;la(QbQqbO|fxZq_GK)9R8OG~&fz6ju{IeM!{)+>9f&QvcbrD~R+=oOBg` z=1h0wK$^B6_O<$l#MB|bO%4*}COBxsV%J*WLA5O2NTC#Ur^3frNBcSo z?V*W7>E)H;ff{QJ7M~)8|LqJXhoF^i;E%pLqQb!ZsJbha#6jxOvbIbL{{4_=WDHk> z5+aB6aF3D$faKl`73yZ@WPF+G$@M7p*cJ*m@4h_^d_o;lN4A_kjriF(n+E`162?Tc zTa77OrfR0ps|qNyd&#URUyn%?D1=;1n*h=mcg<0y0@Ft>L;f}=7tcbM3p;S@N-p1jWM>K1-6= zn7CwfO%qN4JlMXG3F=}Y{E$dh2liZ{>sRLy<=`1++&)Oa42L|7(WJBGL^J9)3*kO< z&jczFFL4`M3fCROwS40#cs|BA4BNm$*Ks)&VcJA&d2K3_>GYq;UZv8M78%<-uyEmP7v?#x=o02Rk)v{kh2fK?##;; z_c-{xGxbQt3fU4HF2Qj;2TDfMaa--*=r2h#JR(-38`V{md3|sMxg_v~Hl4t(XgEWH za+*Dt1_gkBT{jP7>;0X^+Cl*Uzhz96q3j-tq$U59!H*Fpb_TH-o|H>$0kFvXgjM zOX?Z@f2dK-O(i-tnO3k}*ibms7^aVy+3FfkWMC{%eLMOYtb=~(HsHy)Vw_2sIpGm3 zf;=M&CyKd90c-MS2i+i)5~6PnEM0WzU(luv!%x%2s#CX)3fWak%1KK>K7LB3%2ltT zZ%oH;xv-f!!wguoESwVhK)4)p7)la~d*NvLW}38-bF2xu%}sV6`T19)XNbF4s(Xct zMT_nJej2;6ZM-LdZh$I!Q-_`+1cz?bD_5_TE&t6MUBqe?$}B5(2_|C4D8{D?EW-to z=^V-hz}!QyedTR8vlf}iz~0eMhPq_Y%xkVzJnJ{We@iQBUQm|UvOxpsLS_&5a8XC6 zu1OhLo9{5Fcnxrm`*TX?lQ7oMdtjiXez!dHF zy<1br_ff3>ae5Up!tMeQjYNb8V$36D7eMGxM@gex3ozi)hXL(}kcW0)W-*R^vEi{A zv171u)dZ~YEE*^>a|0gv5oXk`{hOw4IQkQM%SI`1+yI0ciu%J4Va&cmb+J09nm4#| ze_+#+@+gvbbvq9s$k>W}NQGtb4^F(NeZiU2%a57q=+c%yL2Sdvxia-x_}Bhdkd`x@sf9(g!#{cvMVa$YT_ms?BU~ z3rXPDTWpmTpsoWro&uUQXTW2AcRxDvF-3a!b5RK2v{*9`qkGaVWCuC@2wv$`#mV4n zfTJFY2qhZN9XT1*5lcbAyt~UZ>{S7rHR9LMhWs5@>F3Qx%}ZrQGn3^S7J~|L?L0Gt za+u$?wlujU1!7QmL{v@NUC0c4rOZ!#=dIOpliFKGH29hvE|5}AH4VJc|D{@}cPFuK zg)kd7O}f-QXXm6@6W$3t1e{N_F~Yib;lq)zMHjn5=2(%HjFGWC&7Vnbl^S9+K9ype zyzUzBWW7O!UGr~X0L5P6;EZsLw78{TAz>{T;Pb%|Q+^BuaXc3wZ9T{D^4g6il$`QSN-S*N(B*YZ3m)+rp3t7v6^L! zv}2?>j_twD49;XwlH4<=E#CxM{Q$~r-W9_R_u6l*n6=nOf>U8h{evh*Nt;>fK3J08 zZlT3~)Jv+S)zT2Pl9Z^HsJj#U6t8MPj3NW<%^KLP8hO6`Y5gAgjI8wnZ6=%j_&b?b zpwZ4$gbTiJ9DVDq6ie>t8O>KeNE6x~b*C8;en%4?pP;xRwiI{ka3&?%?RQ|G!w ztb#4TkV4?($QZ=ab)m!iUSE~ot@nm?hQ^DBe?_N+r5h&~5`0K031056ryXTS7DeKb zfaC{%jA?9lLRhvx+eQo&gjhEL_OY;V}MOs7@6jC6nE8y?& zFhX@ENm(G_m(01W`Y0}3g7xS8y_;at6da2-N*6N2+=*zPQ=YvIhnQOt!INl#B<*Ap z>V^LC=;3GUpUy4Gg4gfxks*AK4+(G(E6N*uT{U~&j4CEgF(E*49I6m2)zMwQiA2{b z(t)AV%Z~I>hU+42yU*|$V`FfzgWZ8FT?saTu2rUq?gu3GU|1|zy|OwIUuy(`TDgk9 z78)%9MINx3UD_~jrv}T}gGVyt1_g!X$+Fw?@4f#M5kI4FP;Q)NSEG zU*w}ulXXJaz3xL2D(we^;hqqrGqrP)KSEEJtJ%i3T@m5k45{~Jh^Ck7iS%zqHKP?T zWCGNtz$%F^!aGA-^qu{RRM~7IMFwmL;OcDO#oF}AHo*+JXoXn(H0P}{N+p%3H{s>D z35XIt4*b4bjmJdc{wXCA{%+e%v^SwC~0k(~{`aR?58I)zAVf=!m zo%3v%*4y&#TeKCgwNa;eT{R$RdRQEGN3W#Z^0vnqA9YTXAux6aND56MiNhEv%9jEP zIn@3b(nmbJA;^{xWdede*SS8@m3AAB_Lx#qki^hybtunAN!GiIzFYTGyxCNMM<(uc zi$rt?jZQ8*tPbNCGs}rq&HB{dR^mEo)PFpY^7QO_1 zP9BEg`9I1rZ3~OGX@yEh!d&)-+R8!Nbp+@3iQhPkk}U_pEUY21BQta`cl-h93P5R8 zP%2~fdiq-z4J0S{!X)IaN#zXLQ)xs&fi5!c>jJfP{hf#JqBsNxY|iRn zt@CzO*n7I%hhI@{TeH#Wb3me9VNA$}eMzL`Hq!mU&uY?^cFJ`ekI$+_Q(yit+%=+gG)!J=B?Gvdte6ggqQs^W!1TcezTPigy!!-= z;~zr;g4{R|`4G%LTAt}xlMF(}87EQgqLC-UBM>AW2z{?yY%6-?VeDNfa_~TK2^4>Q zy@*(1MED)SWGo;=NCa!w&9qISD*iQ7br6|h#FR_g+j6b!y8cv@`;y|JTflEC(hsaQ;E8uoo24q6%FGOt$CKK=^v;5Ce1k=9;^UhWpF0)?{?P$JrqRw zBuikA6tzFGNW`-i8+6-LH+RWW);jR4vQOlkz~u#3#DFZB@Xmq5z=r!l)b@{Kw5)85 zR*Y@SMS=sNPowDOCNX=r;r>bO$ok|Z!Og44ruK1RRyjhhB76WQezPx4y$4FJOuVcr zYctK*N#hfHWkFpFxCrL5`z)v8iHwNd^M~J~@o=&#P@CzyL^of~Q%3ZeNHty*sVw!S z$QL?gwT9xSG$rTDZMUPX#-_-}4bxYN#NZ^p!Yg0#Tf^SmEL8aXcyWj3(g%f+3?$c^ z&NW-z)!&e9=jS^kZ;z}a@d`hDtE64l1T#)2f%fa0Ey&m}Lj;CV_*T}AYs7Dj754fs(Sw$yB6GT~p+bU0-t} zf_7S3VpOCv?pM3zZ`;%tY z{4u4oga-u^TKRNMFI_AZD?+>y);nJOu)!w@;jHj{hy)ze;Zoe)Tzy1 zaWa5T*MCVxe`FKxGIW?IMcMHh>XTniu>n>+gX?kVVvDEbV;e)A?ULF+-PV=OhpAxb zkJ!6k<6a4;gPiH9`jjmVZ0EW)UoJW^xmTSx)1}&u8$V^4W;YJ(>EqE_f&h+{#^+|qv-VvGiAaB`pV2~ z4$6CP=td{LOEX!F2bs71uJ0IZdC84}=76{<)^GEXeQd)x?UGW0Bo^2vCnulp&^SspHT;nm-}38q~6(hyA~696Iob~a?vm^efAr7NcdlFm-{$vj#875 z{N8sL7d+PoTb-RR_uV1%YNF5WZ@0RM zg#UVJO}waASu!rfXhsQ2dv>fMU|tT5n{+$rm@dFvl}tTHCSZ39i<^7-!&2?8kcrH? zzv<*WvN3lLvG?y`dN5zU;6=G=l|Lp%`DgS?B@niR#9DRb24C{D02Jmi#+XStJ?WrvGsz z|7URF@%^o4%8J#%Ba*LCJp7|2&H*iB`XAQ(KzW3ofR`O_CbL(kpy0C;NAvKPTXAA3 z!!dm+@e_&#xqOoi$dRF;43Yhc%MZnBUqpCeRsaT{$ScG9^&XjYlu?ADa zmvih!wrZhs0sNoEM6lHU5_d=@)izmHLnG8JH?QcEv@p^q0HF}4iCju|Q?v}Xj3mouX0)4`FnZ)7JKx2x( z-V2q7R4>zs1(d`aRX=6o>=LE+m7WiXy7ppH<#cNQe=0Hj7;tLBsjzARFASC+^dF_2^Y<^;4Vgc*81O1Y8nW8o z;!U)p?kF$!#AhK$fC8EBCkI>nxAqhEZZqu5ua+W%_#-DIL=&j`a$S)D2Vgy@urESI zDuovgOU>>aiX^0H|1eg`&H#TI)9aK1$XEbUHtw;;zrak)sl1fHWjV6<^}7}4LdS%Q z;DtKdUqB`ymFB&W6;Klr(2SXXKeG#{#+uAr4Ivb`lpy}QRJ%U_9WxbxSkkK3K(M&9 zhI1mtz#IOBw;>t6*kV;C1JA*KhcYu&?{ZY+#lHU-q>zh$aB6+e{DsGtJZ&3Lm}5UW z2xH6Jk@$BxNl5|jcjL?&5G0R`XH@RUf))I5s}oH$fAWJ_0VziCGIf(hMFsEqyt;gA z7GtOMx`TSOc)Ebnnbfi<#_Dz*=J&}80};AfnVO8{q(#9@>8;hb63v=L175s;hmcI* z&#?~cQKe9M01(W?>QbLC_?hQyWjywf5!K@-mtlGT1)I?^V_EV83oP&h4nhFYdVd2^ z&{;{o)VFA+h^1zqXS(=F>#6CX#V`y=AOE}k$@Koyw$F_-k9Tv;@;xB^@PQ=+T+SGQ_6p*y^<9X$^)*g(+=)|J8zf`A13$K!P|oc!mz- z>+gQABb{xM0U&by7W2U|eAGC_(~}E6`m8eCWsj00ZF8PK03*|HK~nNyGb~?evZ3YF zq?@T;q9kfL?Wr-ICu^410EmblE;dTz0;wOsR`lxFWzgwV*H3!ae+x2+0Si~y3c755 zX1qPZ%V!~)Hj-HS`YfQIZaXu_xKrez_>I-$Gjo~gQpk7Hw2+I3{@k`-g8d^z!Ke*C zWj^Z}+*he4+!upfQWMo1uVcY`9J|;6eQJALue=^O6#s50 zHwoa@&Y|Zct()s%Q_$KdMurrBeugLDB?l`k`p zzp#hvX6C%mY7$5`q)QWPj;^^?xTB}W0!No-GIda<*TAUU_Vi&m4Z&5)h~Jb|CST8y z>-BSfy7M#uk9*Ba4SaqJW}`FhYYvc7Hm3~Hodyd8GYkNUteD9ofl$e zZtsC_R5tXHdKT&Bfj-9l@vZ36v&|AFguJNV`#N##d>YrTrSo?$y;=*#E`bQgvXg_m z<|+kbO1ao&Y~cL`-=b*=)B`>sF;CT&YnYWG;4D)2Ged#tr@2X)Molo;RlPw~o_uUe zQ!QbHM>wuikl=@$MW>JGzeDAt)tu@V0jsc#-3TPwajLcSTfvI?J){S0IjHEjA*$Zj zhl_a!aUfO8IY8H5?xYBY_?W3ry+sX*PQM{puF3teEiVEonxGeT;2Uo_-?O7Se|eX_ z51$A?P5?@#P?WbW$t!)AB6mGix?EG}h=7dx*S3585#U4OXZdY9kS+=WyUXl|S+R+w ztzjxgXH_e`(=ZlHKWtTawy{63Vy? zv?N|RngvDwMx-|YYIw~)0n*&t)xUsz8G2TpY>4_LJE+L#at_~NI*XIjh}!*ZiUf4= zCg{4`p=(eLe89HxX*+K0gyH$|;Mwft!>TR)@>_xIYQ?P2q46p~h#1+QnJDft={)I5 zpZk?8l;^%!YgQVsh^l;LEF6_kq#%DoUoH83JG3we=omEYFrTzs>)!EajNGT&45vD^ zUNg3RbKfR#LiVKAgCyoUQnj2^)1*|pYdT@9K%=y^SeDcA+QYG23eZ%3YiRL`nE4-j z(+#X&el^F6LmI0v-j&B6eco#Cjd99nH!e-04oxaeacfO`*!_3u%jOKZ3L$mFx7VQV zJsTZTov+?y$2D`$j<6RYA>z%`tF|cW(C{X7)_OHcGsY52i)t35E^X3g(kUw94yEPk z7<`^?-L_9-+n^eq;##`=EOhiFAA%O99@6$vj_^|f$@R4=GsiFFC<{5ie}ywN|J-yj zedm$Fv9Xv;HZkxmzeu)R=qTK@MljRSC08G2juSntWfs|}Ax#TvmryHbQgYv~nt5oO zeE~)EaV~lA=c$pEtR)!~3M|y@b8!o-6nwfOY^ZX1q+ahYrZ4b1R1~6YF+Id*@sDoS zsy(4+rd7hOTCW)s?dgEJpXAFvUi7lE;>sB8$eo0^{U=OFCIiGHu!h_3q{v)A$Z3*eVVv<( zHnSge6t^vF2(nNx*3ohIxF~J-U_jZ!tFB!qu2QI1oIc%Td(#y6hH|1 zP4@2AG1M@3ME*S~`~L}*NXjt&yr5!cpnA=1V|69*CQd=^yM}|q^c)?f!PDIU8^PWd zLE*C!+%ugD&Fy5L1`nke&`dXh#`WgQLJ*YoMSMIns4|0_b842Cq#qaA>Nci zeAeZXaN19kau`2*xhx6u&}iUN0%pt!G#m*@SEv|#emFQW$VvmVn?9*Bl;XDw+d3zK-w z;;$#!7#Dvxlh%FwIqae~S2dH8B}h}OUK}6RR3xj5yZ&=^%Q>^du{+G<{>T=Wk(iRr z86b0(<TotjvjB2 znc_2QN)&1gx)SWjP}#+B=p=i4zS(G3sBsiRoMIR7!6oi@1{pz%4=Ueew>H+b-7V62$7 zbgWNf$r_qT2pX}9q9SX5(Vy|{1Mo?;>tDXm`E1?2^;yHjNFipMuSxsN{FZW4=>4(# z{?SWayOKXgIx4(1pR12Nv*J;x^l-n!x<@N8i5U&_&W14zzDpdzI%1EkQ>Y)ucf=^1 zM@2{A=VIr4H01n{lql5eQNOYXc2ZWXzM-P0N0|1$S#E-4W|?278jaO&bviGmWjH+$ z*!zzC>{jx8f6``r(-YIv=(?iDwq7w@>xKlrxm7Q8h@;glYo=p8T&a`%;B#qm{{!MY zZ8KBcEG=%_-Ss{(Bf@=x2KFz1*&PTBC?Bn_4>Cihvpy1pUE^v1Zc|l zQ{6ZF?qrBL^K)&Y!Khq)cnFK;C+hXNb59b|Rtcf1MMRj@7^9jZ}&OhPM?g-#(nx)t? zN+gA9=|8@rnEcK2#Q@h?Fu>k`y@~{0597Z}L5LkNQ8aPfF$sn6WR3$=j(*vx@0^Na z#T?>?CM$BeR)Rl z&+F{ez!yi}Hl3D?e{26mlfhWDtRT7h)qvUeehbe*=%>v}?G_dejX;`wRLDOU=)QH} zC#r7H2LDP4_2~dlIc83Js$Qm={^#BQ9WMC)e;imKZ_jt|;82N9=ewN^;5YjdWF8)` zSJvxRe30V4q)3x-1JV5o2bn%SvkdRr0)?z*TJ73Mx09C3^_w#+!-+iE_3IU1`M$ID z*uA~{4CW%0203g7H5DLWEJ?(B72&mZf>*3wj&Xl=6my3@S81Y*{63zR91**Z#pm%- zy~6o``>Y2~yT^6K8_(G%_E4e15GI!2Gy1di+2_NRHhm%iFO7%u5kc|^DoZGVY#_KL zuY8rl<4YY)^e#D%uh~UlBa%bx8@tJ1p3OpSxM&D!%9a90?t5Kw#~pzIYXR^sT!qa- zqUl`PuN0p00i!61s4NmzV+GLO7LU+1aXT;ot~1k=SbsN2RF9!!_+^8?*-QLHc&uM(IixOR;QS{lod?7m(h zjeqd@yb`_98q$4!v0t3iW0IJlax%?(a>$smAZkf!-E=W7<9!`tY*cRs`oc#c8)zpF z)SZ-dOw3qTC{Q4GSo?%m)U(n1jC<1d?7xgXRV|Y!m#tlA`{jJaa5S^S5FqGdocIoL zsYfWw{jwPMeY)LQ&(H8-A6PRzbXER7VirsBsRsrRn_Khwaz=l>3r&!7U~IVldLzU4 ziJaSd7T<=O{;@DWoxZGbzsS#9@NPFJGa%+M6{x4FyL_+$cNm9*2iSH&3y=XJWDGl2mFY3BWLlX|tyg2d+Fx4X)*9hdcPgbJ@)#Iw_`7yy8BD_(w; z#%=2rvAf)oLaTEFIRZw11ftsshVNRr1PHmCS%&$}Ka3d7Gn^@P$(T=<%&nK!E#m_H z$ZvUPa1O|G;K&QyiY5QHTezxC($DmPYdx$S=w587`tYUcq*bzlje*b9a;A(b7@6RW z9EeUFdyQ(c(OLWKa)viRDZ}%)VSP;UIX^vu=v@GkqGSvS78ERBxldeX+Qg6bK(u9L z7zkrF`&BYF)4^HJ&9BY6iWJg=KBvQMx-ZCFg`CBl?3sDk*qWK(L<(b3O- zpc30+J>Rc%VVGR@lKK{iJXw{?zK{DHy7>|48LrKIHM=w%8VQ9&)N7-!qC+~4zo-nC zo98O+Gjyrus?1`{M>AuK6okn!uN6wR1tiCQhzffFlm4F5=Qh_hs}2Z%XPb>Q4ehmD zjI*BgGf+-Bws<(_?s|<`M>w1Ajhn2edwTRVdUoG0c{xFy%^JnPtJqsO-R@ncftJXR z+nxn#+&23#GznCs?ZVx{lh3D$)x(tKWp9ty9#v~BFGE}5XkW4DKh-j#n{xCL3U~$K zb03;i5!wEH(vwZ*)Z}}-sA_G>6k@lT$95Qgw^INvF!osW59!VpkMO=eU)Wua>8p}U z^Dvw#vwL(oU!1NqK{~tH@P?{gdlvv-cN8bjO;8GamUs8zoYUcureiuJf8aw2m(?<@ z9?-+gs$Zc%vCF&F4yc}*nc#Br`AURk;gox$#5vSW<6Gt1PhobFi%f)swNDG zd75e0^>CIh`@Y(sE2Rf8OlEGfX&_m?Gcn())M}to6{WoAgz8e0xf@B7CqWg zB^c2m?-mc9``TIIkFx1}iaOrTmP7jaa=I#6knZ1sdTVC}1wuk=Q^hWIK93%itG6QW zMQ)#;?nyZVn5y8x)jtHD+yoU{?k=}M7au5KK&|QnUzsopqC&DhU4PY1-W9!ag1t-k7LeAnjkwShIy%Z0M;e6d6o`nV9zEY4qBI>&WgZrM_Hs(Lmvwu7yjBgv z8#2eC*P&bj_a`5%c%4U?FE;}!F_MEIPgt&Z1!H5u+jH`Qj~_~Oo7A}YyJ{eqF&cm3 z>@_+ckgJtw6uKfLt$*To++;A-t+C|tO6fYpBMIV3MyW{yD{=2N#;K=z+6pKu=hbBe zJM4}oQWV)t+;_8=>a{dtR}fPyuJt^4=El4%4>c(mh2sDbQ=;=4%DkQS5%G5 zv1)8bBOP~L)+7Og3f^V#*hRNL=Ap=519>1UAlso>(>$ZAJ~xR-K17q@MPVgk7ct8( zymP=cGzjogx7T~@l3ur#x8A)+4Au5tB9Y@g;yl|fm*J)OcT#wk;A7Br z4l0kp&FTDCnvr)(A9QG!B!;WiWyr6-H@oJ+l|<}xM)53@1*4IgR(3bRoFpj(PqzXN zblzI8*)7ak(W{-Y>+&Q)ouVA4$GMANT04fs6^;*&xd}~h5&hIN-Lap}@mYpX8&Wa$ zhy5BM$cpPzpBR$hj4@V7W5b1biZS2+2e2WtC&0 z`Ll)7c|RTyfX>V(3%hvqTn}oK(MJDhCSD5(gZQ{nBGbRFX_kA}K)vP1M$~O%SX0$! z4oQ3rTembVmqr0S-4~m)6>@}g?l`lvTs*^{4Wz0(6sPMwc?dUhf=msWTGuK^TOW^v zhxSeS<6}u+P^a5eyRV}FHCM5bRwOS7B+6aSwGLVU7DQFcWcNoHuXmpSZZ`mIEE=?Mt-~(+|rCI(ro;+Dd2tg zE8vE)>ZVYs_@Z^u5!d~H@y z1?_sDK2EO0&gf^*FX3m5r+DSZ0yoBpdjc4Fn;VI&AEs@hm$l~k$BzZqAu-qYp#u@h zX%rJc+DI+!^N+`>5$*x47+hiLqfP{`X1k`+z?)sllVoTxroS(f!0L~u$BeJp8<&}U zSmdKefvX#*>k&{Nj!?V+S8t8&y5e@96g%8?Wd3kd@v|4htDQ~}H%v%UcDOqX3)1p( z?F6w+okjHM7T5<#D+FAJ{GQ8%D)8N{==M1hQRoG-Assz1>p*<~EygM&@MHnA&Rcz# zP=;*QOqXJpqsH_AeB#!xjGD%li(?*Bl_pjY5E$}Kg8Ny}jRJYvedaS|q9TuDBfKYk zb6*-pCzo@SK{~pN!$rGjkaZk3_D})53MH`DP^U8|HRPgtUvNlsAS)xjE&-<4+yQ4STHCgkK#EAn z9pKt0zBBAvWWtxBTBJj&2*HWzZ|ke>;OBg>9EW4NH2$EcLc{RfaGj$UV+SZ^*!($j zFcqG(Hi@_-@l(+f!+0QK0!SBaN_Pe_=Ftv09``l>G){~6LixOc{(9OjwN0x5@u&&t z?Yjw4TJZ~ zFzJ7@agFeNrEO9f#>4 zruY5TM2boIg(HNm0Pt_*0t^m>=QQCcN#NcPFN3C*6*$;*QsxqO%iN`kC|iK8!>VJI zBOx0A9js36CY?>%O_iuqvY3co0ed|O*xBs`>32YZB=6wlR6^SV1Jnq)+7{1iu7Tsh z(mL+gN94PdsWni2_G++5SZ$fEr<8x25{rkNgRe?~g0O(#CzWUT`k{6kq5B__45Mqf z3awtZpKtd(v1qCsHYE0<&kJ|l4XBop%=v}%5pTr1#F5)zK(v%a7+SFkT_q^TNO#Sb zpbuvxLTlpM1=HkU_!1gk*iN#3?P~Mf==|%d{9UpTD{)yH;4Yxr14%(7Jh|a>89}n{ zGuedzhMzGRSmq3QUU?=-;QD+%RLL9YS!&o5zMdTsUg*@-vt{3h%oFy`a};#dh!rmzIlLI*;vxP&*Y& zt>skH`^-X^TeK4|aM>hmncH@kCL`n$KQ1B%yevEqS@ru)Z;Wd!(6cXaH~Y=w%dp7< zzXRw0G$Kf&@*E0W4JFgqe~0D^jeO(Cw+w5qg74zNDD~cLMy_gW(Obbz=(`KK=A|cA zfDg)AH{PGztK8zc^tp0csIL5S;y;-Qt2e@_g-PN;JGHbAl(hTIRCE+5jM&`pUoC)R zI^L11BRdWlF)vaFS@TQl`RYQ)v`#x1Qm1B0gX2f@ov8vvqm@t{P^o7+5I&DZ1oMSV z6{)ITV=N~$xt=JV%m9w8``Y8k$Yj$U@dEtd+~{&daokdu4}xkY0#uSSyJLxQy5uus z2sqwB&jX*8sERz$Xkv6KF z@=TYWT6-2g-ctVOaT(Fch}Q?FWV)`pT;~QIA!g&>XFfQx2r5)54%hE>g<*K=^V{*n z1wA5r|a>K*`&wsH_p%OLp=V+i|YO&*A1h4xITLMID#b$l^uroh~g@O#`LzPsm< zpc((Y#c((MkQw~cg*HRT79jV@-ubLDf`z#ZBmx|*w}ey3!%ulTO39V{qdU2hEm+zf z*hd~lH<2(5R#F1t&=N-Wb~7(D{Lut;;=v)}ycp@^^}4Hkis#=^0zmPrA*9vJM8bSL z)^0LF)kI)Nu`Klz?a|2tavxxEQ)i?#MOuX{=jEeohz290&}A>hcvM3^M)QIS1>o=8 zuCSSC?ZY}w)=X$;KV%3fH=lM!v>Lu9^*R-TAcQptM)g~$^DTu&79&HHV?AxYoHoU{ zCoN7(^$q<|Vf>45n;3t8IrJ+rDu>Ze&I!v;KJYv%UJ>s=UIqE`8J1ruaa1ed!Pgq6 z$^z$u9Pu$eigbgzqB<^O)cy+Bm2f2W@{uI`)R`N;Kt|!%8QQvloWbCuTjKh=+Q*wC zyYd+x@gwucVx5LB4-##b(`1%7pq~o@dv>i2D*OKTACeU~d{!8+tH*BfuGx@JtZ(Xa zo})A7FqBTc7b}cH8hsV$@=?-Go$X=oeZ;mFqKWkfuEFnf@$bUhFMo~L``ERHoj7A8 zAh&TXd(Tr~?Ap%>_eA=rUA88z&w1@;J%5WHxvCxHl=n}UYs1wWM8X~98e^>XbAka% z<`J`e;XP@l+{B5(XH!B9WD_QqTqGWq#*}TcAn=1gTMfrKDbU#NTR9T@50>r~aVjwvI)DP4*%V4$z1?MFy>Ql}ndGfa8=^tUmb#uhiTFP0H*WO~flK!| zEUv7!{Wv(HPV+F3ZJ&D)@JwK2FsrllBc;*e5um92?)XIPMH@ z*|HCujx=vX4=b6Ys$A1>3muAHG{HLXI&Q*mV6NHrvi}zCxB;$R+@E?CD3G(BJg$8P zy>wcBcb)j1r*N3%%^d<4o6ca=-2#lDIa`Z@sg!q4$@S~u43pem$hM7zdY{YL$H{+3 zFVW|^oZf`EqA#21kuM&`fLu^$Mi;6rn7WDt@}eQ5aTq$yfYL~cN07Rs5@zCWT3czm zJNV^i1aeF;PY5nrgh`2PDkMrr?~TF>-i4+^1*SlG^(@UhSx0;&z7oz?KMF*4C7v9# zauRm}fWdLpL*F%svCwf9GZNF+uYLCE>RIz}DK5CnEt;W0$Cr3|_?dSEdmC=IbAV4d zQp5DpKhs`)JtmLzSo5(Ut=Dtq*fVpaBR%*|FYAlh;Vj!v6X=t0wbJ<_+_#>-*T*Fn0JWhe; zx|L-;E-DJUW^@I@@YiIVs!Tfd3f`yap2RiQjZoC%5`-x@_vWHe)OwDfJYIo$ARusA z0+c=4h#J4XRHoN}OU;~Fn6YoGgm#vRv#YZfYMRT(CcCu5mrYvr;f` zgAID0K%blLKb|W?=ZbM7Y3aXBH9EE#@lef+@q3}dDBm%oQ;4UpJeZM_ysaz5Hy-j9 zd%~;A;&^ps>kmY?hnFb$61vtW*XR_r`OllHik>jI818rNXYs=#~Nztb8eTA|w1peWY_LfpoJy*_7TG-Q+dtii|T zTVa#C0l>=LTfX}(E4x63VM05`AC@C6yyHe0=CgZ7B{~g@Dxb+j;4PJEa`S~|u30Qy z*W@Z}mpqHMpgtj_;)$^{CgX;?AzT3WW}Pb*^E|d+uCqWgmO$rij6~+fQebq=-7*2M zOX`CFs!DHr5~*EF%_I@am-qDLC#q-bc!lP)1s4HXE6@QhKFqMKj?L5+GJ0`n|C87kxi*Bh7lV}Uj3JD@tY$|ty1 zXZw{;NMzBv`NOgj>g0A}@xoaX{IzCa;Mx+R-}l72F5Ed(umq>mfmJBfYqDw( zFe)jnLnw9^NuWFghkVfD;Ur3w-5@KtO8TU2_5J)TCHodN0QP=eTvPGRf4?J`jFZIo z0l^)08G{_X5`zL37S?%xlE;?fn9TthydFR{u}wvfxg@PZN~qivhN;Mc{wPAIm;6@W zrp0541xem+Uz|gHi1|UQW{pQIi%F@9GF^y>D=y7J5&gW%&{0gXdes~Q@j3`NC%@)I zqz#HXDhkXqyWzKVI#Gwe$nd$-ocg@iyhe)R@Wb^)uO;PV@-ht-Pw`ECrh}AAeG#rb za=j@K0vIYew;bz`xUqFPbZe3hAz<;h#cTZxJA$2kTOW)I4b+~O$qZ!EusUxnA6q}W zJBa%pN|zH?Xz|uRdfo|}8tjV${{{@%19}t|_l-6k(t>U9&D4hydt)fqh5j1jnx;F> z=J*kOy>$J44P!U^qwiz|%U#NB%_rJHa?()F3(-*+*YfLRf!d?az z2wbKj7XY^yzOPYmewu7Z+HJr^?gPP8(#jqBhY4u9c{!<^ql;w6M(#+kf zvlxYx`BAt$yOrL{Y{OJNX6CmDU}~`y%xeLWm2jU&B?gPrg)U!EYL94Uj#B%v1`-b^ zU$Gu;lu)mob#JQOV!eeQQsGf}P(LKRm7o(0NUJAb-gikwz>lsIyg#ke)_lRO4RE3n z!D+m%m(~@XF84m&=fSU?>JK_?@L<;>)d*Mur!^|pZIsbP53nuob1-)M@Dh-3mS+u! z&rpR;AhlM2gl^!I&9^b2I>|$^!Ro6UqW#ktTZAPXzA<<(-<#uJgv5}fRrJz%)_np2 z)3P~o>`T#|yfdwz5hSFl3kupXTJ*@FuV#W3wp%}wr;>rm4sApcNLb$SUXauZK0ieC zKQGIreDIGpeaHV1OE1*kslp~2EI#@)jJ|`uS2ovjf7YZ@?qf6>GO#4c!eg$WKc#Z8 zrLe|$>B3(lD1m+nBtg(_dFMnRbN&~5e;rii`i2d|y6El_X{19$YEg>@X%UfDq`Nz$ zL68uU?(XiA5(Vj$4uM4@-Mkn3=id9-^ZoJ7ynnv)%E$g^bI^FvJ_{TKb2nG}spy zkZcY8RKc0>oj#NPVEy~*EM3L7KCmsT))-j#3sN{WQz__d~+;lzKb)$98B`&Sau zEgir#7-7v8jOT45oyGl$Dv!QY3@TI^=vb@74|9n(uP~g2ikM)5?n=LhS@oLhkB-?` z1zIU8iMlu}J&qB|MK>>mu5!=5y-mI^q_KPXWgh3MH)m#m%_thuK~|9teqJDUwzzd-@px$uMRAls=5}#{u5!OAC3_E-fy}OxQzQQ{unarsKmCMI>`j0UEYSw@M9czuk(hqK`Me4V+VuoI%$uY1M8KlN7R*%o zh}&}3Ql-NRG$eVe*D};`fe( z+zQNKA+cusq{>7;0dufeRzKaaMf6lzBxul7%SLWvss_TXh9hEt*gf%d56!I!b|ZFq z^PTS1xVV$+$D2apXh&G&y!i}2G^^HJ-;-?PoQ8t71p`;o^hDBxaExIQ$!j%Mqr-H`ekl(z{fLIn(KMS9qjllfeObw@>tit5OR> zqFgX0SvHA3Vk7zB*>}cEc|1z!54{qt8bkV|v739Pu;4v6Ktb>SJ(Pfxav`3uwMGO0 zA-xc|-vrtutsT3=DR{iTJb#VgkQMYgo!-waP)ldq znpc&E(Hq}#T~LXrbZsIHp|1Nd=CRHEY+OlOG<0>32uTjX5UR_S4}OnQr7%@qW=Ufa zkYQYQ1pWdYOo9pV7T^R0TeQPu^s5!j!{{XqwGbP(I#zks{6t8EKfFlK61P6yjLk*5 z1T7=lgXZrgs@RN7R=%Z!Jt;w(+dH|VeYG&0@y7g71M`JQt@O7o6j|Qweu0Hq3=PJne10&1Z@o_K|_QlZq$3&DY_VDWjnTzU+zKW-YaL>9le= z&tkU};>ACG`u!$w?~_&OV(5$X%eivrs_O^}K_iqQX5 z(|nFK6ZX8AckIEemy0qHnpjy?o~a^?-82;c(e`+u?LFUIsR!{HS*z({2u6o4O0mTK zzPJaqkJLaC7qmOPczu--g9PIEddxeP-{*|TLPBu|)H_F+g_`K=shI>bRA?dC;l$^l zih}pkb)ujLVN1Y+-}xD4BkK<_<|yY|gcSQGnppus z&+`rnYqrOA>4^F=XF}#xg2Y=+CxkUgwp&AM6X{KUj4Q+d(Y zUi+c|#z#};Ip-InQmu{@M+W(K2^__bs$L;N=arR(kHfD#My`nADyVg#wy_USnkHHI--&2w zT&>K6*_2zH-E1&1>G#T-W0AWz1;1`nfl#pH*Durr+82z?>=dwjqhPw~)p*X#%(-29 zS0goE??~Mz_xh}IZ``;|@OOXV%aTU(@8K`goAy*v+ES-WTB$r2DW1ae`oF26AJJb! ztr>aB&T{yPH1;J~hOYJS0dUMA?&&&YI90W-yVi~JW+GjzGm3&_NkhbrR$Nr?mvP?b zrL52qUTDD7GJXkiDZEM_e@fufR-{PObqB_A6TEuYabx6BZV>y6{;2CGE`smoUGzCO zwp{Xhd1u3ZittKfcrJ%}8xx5<<@csvLs#MSS&}^vdvNOA4JFKObZOI8iY(I7W|v%C z$J9WtACojE#UrXo%fRHR34sntT*PhRS?hk~V68St2V_Ap(nbHkY07xkbe%djQ5S^m zNKcUqQ-8dW-Jb57`1H4Ly?&k#4N?azxr5rvH{z%^jp;L8i;apzn35;y@!oq@4!&KP zZ=HP;Qq)7&^(l0MB9WxO?Z3Q&cz0mqIjOY2Gh6BiMCfYq@CK0i*=*Kri0<&~^_82T zlUmzD&X!LPQi)D!%m=S$(W27WLpoL?cTC+RrS4_wx_bQ@1setH(DK!=D8yQw`EW`1 zmjND}#bJE`Oo0gpMFhWSk~f>Sjb695)cOdtzWG4D@E|!s$Nw3J$1kh4eCWyPGn1f* zVp0jCn=1hZD7F?+($j`9 zp&}NKn^rlrd?|MyS}7x;JNk?M`r*@xJV*R}-#2g}RwE{t)%8ghY|=&SaLtznuaieT zGpGm**9tf4WTR=H4<#3y&w=5o8nY}zQR-A_J)7EE;X9=Ye&@d}(xWlxQA@7itbdia+hS=z^rvs+WY2i`GQM$Y|UsZ%pg;@$bR zh@JG~#MF59lIU`pgX-k9`V{d73a(jAMyIv~nLNd?ICXMs9G)AsAy@X(QVQfa!us4V z((?LxXGi8u*C*H`L@eDXl!3t`IekGTG}>+6CFes85Q^yNBh$8TI6U)utx*?e@tGUw#%gUW^(P`sV6<(KfmFi!(qB#;;Hac~}Op30s89PgJBgF8ZrDqwT?VY~*!5NST;OCEi zA|m`Qgqe7HYUH%#)NAhb6RF_G9!_FYgsvmRn)37QyB_vStwuP~ zK57k&y3eHheer4BS1tg?Bz8B%- zb(FT3Y=a?v9EW<-uLZtBHzwQKV*QJ0 z0mGJeS@7N7{av?7OJKhmhECk%_hlz*neoJF9?&;Qf0&OKu6~t5yQZ2b)y-p(Q_+Mt zV9XH0(dCCk(T}LROR+niY%||r!y!t{R(hU{9+no zi}P*+C*m3+Bf~M~7tF0)PQ61HnH{l9Y^~oy(MIPf1Wuv;;hF2)QrPLmSqBPv*2;4I z9*DvdZQsI}nTX{D0&M}3$f&D`Zo z=*^&<8lq`b3M+e6;rC!$-X=H<3o04-p>Aoi(A;!D`&u!>-Lhrs?<{ghg)tRb(H(tRh6=vaXwJJIc)3;(?Zl3f<1C zxKY!ya{!9jv*}$0p^2hVU4ufPZ$B&8_AEW*)#97T#|8L-XX_%Y(Y5h3O|PZ``LSxC z!bnhqUb<;DCV!7nkG&GEq&Z@)s`kXt8f1!VdfT#z81_1UfekYCiANJlvcF=sA9b>us7K-f@=SQ}Fb zf>XH;XA%xDMXOkOz)UL;eoO z=%=Ro{_G`VqplS~<;c=4Pqp?Q8;B4btt}9=qN!_}p>G>Fw-{65oG452L6$;0KTXm;x2DwP zTj{0bsM57s&zX<<@fh{KAQRtV9&9eJtlB2HH(cCL1ZRR#i_X#d;asJ-IHPHXd@(KA zkDORTcdR3@sP}c;7H2t7$cEKjuXLWfKddNp%azz{G`2sUc{LmZY4iZN^i0b zP?j2!L0yoqt`>jYiTfRs=y54v<;&vOiC9cH#*k=P46)qvvEvM@gVnKesgzSadfWT9 z8J%=isOV*j$l|=q!a3H1Ga0)K9QVaCSzpR;bcK&Rt2ZZ(v3=pj0f|_G6Q|W?ql#A4 z=H|Ezs@nB&0ZJxe->d8E>lL>EJt4~fnNS7}!BZ!hfQNvC^=NlH0QE9x-)1@pn}R_w z_`_J3@%uQEAhRCRjB*?=-4EIU!A#I50{qVsQe1IBW)00igt9zmPx|Fl~1Q@ z?Ed&D><3fEH>y%d2&)yz!~Kst!&yxSmt*VqeutVOmBMWUS@ph=O5t%JoIUPXe~>{= z^S)g=iM&*$tcP%ka_O?v>*n`;DaH87Ftm*w5=wLm1eDy1v{X-f?D5$TuWG=oG`6F_ z*DSZQ)zvMN!Dn6Rc1=E8sz==Mae$bmsp^I_g(_OI&&eY8RDhBg>K19il56eIy)3@@ zcurg0$K_(FXTs6ML5EH2sZB;7>=|pqeRhL6AAo%5`(3>g!dG?*W0@Xk=6ui56HP9U zJ!Uaq`5D`emC{OP+@#>8;@>Rly)1gExayZtmr;Y*)CvGk||V-V%6kFF&SCewy5 zsW6oJVA8JxBeOR>=(Mu$8H)y+@Y?-Uifa#$AJ7APgJn%R9ff1iV-d%xLua0|*tsoD zEC-g1MZxdw%ov8LpFt6kAp`H$^|a}M_<0FGY?E!g#S8~G zzzXh|i`9R&Xsm6$!4i0yeZ9Mn4`*^+IUVciIfG2%FoF?qvn_)1OLe0;ulRFuLaHdh6HM5qcQsLJ#}vz&gzl%X&+OvcW)7{ zS&4ZooOq_f$I+u3Zns(VxmAQ%2X3R4;R9JjEH6~9b%q)!@!q}GgUn%xZt&n2 zPM<`K1Su zQhH|#4wCY<&N7)8>k6oJ5R@44zZV|aFDC3 zA=6Dqz!Y)Zr{Fv+!>OVwrVw;4ELX?f^L7So@S=T{6O3ua$T$ogi6Kei0T%Vfm(q=- z59oJ0TlPCv!*<~3ky;-BnPy;gr-Kt`Ol!p`8;c!hylBDHyyV#3WAkEcW`;K96nNv3 zP-WdmNX2jsbzcpIbhVt$lRTxhtcFmyox+C|C%W=Zq+lhCv@=sYSF*vtrad`*ykk(s zVZJ~u?%m6WWk>l$5?DtylP`~^izjH%WdX%$9A2CMC^!(jG%`sE;HvkA*c6Wp(fsFb*1Kzn7tO8>?!=n2+lWZnK;!^cTE+Y`|@9;6zWQk)FlyFy*J}A)3USGVkjk zu~H#X1jXE)K;I!qW*X!Fi!D;-qMd3%?f- zNtT!n(#CBJsAd)y3EtB<4=3j)ZS3sm9p<+;-`?mwJIa<0laoWEI#A8}8bZYS(tT&M z0ee_Nr4#M;)zdefxT5vaA3i-cac8^?%$wX`Mn}r`>XFCdDaqH>1w`7h4xM$AOPB$L z`Jrmonn@@joS(xy437etgD#O^LgJg{Os!%gR`F+AIMJZEBq*HN?*p!=-gxse|Km0- zsgM}ZU?$wpczz;Vup@&iRGpjtT?pSFE;G7iRae8qRZ>A^-m@ru2ngUW`fDiC=9Sam z>i-J8Av2|TS1&D(1?6lzoxjYL7R3jW*MrqQMvQ9R7dt}cqtzJ&6ck3m*j{qidQc(8 zT1G9a9PZ&`<7(B}O}7Laeq00P7nH-FnN+@}TMOT}|R)iXo`-8}UQSfu;m z=D#bnm&$RzD#I2?ge0KPg4u_LFSr1W^&SZ+rv}++{41rEGy03Zg^{% zeaMb#sTI~bZD~gaT6+A~CF8>c3#?u0kzWfn$~dxSG5MOl1df${s%+C(G9PkcuzrWa z_XU=T2-S*YP<&=qar3(;&9HAlF||a25PlJdp8Op20gKNu5mmAx7@nRXtpou88$}&s zbs|JMktgwzOJ%rWeNAoIdoZ=-jfKqhK@c??7`d547Mf0*(tST%oqRau^~itw>qGRa zN@pA%ru8FRGv7r4&oddGGfXXvC-0YL(FvKDF!1tZUEUMMu{8Y@NIaChParYg8HiAm z$P@yrf7C&3%4c<Kh^z0^zEApn)_o~rt$T$yON39Ik#t&gR>s;ZJ@;m{1QubCAWgSM}FS3SMr4v^? zS6oTbIt3-APT6taQ{zL)^XRzlAE1fv&Cix8MQG6SVtHRiw~#9?SR#SPU^b z5am(YcOCQrRcZOQ*Y!&*0TVf|*oBeYi`Rc#-!vg!A-Wsq7&NgA#B<3b)4=02IRn>I ze1QVbWRWU3?{f|6mv#IM+8P>SJ_GyFCsg;l$fQZDg0O5p-%RW=-(IQkdTN2~42gUrS`|pK9(Xw|4isROr0Xs5A3H0_QNO&?XMJ4prpLYS zt6uau30DIuV6NqH1ZRHPi>p=rL;m%zZyGPwB`(p2zT;73<9$G-_-Z**y+KFTvg}P1 zF{DSeBZTB$-4!n)eD_PNBN;Q@45|lZsCKL_g5k%>A7Mhk6SBvj_K^BM4n)sx5bq@( zZT|;}tqMU6BU=dE^nJ+Vxh5ALb~?R0OsZqhDHNGO;Arm;!(B&>q8&0}gS4XboOCOAFmBWSM84i{bVx58$phwRn%%-4xH7Dyun#i5 zgxKl>igd(#!hoUFKy;#yGyKNorMl({b^)KIq@(~1e3MOe8UGl2q1nyhM}{-^jMJg#Xe7{SUR10{|7!yC4pEjm z1YE_%Fa56-&=DQbvwLs58UE{d1O5Rj@cp3-2w?q3b9wha)Ysrvf^#8notSI>6HhNNJ82%3@J8EBQa8*pU{=W`IBmdudyC1uX?*w>EFN@=QugcnP z@Tt7d-gKcrkH^%y)irdDMr^>*@(}7M%ic6|ClLJoyN4>NI{F7-=IZ_WW>+b9adWvB zw$c-swEBZr?QgMQ-iIXb+nej<{iV)jpjtyq;J_ollNfR|=GT9}*eYuy1`5Z=ebGM% zIXr!tbm~Lo0Q~dPiQQNVVxlB^?Wmg5>vW*U!E*5HJ6#0DrBv#zcZK`$g9@94n{t`b zKgvFqxs#olZlHFga!yl0!#`FCgi=oak^aIe!FS9U>KKe&7kYcW_r{_6a@PaKrq|rX zcG(Y$YB`>G9@90?r(J8gd_2h*X2057xPzN~Cl&*jxHhhh3)PEQq$4TKJ~jg!Xc>?^ z6IXxmSH0=HT>im5i0QG(#AG#9uKFX9NBh7_`|5l>?ais2g&+Q-XCX)!Yl)UXrSs_G zXv5?)T>=@8c|iTmg*nScC;_A7c;UFBFZ;*qw{kH+erUJgb^5;6Y9<7b&XJ9L4_~!< z2D+Xt$#el4D1NnW+1alcMdRBZ$}KwM!PG21DPhGiZldE*Ta-UbH-sB(!2AeUu_>$! z_gdd{e#IM4y#QGBUS%IgjJQb<|3>zw#P1)-`9gWErURiwRg{?)fVx#F&6i_*d#AKI z-dbP-I!lWY!>nrZ`P# z8thEF7=_6^!)OOgaALsV_+Yy5iXg>dK)_&s(RX>;f;Ffgg4C&$(il`c4B&&vb#9^) z@dWT#{`DWe?7f9*+3l{-YBwQ6R+V%WdoQ$`78caR@Yev65Gc`YQkr!$SueLHUINX^ zCg9eZ&NUJl$NsF@c25y(*{OBDQwf^9Z2O<$uApYaSb`y`0tp&$+Uj-rgDCkdi-? z{Vx*BANYt9R$T{w^(V=IIz~4cNE{iqtY%sXZT5qryE+N!lSG)L@_Y zbcjB{kT%B60Sa7PaF?4*=0UAr`>NJ5^ow`7P1_v1b!$WP*-E6S(5OjnY%MJ9sad7# z#fFK$5>*M-YM(ycoUe6k3G%VR76Lwl*3sHvntt)C-?aj3&2EP|m!nx?>+l+b*?J8r zFzXm&IO5CKX)yn`FlBLTI+<}V*zX}GQas=zge`UIqitpl{ZaogT(Mp%__2sB_Si=Vk$;qDW^@3tRUXYL(?+ zJYpdC8oy^)BXiXp# z3~%m~gyMq9IAHRuQKn}Ua18`8p9Wp(-{u%yHaZn4X5dhW2|8`!KWS=kFp+mD`e=S> zl4eB=bb_eQk}!QK2TfSukbm~>kHF7a7%j>URU@75*?Z@Tv!l^LNzmN*nLj!%kYX7c ze&aY@Jt>v&M59ob=Ede%0SWz6&W2z3Ts}7s>5iy>&$g!`Xaw~Y!l%oh0Z%# z2QDozT?AUjb}wY--`(9tdE54xFA7)gR{p&BuNSNRCYB$&t1F>(!O7qbO?tN9{PXDDzH-a{~Hg7MZ z#NKDw1u4ZoOz*HBJe9O3H7QX{2|UvUb0xO@UoTim*tOVzdbfQHkS-W6W)?^=c?ONPO(fP?@cFhBHZmPZ?G0Gw| zUV}-6x~kMg+I8L_bxt^tiDN%a#-c-ABNpQsMi7qhk?4J1z0YtH^B?i5PsEjooJ-d4;~7;k8L?NMErS3X@OfgC0AkfBgbyU0D>zIn}(d| zUQ&Z>qrM49>HShEx}l0a0_7tDcCDuxKVkgUmOrK6?TA0Cn0#9>1wG zAAgRX^GVC_VU<+aOR*mYL~!eGa)i%bmg*2WrowRr47&Ot!-^eb=(0@VZs#XB4~{bP zHOfkRAtgw$Eb3?*$`OgHv8)SR9kxKJwA`?cj7TBUf(SMLs8Q_NLpYBsPDl}}TeZh* zD<+S6aWCMB5D73Xh(uq4=gJ*%uc9Ay2IGAHoIAuJ!rumt)916^mlTCa?ZWyTf7b}v zU^=^0!4kC^y|80{?((!@o>M23Q&tBtV$giNJD;B}z(WtyN1ho*c(7b;*G9qpxUGGuax zsi&s_;psv01X?mTCY}}U&#%0Xkvcuk4+_W6u<$1AyWhw52BJ*P=PGW!^HX5r!df_u zrc;|UcRy~_XVW~$_2TD_^us`ZJe~N|j6vk~%Av(HcLRjwod9qbL9#@PXWZ=_;2J9C zG!61P=(#iOr%pfGE5Ja?>;Mw9XGGP1b^6A9XtSKti%F3an03a`;lWR!Jr8|gt$-Tb z;C+3$Nd{v@*2&rr7E7vbU)`GbP}AZ%f-3zfUntRnS>T6SM;)>Lj4kH1))D$2JaMa{T3Ka z^b+y|-==8;&Lk19!VT?r!!oMn2bG4Xj*`)0Vn}%J7N4sF{=cc5r?{puVXBGw~G>KTbQ zFw|%H=4e=kstCJUDvUVx@&_Nn(X4|q=j!2BjSryDu@^7RL&S2i0FFm43UtilEROL3 zTR7g_lN_yQ2IF`nv=4zHG>&@TZtm9TIv1Vf60(1J=&o!sJpb%uM!vr^L!6XW>+v9h)SY_wts}@Z~f@_7J zr!?5WFo^y)sIZZe{qY|gd4!pK0K%!QvHVPL=b z0{;bKnlwX4K-J?@ibA=}|nj31cpsHf-^y&>JkPT8X0Z|8xmC zx!mu>syu0F8K8arek+hXl=3-c>kmNQj4~)~e726h{w`%zTniC;b-0v=<1jeEA{Eoktbhn88$!vI4bWSETfZy3&-IKK$)e?eE@#c~+W%tWGW;fg!ZPTltss24 zeQ)DE_b@jFZ4*540+?6JlLRvgj{>l**mR7ko9At3(1%Q`nNQdmdZA5DTP(W`j8e_* z3%Zlpw2t(%f{UV5y(6?kc|Z{^0nZ74ANt_U*qB8X%8oCmeS`gENZZYYyiJ4~dK+NX ze<|AMG8tean!rb~#lYGXi=i39yUuyt4q@>$2L2dG;%1w~gvmHss=KXCc@NEwEKZLg zi0(|M)Gec5d^zK>vw_$wXk9(NR-a z7NocK>F+b`&U2o*;At)fBSVxIkm~k+BPsC1eRE1ZHcC5$XNCw-!I%XC)}nnE+{UFJ z#BkCN1X=d(nzVp1#R7y}1i&u_i=WJo;P&*_ zR{xj+s&6Wuvi$3y_8Jrl?;09j52jn|Y`GxV`gMFW|&sXKSSJcvh?_=laME3L+b5n^`f`a(U!$=J*=s*oT4L!$=@ zfN(wRglp6@i0g(-(ONU-Zs8#CdYt%QBQ?ppR>0tenLKGItOrj;Tg2x^$M+jQ)+YmM zlxQH^VOjCWn~=%Ge%XHi>^WcC)likR;G)X?kjj-@3t*j+4#9I&^~}}@r4UgaoO`#DA^__&zf8QP$)Dqg2INxBqdgxy;QG7S~~7$J|B|e zu*Pe^v}OpW*HRo1+|waTttfhi;lhYHK~Sn@e!Mx^*B+_Ibv{|_7BdCRbTn&C7H97K zL8^L*;9x3B*XX!mS=*U6TeOm=WV@DN@@z7VCpU{5xq5T{ngbjTqglwhX|U?M+9Mjp z;Na~LC#Qt`ATSh?1SIJ(W64voPgMUu2Ly22pRCC{K@Gep*92qP#yH?I0IkWCpodC} zUx}$0WXq9?-tX^c?qu{mjM+KfuHH32}1>>l}KkMz( z2K^wk?bNj4wc6HZ%L0|T^AQE?)OOhX*t6WPNzc#_V1eBG+Q11S=En}aknf8+3Ws2A z1EdACM)vgMGz@a}4)rS$5zFl;YS-1lSRR^~RH;yYq9@OkeJOYD>eV}&6KP5FB~4cA zQ=%_U28deWlJb8{G<{#)fxhDGL0*|eaDK@ zr7K&G*Av`_)z!#5mWfTyI~Jf6-sMAf3C?<%2nDE$3BhBl(cF|Na2LKbs$j5caF8IO z|I$brhH$wbkpd&8S3LKgxBDTj9`k&BgR5p`QusUVETp+B!>j-HNQBYfmG2pZ!B2tA_~A){Nh*5&Tz6wJ%TQTUX(eU`KXP1t zF_119$+joBt12=ox+{L-^!bn|!_)>Q3224G)kyAN2Hp@m@6FTE<<71Mp5aPPePSl~ z;3HJowI~K)%LaQNSnxolQ6H(Og{6ezE$|-ee5m_P?1K`K#YFM*5+rAXF3;d1^n>?Z z+vOji!Y5Kxq1cx)y(I8yC=rk{%9mHC4FGO$72rAz8V6TqYug2yauND+6#NWS<)&TpH zPe22fL-0LZ|gTkrfMO;m=E<;Az;=P!YaCy!>mZR<9s)+^n0fQGyjX|qO=39ki} zrlp#;fccoI=9bV{dAkBA!Bd#=Y7YQ%5SCA8SgO;|HI(6R)O_&levcE03i<7#KThz@ zl-b_;Pt5ejzr6q+QPNSo>K#By2_NPf>09iHz>UUDx?|ma1n_{Rq?J&qhD-vNpz9C7 zfL6QcKSdRIW+jaaj}}p@g~_bX0^^gy*(jALbR*LO(x;}jU4aEE=e7Wq0XY(1d_ZKE z`$zBFS4dDL9GWt z__G??G6J{mA4AW(bppe`v+Bg-#gY0y!a87(rMpLhuItb1 z{VA`aB*ABp3+R{lCm`UjSKtR%mr(5l|MSb}?-Gvi-yEv^`Pu(HYq$~MD!=&b|C!tb zgZ$sOdv}xm@7?`tjr`xm@c(i#+{R%$ZJOnUiF)5E-kFNt=Jc)A{F{vgO9T&k9@!g1 zGQt)(zTHJagAl>3!*cx@*gm?3=|n@RaIO~<7_3>Vj0oc5IPxkx?b@cUf^nJL_b@Z!J>l+P-?6%>925Y}6mU}vXH{|w}H9w12Ypc@SW}P#2@cnDK*;~0N;4Qj*Ge4NGdwa3P z$#v8qQejA^H9Mh6*t$Muup2yVeC69TEJ(ao)|r7l2w$?p)TRk{FK3rZF!mx}-?r z2pN@;$Ua}NINuY?@^85uT$Y9UC$<{h`?nv zV717j)n|bxJ)SV5PnRmhN`H@~FD!=bExDe%SF9Xq^zkD^(my zXK$}C-iM_9I`?MOX1KXHR35x;c}XnPR?g38BjW2Iz$RGbH(rq?)BLf}$s`To*2coV-fuBkVl@n!{om2?*Pqy+%S4gQBnIClzxT@L9jV{)9BO$7 zYkmm^RpW17gpJ)f#rmgh?6@`lF~={ewVFE!b$vVVB4$87UEfU|NwrFeZnT0RRQ29e zt5uk*#jp02eR&4IugH2)^vYcFy5Gm)j$82Hx(x~s&SlefvFSGs zjSA--9P>!6n)8f{$p5lAj3GR(t2VV6SnA{C4MVD8Kw14x^zS)|%M6xv z5pdWYr^ivsrlFTiJE!-0KQ4Ho*~*)C)<*lV*5y5IH^)oOrT8S%d)fC| zA-6%I66?KO^XBNm;JuQUX4u|s%E|iqAutQSftAbah0yPB^|A9q>yV%WG{KmR=M8L_ zo|pZT%ijh?(Yj0*nl8yNqmut|5vTUezbiNcSx>s6(T~IfISJWkTvWaL86&7jI`v$2 zLe;$t*`EWPCz??bY>b`Rd&l>^PuPzoa>FS&u18#wj70G$&B>)ncD(g% z>_+4mncLjYCYxSn92`S>g3jj4Z|2?|j!Z^)QTv%Fk}>{7yhvIYS?0B~3++>{-7E2y zDb_uI`Gv-M&pGW|5@&ab(NA)Rt~@F)+;R$@1FXdA&+AdNM;dG%5|*AmALIa%O=$bM zg-hFWZ7Jfd^S|HSJv2!P58YD%!`R>ZjcgaF9-tCn0+ ziA)T!rm^Ko z0d!*dR`B#`UFm#*odr~$`mc&q#jz<*L@^4{_)sd1k81iTiw){AMbBq!+O)LQj0d5Y z51C7;USfoZbFZzgD<)bL%~BVR<(GWEMrV*6Dw%w{9M0`fAj|7aSqpQ)U|)kJ{~L(r z`xLYa$_UM-&Q3^;3$4$RmA%!kc4=TWvLC`=apErU!)x)NN7WX|K2T5DX6O}?!*qru zKmM6jQ}GKj)!WaXLm15tIzqA*sLqtOuTRK*l|Gx}GP+rpO4;w=j^j?2rx{Isf+}SC@_AS|k4%I4pKs9(@g8MO$g-qY_^&)s03_Na08FhuKmi?gST)j#!#+?8bg z0}~cS&%cUxja2`BIwG56f0YNM?7~JiJ+X+{O=|!XC!@y<>zsf+~aBc~59X2J^}H zzkXqiZ?XWRvWV&n?B*9L*iRhAqBB`U8t1X8j(^jk^ojRHx~og>3VZXwdA4}*jf}P( zr-;e4z5DW#6z09TNv}{-%-#^fy|e!f3i)?cfnWy@;fqh`5~!lv83-51lCHyfsykmB zA;T)KwO7-HZGO1v+B_eAv%7a4uIb##pNM6jt8?DF{1u8d&JwN#m1vwZJtSE2o;kV^ zQ`krA~x$qM+9NjF$dRe$(?6Zcl88=Gv8T)a-UVj05K z+!pzqkm_Ez8IKEfIVl^DF9D4|(CRp)zQWqJkSxEUr|WeAKQP zqys!C2#|v7NCvSsyT~FRI6lPT;5`#|6ml+efEiMRi<>tcQ&S){lCYQl6CxA>;QAxi zk)!XdfY#5|#j4SwI^h_Hzn&VWAF3NNJ@~8qxM*Il*u3r7G!d*W=|i>`XW~56c$tN! zozyV6?DG|7)ZV0i7{qqVl#$xU&1TZ{bfDWk1N=qYk6L+XY|OJ7|P&n10=58gw&i z*vrAoyxH{E{)^S9f)yKyPD1eCn`3YXB7Np` z__tC5Z}|V--Y4|FU`!B(fP!uK&7lv@7z?oe-+*Hqw%~oqo|VQj$Qc7}@*qrf7U0J0 zEH9Widq1<&&3o9i@OxhcOjVo3oPoF!?jcR&)ZYI;`6D9}&1am2Wa}1q+7is!? zxqI}}^;&;gD4k41E;CM9${_y=rfRMNS(VvLZOQUbMyIjBm_osGjgZ-f!6!*L6c=Ka zGbcHk&L#(I{j7I%Jal3jM3I!g;jd`DF;(pHpTfD(! z?d-PT`3x}JzO~sCS}b80X%n5AtGSx2b#8y(;t!#H6~!QHLyI~>)EyK^`&uHW=;{3& z**ypg3w1ZLvo7mN<;i62XI-~-!N~+c6D1|3ft|%ePmxoG1O{n~;n^L__G$opK#D4Tv z^iXCw&%2RmtN^3?$JbpG+BPLD8l~I44!USQb@Wr$`<FtzD7oJQPWtyQ$tqW9+TyATBr{GmZW)bDGiOV)H8s1Fz z$9|Fof;4>Y94{?gR;#y1a$+_oN|L_*KZJc{R8`%(ugIpQL8Q9`L0XzkNP~)kv~)Lu zG;EMA0qNK@NSBn9pfqf{rMtV~PTzCh|2g-5xt|yV9BaAOoa>oS{Nl33asy#tIbFRO z5+%MG7dz%MW3#^nzyjM_!1cpvW=j30nRWBpZNU$%;Pza+mG2fPCl{@!dkomDHxP(L z0m6NeR*Sb(X@BCC@J_kE&}L5Tn@BIXj)v)NHvUtpR-!ne-9P9JOr1WFE6pt>zo9 zQ;<+!Hip?WxgFsH@%ln^LoKNl1$Xu5I^zBW5hIr?@dSG;d&0k7mn5$mmG#ODmerAqe9!dMWJIo>ni0dnk|49eCv-kZ{QtU?T_{PV5dqo z$?t(OF!X*4rbwB1C0}PVAH~z^seeLibZr^6{mns2F_?G=r?RIs+d9M%u$h*G(u7J* z*S5$3{o;LTrlTjd7rV?dQ=&L!__JC3l@v-i(6 zaQABY--+E_7`+4UJ^PgbUN_I%R~YlzI^{+*&DK-gQe^Y)Z0?AeCJ&9Vs&$jSqnD8s zxqD5n;Zvo61;Ui(TJMFT>$dVmc5F4_{OQJGNR;sX&DGX#@-hvUy5fL~sUwv%A;9cx z7`6tYqUTzq&JA;4KZUG$o^HLf45B=0_BhcuOMOj0bnc6EK&UE`hZe9pd%0I{R!zpY zWm}tO^XpzuIf?t-oMW#|MbLAaBrc=mt4{GdgRM;ChN~^Bu^2{0qo}YMQn9FN%|;j9 zQ{c7moAPmenMv>Ct-O@0+?{1nSitqsu;QR_sl#%F*BF>B-ppyQG~k_ZA62D04NPtA zHOl7cDr+)q{Mcv@#D1Nh7OyLHGHq2>2!QKkC2ywtZ#7%dfC?DWH=s41^sVlQ+UI7- zS?+k9)81qeQ!5jI3hI}%ZR`2eJ$76_?ZMgE%tOlR^J=w#yGeZV=lLc^{1fnK&^e!b z>4~AgDsA7Sf+DBioJf+rVotS(xiOzj8l6{r8MFa`(XrEs`GV$~qh5OrzwZJXuz~(S zE9)R^h~eBY;`pbK ze&7VK-l?@i^Ik1qMI8)(%PzM^3&Tj?B3@b$I1fa@B|aRG<<6A=v?bN2KS>&|?_0LM zSy33w=%5Qd9#65|DzhAYF)|mV%c=q!INutQO<=7)M1TATi^JSnm9p^!4gLEP*ta=A z55-2HisN?w9X~A6#1AS!=FBES7|SI3K>({d+&uwwD08l(X3<=*NCqYzr?jh;N};<` zQAi@xsKSP)Bs?08yXnsT4$88M@lQawSMCSMlwA-k_P8CCKLH#-UoZ)eR<1(6xj-7> z>>W6T^!Wh5K6YhaH>m~2gccD=+*bvlouOKdE+t%|%hSG!0b_M<%Cu{#ECDw1EIN*n z@+^_-yrFVy%<6Y?`wb56Qp6OZM_v2tNU3mRk?8qsyG75A7;iZJ%W$O}o2pJCV@)73 zr))UGEJhT&=+H^Iy|rxVe0Pamb3GJQT3n#+I0R4N)c<4dSe%D-a}f=`9YTu)|25Ax zm|N(2KW5%_jnzbvO3_ql@AH6?_bKmvzXm&L^& z?`s=nn&gfK(H#H`*jfxqs1w@&QD%&+!u{zc8XabPIr~k)^6wzrGS0@`GhAgRoMBsf z;mcpi!PujN1ATFoS+g&$cdAB3&%+&+hieg?#stM)wR0|EGfmE$+%~U&OxrA9x$ZZ0 z*JRBK?8&RUpVYChHlbGlhow{2mUR%H^P|MshY5n|3=WrqtVc{Sx}`&2XTSVdnhOX1!07B%msPLxTfff`(hIHKDMd0IJDuphH4XNW!94VOe5)5uTX-yO>SP}C-C zg+l8Auh~xRl{#HY<6iRqx)vQXd#k)8VbQ#_CjCYoxsLN|ZKn{tVlJcKo47MgrB1aI zz|v&(8?ZESQL~!O?*Hu>_nc7sD56)g(S;;GX$(lzf4ap_g3}P7LzarG29%H0jPwoA z-ScpwwuJ#5s=B)+MDp6WEaBLI11N+u7RO_>&CYz^{k*1ykZ{?s4+*hgi40RzK+sO} zm@26{=x@#Y_$CWFsjrv-op7ZzSG{Moc0gY6rPRRfdq3mZj}w&NRMI?wwL^Wj^#Fv@ z6HuVO&0!tsK0(E95PTDBS@8(18^G8mkPii2T)(ilM+xnry!Lnb$IrylHPPzpN2{Nl zO)n#=hS9yg=uBor1jM81_}k-SezwE(C*9_j$at5pBD#D{Ij-E`wOt}0j767-sJ%qq zVwi;L^ln4#!yfnZT{d^6k&(1l4VHe5&8QN7@xD#mYj>Ji*TMlebvES3S1zNyp+QM( zji0p-!kz|9DL4>1d!*~c6SGkn#NnJhY0fwkK3eb}sUctPchT74#(?JQrkkOrt6#k2 zdVhTVs*!WT0>Ujv261^-yNfq%98-vz~orJtF{StBK{p;4zU>Ame! zZSv6H=J*>A0JJUT!z&KF4Ew%@B;&iAdM5Oc+p-@=-^Sgm<%+g&RSpiDH?q#QK9gke zVL(C_^n1}LNO?CND+^I6SyjD2Z}1@y!*QMCo3yYyxU@#V4Zd9ezFt>qh@2S$jkMG# z`U_t*2YCWmB$L_E%C%bc)kWjdIT@q*phl_Z?CpU0q{rD0Ivc#M3cR`sBU!fUO>_>9 zX!7*jpIvJzh@k=wfZRswpfvv=(fF=NJxxwhsdb{#L^1U@<@USY_!44B77OD|ff?P# zS?VH9w$04hudS%&2|W)B#WlnHCT12&jfCg#zkb4-9VlKv4G?|>MFB1*wYSp;i}W>1 zM%D^W^@grM6rd0&N7nIIVk2~Zv9p=@!OJv{b8rF%oIKhc9gh2JEyMQ2gm4&r%Jm;( zxbOd&Cp}^MHK-{3uOHy?I zc`*Cg`pn$7cjS$vjU6#pE3s_OtvfCjrvdPFC>=y}cZj9_VHXOL%lOJKEMb$L>Nt4g z3z(iF+RSc?kDdf0B(cD{n#C+#bIurV(yC09&)`x)6gYi>bKxB;y_py)pVjztu{gXe z;6K%8{EMcXnO9g_`e5t?8L`)BCmBjQK3=8x@aLy5_&T!R)J5C(9DBjWnn)5n)CH|6|Qcl20LUI`2A;mPYnjY z!j~W0Zx!a7S`Uh)==1^6h-%@1-Y*j}w6_n(kquc7!hXwy&%+*=RFWCUNVZ#}oTGTm zeGg~6ec(^RmQ*YSfsBv&`Jw0h0Cb8q&$Aak^1c-3p?TjWKOeoUkO-ug6CJeDIg38X zPLF^~>40?D!1Zdov=M4WL(;Ho|JkerupGA*{Miz%vN-`qiBsu->y|8e#hL)MID*_& zKlJ|ka5_e|mGYMT=RP_uYu|^pvl+WF4moUP56@`Q4}lZOY%V_r$@xW!?B${ACGNv` zyj7X^L+gY(7AQJy>s9hlboWmjs607L9oXna40~ZBs*wBpZTBAthaGj-t?vsFNBT?M=&l8xpv-K3)#>xn%&0g09CE>VMjEJ_^G zmTG@?riu|@WXQIZfY<%YbfxlR`*!szdn|$TpZ2Y>!RLecUaPXyUe;F=;843J47ckL~zZ6~rv9D((Z7priaR%h|wzwy}%KJ^{&0NUWHi*lnn=U5zw%+E;p2?7cZBl*;NdA8o`1KgWI*2$$da*hPr_M>EQ=!vt`SlI~ zjL-8TIGjP~reIwGA?&haY>2mWdBgaaNXPI(G%LWbzb~n3EY0-~v0~okfj{_lOS1Cj39B#B@?jqR9NtNP2imV zk$``6RN+ZLbKLpl`SSTcThj@CUZ(JMBD8Oj1!OwOCS5O>82^MIn1-6 zPDAdG0AXa?v8_xY?gn!eiTp3C!$w}Oys{< zyrS|>+&}fpBWvOF%J|9vp-iA8;yKf;>8xCt1FV^CorS6vJ0~p?n4Ut*W6I+!nPXjk zEX4)MpRribeERy8m`Kun^OFs(i;p&&=KfV#^lH zg4QB>R%tkY5Sz(_@w$z&61Pz9si%@>gcx;src_WT)j$xsa?RMEU+;bo#zx5|3cT>t z+njBCvZ%RYWcit9z-3p+cx>ZZ>;zIbUhMYWhHjbQr)7=W;MM}KPOfBITKK$Gg02gW zYrV}457-06A!~TYo|VXzxSO~rj>4vW=IaFbduAzTPoC)ec-aYj>XZH{cRGpObv;c(pkE`&-T2R8$(uFb zV4oA{iOFl$*_$Y#AXEAc;Ql#o@y?Fd45_o{>!Id7?QZd%FNclUtLTo21SrLxoBDOQ zNsM>kB)Oq|F%hrTXVG*gboADpDIUl0!QmhONeZDpz_azwSXqEE}_# zSgFndX^Qj4&nn^~rq2mB%0g#g5Ru0aDolQkVKhL8#vzz{d7$U%AZ(+2xV&`v?-r>v@RONi0kXLB?X zfgP%@O;L)|SfSdWP1R2x)YmnILo6PkRT1Hm0`27Lq%iv9XA~v+yDn^j+5$t12->-# z=rNuadAm}nrZ%Yt8oOl<->)r0#?avMsCt|y5?XGjV-tN| zrJ7a0-$zD@p1tQ`hW(0Phh%jJ%_Qi^F$IJnG4J7{b3A=5SmSoL)|a$t?|&n5)a5vr zUpnNq&}eGNknYqKMm(L_^a4X(+OYtbRyeK_sz46=LBt>m<7zdqmsgq9*LrkC^H>xx-9p;vm8j$Lg`k04bmk6Dkkv(=Qf;QI|G3v?;cK>!Xbv^EmyF3Pb{q3G~(oQXLm%mzg z69WISJhRz&ZA`xbh(dm^KOK~`dy$Yx3;;H{TcpMiKdH%+lbZvntJd^e6WsuK!cWc> zpC@i#K0PV9mXP}tL*Q)dpMa4yC^w7A;5A;nxrhAH?Jcjs3Z7GnS6jxlnw9ZPh_+#~ zKf<1!(!^vJ&61fMW*H4{5m9S_If8x;?-KP3Y|?5*V)12+m4YOk-zGGVnTb!r zBj4MzWBd}$1o|izRlbteo*I-&gBPM&7#SMqSFZE7;@PxSHp|r5fbg>UXXg7*CYa-6~zR=H75INy&$$>DPPK7?-LZXrzQhnn#*1`3v>`B*63 z#)n7a>RIVl>{Pg7FJxj9mu>i}`d%W2(s>fg51-;Oz$93!sNXILf{s(t+8tB}88iw< z&_RGN!`hd3g`Zig#cK>I)(@Q0V z7tcS?^jGOMd%8JIjuwt6eaN(-x9sLxF)MwQ={agU#s^K6TJh7PEk##H?rJ5DiS4$0 zY?#o0_280uERWdm!_{eHw=G$?V(+idVKj-+lQ9Q^bl_XN`l* z8*yCl?b&*(oL`~0U|(Ga{-$u%opr$v=21^#@v{QT2#Msu25FKr8Q}cXjeF#2cT*jC zLd!x}-mICKLECKOL`1v6cvHmX@IWkx|JLY*Brb+32P7?l;pT;d#|k8;XW4qCm})cQ>yFzx@C@KpZ$qv z@~}wF0hLMVpx~4+&f{t}*r{t^s?@O5VfOW){UAB%v*4fFe1-)r=c}wAY|GIVpzjlRwPz3phhJnulHJUeb`lqZ4c0A)J zjCaS8>iB(?7|40uvHPy-G}_cYnw6NuFYU86tIhrBS(Q3?RnT%wWAH%HiGu{9e&w~7 z1z`--wL~*Ly|Jyrb&O$igh%zT_`ti85$Zzy9Aks9xcqc3t za}BxUl`B@9kwROOlepP7^n_6T7Vjo5gMlO-&X^zeB71~t`C`$M!OuMi!eRV=I9H%o zIFi$puo+t;t&V;Y zwDZyn5JS)=?89iIc5RK5Ndv%>%8g4zx>{zsV7EA=W<#1^J=Jvzer^t!=i)`E3^~V>b2Nx@EP7a zU9+9nK|JZ@pg7y#)#{5YhO~dtbq&n{zDXmcl4);}55%{25&>t|rStk(F3unm@)3RH zi`gcgw{_Zsav1gUbalT0)hn9R*Kn04{$WIMlU=#!TH;%Q%mSBozu1!Y1q^}Db@N^0 z5n7TG4)qncS{I%&l!S&P@0h74u1U%ou$KuE+wXY-y@p>&osb(G&XIk? z?Z93z1772`PU4mFHlsrI)pIl9+}(B!vEbM4+{s9pdWiODV?Xo)VSmR!K!9NJS!CFK z#q6oaYD6>EbZz2(DV|+ZBMlKZ(_ytQlz-Y69D2qR3om5cmcZTBw>7K7=EAA?8R{3p z8!PeX;zQ;xRPrHlgUPRYa(j_oU^wb7i`O0%cF#pyUXhL?7ET!ayp%*8 z;5mElg-{<7V|xoP+HLIjeiw5z_I6iKm#SWO*n?EB6J}ZOR#ErThd!v(mG)XujD?$# zBOGr*qfY&6ZTg%{DGg+fm+Ho2!LNJk`wS{t?q-U22G#lQ>22?2AfM$ZLlc)SET%WZ zO_-x7^1i7u0>7(=;wcz$IZZi~KjpWbWpJUw^7x^OC{dr;3)8w9%vMFbmR?+gHDXCV z-wD7V)FsSGW-!G*eC7(4*?MBb1GFSu56pBfd#w;&G2yuE-Wso&`lAo5BO!BQDE%q< zdD4BR-=y2$)!I@TU5OsFBJ*WVjhoNudtaI;%jG4@?L_MUXFPdUXhmvc4!V$kD9~0C z{~l7lpr)ENu#2_5iWwKnHRVA2Vdun zy)yK-g}$Drdx?&xgU2rB*LCE&fN4&cLgPvO~AkZ}z;uz318g4SGpM&lquk5mXH`Ynb*Mb!LB|vUz@xmoiuGP2$#t1pTtTx@$AfKm-O7#6&L*!vQ3qBT;tulE*@{)sI&@ z{?&}9!FsS4=*>eWgffm)bt|^cXL09 zV})=Sqh|F)jn!F_SXG+9?7r3P4bsEYu45G{L$;*8J{NJ|1LDj^3q42E8LeM{{jSh- zqWO5&AqjrNoOq?6ibQ1!ub41Ms5uFsGB+q8Vup5pv^m?+6q@PXJ9B2*C9^dFVuKAX zg;x^yO?JGk-u#(aG#jbqQb9MG_-?W{A>B0fkcIS5OBj38=-$8V(j*W-m97;MX=r#p z_pTBY*+catY~SZGd$ae3sA4TbiikNhZz)47v9-QVi8N>1vrR!|rNWhunIDs7g9?ZeZGRDp>QSj**DlE+t?Skr{F9;N= z=p2}j^`Usb3p&1d&A5P;AQPCTY+q^_;Q|6_jmrRm!@s#`woA8+^{o2xW1cz$+!z{Fwd<0BQ%)t zgvai?XYTo&z`(_k6MLJ;$_w0F26SKmf>FgGIHg0FXhU%Rpu^k#1}9a5qk3VggPDD_ z>F(-gYOa#f>ik%EY1x7?)+%z2x)!Y8XeSA^wQ1+-5A-~}%5-D0@K<&T;>h}iQTNuP zL7`qU0QnoUQdZs9njFSz^Pba|tS1Gs?cn4BB}2(=kAT~}T^RM65q zja|sFVP1u+$RWH0n9nj?w8p}d-b?~9at$xsOK6ipi$t0dK{NRj??!Wr@T6&SK=5${ z8Q;%-FFYANEJ^O$`FN)b))7f7vT;)0;ny5*n~UC3Ks$RXoHwO7ZW+X`KzDs)Q?_O8 z#DcV91YR-bt(&7?`)BQ>35NLuQVu}2R>odD=rlhq1W2iH^nQGoJo zbjTkRkB`OAWJ>KjKI3lnzc3vZVZJ;A&QsoNEMzYQA2YxI=1J@HwFd8MRSb$tOgB0M zWY_vo_Boeg@-vc(zPfD4wqrDn#G2gd9n^?}NgDTwL^H+smV% zw2*L#l7ebWS`1bk><00TMXl^%(W~=?Sl*Yv%HkmoVq^>nvFAP%wZ&Oly|sDW{aG70gjgJ^q~bQRzX>l!6?BR05G+ z6MW#;vJ%5ViiY1e9_my5H5wiSEuLZ;K13_5)=Y)WoktC>_0~(~^Ghv95)ngjo#dpF zi-pylID-?#{QZ>kn%grfcp~ArWW0dRZfCjY=d*&t98^aPJ18HYY-1WpHToi-wMn*{ zi@Q=+H7F*qd^&wRwHhyt07`yFrjga>k2$>9Sg*UD|MH+@Mxot!)co|FP(PpI-Nz-x z;trI2(3j05U+l*)47kuUwD|mi-k4hoiBN$brsCCg2}Ck2v3;LCU*RJG_>lzHZN0<4_S2o-c2JVp*TG;Ms?Vgh`)hV;MFNb}F3HomZ6jO;G+Z z`7j&({whiWYN}PmLqFU$xgaZt5+M4NsV&`qIVpZ_?QN&EDzhn{$9KJ9lZ&>f-V8B^ zrB7a7@03Q&rMjez7+InD&HKy)E;?sV#Pj*jL#gShM_(a47w2)sx@1UdCIAuf^H{ic z^r_mKKlF?m6(bY=%Mi~P|hdg+| z;wUc-eT$Uf%VI!tS}<;^C6ETPT$!Gg?%33az7zu&`_pX&HYp+biM~BOK-*OLdEQ*4 zRv?6X##hXm-cw(|jD%$GS?rhvK&$XvF7DcWes_8@Qj{BAk4OGp%9Do`6KKd4)YQAR z0OI?CIZ6?W6V0Sp{E-sU$y9Swa|*^Sc40*9$yhUSXrD$Oj1)&G*1PQH+~1?^8Fq=t z1fjxfLg(pD0%9!`mJI%9qMbkRoTKFv7?6D;31I1wx)pH&d7Vy!qMSzMs^3+9>U{vm ze5E$K_VKBOavyGv-3$JM_U(c8l8U{*Qhg>Ps$1*yo7tfcRl($~W zaZSF*7$Kf^jL-4tIG?+^IYyEpd_2bWdVc@liSr}Un0=py-S0C`oCNAEi!{Wg2=lK7 zlsdt-Fh832;QZq$ulo=SccEUOVp9uRkGq)QD?^y?&-^V6V||JRtn$X0?!71`)zWYXoB)o5k`c zsqBF-iXL@^{wD4naBFQe^4X7uJK>;O)fv3cq;%}mPT<_bFCh}^Gcf%Ewo7w-vTFj3 za{2M+R@q9PgFo6J`=ZrbL<|0eO+?m7;S?VEZlidFF}_wg*=!_(CfEy-rr8#bYumh& zrJK9KeA`SP3g z-ZBG$7H;W}BTHrHgj|X(pRz0+otqv=IKc}`la;R5?msJ?QQkY?Is4$?d3eXao_3(! z5R<&zHn>l0Vg9I$4&wc<@9*LNhLX(@2)U z-wKq>4|qJ<@UxtH7qzVdjp|c$itleK0o&P6yPS#C3}(HzxfvO$j!K^9&kycRUDWh% za0WRCzu*0Bp6D<1_6Mjup-B8u8 zG{o#7?BhWjTE31zk`PCIj^d6)w<{O?^|YIoD$*@bpdfE?QXD`xf9NFq3AB*HaR&d9DaE}L|{CP2T81rQBy-a^uj1KL_4QbwOok-3)9 z-CtO7?u#pAG5qvcX&fxkNlI_~eXnN%aAN0N2i5zG`{?Swfu>`QjtbZfsGX`}^>5g? zj&xjJ(5^G~o3cnEq@<5PnkT#b#xmC=4VZXP3wd@%-H!wb;sET#JdZ^Y&A!85&90P_ zSKerprkT zGIh6l{QInapxEhMbI$f_NSe{*6KpC^4+UnjF(%|-w$eIoo0pS17(zCG9Xza-j*ajU z?lDupCl1u2kjP0@%C$N$l8*smHRruU)>byL6tdT}#n)_?6z)pjYRiwANpp{%3C4uL zt8ht509JMCi(OB##5gK$^TOC$X^M}wjvg^{sKS+ zlLhR)m5|&Tq6OD2(XKeX42^-eWbwSy@wvtRa>#L#0GfNX?c=E;7oFk#=7u&*8PV`; z4CX}2e&(Ma%JiC0ElN?KRi;!A9e1?5bJ9+_DUc(a1`5B{*v#bV+R8&Hdm)EP&3Utb z@^uY!p$={5^dUry&~;C*t66x6F}bT{x*dC?`ptYC5?Z_rTeJ2PuLrhI4HT5L1uR1< zd(Pb6J9^e~Y^_To3ZqtShI24fzO=RmwK23^sfYT*N4`^2ckruEGb#?NsbWIW(wqV2 zEK3flA00SZ~>AhY%$U&+sYCDE1Ri^GfKBGcpeMO~PCUUCY-xGf%UqnYy z3hR};ui)N7ba7V(!52Hk9~1IR-Yq2a9S^5Y`GfB{eu~lmVfDVVrMcEnDTihygPEc2 z%&`{@t5izV%V#Q~v7jcb{$(80X40`FEhxPP40%Uwk&E~+8U!5iUgN z9lBH<8vWO?qaGvkD6(thEcPL;6(-X$!^6$a6Zat*l7`fAiXfLq0?FidJ660C-riR) zU;`D^@}8*UNL_sKWUzz`_bt-=Ayr9)g%wcFL?BOdycCY&2l!N%hbFS&Pb|DSQ_^E^ ze<>pb(UAWDx$Hz&(dxQrL6fr`!Qa>=<&d;$$+<8R7{7Ob#`GQnzFm zYbK5~N)-2-B>6*|lH1O_@m@SnH6woMA>ry%!t~hPAK{#evkSgv!IMb(r1+><0Ob1N zP~K=Zmb#oM+?`7ig89ztVwF zZV$z=x;@^uYq?d?z8eUu26)8UmbY7P{)Y0(cMl+l0wc+G&P22=pxMl=Rq%>Fx!R)d zR_SdupdmbQy#H(PF&6o|2Aj4ROa{38e2%*FEeOefQEHD~-xNk#q$I5(4!)wal|T|6 zqYr}lwG~rFo7OA!0IL~~eXkQ5L*ZSOFY9ksQ_`I3RZtU^-bG=dX(^-9;ngnTq3;5L z3p1uanO@afu}pK+9#6focrSiv>~D)KM~hvHQ94L_-+7XOAy;QQZ=1?ZK$O@O3*q|V z+06bEf$A4Wsqk*PqKAb)snh4-YX<=*0nL0Bul1`XOsDtY z`$K;Jre+j>au{96)*8aBjln!uv06z4!3+Z?G*t@ zdHV8PJZHnCMC|1El(T{*A5bC`IxWt7-{7&ZJd{LWg{D$4qccc+82iSo6UwGdscaQR zB|4^%CaGwAEc2l+(L?zl(+3SANI;{^PxtV*ryFn%bv_F%QWBDE5t#ruv3feDQ$=6_ z{uzFK9P(ZyY40{;m$pF zRF*{4MpM7B&EBE)B|S-X8W>NKJ>#FUk!w2NDk@6~G3)s=)AovbtnlL9Pdoj$KQDK}tE&Y~dU&&IIKQ3cQiA_4eydrd&CE^eQck?g z>xz1eLLo3ucs>%;a0Ukroyla3lf^q(vI_w{mvz&03e*BfB}pNs$V zryOu=QEUR%|GD^oT}S~JZ1CKmrc}-Ub>F{#lKXpWGKM$*>wo#rh2p5d>MP=U2v+^? z2LOMH4g|O6mCO0x5AgRwETRwqE}%MdH2uGx4GBtv4Q_1_E$8?DTLiw+U`p^601-H(J(xLo&h5vr(691ot$oYhM zHf2WrE>jX^N}XH4T2~~<(bn~wpuRNQnmoIjDKda8Hn9!HUUg%scp&qiq9pd{*0C_D0(DH98B8QMF>Yr29 z7Fef%+*5z$z&2Ktk@-7tHOclS(IWRE48sSCWjzgWio_?wh(*7sTW zAxdG@>9}?gTiFju-A@MOHMeIo`Fw33MGiYK#~RO1w}2F#!i*i3p8KYo>rI5f**o9^ zQPt?E_jp41>+$C- z+44oVu{`A&rG%v(S|CiyIZ8Gs(tii&G2gbvg!TVcFr@=)bun@9>+`d}G$X6h%@UyR zxK2XSd-e14@ff}=h3)j3U;zM`UG4kar)=mn?llx?HJ-`a9ClUViCnH&j@3I&NOwN2 z9u~hl#O1S|#QO-c%qsr2)^fG{Qc}JvPz{6~rS-UHzk&YyC9=GPT;wr+5x-+e?UedU z*(fsxJ|92W(3Lf#L3yccHBqVt*oT5eDKen7qYcaeUjy?3!?EBplUkF-qpYy$Z{)Uh z1H@4jf(mmUcFp{AyOVwDo-mxlJFr`3DXnYX3GOCWG){wZzM8ymyfl@#x)soQ-U9t_ zRaVZe2mq2%2e|thtM7^lwg8yUJm)g20OrACa453QSD?VG4u<&zwYsBhfOwRWEb5Ur z4fe3^2(a^r|A~!B@)d9uCEk5=4i#Dq5W&Lv`p4(qYwU*`+bN*AHX7|HIDmf2>$v^6 zCR0t!e?uW-#6Npe1SHj4P=8x>AeJB16v_bc0x-wdxZ*!LE>K3Ee7n1tNvS zCb&`UAFbe_J~#Rut_IR}JFRfZGQET%4qc(fwIFPADnSIREo=aVXiRw3_NDrNVi3Vg z5J)kQ(nH`+rkjnhME<96@S>-d=FlLL8r7_P}(dFhB0OG>Cw(o{^d;rb!U6tvx;jMTGl(Wb6 z=`QO31a20jzY+UES1KLDhOvAF$K$^|F|ho~$?C&;T5n(~tsCK_xZglyVSobjb)jyf zE!mLBPI>z%_!KCH{1c@RQWgMD?i$gXz^MVS^c8egN?>!2zLupd1Uy@_Q$TLE?7yYo z(!Y17Up;66aq=ZkL>b>Hcr{+Jx@(~NRw*2%y5U!m^^_3M1y_;YG}o9>82HQW0DwQVZZS zo~}l_onzew#EMKb)OR{l9U-x^LTs~xfc@)a0%i_SQ9xp|71p6ePhO{Jt0}M?7Q{FwT|r3U4ne1wzZpde zYMJG*=9it*QySmYIqY%~uVnmtD!!5ft3g80niCXcoTZxK%{mRB70t49Ugu3;`WYEF zC>~iP@>vDa&xetS8^fq?1HA+=TzHVJt@fPPiYeayb>e29nXpA0OSgt!M=;T9un zto|u5Jm&!(0INq~mHNcB1QWPazB=E}-+s%*&`+^)YxIEMdBZ-UUAm0dhxiCM%vy>r zO#LAO72R9ik7In7#B}4pyQR1r7@rOP#f$UQr+#&u-`N-~%(h)uP(!0WQ22T@YoG)@ z_?LxRKO9ON<+6>UN&3Rx_e|8z630YBJzu4%+VsXOl%3;Z&`25hG!c$$!4_*K^zvJo z6hg1l$i%&i2cp&bQ z{mHkV?;dqSIxz14ay8A#0>go$ht?t)o&tcb8G%85892Lall}fN`iR|4=sVLi8yoe5 zUv>x(;^$SW<{=IUW}nF96omO4F(x>3k)4wA&u`${@qxXk z)@K9J_;#-0qY~kJEEVx4t(QKIyuEB1Vtc`hx96(rwew;xc29C;5JL=Q?+@$9e|(XQ zlURLqV}_|y9)O1&E&qv=qjASE_9s`d+U)*YIRwaJtZV>@bE*9ln0je%Erkh_VM%^! zs(kiu^2i_qV%M7-Oij*EC5h+VAvQe5@Q>D`1@dI_yE7%p=Y^!QgYMm=#w ztK}%25q@j7a{2Ge^!%%jr?gMIN71M~%_G|>13f1$EV6a2XY0PuM*!=tG>7dE50fsB zNuDJ5f`Q^t^eZOZN(&l`7Tw0Mk4({KyM=uOB}agi8<7HJfX{qD_#fBmF^PP#+{|VE zsyQXtrWg+KYTW%kGEuGK(2q`P(`CJkl?Yp;^4PHry~LKcsyF7;Vsn%jd$b=>~ zL}~e2%v7maTN!j73r%{d&Q#aON$Z~bRt(oU@SFnb_l$BaJ2otGW+crOM;%nPk@Yyw zEoSQqUC!M`bQ5&tz4F8mgQL*U;^%;$%8gtidNwJA+c%&l!l{1H-^+!6{7e>QOY;~T15|d8c9^d`u-vb`d!$2Jbe;3^F+L&$-W%2E4 zD{?GFcLZHpJ%KYvmD{l?V9Te>67%@=fp0!N=1-YyRIi~|s28`46rhKWN?Qk8#eV&6 z!}(U=&nGVh&HFp#Q9$~5)06l<2*ag#VZdKol?4F!74wBCOhbq6vS~YIsSmwUll*}5 z|9Hl3~Z&VP5!!fpGQ$k~TYDW0ikRB$Y?g@m;t00g%^^>f6N$p?!|ucAn@Q z_`Wir-BrlBOuwV&2Pt>Ab9T9|$I> zy{ldUIO8kAU@Qz-z(6&q-Z5xu_Of%9CK7lu%oNDuKu~ZoX%tl_#gqFyM^YX%%gaA- zVm>-(OXuB0T30bSzf`2;ji%Bas6Mt+ zS4iqY^e`n6_0n?4nz}SY&G3?(+rMxCP8IF*?zeILQ&bE26Jb~`6k?tQ4*Cmq>*?BM zHT%2Pgsh5tBmxA&xgx;XgKTudxHPbkgkU|+|MaB+y3pO_#U}kCUtp4ky)0(cL?ZJ2 zP0)29_Cv-Z3=aIv19Ir6k`J3SURj)Cn}O&VUM|m;xA!M1w!P<;FbVpl5ff$lcI@0v zYkgtW*7gy1Jii{Gv8gcqB`XR6K%y*MN&82Z)uEBsULlp{!dl~ zqXBt6O#$&j;tOu5(@NCKWt*BRv7u*RH|ri{#Zu2D0P^y;#dg^%nJ?R7Nnn`NHcf2i zXe`Rz_+I%ooRp^~ti83%9rWe$$oTu5`ro&B`!^i?{Nalz=m8=2U4nkP?4JYI+T^!y zWS9Q<-Fq^zK7wY5c_pi4CJ3-Gks0uws^7?a9LR_rcBqYl8qwC3$ zKxa2-@>|0ur7ef9D@RtRc#69_`1k|5A7ngIML*|%!0h(b1IaPbE&=c#yln@!O`N|ow=`Us% zJRjaN^A>y^5A=%~N!v4}ySY(T447@%FOCXC^jwbFpki80Abbg6ICHQ+#E7X?drj!N zCZ=8&lYoR*$KVfZ2AuFoD79xQ-fRz#VJ=AHD+r^f+(8HHzn4}LWII8@L?bSMUOfMz zzSQQalpI+p%ZyEJNjf^?JQ`^N?(igl8%xMqnDf-c#wlIyl6*x?v)Y;{i?W<+c-ONE zKzy&POy}iUu>}4es7XRnE$hIhDCNg`Y7|C-T)qYo>@3yKkJvNe(BNfP{alq9IKL;WNK^$8D-D_f($*OqVK)+@-HiQWqs@3@1F0Rz4zJ2N8oCA zY$m0j`T1dNg@+NBq2>CU1|rRXtK$xq^6CZ%2)V?xt{?5u^bgvy!F`zXZ|;#oWi~9` zXusys5X*>?4|b)WN0kU5^fDy*0YdPrIPOcU>eh%qJTn?rH5w9eie=!fFEu`$jiS8+ zV+;0-ruCLwNOx=V>pjDYhgvRkV+lF=Gkvb-!5vCDxU+Jqg>iW&%u zRWLnhIz#C+J_yQ4@4%Rby`Q40JS;l#-lmJE$Wbk9nCNl$-M@!?)t?`FHRtPTjUDD4 zhCKX;o|^1F8Mf3$WB#B6xYK-XlTM94$om(P6!X3OczA=_y42UV$x8bBv4|Ik%DE&L zd}9gtr-W~5+MBJFi=Ga}=wN(Q3KD*jh3+P3cKX9Z`u11Or=}P=k9SUE%T7mF@*B?u zG?v@yZ_Rs9@uoGE;PRna#d9}%Tb_A*XGj;vv$gW2a8CtJOYyQyfBGZUNv0jY_(Y^< zvQ}GpYm)GW@Ocy9(3=cNH~aCQ4-5qejs|LuwSy02gKbU1MJ8U7%wL*c2vEdJaz@f7 z14&9ppwqcK^*rX^~k#EuCo@Y!-Z{@3>D%)%0<|oihr@W&_au%9f z!_slo+y0sRW8ymsD<@9x24O~KX|vzGN&%}Doqyu7;7(#Kr37l{QPDLw8@Il+|Nx_h{pd3F;fpg_f{UD4;@mm(f*k2Ah8lHCH1|c8mpe+_CnqP~p7&<%ylkshqSB zL7}OyE7w5bICYYi+waf1lR>IbOc)c#g&tL`DT8K?Vx`Z&8~O!u+P-m2IjTRPrANsX9DWVwOvPbdECH(XDK13)*Q2-FK?}z+YlYc zN&Z4BHB#7f-|ivh6gRJ*p7)imQB^eJG1&Ud9KQS1?WSKBzxd2LDi|oxdNM8g3t)y) zM39!U76{A7j5f=Qpbl~IK0uMn-8^?jnrG+5^~4;PTid8y03=CxBt?1;20UJHErvsW zCcR$a#9AFTcjGj9ECc5qq`|VZ)G`X@9Z-0k^K9=5$BwUdbN`ir-wz*31D#J@!eYeo zJ5Eo`;)d=D8XT?7knjJuJ7$2=MIT4N1^X=oI& zzLit`DL{ae_U^SQy`?`W z0gjM4$yD+cX&KKt(rJw?vO@ zQLx?f$GmgtMw^w}=JBPs+(xXfhuFiE5B*NbYJEdt;E{|1jlXjI%VrE&^sfrPMZ%~n zOn=c-UIplBn%FyIf3-NMI9Nmw>=qjphs^!t7M zUiU1R#98q)8_rI*LSLt?#ZkWXfLFAGqHSn4AP%wJi2+&g=t;iRvx`*#ht>@dHk|h; z?-19&{)1rtRMr_5{q)LBAd-J&W)(aF09HYI-vmtiq}0ZqBD&9y;D){=@axv*;9kj1m^}SD@O`S{( zWc8Go@flT)dr8$o%C|Lx9MhV9g! zF)DhrF4M&+Df2|~79>%TH6Y&K&cRwojraM!Jf~-{vM@n9W?y$r$=fwj{hTX$4alc& zlZ6g?pORh2Mb*Zn);|e}cT<%lp}C}}{QS7DtD{)tY;)8U?-)8YSH04YNQG`l@3{Qk z-MTxj6ZbCin)&n}=Len8gj-pxM)3KGFXzquz4G$s3Vum69LWZ-ee|TW_PZXm6u1tr0KyZ<@0XMAQ7xWV26%or~ z+G1sF>2*;3D*DXaj1cGDv&O!=X(L|RPv0;d!)+~f!sne@|4Ncj!vUp3*S`v2r~bmz z2G3P2VoK4B%SD(tosH%WT}^IRge%D63Ou(4kA*K1q?dRxI$AAi#S`$b)7fGc2&IHu z{SBCw05MWTs1a1bqWxIN1dDg8mK71u;Y?j#x|}+AvBCT!3E)SA)e0AB1`kfJMb=f~ zhOV=fF8|H&hsg*&26GeV(@pJivtD2ZeM%HQ(mUKINaj`&-hDa2=J3T60(HdWEV-ZG zeL_@L@4zM*@m~SzKY+>p0zc9%bD697dOG3E+Qa?GKq-r_0wWlq2*-Kv;;!Yg6#i$;5|WxE{>p4cb#4&AmqHPk zedJm(cG!a(ex{hoxcc&KDM1ZkVq`(yzgB*&l4{&>Rr|hGM8eVNO&LRLuHDhjAK1U5 zc35KuOV=$M4jp%Ksc>T45{|Ht*g?b^P4N#eWgcr5C@=Ca@3zP=DRLY#J~DAx@x+U0 z-)3Mt?xGf+Qec{APsgC?UEYPv^(1^vj(Ljwf8U@G#MOB2IRHf{_1i=3;hs7SaopXP ZBB=4FYYfpl?tK9tD|6ceh5JrM{SEydND}}6 diff --git a/examples/xnft/explorer/published/icon.png b/examples/xnft/explorer/published/icon.png deleted file mode 100644 index c4596ca0b860b8e6ccfd3ed23cc02b8267d81c1a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 19205 zcmeEu=SKfGU# z;!pSO%-j=eR$S{^J6us-3LS+Q1qKENUHYTAG7Jpd@$(;KIPk=`dxi!4g=i!rB@XlS z{5!j)C>{oe0!CU~RMkCwf62{TXFB8Q$*YLKQnJNufbnyc$#3;v9lhu_?L36WD)2AA z;<_4MrQOGk6w)#0hkkwKi5}kZ^;Lu=Pve!{P`$~;a=~}Wv%9XBJ#*EA!-8&yK7vnw z`pjmp;-M)5M_z~TvZ$oN4F2!e|Lws4uN@fY({zUQm+TJJqN54f6o1D_^;#2ql)Z^z z*bJjCSr+kkLD3kU^hHMIq^;m4%MzUy1arpib@5)Y)e*KX_x*rP!er-b<2R(BQ!Trf zR-@p&X{sg1&Cimb=PqRpID^3#qnzL+!<7B26$DGfT zfgDg7M@gUFr;JiO-XXan>wBwiWCM)i_L-8CO4QuehJ7*kJQ8 zed)kzrCz*2x$V`gFzORA38|xp-Tr!d^2?WY!jBg;(pHCucMBb< z!nQ0cTJyVoe)!`r!EDjwBTr(af9j_t@CV)`8@`*Fx;Va!XxlF?-aAJ)7bDF57`hn} z*RB02-YHKE&ZnGox*XGn|7L%g@dyTor(F@-!k@A#1+76r_U1@alS4kzh~UBt{z*JW|+2Cx?d-w&Z)%JBqi1FA_>FIYXe@cpR7y?&mvng`? zt=Mp9l;04y_N%GP!J{^>b5)s!Z*a~`P}93*2~FNa>a^%iyB{P&X>AZ+@=A&T)HmZW zK`(1k{2KV4Ah`(8;E%dK%TMzT=K*qbw;t%&?vg>?efd-5BO@4fsp7M5E>2Nt zo1_HwW}@J?B(h;gt&MW;Zt!S!)-a&K-ezuc3m0q$|2zb<9dpwa^wi#SKv^K)*ygn6 zJx5RlhEkiv3E+wolz@1B@&QMnUr9v1sc6?Ttk@l_F`G!O)^K%LVu_<0$y3f8rti0e zpjI%)`AWB*9Si^PG6n!A0Ih zv(G725c5hK#Zl|f>3tK?LaYsK*I?i^M1HKE@zMp}97usa#n40+E8G3dlruC~N5nF) ziL0aK(7={FrS;+7XE&k zN?1<|5;xVvNh4^qEQ=hhqZjLsR&Pd-2~BQ(miDp?MdIl8e;gi)`r{3`aL2jJgpmg4 zYW`O;xY=n19(vYXsrCHROvSZ7OAojPDW9l}eWIx4FWVNv#zvAT75*=9H zdpLB8dD#$jUO9Q^d2xcbjw+`GjYenl7|08%FLD8!~ z$3W8Kypxl|r{qjZ2#PRr6(ML;zBuHcmTg#}I zxp{-6iMO8zbJ_a4%C~ON2xM-yC_lVHte};LfxG+Fxj@?J)*dnGM7tuEMYhV$TFeXM zTnTk-`i4YWfx5dIL8H&{YnS0#dR#5^0<VkD@M-O#W zMnV+L4j^NBjgzrIb6q`8#DM*?+2=Z)K2!qJ+6+gxeyE!3junp(0Sw|i>3*OvG*n&7 z#rD}5kI_-Wu57+I@@Hh447bo7aym``A_RxTNH?K8gS9FsIi8FGf`FHj_A^PrSX#b} zmgE2?2ppE19li9#K>Y1~?Z-qFZ>z+5EiuealW&@@Fi78wi|CtZLM)s0X#Xzps2D~e z3LwRZeEv$Mq%eYLPn;z?Yp{(DHu5be_Zxu;1_;U~u0<8zDf0G#Q-8SQ=tt;K6s`jz zn5f~m&ER<`CUZZIZdh)wWM~+xDBkJ$)w}2G$>eD4v4#A=9?lAb%ojTE{y} z%I;s(qQ%mKx=_&~{nCrnIQLnIS^-|Upx>X*k45F1=(=Q3JlFtp=6g2rd)A1cTj3Pm7uw50>b7Xy}8!~J2d zT0mJU=XWtf5Y&(xc5a;HT2J-~upN_nwtoc19)Df=90}!>Sh9;(sH~e_m z=%^McA^0b6_92gyPq-cOanxYMX=w&)nOA;y0|QyU?#*>Y`py#m!d3Kysmia8Zm(x7 z*~*wHN7AwFcx#wd893f*6+l} zcZ$#EzCqM9i<69_4xOimAh?91RtdSdoOtod55z*394#&Iz{DJYP3dSdTN2=$?6&Dn z>fZLkgA(!JTtS?Yf8bX=ToQq$8W3X=ws7%}8|bX9s3o|XOd#i{!Ix5V59nMD~b zyztzXF*lK~5Zl#5TA_*LaUy<4v`7#I59?^%nKkEOditQUzbGGzr{97R@6H2GWA+Zi zT2m{JlbTZCwwV8Ss&NX9at8TD=RH-@%Rv&>#Mrr!#cfvRZX@s8-F3POV)NMtf6;I2 zUNNiSHDtP<&#!-MT>m6PDLNFUF|!Cc1UKerg^PwV!8Zz72!R+O1(@Rz?sz+9=ur54 zUZ0pHXk==X>$P_<`3Yw+7Zo-n^yppSz})sXmIk@Bj9!k;u69oi5>BqJ1S~7Bqe6yA zCnI3O(BK0QMUBOB?;g^M#yRX8(IEP7N6 zeMplJt9a1})4HYDB*U4fM?De+$H}$tNL+CDZ_CG4xn!HsA9YmQn?P|cFlxtgyM$M~;NvCp&QT6$T>zJaGCxHr(ph6!gOh`&n-PKqJ1lt< zj7KwI_ow?NV1PonEjOQUlm>#ex`@oBn8%)W19mx1=N{um%CpgUsjh(E`|5l(u2a*Q z0Z9^EINIk0q9sY5ga^16uX{U$qUcHj!)0$TLlUJPS-#hL5NsGX9s+`H(S%-hhrMB z<9W1GYJIkO5~BCbW%N+B?Z_pY`>u7k=a$_}bj2N~_t!^y2{aItrGY31n^GIWKXVKa ztfyaT(R-hNRM$v*q+rKz#GuL8!a1dT(y^RdNMUmp~Tt~E;6@hZNpZL(S{Mfy=h(~`k78j zA2)6Cje4hi13ed&=r`~r^jQc?*GBn8JFMQ$$@R|iVZyGne}Fe!|4^PzT8yZlkxaaU zyzU$FWbaCADT!{!Aoq{L4jF6}JJ4d;u&Km+EWN;~!`AIV-jobxHbzh6*N_XbSIFa~ z{Yp755=B_F$%GSlA*Jedm>P$l@8kdI^_e!*?`NMaj&kn17KA`73yR)Z+Jfo`6~Wxs ziD`XwkrhUB%8QrQ@9L%H((yMAa6A+P2oZ>p4R{6{ha}e4l|i*QZ4&kS*^jJFJ_!Xz}>;seKDH2UHzZa_u@QE z1Rl0^Fu#_uoCTxM`xi4?j1&DdgZpeURWY_jcI~-CAF#kswbj=Zqp_GTGYdL+tGD#a z&59(fPMO_`Uk4z5YVz<_{>3sq9*Grs60x{C2bb};dPJHIzchhahBpC=H-`%j9oO{R zCU?)`&eYy5g~y)rYNQN>{f8p+iqVM~8X z@Cl4sY-DS<8ME0Ci0OAFX>+GXEWT}-6hElRdp1(hMbHpi^>xrH5(Xd+hW|?a~2ufns8q-FcRR0UOJ&MxgsgB^!$`=`zlEgmE64yFPnd z0xWMnjzOn#(&@Jn@*SXRB5a^lKTE;uWn8W)Z$!8Q^T45zg5e=CN-%d2X6g(HEv)AJ z`(67o+%Q+BoxP0tBQgkz)M0hOX}y#=Gs=674^=ZLeoOVbL=fIkN2hrE6+0Rw{>G{I zXvx=CVDRT5BSjNYji!@Hl)Lt+H?o~3-Sv1syaaYhCwHjuafX&}h)=E6g)v;+SdDP; zJmI)`8w^M>ssIpE}idIMwgFX z*0xx-DVW5}@KjhCa_BZAyG?jSP9|k45QUG?gycuWBsgz*_^G*v?Fhv<>p&p&2)PWp zAZ;pH;8EiuFFra(U+ZHXFeNuqQ~WW9wU@h}?1E$s!X6f2zkl&%vwrLe#c)N5T`)^c zB5Gk5@RXM{iSVMPr0TT{myT_|UXe3Rh1?18&7c4I4)J^av(oB_NK;L*Casqa#{x?c z%uKO(+WBJ69qcdlYqPusGpmE0r~9Y3-9|cz1a3=>Uw;!R(Y94YM*K=k`q#rc5_xfx zKT@Qf`A6kuae23wb!_X&9<6%VFto$EBYFF);sS*w9w7}JI-G@s?|a?dAa(Ds^17mp z;ivaP%RXBPQ$JpuU^p2(WmhxHNn@nNy>@*v^nVoXz*nvo>Ize;=F6y~T39yqmS1DdVW6 zf%;u$vA(`d;DQDlsG14i4j|E`0qL_{cY%T1JhUX@RGIebrDQGU>L4ZOpK6g0z~88q zm0!oDV{yO1k_p1b;+pv<KV~(I^g7zhV;J%}I$MEm}v6NRWRc7boL4X9Ct-r1z*uoHaleT_Ttf!2-~CZ)=T{Lo zCRnU|6HP6ZVKmnJSP}Rq?V%-<_M37RdE&tU{q|p27OUp--$xmwKk*vEV~GR#Cn%bn zg!Pro4#-+kjO)%L@b6es?3^&TCJI1&6u%>a`S4|Wu8}Asc08$t@MZ zq8c~&YnCr=@>Kv#RRk3TqA0`@2Dr#vgzpN&V6U;!`#6X}&u=3p8kyvD;4uGi2-3X& zFVsR{fQyq=8O?r1fmIeDO4*4PPR7sfQ z24J3|5|F{d=s~krv-r>%91)RU3ouk4vO7K=x4sndFJlgCaC-kbBvvHIkc5O(Idv6Z z_XUitqo!QaR(BX!St$4q?XIuv{vzNoCH+N$);Ri4OWquE!@ybiesE=>;9#znn z7WD1<;qfKsb3FKu?M^FNOZL~`8N4 zQNUxOumB5IE%nfX%VstU=5Pkh@Q!L=>GublH5#H_ya->xp@-yCFRS&(z{3nyr$wv( z>j?+T3J?jR%%MYoq2#lE@j*PhBbaFC&r6YSnwHoArUb(xV_7&DI&r>vr~bkp3sJMR z{u>gb4zPs;^$|NnFzdf&Uw#nH?szdL8&dF_c@Umrcy1euhh{YpnXA#C=ABI%0>zxm zFwTb9^XI+ZFXXTkb0xXrL9)gQXdxm&9bXql{zr2BmuZ@8IhDJBjH&_QU{{Zgu1O`N zhUwlY$3g6~$3yITq=jLudM}*0#e^2v5pebixo$)@8VelK$5;04Uw{EjpLKa%i7q0S z%-KtU%*DrcND8C6d8z~XxY`UpHZ*U4Tjxsxo3_e%e$)Njf|myuMv;==c+DGpK+;U) z((*!| zit$w&+8}RkOc9tVE2CTixS21{(vV0)V~M zs2{;6h{WOW$YMht;7J@pIw9S|2mpGhr3dU5{!%aV!XkgdsQIGg8nw+x zK^A~G!5#dv*$xh?d2SCOTm(M+xz{2MnWAtSnV^; zBSrG`XYn}%QAJedHnRcn_Mjy%EC}<*QCd(uGQV7I?jNxw4;m#2ia4`2{Cf}0& zowOG|KZZCmueidbx@>ABLbtI4Bx4g#uHi(Q{^d&r&u{-K5!$+@Lj;ng#YYmgVw{TvUa zNJDeXUwXasOZ*-4fStBhvf$L98*E1j=p`<5Wr=v7#5@vxx2;+OBpORM$}&A?`ay0P zcIEI-eR+}g)l~h_Pg?=imHF{aqC??Vo4@`_3Pc*|Zmf&Z(T3plguK;6ciAOBKKN<7 z;0bYYvt0mbnV^e|Xe#1k4=5$TZ2yoQ1CRJ=Vb<7d(_oQ}L7_8^K zAv7ZJz5u!n+)oCk^yzWK2=C#stEKJ$yaV{xo>hEwW)Chn0Q5x?C|$^$bGhw#;QnDN zIHXpKnQQ{zb5LgI0=vr;cN_?dtG5d8?bO zGoB(4b~XSgIU7sI0i?VF(sI@FFdchTwy3nkSQ1hNrDQ@`x2Ko>gkBR_0?Xgwf0YDM zI|Y7=^bi#K0FgXY$snDFET_B-d}we~H}KVbPn70K`gU93g`jmGj>50(!z5%Ux{V&PIsiGZqz<@>BHPs*e!ELjZb_7DR#|&>!5SP5>&A*rhW= zA`BNamhT_jVw+U}`ti*v?K`pWQPi-+JV!0#SAF(X_`f8Tq}L;KbQ0mcI=#$dU6%%yJeD>rj5+6k^A-6Y3HU^^tJ(%d=1K$PxfZWd9o-U+#F7QR`%E@?aDpP8b8BpNc=ANX2m zOQ^W5oF_Oinco{B6COtZFQDT#Mwi<*7gf{%+oJZ!I$mYE&HG}y%Ox`N&*f>3R;2I>KXBPAUdA17T7LDEvnWp8lH&C0ReT#7$S{mQ@Xe#dqXa~8M^u;SU!MgiKQ z|G{iV4=}ammmYdMG9O`~!3Yr}Chi6ua|?8ZVXWemNP7aAi@Lub6_*}wFFW+}`>R#4 za3Iul|8Cd27mKk9P;mFJ(iD~+{&nafHdA2Qu{`bG`T+M32HS$`ki3+RbvOoJw`U%N zhiNkh(7Cd^8{nq-Ict9JDx1Hs63RON1BGPyxO+E%W6ly$uDS|5laMtn8hhM8vV&7T-VesvGB092LK(7M%2Q- zqE=d;t^vFyJ~xt!deR2+xcXi$E88T+vhpZ*59{|62o3rr%0EE3wqDfWqYQlm!P+c# z1^KqaAdn;mbI&f`E5dl>_LDtNHFC*VQHB2Dykbjp`@CoUWFlcbCLA-Rn@O^#d{Q#7 zw!1^#co!X{?_rvyFaNUKX3xW>OK9OA)y3$@zIVV@}2N_;wP2=9-*ZKY54 zQ_I3Ic~uUwQQNOtSHUqxg$fHPR`${5gO^W|-(F{berzJQ-%Y(7FI@3 zRaoQc%wbBb_bc3k1EhwQ5|=+8(%`uEe*O0^a@6-mfAs4=*N=MtjgR;&EUW+G=W}z+ zQtNgFg>c1%eC+!$k-X>37=vBYHsj-_;)lLKx(1%z)(dyzB=e4V?di)oer9rYuCbe; ze~?j_M+R#FPc~m?Cq*{?cN$~$a(tz@pBMR0winjO-na@ zR7|zUOciW4DSmJgL*6F|)zf@5FS(p`VfMAs*0%S{W}BK>XuICA6}_!4tS%4bI{O*I zIz|&~`+3Y?Kf6^o3j|KlWjr5QW`ptMVD{5VD@&jR&fJ>LrBr@Ci@eW z!5>R=o0_Ln^@*7jcL@Lm_$N5({}c#_1(BJHGi5QbZ3eQ=SQ$7mhLqzLD#g=W-0yUp z@s!oG+)h*$=ICxrL0ru0=c$dwZFF^$4@CLh&;283O{dwBy-P-q9wmOx)gWghhHQ{M zX7ljWZa_iw7As~E)@qUJFyKPw`s1vm^>v>9k>l?_7cZA-dovB5MBbHK$MJhD;g%xD zr4Fsl%DV=5?y-|=TU`x@iAs*WGZ=!YkSY!maXr7Uw zSIz!r_O^Eo%Y5|pA=wVI!k0%SN?x;dcf1+J2itfq7rU3s`aa%bQ`4aq&+UkgKODP& zG3IxZ+e22sou(f!9SV0uVb1Q_&^@`A=Wb?GZ_9iPz#BVKJwp@MwtqU}$$F*TRVgeq zU$Gt=1}p4rj@UfcW(KzO9fPa^EHV~cG$NSC`y9^&Ca)mKbVO$ikL&Wut}j$AeO9H3 zDfmdia`({7GuBgI-*?j#@t(cduwB1Xn~vqpxW%`*7hC`!@saFl6Wl$YIvl(R-4j>; zVi$Yxo&^GY)O%R%T7=c?4leScn( z&3Q}g+=>_&AX+2LUsfgnq;+Mld}oKt-DGc^;wj(qZsP$*E?4Gy*vpDhGA_D}xp(;b{ImKd@55Qyczn;Nc6%*M{xD~{}iuU^P&Zlv|?N~oW(31v|q z!`_1TxZZl_MqW3}#>}+z`IFZ*#PZ&sB`5QS7reA!thNubhcY!>rc?(u^hc!eb{9Yh4=OR)Cg_Qk^cj{{FrkGsp^Ho zdl$bGrIb^G>E!$bE3Fv=q#2B&HYK+uTj3=pH0p{_m?Y{MeT=v z-m?@zwc2&$uR@hazgwnrOTRhhs-EAc60n@2-Ed}_wIhY}2^=?v!Ro&{Qhv;R-gsB! zms|?P7yTmW?nX)1DwKUa!9dtJC92l_yfWu{{4sGUdE-xp$1RWpB&kd^iL*#r1d^D#AIwr6bX(x~$gV1W`g*77RUHvBA zkf$I?;JB99qEmS7-OhK$-%Dv|r#-oo(;EUkV=0yk@e!ErMLo%+43BEG_kkjL*f`>{ z>8*_l_ir$5@Ae*vt6qo;uq2sDhL^8J-DpBP)#=;lZ^v>x#Qr=F3_wqHRFxR&V3{6eq=YDcRcbo=#`{OLpeErE^n0zgtzwT_1;+mt4IZWC*0OI z=GIIby3nkedHNMjDis^_tI=WhaJ|7UfAx@4-DJ%Vc|^dWU?=)J>>$w=58RS35|MH0 zQ{}Pp+;`rA){QP=j!I>}9u{73?C*(Vq{j^Sj&B%>40GiC3#`L%tQ2dg>^7VV)4vW^L8T+E;tmp@;2KRyN5X1 zLGoPA9^ei#dPqb3jd1rn_w#Po_S;ym3LlT7I9Tnu7I@PCYTIx!!YyIBynrlVm&Km*GIrg6! zlSj|lyvhPC1c6k^x1BBog>Qzy7i@4KLQh+ClXYVolN8Mf)Fwe+Q!TY<$```%eKe_p zh|Qbjn5b#`gl;@sFajy{TCucKU7P~QGX<;oj{U|OqJ+NV-l8ECiNc$4!qCHbq&w=^ ze{9TLl5e@yP`P&U)ix^nch5%z&+PjHnoJ^MIf`)$(Lfof$mG_ATKyHhheSrH#oo?Y z#PZI$J%im{p>`2s?RR5Cn{6as1?exPrWu8O0*do902Lst`y`A$z9y&O)Fr`b; z`sTU?f$YQ;b-`nd>p|@%px9DCR1A9RswH5B`Q3x`JoyU0+)YDq5WW2Y5mu{VLjL9(>)+7d%AJ+NeN?ULp{c8z2u90 zBvk*YP(S^%O6pYjWI5=sSPBVwEeSN$3rc(mcyv;Wgrd>0``)KE7V4p+<%$onfCn$l^@Egq`x2C zFT3MO6s&71DKK|$dobiVyXXlA=dUZsWY#KMN8TF3&A8C3xTa12tdd@!2cF0rr)9?~V+tcQK^F^q&zM#&Pyr%JH_ECSFPW?Ng?|}43u+=>$Yn4SuX7{OU z8%!nxXb(8Qo@{fjev~Kb^Gi(n|Hj%w4;))Gd&@i)tDi~ECavsYeYF-c+J&A0)IRu$ zqyAk+n>3w(vpF1%BJEmgF>>_cMNeoY2g-^`x|x|pEkIcf&m8>J(>?2LF_j_~GS}<> za{{r1j}aC^D`9=$7fsl0tg`ldUNE%f)Mg1TL{N#Nbo;Akc2Z8zozTs|!O4xQw2Fot z=f%487suehoDU3#R`Nww^Ai0*vxEm{hx^ErijGE7KxFEx5=_~_G-jlFPWvGfis+kC zE3(G$<-%SDO7!zB5`OpRxJ{8oqL+H@iiBR2Q0xa)rQHU5Xc%JoECLTtmm zp_R4Bp}D*%uBPBd0o{wAK966TOmBL`{f(L-9g9Ie;R8#k?_OwUmIqTy9T$kfUqm1g zA0B;j;*_SqfYF;f2KYvN`EdQiBxijgBqhkwGM@b_K9c%t!Hl8Yy z4TTF{_)7QNrc6nVkWx9@q#*;gk~$Ka?GU)dM_~JWN!0EPw*Fmb3{afil>nv=7D=Zz zrlBn2yMZ3+Xh-Emo?sF-25(dee{dJGtIO5bm|~(al&&K@d1yN=voWI;jg1M92Z=~< zN{;c6gk|tLo;Ay$A4%kTLhHu1rchg9E?y4=u(+rsss@2vX1&Bl2G^=s)w@;oMj$4W zLy+S2OFiiq5i5G`oB7W-j^2Lf^K}FcP8V)#Zsrf#Mv0_sH#Bz|xlgK|?MV%cKByAU zdSO*VC8@KB+(eQOq{ct#DK(gArp9$w{xr};b1$HV*Z?9YP37Fy#SdTvJR|_GOcM3| zasW<*A7v3uD3iB@&tQzR9HR(X6@~}gR`SDuU7o+Hd zD~lDLF|Q;T;Qsx-r^NjtT{yv;_yL_1MIZaw>j?XB@yU-4h&w$P6eI?LqX=*jmSMAY zCPTf%^?*XXog&fa_fuWY)H8Yam^4J&aRr#Y?I$SW#LT)E3ams(-5R&DivPNCo;dS^#PIx#%qdwHpqvLTyMb5J7?A7H)x z0x9HEx{2KF?%YqdD4HOt-xCm&A{GFALA&+_v|!fz zrBLgq`X)$=dR%^2G^tpLQ9IITG>!D2zH0xF=kultfOKpAy#&ZfE{sTSR+b|1#u7OA zftdRK25BZSvlYyj`QQ;xgey{r_VD@sL!!_RK@X*T@!be^X& z0^Z!})3R1wwvG4VX$!zf)ec(dQky`ed{nu2?2aUIv)2MO2(rOe zamCtww_SD11{M*~IaDB?8$#+qNCnqXX8wW0>O01eU$_P-gY*R0Jh`P$ylG?w0A}(E zOcWjd6xk>yzVIPhGm~7HTXV&Su*c@(fXJ%u78$>wVmK z&W@>gS!nJYX7!+iS{g(zm*=r2 z4E$43B6*?;hZVRkJ55FAxIHLyzCU3lgYNHoZgNM3y!YIXTkQGsKujZ_@=NN#UO`6v z@tV@MKlbHs>rbi0rNUJ*b8@c&Kzc0%H2lmA@d8l_<*^`+&ZJ6bsq8eba6`}|<+=K8cm#2?1 z8-OO~jpHw;^+$(T{P4cpoi_hK8;z(=Ur#{cs8#R&eWC~h;4a^Wn}qgK;0}|u=6*DQ?J)B2y;rAu z$ydLlB2c33rrLnQ+|G76Rc~L4d$aO}v-4yeFBlFL8Ks(85K_i2xJdacMA!y9#RnVE zR7N}v{aiA#3p&hoGRWPwOlI)WXk}is1-3nin;c){0n||01{M%Ojttr{cPkhyhfdcK z@D-Pq?leKtaww*52BbR4G@Zw}jYp^Gis&0Gk+C@k;>?j90VjMAh)oQ6($>^pO5YVbRyNU%A~T zSid`3n#S&=a;(d-EWnthc1J!oMXMK?7&Rw#(>Q%Eb0(4~&KsUj{J?*V`n@GYe1OP~N02n0dNf zbel9J7d~3Wuh+L#nJIr=Vy;Jvbz5zXHZ`&q$$o~pO=PY(y?S_W^o= z=4ONcxW)MuLPul5Q>zaT1mvVg$6-f5%ipk=my!580QF9@l$ss-`kEaAn(5lg@Z$`qmna^e4x8p=OWWC{;n$6tpTr z{oi(-KaAC?wn`^A9tvEGR*n|j#jZc4aspVHjxM;xZSt=;-tfrBxbxMS)9Qa9^GdOb zP&pC!wqCtqS%^c;z-?4vex%nL1qVnix#d2tZlojd^hoSd-^y{P>66VluWx>+%PmDt zI25WJF=?b1R0ag2^CQ@{roxBfOvL-m-&K`*yd9=E&44X`x%{{}cC?N5uS<|!9D!JO z``G=!Y@>|Ju&Bc)bKXKj32Ox)!3D~5YiOTRlec}HM)K3?PjHURr(8TgxBjY8-}ZeJ zS)bkC{9J-f{O-}nKneHr1PLM-#$E{vHT|4(G2=P7s0Zd&r5x|6NnbVv0bh50T z%#CPk6is9!!4U-YF2D*^WjMlpN-VIKmGg4-kbcetCyp(G^hWe1V7(xh2~}3MPS(hh zvR&u2uU&)NUxZp2&9#p?)UoX*3RcV3znuWzBFY+qnZxp}Hi z_j2*_o2V&u{+lc>THtEDYd7T<^q6jJDl#Pu=D`sddW6I*=*^b~a<9WSG*tL>BwPF_ zTjQfrn1uHQ9PskG_`>3UExSa(XSA1cNqf$z!bQjI|Flhu$4((G%q`EiOS=Ji84QId zGux3~1!)Ygt&jmmoA1rLJsEvz=hggQX0LpFZN~ZJ zt#=qCgVHJC_Uf*>=t}irr56X3j*RZqXCfrkafv!e{j2fjUv;xGYLAU{YH=R92GtH~ zF6!T@2R29>?^6!Y|5%ZRcYthlLF?p3eTo{N)3?>?B|f2di)PEJ&{z3Ir~}otg?uM~ zbne8NJ5>|1suHc6Ih3_r*w8{oo@u3}l1^9>Gu@Gu1iIn=gAOrBsI8Nex4?Hcliq}ukKX)kc zrypE1zx0*fakt@L4}lUu`FiI{<}d=?{&xr${%!T_h9LjTI-qLonnb+=(js+ihsqy5 zDA9+DnD7cvq$g3C8s*Rjk9zj_tC4~Qlwc&Dc@~wO z9P(mDRER|ZOjx2S#{fZH=BuY3DbuTJe2pYk zA1cY!xsl$31_kv4kVYjg+D8xMYPR=oavK{gCi?XKprD05k* z?zXZ?Ts;S+O*g@B>#r(Q4Na}6@9run5a~IwOcD|Q8IPvXmeHrlIT2{$zrwbE)Mr^C zSkL5+x=PuPH-s5F_bRwB@X=0I0#n>iVHYZ3RUu zS4TUZnu%RDv_(C*mb_B$n5FHs(|51h&}KoklbvRRIw%OcsF863`$%x*!?Plu9hK~_2$zB8?W_cV~`1s0h&m~iA*N3w0o!ur1Hu;?G z0OAHh=*;pXI$df7Nsg$S=24w z#jaM48j=onsxvhp4m((JZ37V^D7wstTm_PH> zD#scg9hN%x2`|XKgA{JOCua4Qp62AWBG9!#E;9fUQ+m2F1vj>m89104fmLUX+gKKVuvlSFzz0ZyEuur_%07Hv#8Eq0(+{+%;K z1v+Abjx+OH4||WhFXo{f^8YNS_U?|z9y+}CPmhC0r){N3nkxDuH<#kAo)yyHDi)WF ze4=y`&~18t%g54hWO2CvS}|=~%Yi3L;r8Di5@5xoY>U+z>+9a-+>RD_d~r@z&9VJa zp7dTmwZi~#R%Okzu0S#d6s=7JJ=svPoM2qrX}2B4Y7c=M$c?ls;5t(ah`HP~N!oJD zLd(Ba2g+G$BfCM2(de&t)b8X}3LLf@j+|U;K#P0M8~30JWEBWl8N9aK_iidXIbGB! z3SP)#yniqlnI1dX-rb_k%+qL(^p41+w@&j6+rc)#V0JBby)gJn~ zO<=W^Kbwx`Tc#&fI#m{3p>^8{eF6@5w?4uT$9$TI&rDHvn@X!Chw3k1fS(Q5?3(Yp z7O!0@;0abt0CX>%tD07H2+>dMTx)0s2xIZaY@QYZh@rt0$;UNc*BI;%Ztgl#L2ff$ zwTuvK^U77sa;vYtn{c@j9`|beGOKl&&0b0t-pC1Z#JuK`>%fM#>*t1WRs>N%8#S~( zJoNHbH?5siPHl%S!p=@ix{X9OJ=T_|hr21csx~~Fxp&={(Kn1RL+}soHWE+q*!Hts z$Rz#EF`^cK7;lj2YW=NG5huvi1ZDj?ck30;K5DRtW}NVRZvB`O$mW+UJ^i>FxuFuJaFn+4|BT72bAz#sUg8nrgOS-Yw4A zW@2I*acNjbtw^a&!eC{KPipq?W-vWD#IsYHpk( zx5e10iPmC5E9leXu^AxWvZr=V9zp3R`SrDUR+7hm40K;m%JXnOk-pbQ6TwQI44{}R zTjsl+&_1ubog*?6KvN8_iTiFRN+RX|Bd7@&GxvGouA7hW8I z1oyzwkEe^7oLyJ`e=kZwJrBT#TDiHGtc~mF!$V-s90TsDR@7{6CUbTD%jKinnmOM7n;**o)5?yeHehy!F_JY%z?tIS% z23G8Zrax}!BLEKT;L9pPdsewtb4f|DVlppx8)o~*=ZXqJWvK*c_&VQgLs3yBqwKh0 zWZ|v+7*a-ZA0C&EnF{b3u6X0WC0G zx9F*{F8$!AgQnapF6|=6ySiuAIScIC2}ZMb@#WY8BT!5f5d3Z20K~u^J{HiZj4X+d zLy1Z^#OwCiGF?5>AuwmFa^THVQi!YSsZUC(zNBg@)NeWusd$xSE@-Q*42ThhfpRr1 zP}UE6|EgxEWaUWS?6XKhG=3D@u%ybC`(VUwI-?UFhJ>eI-0PRO}`dBVkp|*xw zfQ|yT9@zemuL2Mm6R;08;z(-V3;O~nQ1n7j5HRw9YO4^|0fvZW`MIkYc>4HZ>wE8W@(gKrp+UVa!{YFCqYV>HS0~IxEVqe*mP=qTg=BL$93}kM zos;O7C;uY=EmZZ6=0#`R?ec@Yc>dN9_Y^nrZ@}F_1vwz@;mp6)G!PpOc^REBZq}*Y z`qU51y;zY0W<1_EtHBtt4J{3A;Ad%aWpPP;5~>Y;=4Z5*mQ|pCx|;c?m|Wq*c3^Mh*Pfi?%ma0P4BhN)_`l!QLIq@ { - var HCt = Object.create; - var WW = Object.defineProperty; - var VCt = Object.getOwnPropertyDescriptor; - var WCt = Object.getOwnPropertyNames; - var GCt = Object.getPrototypeOf, - JCt = Object.prototype.hasOwnProperty; - var p7e = ((t) => - typeof require != "undefined" - ? require - : typeof Proxy != "undefined" - ? new Proxy(t, { - get: (e, r) => (typeof require != "undefined" ? require : e)[r], - }) - : t)(function (t) { - if (typeof require != "undefined") return require.apply(this, arguments); - throw new Error('Dynamic require of "' + t + '" is not supported'); - }); - var vs = (t, e) => () => (t && (e = t((t = 0))), e); - var I = (t, e) => () => (e || t((e = { exports: {} }).exports, e), e.exports), - y7e = (t, e) => { - for (var r in e) WW(t, r, { get: e[r], enumerable: !0 }); - }, - m7e = (t, e, r, n) => { - if ((e && typeof e == "object") || typeof e == "function") - for (let i of WCt(e)) - !JCt.call(t, i) && - i !== r && - WW(t, i, { - get: () => e[i], - enumerable: !(n = VCt(e, i)) || n.enumerable, - }); - return t; - }; - var qe = (t, e, r) => ( - (r = t != null ? HCt(GCt(t)) : {}), - m7e( - e || !t || !t.__esModule - ? WW(r, "default", { value: t, enumerable: !0 }) - : r, - t - ) - ), - jo = (t) => m7e(WW({}, "__esModule", { value: !0 }), t); - function v7e() { - throw new Error("setTimeout has not been defined"); - } - function b7e() { - throw new Error("clearTimeout has not been defined"); - } - function w7e(t) { - if (AS === setTimeout) return setTimeout(t, 0); - if ((AS === v7e || !AS) && setTimeout) - return (AS = setTimeout), setTimeout(t, 0); - try { - return AS(t, 0); - } catch { - try { - return AS.call(null, t, 0); - } catch { - return AS.call(this, t, 0); - } - } - } - function $Ct(t) { - if (ES === clearTimeout) return clearTimeout(t); - if ((ES === b7e || !ES) && clearTimeout) - return (ES = clearTimeout), clearTimeout(t); - try { - return ES(t); - } catch { - try { - return ES.call(null, t); - } catch { - return ES.call(this, t); - } - } - } - function ZCt() { - !oI || - !C3 || - ((oI = !1), - C3.length ? (l_ = C3.concat(l_)) : (GW = -1), - l_.length && _7e()); - } - function _7e() { - if (!oI) { - var t = w7e(ZCt); - oI = !0; - for (var e = l_.length; e; ) { - for (C3 = l_, l_ = []; ++GW < e; ) C3 && C3[GW].run(); - (GW = -1), (e = l_.length); - } - (C3 = null), (oI = !1), $Ct(t); - } - } - function XCt(t) { - var e = new Array(arguments.length - 1); - if (arguments.length > 1) - for (var r = 1; r < arguments.length; r++) e[r - 1] = arguments[r]; - l_.push(new x7e(t, e)), l_.length === 1 && !oI && w7e(_7e); - } - function x7e(t, e) { - (this.fun = t), (this.array = e); - } - function R3() {} - function pRt(t) { - throw new Error("process.binding is not supported"); - } - function yRt() { - return "/"; - } - function mRt(t) { - throw new Error("process.chdir is not supported"); - } - function gRt() { - return 0; - } - function bRt(t) { - var e = vRt.call(iI) * 0.001, - r = Math.floor(e), - n = Math.floor((e % 1) * 1e9); - return ( - t && ((r = r - t[0]), (n = n - t[1]), n < 0 && (r--, (n += 1e9))), [r, n] - ); - } - function _Rt() { - var t = new Date(), - e = t - wRt; - return e / 1e3; - } - var AS, - ES, - l_, - oI, - C3, - GW, - YCt, - QCt, - eRt, - tRt, - rRt, - nRt, - iRt, - oRt, - aRt, - sRt, - uRt, - cRt, - lRt, - fRt, - dRt, - hRt, - iI, - vRt, - wRt, - process, - g7e, - m = vs(() => { - (AS = v7e), (ES = b7e); - typeof window.setTimeout == "function" && (AS = setTimeout); - typeof window.clearTimeout == "function" && (ES = clearTimeout); - (l_ = []), (oI = !1), (GW = -1); - x7e.prototype.run = function () { - this.fun.apply(null, this.array); - }; - (YCt = "browser"), - (QCt = "browser"), - (eRt = !0), - (tRt = {}), - (rRt = []), - (nRt = ""), - (iRt = {}), - (oRt = {}), - (aRt = {}); - (sRt = R3), - (uRt = R3), - (cRt = R3), - (lRt = R3), - (fRt = R3), - (dRt = R3), - (hRt = R3); - (iI = window.performance || {}), - (vRt = - iI.now || - iI.mozNow || - iI.msNow || - iI.oNow || - iI.webkitNow || - function () { - return new Date().getTime(); - }); - wRt = new Date(); - (process = { - nextTick: XCt, - title: YCt, - browser: eRt, - env: tRt, - argv: rRt, - version: nRt, - versions: iRt, - on: sRt, - addListener: uRt, - once: cRt, - off: lRt, - removeListener: fRt, - removeAllListeners: dRt, - emit: hRt, - binding: pRt, - cwd: yRt, - chdir: mRt, - umask: gRt, - hrtime: bRt, - platform: QCt, - release: oRt, - config: aRt, - uptime: _Rt, - }), - (g7e = {}); - Object.keys(g7e).forEach((t) => { - let e = t.split("."), - r = process; - for (let n = 0; n < e.length; n++) { - let i = e[n]; - n === e.length - 1 ? (r[i] = g7e[t]) : (r = r[i] || (r[i] = {})); - } - }); - }); - function M7e() { - mpe = !0; - for ( - var t = - "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", - e = 0, - r = t.length; - e < r; - ++e - ) - (Zg[e] = t[e]), (j0[t.charCodeAt(e)] = e); - (j0["-".charCodeAt(0)] = 62), (j0["_".charCodeAt(0)] = 63); - } - function SRt(t) { - mpe || M7e(); - var e, - r, - n, - i, - o, - a, - s = t.length; - if (s % 4 > 0) - throw new Error("Invalid string. Length must be a multiple of 4"); - (o = t[s - 2] === "=" ? 2 : t[s - 1] === "=" ? 1 : 0), - (a = new xRt((s * 3) / 4 - o)), - (n = o > 0 ? s - 4 : s); - var c = 0; - for (e = 0, r = 0; e < n; e += 4, r += 3) - (i = - (j0[t.charCodeAt(e)] << 18) | - (j0[t.charCodeAt(e + 1)] << 12) | - (j0[t.charCodeAt(e + 2)] << 6) | - j0[t.charCodeAt(e + 3)]), - (a[c++] = (i >> 16) & 255), - (a[c++] = (i >> 8) & 255), - (a[c++] = i & 255); - return ( - o === 2 - ? ((i = (j0[t.charCodeAt(e)] << 2) | (j0[t.charCodeAt(e + 1)] >> 4)), - (a[c++] = i & 255)) - : o === 1 && - ((i = - (j0[t.charCodeAt(e)] << 10) | - (j0[t.charCodeAt(e + 1)] << 4) | - (j0[t.charCodeAt(e + 2)] >> 2)), - (a[c++] = (i >> 8) & 255), - (a[c++] = i & 255)), - a - ); - } - function ARt(t) { - return ( - Zg[(t >> 18) & 63] + Zg[(t >> 12) & 63] + Zg[(t >> 6) & 63] + Zg[t & 63] - ); - } - function ERt(t, e, r) { - for (var n, i = [], o = e; o < r; o += 3) - (n = (t[o] << 16) + (t[o + 1] << 8) + t[o + 2]), i.push(ARt(n)); - return i.join(""); - } - function S7e(t) { - mpe || M7e(); - for ( - var e, - r = t.length, - n = r % 3, - i = "", - o = [], - a = 16383, - s = 0, - c = r - n; - s < c; - s += a - ) - o.push(ERt(t, s, s + a > c ? c : s + a)); - return ( - n === 1 - ? ((e = t[r - 1]), - (i += Zg[e >> 2]), - (i += Zg[(e << 4) & 63]), - (i += "==")) - : n === 2 && - ((e = (t[r - 2] << 8) + t[r - 1]), - (i += Zg[e >> 10]), - (i += Zg[(e >> 4) & 63]), - (i += Zg[(e << 2) & 63]), - (i += "=")), - o.push(i), - o.join("") - ); - } - function JW() { - return Buffer.TYPED_ARRAY_SUPPORT ? 2147483647 : 1073741823; - } - function f_(t, e) { - if (JW() < e) throw new RangeError("Invalid typed array length"); - return ( - Buffer.TYPED_ARRAY_SUPPORT - ? ((t = new Uint8Array(e)), (t.__proto__ = Buffer.prototype)) - : (t === null && (t = new Buffer(e)), (t.length = e)), - t - ); - } - function Buffer(t, e, r) { - if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) - return new Buffer(t, e, r); - if (typeof t == "number") { - if (typeof e == "string") - throw new Error( - "If encoding is specified then the first argument must be a string" - ); - return gpe(this, t); - } - return T7e(this, t, e, r); - } - function T7e(t, e, r, n) { - if (typeof e == "number") - throw new TypeError('"value" argument must not be a number'); - return typeof ArrayBuffer < "u" && e instanceof ArrayBuffer - ? kRt(t, e, r, n) - : typeof e == "string" - ? TRt(t, e, r) - : PRt(t, e); - } - function k7e(t) { - if (typeof t != "number") - throw new TypeError('"size" argument must be a number'); - if (t < 0) throw new RangeError('"size" argument must not be negative'); - } - function MRt(t, e, r, n) { - return ( - k7e(e), - e <= 0 - ? f_(t, e) - : r !== void 0 - ? typeof n == "string" - ? f_(t, e).fill(r, n) - : f_(t, e).fill(r) - : f_(t, e) - ); - } - function gpe(t, e) { - if ( - (k7e(e), (t = f_(t, e < 0 ? 0 : vpe(e) | 0)), !Buffer.TYPED_ARRAY_SUPPORT) - ) - for (var r = 0; r < e; ++r) t[r] = 0; - return t; - } - function TRt(t, e, r) { - if ( - ((typeof r != "string" || r === "") && (r = "utf8"), - !Buffer.isEncoding(r)) - ) - throw new TypeError('"encoding" must be a valid string encoding'); - var n = P7e(e, r) | 0; - t = f_(t, n); - var i = t.write(e, r); - return i !== n && (t = t.slice(0, i)), t; - } - function ype(t, e) { - var r = e.length < 0 ? 0 : vpe(e.length) | 0; - t = f_(t, r); - for (var n = 0; n < r; n += 1) t[n] = e[n] & 255; - return t; - } - function kRt(t, e, r, n) { - if ((e.byteLength, r < 0 || e.byteLength < r)) - throw new RangeError("'offset' is out of bounds"); - if (e.byteLength < r + (n || 0)) - throw new RangeError("'length' is out of bounds"); - return ( - r === void 0 && n === void 0 - ? (e = new Uint8Array(e)) - : n === void 0 - ? (e = new Uint8Array(e, r)) - : (e = new Uint8Array(e, r, n)), - Buffer.TYPED_ARRAY_SUPPORT - ? ((t = e), (t.__proto__ = Buffer.prototype)) - : (t = ype(t, e)), - t - ); - } - function PRt(t, e) { - if (Xg(e)) { - var r = vpe(e.length) | 0; - return (t = f_(t, r)), t.length === 0 || e.copy(t, 0, 0, r), t; - } - if (e) { - if ( - (typeof ArrayBuffer < "u" && e.buffer instanceof ArrayBuffer) || - "length" in e - ) - return typeof e.length != "number" || JRt(e.length) - ? f_(t, 0) - : ype(t, e); - if (e.type === "Buffer" && Array.isArray(e.data)) return ype(t, e.data); - } - throw new TypeError( - "First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object." - ); - } - function vpe(t) { - if (t >= JW()) - throw new RangeError( - "Attempt to allocate Buffer larger than maximum size: 0x" + - JW().toString(16) + - " bytes" - ); - return t | 0; - } - function Xg(t) { - return !!(t != null && t._isBuffer); - } - function P7e(t, e) { - if (Xg(t)) return t.length; - if ( - typeof ArrayBuffer < "u" && - typeof ArrayBuffer.isView == "function" && - (ArrayBuffer.isView(t) || t instanceof ArrayBuffer) - ) - return t.byteLength; - typeof t != "string" && (t = "" + t); - var r = t.length; - if (r === 0) return 0; - for (var n = !1; ; ) - switch (e) { - case "ascii": - case "latin1": - case "binary": - return r; - case "utf8": - case "utf-8": - case void 0: - return $W(t).length; - case "ucs2": - case "ucs-2": - case "utf16le": - case "utf-16le": - return r * 2; - case "hex": - return r >>> 1; - case "base64": - return D7e(t).length; - default: - if (n) return $W(t).length; - (e = ("" + e).toLowerCase()), (n = !0); - } - } - function ORt(t, e, r) { - var n = !1; - if ( - ((e === void 0 || e < 0) && (e = 0), - e > this.length || - ((r === void 0 || r > this.length) && (r = this.length), r <= 0) || - ((r >>>= 0), (e >>>= 0), r <= e)) - ) - return ""; - for (t || (t = "utf8"); ; ) - switch (t) { - case "hex": - return zRt(this, e, r); - case "utf8": - case "utf-8": - return I7e(this, e, r); - case "ascii": - return LRt(this, e, r); - case "latin1": - case "binary": - return qRt(this, e, r); - case "base64": - return DRt(this, e, r); - case "ucs2": - case "ucs-2": - case "utf16le": - case "utf-16le": - return jRt(this, e, r); - default: - if (n) throw new TypeError("Unknown encoding: " + t); - (t = (t + "").toLowerCase()), (n = !0); - } - } - function N3(t, e, r) { - var n = t[e]; - (t[e] = t[r]), (t[r] = n); - } - function O7e(t, e, r, n, i) { - if (t.length === 0) return -1; - if ( - (typeof r == "string" - ? ((n = r), (r = 0)) - : r > 2147483647 - ? (r = 2147483647) - : r < -2147483648 && (r = -2147483648), - (r = +r), - isNaN(r) && (r = i ? 0 : t.length - 1), - r < 0 && (r = t.length + r), - r >= t.length) - ) { - if (i) return -1; - r = t.length - 1; - } else if (r < 0) - if (i) r = 0; - else return -1; - if ((typeof e == "string" && (e = Buffer.from(e, n)), Xg(e))) - return e.length === 0 ? -1 : A7e(t, e, r, n, i); - if (typeof e == "number") - return ( - (e = e & 255), - Buffer.TYPED_ARRAY_SUPPORT && - typeof Uint8Array.prototype.indexOf == "function" - ? i - ? Uint8Array.prototype.indexOf.call(t, e, r) - : Uint8Array.prototype.lastIndexOf.call(t, e, r) - : A7e(t, [e], r, n, i) - ); - throw new TypeError("val must be string, number or Buffer"); - } - function A7e(t, e, r, n, i) { - var o = 1, - a = t.length, - s = e.length; - if ( - n !== void 0 && - ((n = String(n).toLowerCase()), - n === "ucs2" || n === "ucs-2" || n === "utf16le" || n === "utf-16le") - ) { - if (t.length < 2 || e.length < 2) return -1; - (o = 2), (a /= 2), (s /= 2), (r /= 2); - } - function c(k, O) { - return o === 1 ? k[O] : k.readUInt16BE(O * o); - } - var u; - if (i) { - var h = -1; - for (u = r; u < a; u++) - if (c(t, u) === c(e, h === -1 ? 0 : u - h)) { - if ((h === -1 && (h = u), u - h + 1 === s)) return h * o; - } else h !== -1 && (u -= u - h), (h = -1); - } else - for (r + s > a && (r = a - s), u = r; u >= 0; u--) { - for (var w = !0, M = 0; M < s; M++) - if (c(t, u + M) !== c(e, M)) { - w = !1; - break; - } - if (w) return u; - } - return -1; - } - function BRt(t, e, r, n) { - r = Number(r) || 0; - var i = t.length - r; - n ? ((n = Number(n)), n > i && (n = i)) : (n = i); - var o = e.length; - if (o % 2 !== 0) throw new TypeError("Invalid hex string"); - n > o / 2 && (n = o / 2); - for (var a = 0; a < n; ++a) { - var s = parseInt(e.substr(a * 2, 2), 16); - if (isNaN(s)) return a; - t[r + a] = s; - } - return a; - } - function IRt(t, e, r, n) { - return YW($W(e, t.length - r), t, r, n); - } - function B7e(t, e, r, n) { - return YW(WRt(e), t, r, n); - } - function CRt(t, e, r, n) { - return B7e(t, e, r, n); - } - function RRt(t, e, r, n) { - return YW(D7e(e), t, r, n); - } - function NRt(t, e, r, n) { - return YW(GRt(e, t.length - r), t, r, n); - } - function DRt(t, e, r) { - return e === 0 && r === t.length ? S7e(t) : S7e(t.slice(e, r)); - } - function I7e(t, e, r) { - r = Math.min(t.length, r); - for (var n = [], i = e; i < r; ) { - var o = t[i], - a = null, - s = o > 239 ? 4 : o > 223 ? 3 : o > 191 ? 2 : 1; - if (i + s <= r) { - var c, u, h, w; - switch (s) { - case 1: - o < 128 && (a = o); - break; - case 2: - (c = t[i + 1]), - (c & 192) === 128 && - ((w = ((o & 31) << 6) | (c & 63)), w > 127 && (a = w)); - break; - case 3: - (c = t[i + 1]), - (u = t[i + 2]), - (c & 192) === 128 && - (u & 192) === 128 && - ((w = ((o & 15) << 12) | ((c & 63) << 6) | (u & 63)), - w > 2047 && (w < 55296 || w > 57343) && (a = w)); - break; - case 4: - (c = t[i + 1]), - (u = t[i + 2]), - (h = t[i + 3]), - (c & 192) === 128 && - (u & 192) === 128 && - (h & 192) === 128 && - ((w = - ((o & 15) << 18) | - ((c & 63) << 12) | - ((u & 63) << 6) | - (h & 63)), - w > 65535 && w < 1114112 && (a = w)); - } - } - a === null - ? ((a = 65533), (s = 1)) - : a > 65535 && - ((a -= 65536), - n.push(((a >>> 10) & 1023) | 55296), - (a = 56320 | (a & 1023))), - n.push(a), - (i += s); - } - return FRt(n); - } - function FRt(t) { - var e = t.length; - if (e <= E7e) return String.fromCharCode.apply(String, t); - for (var r = "", n = 0; n < e; ) - r += String.fromCharCode.apply(String, t.slice(n, (n += E7e))); - return r; - } - function LRt(t, e, r) { - var n = ""; - r = Math.min(t.length, r); - for (var i = e; i < r; ++i) n += String.fromCharCode(t[i] & 127); - return n; - } - function qRt(t, e, r) { - var n = ""; - r = Math.min(t.length, r); - for (var i = e; i < r; ++i) n += String.fromCharCode(t[i]); - return n; - } - function zRt(t, e, r) { - var n = t.length; - (!e || e < 0) && (e = 0), (!r || r < 0 || r > n) && (r = n); - for (var i = "", o = e; o < r; ++o) i += VRt(t[o]); - return i; - } - function jRt(t, e, r) { - for (var n = t.slice(e, r), i = "", o = 0; o < n.length; o += 2) - i += String.fromCharCode(n[o] + n[o + 1] * 256); - return i; - } - function mu(t, e, r) { - if (t % 1 !== 0 || t < 0) throw new RangeError("offset is not uint"); - if (t + e > r) - throw new RangeError("Trying to access beyond buffer length"); - } - function mh(t, e, r, n, i, o) { - if (!Xg(t)) - throw new TypeError('"buffer" argument must be a Buffer instance'); - if (e > i || e < o) - throw new RangeError('"value" argument is out of bounds'); - if (r + n > t.length) throw new RangeError("Index out of range"); - } - function ZW(t, e, r, n) { - e < 0 && (e = 65535 + e + 1); - for (var i = 0, o = Math.min(t.length - r, 2); i < o; ++i) - t[r + i] = (e & (255 << (8 * (n ? i : 1 - i)))) >>> ((n ? i : 1 - i) * 8); - } - function XW(t, e, r, n) { - e < 0 && (e = 4294967295 + e + 1); - for (var i = 0, o = Math.min(t.length - r, 4); i < o; ++i) - t[r + i] = (e >>> ((n ? i : 3 - i) * 8)) & 255; - } - function C7e(t, e, r, n, i, o) { - if (r + n > t.length) throw new RangeError("Index out of range"); - if (r < 0) throw new RangeError("Index out of range"); - } - function R7e(t, e, r, n, i) { - return ( - i || C7e(t, e, r, 4, 34028234663852886e22, -34028234663852886e22), - L7e(t, e, r, n, 23, 4), - r + 4 - ); - } - function N7e(t, e, r, n, i) { - return ( - i || C7e(t, e, r, 8, 17976931348623157e292, -17976931348623157e292), - L7e(t, e, r, n, 52, 8), - r + 8 - ); - } - function KRt(t) { - if (((t = HRt(t).replace(URt, "")), t.length < 2)) return ""; - for (; t.length % 4 !== 0; ) t = t + "="; - return t; - } - function HRt(t) { - return t.trim ? t.trim() : t.replace(/^\s+|\s+$/g, ""); - } - function VRt(t) { - return t < 16 ? "0" + t.toString(16) : t.toString(16); - } - function $W(t, e) { - e = e || 1 / 0; - for (var r, n = t.length, i = null, o = [], a = 0; a < n; ++a) { - if (((r = t.charCodeAt(a)), r > 55295 && r < 57344)) { - if (!i) { - if (r > 56319) { - (e -= 3) > -1 && o.push(239, 191, 189); - continue; - } else if (a + 1 === n) { - (e -= 3) > -1 && o.push(239, 191, 189); - continue; - } - i = r; - continue; - } - if (r < 56320) { - (e -= 3) > -1 && o.push(239, 191, 189), (i = r); - continue; - } - r = (((i - 55296) << 10) | (r - 56320)) + 65536; - } else i && (e -= 3) > -1 && o.push(239, 191, 189); - if (((i = null), r < 128)) { - if ((e -= 1) < 0) break; - o.push(r); - } else if (r < 2048) { - if ((e -= 2) < 0) break; - o.push((r >> 6) | 192, (r & 63) | 128); - } else if (r < 65536) { - if ((e -= 3) < 0) break; - o.push((r >> 12) | 224, ((r >> 6) & 63) | 128, (r & 63) | 128); - } else if (r < 1114112) { - if ((e -= 4) < 0) break; - o.push( - (r >> 18) | 240, - ((r >> 12) & 63) | 128, - ((r >> 6) & 63) | 128, - (r & 63) | 128 - ); - } else throw new Error("Invalid code point"); - } - return o; - } - function WRt(t) { - for (var e = [], r = 0; r < t.length; ++r) e.push(t.charCodeAt(r) & 255); - return e; - } - function GRt(t, e) { - for (var r, n, i, o = [], a = 0; a < t.length && !((e -= 2) < 0); ++a) - (r = t.charCodeAt(a)), (n = r >> 8), (i = r % 256), o.push(i), o.push(n); - return o; - } - function D7e(t) { - return SRt(KRt(t)); - } - function YW(t, e, r, n) { - for (var i = 0; i < n && !(i + r >= e.length || i >= t.length); ++i) - e[i + r] = t[i]; - return i; - } - function JRt(t) { - return t !== t; - } - function $Rt(t) { - return t != null && (!!t._isBuffer || F7e(t) || ZRt(t)); - } - function F7e(t) { - return ( - !!t.constructor && - typeof t.constructor.isBuffer == "function" && - t.constructor.isBuffer(t) - ); - } - function ZRt(t) { - return ( - typeof t.readFloatLE == "function" && - typeof t.slice == "function" && - F7e(t.slice(0, 0)) - ); - } - function QW(t, e, r, n, i) { - var o, - a, - s = i * 8 - n - 1, - c = (1 << s) - 1, - u = c >> 1, - h = -7, - w = r ? i - 1 : 0, - M = r ? -1 : 1, - k = t[e + w]; - for ( - w += M, o = k & ((1 << -h) - 1), k >>= -h, h += s; - h > 0; - o = o * 256 + t[e + w], w += M, h -= 8 - ); - for ( - a = o & ((1 << -h) - 1), o >>= -h, h += n; - h > 0; - a = a * 256 + t[e + w], w += M, h -= 8 - ); - if (o === 0) o = 1 - u; - else { - if (o === c) return a ? NaN : (k ? -1 : 1) * (1 / 0); - (a = a + Math.pow(2, n)), (o = o - u); - } - return (k ? -1 : 1) * a * Math.pow(2, o - n); - } - function L7e(t, e, r, n, i, o) { - var a, - s, - c, - u = o * 8 - i - 1, - h = (1 << u) - 1, - w = h >> 1, - M = i === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, - k = n ? 0 : o - 1, - O = n ? 1 : -1, - D = e < 0 || (e === 0 && 1 / e < 0) ? 1 : 0; - for ( - e = Math.abs(e), - isNaN(e) || e === 1 / 0 - ? ((s = isNaN(e) ? 1 : 0), (a = h)) - : ((a = Math.floor(Math.log(e) / Math.LN2)), - e * (c = Math.pow(2, -a)) < 1 && (a--, (c *= 2)), - a + w >= 1 ? (e += M / c) : (e += M * Math.pow(2, 1 - w)), - e * c >= 2 && (a++, (c /= 2)), - a + w >= h - ? ((s = 0), (a = h)) - : a + w >= 1 - ? ((s = (e * c - 1) * Math.pow(2, i)), (a = a + w)) - : ((s = e * Math.pow(2, w - 1) * Math.pow(2, i)), (a = 0))); - i >= 8; - t[r + k] = s & 255, k += O, s /= 256, i -= 8 - ); - for ( - a = (a << i) | s, u += i; - u > 0; - t[r + k] = a & 255, k += O, a /= 256, u -= 8 - ); - t[r + k - O] |= D * 128; - } - var Zg, - j0, - xRt, - mpe, - E7e, - URt, - q7e = vs(() => { - m(); - g(); - (Zg = []), - (j0 = []), - (xRt = typeof Uint8Array < "u" ? Uint8Array : Array), - (mpe = !1); - Buffer.TYPED_ARRAY_SUPPORT = - window.TYPED_ARRAY_SUPPORT !== void 0 ? window.TYPED_ARRAY_SUPPORT : !0; - Buffer.poolSize = 8192; - Buffer._augment = function (t) { - return (t.__proto__ = Buffer.prototype), t; - }; - Buffer.from = function (t, e, r) { - return T7e(null, t, e, r); - }; - Buffer.kMaxLength = JW(); - Buffer.TYPED_ARRAY_SUPPORT && - ((Buffer.prototype.__proto__ = Uint8Array.prototype), - (Buffer.__proto__ = Uint8Array), - typeof Symbol < "u" && Symbol.species && Buffer[Symbol.species]); - Buffer.alloc = function (t, e, r) { - return MRt(null, t, e, r); - }; - Buffer.allocUnsafe = function (t) { - return gpe(null, t); - }; - Buffer.allocUnsafeSlow = function (t) { - return gpe(null, t); - }; - Buffer.isBuffer = $Rt; - Buffer.compare = function (e, r) { - if (!Xg(e) || !Xg(r)) throw new TypeError("Arguments must be Buffers"); - if (e === r) return 0; - for ( - var n = e.length, i = r.length, o = 0, a = Math.min(n, i); - o < a; - ++o - ) - if (e[o] !== r[o]) { - (n = e[o]), (i = r[o]); - break; - } - return n < i ? -1 : i < n ? 1 : 0; - }; - Buffer.isEncoding = function (e) { - switch (String(e).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 !0; - default: - return !1; - } - }; - Buffer.concat = function (e, r) { - if (!Array.isArray(e)) - throw new TypeError('"list" argument must be an Array of Buffers'); - if (e.length === 0) return Buffer.alloc(0); - var n; - if (r === void 0) - for (r = 0, n = 0; n < e.length; ++n) r += e[n].length; - var i = Buffer.allocUnsafe(r), - o = 0; - for (n = 0; n < e.length; ++n) { - var a = e[n]; - if (!Xg(a)) - throw new TypeError('"list" argument must be an Array of Buffers'); - a.copy(i, o), (o += a.length); - } - return i; - }; - Buffer.byteLength = P7e; - Buffer.prototype._isBuffer = !0; - Buffer.prototype.swap16 = function () { - var e = this.length; - if (e % 2 !== 0) - throw new RangeError("Buffer size must be a multiple of 16-bits"); - for (var r = 0; r < e; r += 2) N3(this, r, r + 1); - return this; - }; - Buffer.prototype.swap32 = function () { - var e = this.length; - if (e % 4 !== 0) - throw new RangeError("Buffer size must be a multiple of 32-bits"); - for (var r = 0; r < e; r += 4) - N3(this, r, r + 3), N3(this, r + 1, r + 2); - return this; - }; - Buffer.prototype.swap64 = function () { - var e = this.length; - if (e % 8 !== 0) - throw new RangeError("Buffer size must be a multiple of 64-bits"); - for (var r = 0; r < e; r += 8) - N3(this, r, r + 7), - N3(this, r + 1, r + 6), - N3(this, r + 2, r + 5), - N3(this, r + 3, r + 4); - return this; - }; - Buffer.prototype.toString = function () { - var e = this.length | 0; - return e === 0 - ? "" - : arguments.length === 0 - ? I7e(this, 0, e) - : ORt.apply(this, arguments); - }; - Buffer.prototype.equals = function (e) { - if (!Xg(e)) throw new TypeError("Argument must be a Buffer"); - return this === e ? !0 : Buffer.compare(this, e) === 0; - }; - Buffer.prototype.compare = function (e, r, n, i, o) { - if (!Xg(e)) throw new TypeError("Argument must be a Buffer"); - if ( - (r === void 0 && (r = 0), - n === void 0 && (n = e ? e.length : 0), - i === void 0 && (i = 0), - o === void 0 && (o = this.length), - r < 0 || n > e.length || i < 0 || o > this.length) - ) - throw new RangeError("out of range index"); - if (i >= o && r >= n) return 0; - if (i >= o) return -1; - if (r >= n) return 1; - if (((r >>>= 0), (n >>>= 0), (i >>>= 0), (o >>>= 0), this === e)) - return 0; - for ( - var a = o - i, - s = n - r, - c = Math.min(a, s), - u = this.slice(i, o), - h = e.slice(r, n), - w = 0; - w < c; - ++w - ) - if (u[w] !== h[w]) { - (a = u[w]), (s = h[w]); - break; - } - return a < s ? -1 : s < a ? 1 : 0; - }; - Buffer.prototype.includes = function (e, r, n) { - return this.indexOf(e, r, n) !== -1; - }; - Buffer.prototype.indexOf = function (e, r, n) { - return O7e(this, e, r, n, !0); - }; - Buffer.prototype.lastIndexOf = function (e, r, n) { - return O7e(this, e, r, n, !1); - }; - Buffer.prototype.write = function (e, r, n, i) { - if (r === void 0) (i = "utf8"), (n = this.length), (r = 0); - else if (n === void 0 && typeof r == "string") - (i = r), (n = this.length), (r = 0); - else if (isFinite(r)) - (r = r | 0), - isFinite(n) - ? ((n = n | 0), i === void 0 && (i = "utf8")) - : ((i = n), (n = void 0)); - else - throw new Error( - "Buffer.write(string, encoding, offset[, length]) is no longer supported" - ); - var o = this.length - r; - if ( - ((n === void 0 || n > o) && (n = o), - (e.length > 0 && (n < 0 || r < 0)) || r > this.length) - ) - throw new RangeError("Attempt to write outside buffer bounds"); - i || (i = "utf8"); - for (var a = !1; ; ) - switch (i) { - case "hex": - return BRt(this, e, r, n); - case "utf8": - case "utf-8": - return IRt(this, e, r, n); - case "ascii": - return B7e(this, e, r, n); - case "latin1": - case "binary": - return CRt(this, e, r, n); - case "base64": - return RRt(this, e, r, n); - case "ucs2": - case "ucs-2": - case "utf16le": - case "utf-16le": - return NRt(this, e, r, n); - default: - if (a) throw new TypeError("Unknown encoding: " + i); - (i = ("" + i).toLowerCase()), (a = !0); - } - }; - Buffer.prototype.toJSON = function () { - return { - type: "Buffer", - data: Array.prototype.slice.call(this._arr || this, 0), - }; - }; - E7e = 4096; - Buffer.prototype.slice = function (e, r) { - var n = this.length; - (e = ~~e), - (r = r === void 0 ? n : ~~r), - e < 0 ? ((e += n), e < 0 && (e = 0)) : e > n && (e = n), - r < 0 ? ((r += n), r < 0 && (r = 0)) : r > n && (r = n), - r < e && (r = e); - var i; - if (Buffer.TYPED_ARRAY_SUPPORT) - (i = this.subarray(e, r)), (i.__proto__ = Buffer.prototype); - else { - var o = r - e; - i = new Buffer(o, void 0); - for (var a = 0; a < o; ++a) i[a] = this[a + e]; - } - return i; - }; - Buffer.prototype.readUIntLE = function (e, r, n) { - (e = e | 0), (r = r | 0), n || mu(e, r, this.length); - for (var i = this[e], o = 1, a = 0; ++a < r && (o *= 256); ) - i += this[e + a] * o; - return i; - }; - Buffer.prototype.readUIntBE = function (e, r, n) { - (e = e | 0), (r = r | 0), n || mu(e, r, this.length); - for (var i = this[e + --r], o = 1; r > 0 && (o *= 256); ) - i += this[e + --r] * o; - return i; - }; - Buffer.prototype.readUInt8 = function (e, r) { - return r || mu(e, 1, this.length), this[e]; - }; - Buffer.prototype.readUInt16LE = function (e, r) { - return r || mu(e, 2, this.length), this[e] | (this[e + 1] << 8); - }; - Buffer.prototype.readUInt16BE = function (e, r) { - return r || mu(e, 2, this.length), (this[e] << 8) | this[e + 1]; - }; - Buffer.prototype.readUInt32LE = function (e, r) { - return ( - r || mu(e, 4, this.length), - (this[e] | (this[e + 1] << 8) | (this[e + 2] << 16)) + - this[e + 3] * 16777216 - ); - }; - Buffer.prototype.readUInt32BE = function (e, r) { - return ( - r || mu(e, 4, this.length), - this[e] * 16777216 + - ((this[e + 1] << 16) | (this[e + 2] << 8) | this[e + 3]) - ); - }; - Buffer.prototype.readIntLE = function (e, r, n) { - (e = e | 0), (r = r | 0), n || mu(e, r, this.length); - for (var i = this[e], o = 1, a = 0; ++a < r && (o *= 256); ) - i += this[e + a] * o; - return (o *= 128), i >= o && (i -= Math.pow(2, 8 * r)), i; - }; - Buffer.prototype.readIntBE = function (e, r, n) { - (e = e | 0), (r = r | 0), n || mu(e, r, this.length); - for (var i = r, o = 1, a = this[e + --i]; i > 0 && (o *= 256); ) - a += this[e + --i] * o; - return (o *= 128), a >= o && (a -= Math.pow(2, 8 * r)), a; - }; - Buffer.prototype.readInt8 = function (e, r) { - return ( - r || mu(e, 1, this.length), - this[e] & 128 ? (255 - this[e] + 1) * -1 : this[e] - ); - }; - Buffer.prototype.readInt16LE = function (e, r) { - r || mu(e, 2, this.length); - var n = this[e] | (this[e + 1] << 8); - return n & 32768 ? n | 4294901760 : n; - }; - Buffer.prototype.readInt16BE = function (e, r) { - r || mu(e, 2, this.length); - var n = this[e + 1] | (this[e] << 8); - return n & 32768 ? n | 4294901760 : n; - }; - Buffer.prototype.readInt32LE = function (e, r) { - return ( - r || mu(e, 4, this.length), - this[e] | - (this[e + 1] << 8) | - (this[e + 2] << 16) | - (this[e + 3] << 24) - ); - }; - Buffer.prototype.readInt32BE = function (e, r) { - return ( - r || mu(e, 4, this.length), - (this[e] << 24) | - (this[e + 1] << 16) | - (this[e + 2] << 8) | - this[e + 3] - ); - }; - Buffer.prototype.readFloatLE = function (e, r) { - return r || mu(e, 4, this.length), QW(this, e, !0, 23, 4); - }; - Buffer.prototype.readFloatBE = function (e, r) { - return r || mu(e, 4, this.length), QW(this, e, !1, 23, 4); - }; - Buffer.prototype.readDoubleLE = function (e, r) { - return r || mu(e, 8, this.length), QW(this, e, !0, 52, 8); - }; - Buffer.prototype.readDoubleBE = function (e, r) { - return r || mu(e, 8, this.length), QW(this, e, !1, 52, 8); - }; - Buffer.prototype.writeUIntLE = function (e, r, n, i) { - if (((e = +e), (r = r | 0), (n = n | 0), !i)) { - var o = Math.pow(2, 8 * n) - 1; - mh(this, e, r, n, o, 0); - } - var a = 1, - s = 0; - for (this[r] = e & 255; ++s < n && (a *= 256); ) - this[r + s] = (e / a) & 255; - return r + n; - }; - Buffer.prototype.writeUIntBE = function (e, r, n, i) { - if (((e = +e), (r = r | 0), (n = n | 0), !i)) { - var o = Math.pow(2, 8 * n) - 1; - mh(this, e, r, n, o, 0); - } - var a = n - 1, - s = 1; - for (this[r + a] = e & 255; --a >= 0 && (s *= 256); ) - this[r + a] = (e / s) & 255; - return r + n; - }; - Buffer.prototype.writeUInt8 = function (e, r, n) { - return ( - (e = +e), - (r = r | 0), - n || mh(this, e, r, 1, 255, 0), - Buffer.TYPED_ARRAY_SUPPORT || (e = Math.floor(e)), - (this[r] = e & 255), - r + 1 - ); - }; - Buffer.prototype.writeUInt16LE = function (e, r, n) { - return ( - (e = +e), - (r = r | 0), - n || mh(this, e, r, 2, 65535, 0), - Buffer.TYPED_ARRAY_SUPPORT - ? ((this[r] = e & 255), (this[r + 1] = e >>> 8)) - : ZW(this, e, r, !0), - r + 2 - ); - }; - Buffer.prototype.writeUInt16BE = function (e, r, n) { - return ( - (e = +e), - (r = r | 0), - n || mh(this, e, r, 2, 65535, 0), - Buffer.TYPED_ARRAY_SUPPORT - ? ((this[r] = e >>> 8), (this[r + 1] = e & 255)) - : ZW(this, e, r, !1), - r + 2 - ); - }; - Buffer.prototype.writeUInt32LE = function (e, r, n) { - return ( - (e = +e), - (r = r | 0), - n || mh(this, e, r, 4, 4294967295, 0), - Buffer.TYPED_ARRAY_SUPPORT - ? ((this[r + 3] = e >>> 24), - (this[r + 2] = e >>> 16), - (this[r + 1] = e >>> 8), - (this[r] = e & 255)) - : XW(this, e, r, !0), - r + 4 - ); - }; - Buffer.prototype.writeUInt32BE = function (e, r, n) { - return ( - (e = +e), - (r = r | 0), - n || mh(this, e, r, 4, 4294967295, 0), - Buffer.TYPED_ARRAY_SUPPORT - ? ((this[r] = e >>> 24), - (this[r + 1] = e >>> 16), - (this[r + 2] = e >>> 8), - (this[r + 3] = e & 255)) - : XW(this, e, r, !1), - r + 4 - ); - }; - Buffer.prototype.writeIntLE = function (e, r, n, i) { - if (((e = +e), (r = r | 0), !i)) { - var o = Math.pow(2, 8 * n - 1); - mh(this, e, r, n, o - 1, -o); - } - var a = 0, - s = 1, - c = 0; - for (this[r] = e & 255; ++a < n && (s *= 256); ) - e < 0 && c === 0 && this[r + a - 1] !== 0 && (c = 1), - (this[r + a] = (((e / s) >> 0) - c) & 255); - return r + n; - }; - Buffer.prototype.writeIntBE = function (e, r, n, i) { - if (((e = +e), (r = r | 0), !i)) { - var o = Math.pow(2, 8 * n - 1); - mh(this, e, r, n, o - 1, -o); - } - var a = n - 1, - s = 1, - c = 0; - for (this[r + a] = e & 255; --a >= 0 && (s *= 256); ) - e < 0 && c === 0 && this[r + a + 1] !== 0 && (c = 1), - (this[r + a] = (((e / s) >> 0) - c) & 255); - return r + n; - }; - Buffer.prototype.writeInt8 = function (e, r, n) { - return ( - (e = +e), - (r = r | 0), - n || mh(this, e, r, 1, 127, -128), - Buffer.TYPED_ARRAY_SUPPORT || (e = Math.floor(e)), - e < 0 && (e = 255 + e + 1), - (this[r] = e & 255), - r + 1 - ); - }; - Buffer.prototype.writeInt16LE = function (e, r, n) { - return ( - (e = +e), - (r = r | 0), - n || mh(this, e, r, 2, 32767, -32768), - Buffer.TYPED_ARRAY_SUPPORT - ? ((this[r] = e & 255), (this[r + 1] = e >>> 8)) - : ZW(this, e, r, !0), - r + 2 - ); - }; - Buffer.prototype.writeInt16BE = function (e, r, n) { - return ( - (e = +e), - (r = r | 0), - n || mh(this, e, r, 2, 32767, -32768), - Buffer.TYPED_ARRAY_SUPPORT - ? ((this[r] = e >>> 8), (this[r + 1] = e & 255)) - : ZW(this, e, r, !1), - r + 2 - ); - }; - Buffer.prototype.writeInt32LE = function (e, r, n) { - return ( - (e = +e), - (r = r | 0), - n || mh(this, e, r, 4, 2147483647, -2147483648), - Buffer.TYPED_ARRAY_SUPPORT - ? ((this[r] = e & 255), - (this[r + 1] = e >>> 8), - (this[r + 2] = e >>> 16), - (this[r + 3] = e >>> 24)) - : XW(this, e, r, !0), - r + 4 - ); - }; - Buffer.prototype.writeInt32BE = function (e, r, n) { - return ( - (e = +e), - (r = r | 0), - n || mh(this, e, r, 4, 2147483647, -2147483648), - e < 0 && (e = 4294967295 + e + 1), - Buffer.TYPED_ARRAY_SUPPORT - ? ((this[r] = e >>> 24), - (this[r + 1] = e >>> 16), - (this[r + 2] = e >>> 8), - (this[r + 3] = e & 255)) - : XW(this, e, r, !1), - r + 4 - ); - }; - Buffer.prototype.writeFloatLE = function (e, r, n) { - return R7e(this, e, r, !0, n); - }; - Buffer.prototype.writeFloatBE = function (e, r, n) { - return R7e(this, e, r, !1, n); - }; - Buffer.prototype.writeDoubleLE = function (e, r, n) { - return N7e(this, e, r, !0, n); - }; - Buffer.prototype.writeDoubleBE = function (e, r, n) { - return N7e(this, e, r, !1, n); - }; - Buffer.prototype.copy = function (e, r, n, i) { - if ( - (n || (n = 0), - !i && i !== 0 && (i = this.length), - r >= e.length && (r = e.length), - r || (r = 0), - i > 0 && i < n && (i = n), - i === n || e.length === 0 || this.length === 0) - ) - return 0; - if (r < 0) throw new RangeError("targetStart out of bounds"); - if (n < 0 || n >= this.length) - throw new RangeError("sourceStart out of bounds"); - if (i < 0) throw new RangeError("sourceEnd out of bounds"); - i > this.length && (i = this.length), - e.length - r < i - n && (i = e.length - r + n); - var o = i - n, - a; - if (this === e && n < r && r < i) - for (a = o - 1; a >= 0; --a) e[a + r] = this[a + n]; - else if (o < 1e3 || !Buffer.TYPED_ARRAY_SUPPORT) - for (a = 0; a < o; ++a) e[a + r] = this[a + n]; - else Uint8Array.prototype.set.call(e, this.subarray(n, n + o), r); - return o; - }; - Buffer.prototype.fill = function (e, r, n, i) { - if (typeof e == "string") { - if ( - (typeof r == "string" - ? ((i = r), (r = 0), (n = this.length)) - : typeof n == "string" && ((i = n), (n = this.length)), - e.length === 1) - ) { - var o = e.charCodeAt(0); - o < 256 && (e = o); - } - if (i !== void 0 && typeof i != "string") - throw new TypeError("encoding must be a string"); - if (typeof i == "string" && !Buffer.isEncoding(i)) - throw new TypeError("Unknown encoding: " + i); - } else typeof e == "number" && (e = e & 255); - if (r < 0 || this.length < r || this.length < n) - throw new RangeError("Out of range index"); - if (n <= r) return this; - (r = r >>> 0), (n = n === void 0 ? this.length : n >>> 0), e || (e = 0); - var a; - if (typeof e == "number") for (a = r; a < n; ++a) this[a] = e; - else { - var s = Xg(e) ? e : $W(new Buffer(e, i).toString()), - c = s.length; - for (a = 0; a < n - r; ++a) this[a + r] = s[a % c]; - } - return this; - }; - URt = /[^+\/0-9A-Za-z-_]/g; - }); - var g = vs(() => { - q7e(); - }); - var SF = I((Aon, j7e) => { - "use strict"; - m(); - g(); - var z7e = Object.getOwnPropertySymbols, - XRt = Object.prototype.hasOwnProperty, - YRt = Object.prototype.propertyIsEnumerable; - function QRt(t) { - if (t == null) - throw new TypeError( - "Object.assign cannot be called with null or undefined" - ); - return Object(t); - } - function e7t() { - try { - if (!Object.assign) return !1; - var t = new String("abc"); - if (((t[5] = "de"), Object.getOwnPropertyNames(t)[0] === "5")) - return !1; - for (var e = {}, r = 0; r < 10; r++) - e["_" + String.fromCharCode(r)] = r; - var n = Object.getOwnPropertyNames(e).map(function (o) { - return e[o]; - }); - if (n.join("") !== "0123456789") return !1; - var i = {}; - return ( - "abcdefghijklmnopqrst".split("").forEach(function (o) { - i[o] = o; - }), - Object.keys(Object.assign({}, i)).join("") === "abcdefghijklmnopqrst" - ); - } catch { - return !1; - } - } - j7e.exports = e7t() - ? Object.assign - : function (t, e) { - for (var r, n = QRt(t), i, o = 1; o < arguments.length; o++) { - r = Object(arguments[o]); - for (var a in r) XRt.call(r, a) && (n[a] = r[a]); - if (z7e) { - i = z7e(r); - for (var s = 0; s < i.length; s++) - YRt.call(r, i[s]) && (n[i[s]] = r[i[s]]); - } - } - return n; - }; - }); - var nNe = I((Si) => { - "use strict"; - m(); - g(); - var wpe = SF(), - aI = 60103, - H7e = 60106; - Si.Fragment = 60107; - Si.StrictMode = 60108; - Si.Profiler = 60114; - var V7e = 60109, - W7e = 60110, - G7e = 60112; - Si.Suspense = 60113; - var J7e = 60115, - $7e = 60116; - typeof Symbol == "function" && - Symbol.for && - ((U0 = Symbol.for), - (aI = U0("react.element")), - (H7e = U0("react.portal")), - (Si.Fragment = U0("react.fragment")), - (Si.StrictMode = U0("react.strict_mode")), - (Si.Profiler = U0("react.profiler")), - (V7e = U0("react.provider")), - (W7e = U0("react.context")), - (G7e = U0("react.forward_ref")), - (Si.Suspense = U0("react.suspense")), - (J7e = U0("react.memo")), - ($7e = U0("react.lazy"))); - var U0, - U7e = typeof Symbol == "function" && Symbol.iterator; - function t7t(t) { - return t === null || typeof t != "object" - ? null - : ((t = (U7e && t[U7e]) || t["@@iterator"]), - typeof t == "function" ? t : null); - } - function AF(t) { - for ( - var e = "https://reactjs.org/docs/error-decoder.html?invariant=" + t, - r = 1; - r < arguments.length; - r++ - ) - e += "&args[]=" + encodeURIComponent(arguments[r]); - return ( - "Minified React error #" + - t + - "; visit " + - e + - " for the full message or use the non-minified dev environment for full errors and additional helpful warnings." - ); - } - var Z7e = { - isMounted: function () { - return !1; - }, - enqueueForceUpdate: function () {}, - enqueueReplaceState: function () {}, - enqueueSetState: function () {}, - }, - X7e = {}; - function sI(t, e, r) { - (this.props = t), - (this.context = e), - (this.refs = X7e), - (this.updater = r || Z7e); - } - sI.prototype.isReactComponent = {}; - sI.prototype.setState = function (t, e) { - if (typeof t != "object" && typeof t != "function" && t != null) - throw Error(AF(85)); - this.updater.enqueueSetState(this, t, e, "setState"); - }; - sI.prototype.forceUpdate = function (t) { - this.updater.enqueueForceUpdate(this, t, "forceUpdate"); - }; - function Y7e() {} - Y7e.prototype = sI.prototype; - function _pe(t, e, r) { - (this.props = t), - (this.context = e), - (this.refs = X7e), - (this.updater = r || Z7e); - } - var xpe = (_pe.prototype = new Y7e()); - xpe.constructor = _pe; - wpe(xpe, sI.prototype); - xpe.isPureReactComponent = !0; - var Spe = { current: null }, - Q7e = Object.prototype.hasOwnProperty, - eNe = { key: !0, ref: !0, __self: !0, __source: !0 }; - function tNe(t, e, r) { - var n, - i = {}, - o = null, - a = null; - if (e != null) - for (n in (e.ref !== void 0 && (a = e.ref), - e.key !== void 0 && (o = "" + e.key), - e)) - Q7e.call(e, n) && !eNe.hasOwnProperty(n) && (i[n] = e[n]); - var s = arguments.length - 2; - if (s === 1) i.children = r; - else if (1 < s) { - for (var c = Array(s), u = 0; u < s; u++) c[u] = arguments[u + 2]; - i.children = c; - } - if (t && t.defaultProps) - for (n in ((s = t.defaultProps), s)) i[n] === void 0 && (i[n] = s[n]); - return { - $$typeof: aI, - type: t, - key: o, - ref: a, - props: i, - _owner: Spe.current, - }; - } - function r7t(t, e) { - return { - $$typeof: aI, - type: t.type, - key: e, - ref: t.ref, - props: t.props, - _owner: t._owner, - }; - } - function Ape(t) { - return typeof t == "object" && t !== null && t.$$typeof === aI; - } - function n7t(t) { - var e = { "=": "=0", ":": "=2" }; - return ( - "$" + - t.replace(/[=:]/g, function (r) { - return e[r]; - }) - ); - } - var K7e = /\/+/g; - function bpe(t, e) { - return typeof t == "object" && t !== null && t.key != null - ? n7t("" + t.key) - : e.toString(36); - } - function tG(t, e, r, n, i) { - var o = typeof t; - (o === "undefined" || o === "boolean") && (t = null); - var a = !1; - if (t === null) a = !0; - else - switch (o) { - case "string": - case "number": - a = !0; - break; - case "object": - switch (t.$$typeof) { - case aI: - case H7e: - a = !0; - } - } - if (a) - return ( - (a = t), - (i = i(a)), - (t = n === "" ? "." + bpe(a, 0) : n), - Array.isArray(i) - ? ((r = ""), - t != null && (r = t.replace(K7e, "$&/") + "/"), - tG(i, e, r, "", function (u) { - return u; - })) - : i != null && - (Ape(i) && - (i = r7t( - i, - r + - (!i.key || (a && a.key === i.key) - ? "" - : ("" + i.key).replace(K7e, "$&/") + "/") + - t - )), - e.push(i)), - 1 - ); - if (((a = 0), (n = n === "" ? "." : n + ":"), Array.isArray(t))) - for (var s = 0; s < t.length; s++) { - o = t[s]; - var c = n + bpe(o, s); - a += tG(o, e, r, c, i); - } - else if (((c = t7t(t)), typeof c == "function")) - for (t = c.call(t), s = 0; !(o = t.next()).done; ) - (o = o.value), (c = n + bpe(o, s++)), (a += tG(o, e, r, c, i)); - else if (o === "object") - throw ( - ((e = "" + t), - Error( - AF( - 31, - e === "[object Object]" - ? "object with keys {" + Object.keys(t).join(", ") + "}" - : e - ) - )) - ); - return a; - } - function eG(t, e, r) { - if (t == null) return t; - var n = [], - i = 0; - return ( - tG(t, n, "", "", function (o) { - return e.call(r, o, i++); - }), - n - ); - } - function i7t(t) { - if (t._status === -1) { - var e = t._result; - (e = e()), - (t._status = 0), - (t._result = e), - e.then( - function (r) { - t._status === 0 && - ((r = r.default), (t._status = 1), (t._result = r)); - }, - function (r) { - t._status === 0 && ((t._status = 2), (t._result = r)); - } - ); - } - if (t._status === 1) return t._result; - throw t._result; - } - var rNe = { current: null }; - function d_() { - var t = rNe.current; - if (t === null) throw Error(AF(321)); - return t; - } - var o7t = { - ReactCurrentDispatcher: rNe, - ReactCurrentBatchConfig: { transition: 0 }, - ReactCurrentOwner: Spe, - IsSomeRendererActing: { current: !1 }, - assign: wpe, - }; - Si.Children = { - map: eG, - forEach: function (t, e, r) { - eG( - t, - function () { - e.apply(this, arguments); - }, - r - ); - }, - count: function (t) { - var e = 0; - return ( - eG(t, function () { - e++; - }), - e - ); - }, - toArray: function (t) { - return ( - eG(t, function (e) { - return e; - }) || [] - ); - }, - only: function (t) { - if (!Ape(t)) throw Error(AF(143)); - return t; - }, - }; - Si.Component = sI; - Si.PureComponent = _pe; - Si.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = o7t; - Si.cloneElement = function (t, e, r) { - if (t == null) throw Error(AF(267, t)); - var n = wpe({}, t.props), - i = t.key, - o = t.ref, - a = t._owner; - if (e != null) { - if ( - (e.ref !== void 0 && ((o = e.ref), (a = Spe.current)), - e.key !== void 0 && (i = "" + e.key), - t.type && t.type.defaultProps) - ) - var s = t.type.defaultProps; - for (c in e) - Q7e.call(e, c) && - !eNe.hasOwnProperty(c) && - (n[c] = e[c] === void 0 && s !== void 0 ? s[c] : e[c]); - } - var c = arguments.length - 2; - if (c === 1) n.children = r; - else if (1 < c) { - s = Array(c); - for (var u = 0; u < c; u++) s[u] = arguments[u + 2]; - n.children = s; - } - return { - $$typeof: aI, - type: t.type, - key: i, - ref: o, - props: n, - _owner: a, - }; - }; - Si.createContext = function (t, e) { - return ( - e === void 0 && (e = null), - (t = { - $$typeof: W7e, - _calculateChangedBits: e, - _currentValue: t, - _currentValue2: t, - _threadCount: 0, - Provider: null, - Consumer: null, - }), - (t.Provider = { $$typeof: V7e, _context: t }), - (t.Consumer = t) - ); - }; - Si.createElement = tNe; - Si.createFactory = function (t) { - var e = tNe.bind(null, t); - return (e.type = t), e; - }; - Si.createRef = function () { - return { current: null }; - }; - Si.forwardRef = function (t) { - return { $$typeof: G7e, render: t }; - }; - Si.isValidElement = Ape; - Si.lazy = function (t) { - return { - $$typeof: $7e, - _payload: { _status: -1, _result: t }, - _init: i7t, - }; - }; - Si.memo = function (t, e) { - return { $$typeof: J7e, type: t, compare: e === void 0 ? null : e }; - }; - Si.useCallback = function (t, e) { - return d_().useCallback(t, e); - }; - Si.useContext = function (t, e) { - return d_().useContext(t, e); - }; - Si.useDebugValue = function () {}; - Si.useEffect = function (t, e) { - return d_().useEffect(t, e); - }; - Si.useImperativeHandle = function (t, e, r) { - return d_().useImperativeHandle(t, e, r); - }; - Si.useLayoutEffect = function (t, e) { - return d_().useLayoutEffect(t, e); - }; - Si.useMemo = function (t, e) { - return d_().useMemo(t, e); - }; - Si.useReducer = function (t, e, r) { - return d_().useReducer(t, e, r); - }; - Si.useRef = function (t) { - return d_().useRef(t); - }; - Si.useState = function (t) { - return d_().useState(t); - }; - Si.version = "17.0.2"; - }); - var to = I((Mon, iNe) => { - "use strict"; - m(); - g(); - iNe.exports = nNe(); - }); - var lNe = I((Ji) => { - "use strict"; - m(); - g(); - var cI, TF, oG, Bpe; - typeof performance == "object" && typeof performance.now == "function" - ? ((oNe = performance), - (Ji.unstable_now = function () { - return oNe.now(); - })) - : ((Epe = Date), - (aNe = Epe.now()), - (Ji.unstable_now = function () { - return Epe.now() - aNe; - })); - var oNe, Epe, aNe; - typeof window > "u" || typeof MessageChannel != "function" - ? ((uI = null), - (Mpe = null), - (Tpe = function () { - if (uI !== null) - try { - var t = Ji.unstable_now(); - uI(!0, t), (uI = null); - } catch (e) { - throw (setTimeout(Tpe, 0), e); - } - }), - (cI = function (t) { - uI !== null ? setTimeout(cI, 0, t) : ((uI = t), setTimeout(Tpe, 0)); - }), - (TF = function (t, e) { - Mpe = setTimeout(t, e); - }), - (oG = function () { - clearTimeout(Mpe); - }), - (Ji.unstable_shouldYield = function () { - return !1; - }), - (Bpe = Ji.unstable_forceFrameRate = function () {})) - : ((sNe = window.setTimeout), - (uNe = window.clearTimeout), - typeof console < "u" && - ((cNe = window.cancelAnimationFrame), - typeof window.requestAnimationFrame != "function" && - console.error( - "This browser doesn't support requestAnimationFrame. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills" - ), - typeof cNe != "function" && - console.error( - "This browser doesn't support cancelAnimationFrame. Make sure that you load a polyfill in older browsers. https://reactjs.org/link/react-polyfills" - )), - (EF = !1), - (MF = null), - (rG = -1), - (kpe = 5), - (Ppe = 0), - (Ji.unstable_shouldYield = function () { - return Ji.unstable_now() >= Ppe; - }), - (Bpe = function () {}), - (Ji.unstable_forceFrameRate = function (t) { - 0 > t || 125 < t - ? console.error( - "forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported" - ) - : (kpe = 0 < t ? Math.floor(1e3 / t) : 5); - }), - (Ope = new MessageChannel()), - (nG = Ope.port2), - (Ope.port1.onmessage = function () { - if (MF !== null) { - var t = Ji.unstable_now(); - Ppe = t + kpe; - try { - MF(!0, t) ? nG.postMessage(null) : ((EF = !1), (MF = null)); - } catch (e) { - throw (nG.postMessage(null), e); - } - } else EF = !1; - }), - (cI = function (t) { - (MF = t), EF || ((EF = !0), nG.postMessage(null)); - }), - (TF = function (t, e) { - rG = sNe(function () { - t(Ji.unstable_now()); - }, e); - }), - (oG = function () { - uNe(rG), (rG = -1); - })); - var uI, Mpe, Tpe, sNe, uNe, cNe, EF, MF, rG, kpe, Ppe, Ope, nG; - function Ipe(t, e) { - var r = t.length; - t.push(e); - e: for (;;) { - var n = (r - 1) >>> 1, - i = t[n]; - if (i !== void 0 && 0 < iG(i, e)) (t[n] = e), (t[r] = i), (r = n); - else break e; - } - } - function Tm(t) { - return (t = t[0]), t === void 0 ? null : t; - } - function aG(t) { - var e = t[0]; - if (e !== void 0) { - var r = t.pop(); - if (r !== e) { - t[0] = r; - e: for (var n = 0, i = t.length; n < i; ) { - var o = 2 * (n + 1) - 1, - a = t[o], - s = o + 1, - c = t[s]; - if (a !== void 0 && 0 > iG(a, r)) - c !== void 0 && 0 > iG(c, a) - ? ((t[n] = c), (t[s] = r), (n = s)) - : ((t[n] = a), (t[o] = r), (n = o)); - else if (c !== void 0 && 0 > iG(c, r)) - (t[n] = c), (t[s] = r), (n = s); - else break e; - } - } - return e; - } - return null; - } - function iG(t, e) { - var r = t.sortIndex - e.sortIndex; - return r !== 0 ? r : t.id - e.id; - } - var Yg = [], - MS = [], - a7t = 1, - K0 = null, - Ec = 3, - sG = !1, - D3 = !1, - kF = !1; - function Cpe(t) { - for (var e = Tm(MS); e !== null; ) { - if (e.callback === null) aG(MS); - else if (e.startTime <= t) - aG(MS), (e.sortIndex = e.expirationTime), Ipe(Yg, e); - else break; - e = Tm(MS); - } - } - function Rpe(t) { - if (((kF = !1), Cpe(t), !D3)) - if (Tm(Yg) !== null) (D3 = !0), cI(Npe); - else { - var e = Tm(MS); - e !== null && TF(Rpe, e.startTime - t); - } - } - function Npe(t, e) { - (D3 = !1), kF && ((kF = !1), oG()), (sG = !0); - var r = Ec; - try { - for ( - Cpe(e), K0 = Tm(Yg); - K0 !== null && - (!(K0.expirationTime > e) || (t && !Ji.unstable_shouldYield())); - - ) { - var n = K0.callback; - if (typeof n == "function") { - (K0.callback = null), (Ec = K0.priorityLevel); - var i = n(K0.expirationTime <= e); - (e = Ji.unstable_now()), - typeof i == "function" - ? (K0.callback = i) - : K0 === Tm(Yg) && aG(Yg), - Cpe(e); - } else aG(Yg); - K0 = Tm(Yg); - } - if (K0 !== null) var o = !0; - else { - var a = Tm(MS); - a !== null && TF(Rpe, a.startTime - e), (o = !1); - } - return o; - } finally { - (K0 = null), (Ec = r), (sG = !1); - } - } - var s7t = Bpe; - Ji.unstable_IdlePriority = 5; - Ji.unstable_ImmediatePriority = 1; - Ji.unstable_LowPriority = 4; - Ji.unstable_NormalPriority = 3; - Ji.unstable_Profiling = null; - Ji.unstable_UserBlockingPriority = 2; - Ji.unstable_cancelCallback = function (t) { - t.callback = null; - }; - Ji.unstable_continueExecution = function () { - D3 || sG || ((D3 = !0), cI(Npe)); - }; - Ji.unstable_getCurrentPriorityLevel = function () { - return Ec; - }; - Ji.unstable_getFirstCallbackNode = function () { - return Tm(Yg); - }; - Ji.unstable_next = function (t) { - switch (Ec) { - case 1: - case 2: - case 3: - var e = 3; - break; - default: - e = Ec; - } - var r = Ec; - Ec = e; - try { - return t(); - } finally { - Ec = r; - } - }; - Ji.unstable_pauseExecution = function () {}; - Ji.unstable_requestPaint = s7t; - Ji.unstable_runWithPriority = function (t, e) { - switch (t) { - case 1: - case 2: - case 3: - case 4: - case 5: - break; - default: - t = 3; - } - var r = Ec; - Ec = t; - try { - return e(); - } finally { - Ec = r; - } - }; - Ji.unstable_scheduleCallback = function (t, e, r) { - var n = Ji.unstable_now(); - switch ( - (typeof r == "object" && r !== null - ? ((r = r.delay), (r = typeof r == "number" && 0 < r ? n + r : n)) - : (r = n), - t) - ) { - case 1: - var i = -1; - break; - case 2: - i = 250; - break; - case 5: - i = 1073741823; - break; - case 4: - i = 1e4; - break; - default: - i = 5e3; - } - return ( - (i = r + i), - (t = { - id: a7t++, - callback: e, - priorityLevel: t, - startTime: r, - expirationTime: i, - sortIndex: -1, - }), - r > n - ? ((t.sortIndex = r), - Ipe(MS, t), - Tm(Yg) === null && - t === Tm(MS) && - (kF ? oG() : (kF = !0), TF(Rpe, r - n))) - : ((t.sortIndex = i), Ipe(Yg, t), D3 || sG || ((D3 = !0), cI(Npe))), - t - ); - }; - Ji.unstable_wrapCallback = function (t) { - var e = Ec; - return function () { - var r = Ec; - Ec = e; - try { - return t.apply(this, arguments); - } finally { - Ec = r; - } - }; - }; - }); - var Dpe = I((kon, fNe) => { - "use strict"; - m(); - g(); - fNe.exports = lNe(); - }); - var dNe = I((Pon, PF) => { - m(); - g(); - PF.exports = function (e) { - var r = {}, - n = SF(), - i = to(), - o = Dpe(); - function a(T) { - for ( - var P = "https://reactjs.org/docs/error-decoder.html?invariant=" + T, - R = 1; - R < arguments.length; - R++ - ) - P += "&args[]=" + encodeURIComponent(arguments[R]); - return ( - "Minified React error #" + - T + - "; visit " + - P + - " for the full message or use the non-minified dev environment for full errors and additional helpful warnings." - ); - } - var s = i.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, - c = 60103, - u = 60106, - h = 60107, - w = 60108, - M = 60114, - k = 60109, - O = 60110, - D = 60112, - F = 60113, - N = 60120, - q = 60115, - z = 60116, - H = 60121, - Z = 60129, - $ = 60130, - ue = 60131; - if (typeof Symbol == "function" && Symbol.for) { - var te = Symbol.for; - (c = te("react.element")), - (u = te("react.portal")), - (h = te("react.fragment")), - (w = te("react.strict_mode")), - (M = te("react.profiler")), - (k = te("react.provider")), - (O = te("react.context")), - (D = te("react.forward_ref")), - (F = te("react.suspense")), - (N = te("react.suspense_list")), - (q = te("react.memo")), - (z = te("react.lazy")), - (H = te("react.block")), - te("react.scope"), - (Z = te("react.debug_trace_mode")), - ($ = te("react.offscreen")), - (ue = te("react.legacy_hidden")); - } - var ne = typeof Symbol == "function" && Symbol.iterator; - function A(T) { - return T === null || typeof T != "object" - ? null - : ((T = (ne && T[ne]) || T["@@iterator"]), - typeof T == "function" ? T : null); - } - function l(T) { - if (T == null) return null; - if (typeof T == "function") return T.displayName || T.name || null; - if (typeof T == "string") return T; - switch (T) { - case h: - return "Fragment"; - case u: - return "Portal"; - case M: - return "Profiler"; - case w: - return "StrictMode"; - case F: - return "Suspense"; - case N: - return "SuspenseList"; - } - if (typeof T == "object") - switch (T.$$typeof) { - case O: - return (T.displayName || "Context") + ".Consumer"; - case k: - return (T._context.displayName || "Context") + ".Provider"; - case D: - var P = T.render; - return ( - (P = P.displayName || P.name || ""), - T.displayName || - (P !== "" ? "ForwardRef(" + P + ")" : "ForwardRef") - ); - case q: - return l(T.type); - case H: - return l(T._render); - case z: - (P = T._payload), (T = T._init); - try { - return l(T(P)); - } catch {} - } - return null; - } - function p(T) { - var P = T, - R = T; - if (T.alternate) for (; P.return; ) P = P.return; - else { - T = P; - do (P = T), (P.flags & 1026) !== 0 && (R = P.return), (T = P.return); - while (T); - } - return P.tag === 3 ? R : null; - } - function y(T) { - if (p(T) !== T) throw Error(a(188)); - } - function d(T) { - var P = T.alternate; - if (!P) { - if (((P = p(T)), P === null)) throw Error(a(188)); - return P !== T ? null : T; - } - for (var R = T, J = P; ; ) { - var Q = R.return; - if (Q === null) break; - var he = Q.alternate; - if (he === null) { - if (((J = Q.return), J !== null)) { - R = J; - continue; - } - break; - } - if (Q.child === he.child) { - for (he = Q.child; he; ) { - if (he === R) return y(Q), T; - if (he === J) return y(Q), P; - he = he.sibling; - } - throw Error(a(188)); - } - if (R.return !== J.return) (R = Q), (J = he); - else { - for (var Oe = !1, et = Q.child; et; ) { - if (et === R) { - (Oe = !0), (R = Q), (J = he); - break; - } - if (et === J) { - (Oe = !0), (J = Q), (R = he); - break; - } - et = et.sibling; - } - if (!Oe) { - for (et = he.child; et; ) { - if (et === R) { - (Oe = !0), (R = he), (J = Q); - break; - } - if (et === J) { - (Oe = !0), (J = he), (R = Q); - break; - } - et = et.sibling; - } - if (!Oe) throw Error(a(189)); - } - } - if (R.alternate !== J) throw Error(a(190)); - } - if (R.tag !== 3) throw Error(a(188)); - return R.stateNode.current === R ? T : P; - } - function v(T) { - if (((T = d(T)), !T)) return null; - for (var P = T; ; ) { - if (P.tag === 5 || P.tag === 6) return P; - if (P.child) (P.child.return = P), (P = P.child); - else { - if (P === T) break; - for (; !P.sibling; ) { - if (!P.return || P.return === T) return null; - P = P.return; - } - (P.sibling.return = P.return), (P = P.sibling); - } - } - return null; - } - function _(T) { - if (((T = d(T)), !T)) return null; - for (var P = T; ; ) { - if (P.tag === 5 || P.tag === 6) return P; - if (P.child && P.tag !== 4) (P.child.return = P), (P = P.child); - else { - if (P === T) break; - for (; !P.sibling; ) { - if (!P.return || P.return === T) return null; - P = P.return; - } - (P.sibling.return = P.return), (P = P.sibling); - } - } - return null; - } - function S(T, P) { - for (var R = T.alternate; P !== null; ) { - if (P === T || P === R) return !0; - P = P.return; - } - return !1; - } - var b = e.getPublicInstance, - f = e.getRootHostContext, - x = e.getChildHostContext, - C = e.prepareForCommit, - E = e.resetAfterCommit, - B = e.createInstance, - G = e.appendInitialChild, - L = e.finalizeInitialChildren, - ee = e.prepareUpdate, - ge = e.shouldSetTextContent, - fe = e.createTextInstance, - V = e.scheduleTimeout, - ye = e.cancelTimeout, - ae = e.noTimeout, - le = e.isPrimaryRenderer, - Me = e.supportsMutation, - de = e.supportsPersistence, - ve = e.supportsHydration, - De = e.getInstanceFromNode, - me = e.makeOpaqueHydratingObject, - _e = e.makeClientId, - Ye = e.beforeActiveInstanceBlur, - Ee = e.afterActiveInstanceBlur, - Be = e.preparePortalMount, - kt = e.supportsTestSelectors, - Ve = e.findFiberRoot, - We = e.getBoundingRect, - er = e.getTextContent, - Ue = e.isHiddenSubtree, - Y = e.matchAccessibilityRole, - W = e.setFocusIfFocusable, - j = e.setupIntersectionObserver, - ce = e.appendChild, - ze = e.appendChildToContainer, - we = e.commitTextUpdate, - xe = e.commitMount, - Ft = e.commitUpdate, - Ke = e.insertBefore, - pe = e.insertInContainerBefore, - Re = e.removeChild, - Se = e.removeChildFromContainer, - Pe = e.resetTextContent, - At = e.hideInstance, - Ie = e.hideTextInstance, - je = e.unhideInstance, - qt = e.unhideTextInstance, - Fe = e.clearContainer, - He = e.cloneInstance, - lr = e.createContainerChildSet, - Xe = e.appendChildToContainerChildSet, - Ze = e.finalizeContainerChildren, - Ir = e.replaceContainerChildren, - $e = e.cloneHiddenInstance, - tt = e.cloneHiddenTextInstance, - oe = e.canHydrateInstance, - ie = e.canHydrateTextInstance, - re = e.isSuspenseInstancePending, - U = e.isSuspenseInstanceFallback, - se = e.getNextHydratableSibling, - be = e.getFirstHydratableChild, - Qe = e.hydrateInstance, - Ae = e.hydrateTextInstance, - ke = e.getNextHydratableInstanceAfterSuspenseInstance, - Ct = e.commitHydratedContainer, - ut = e.commitHydratedSuspenseInstance, - St; - function wt(T) { - if (St === void 0) - try { - throw Error(); - } catch (R) { - var P = R.stack.trim().match(/\n( *(at )?)/); - St = (P && P[1]) || ""; - } - return ( - ` -` + - St + - T - ); - } - var zt = !1; - function jt(T, P) { - if (!T || zt) return ""; - zt = !0; - var R = Error.prepareStackTrace; - Error.prepareStackTrace = void 0; - try { - if (P) - if ( - ((P = function () { - throw Error(); - }), - Object.defineProperty(P.prototype, "props", { - set: function () { - throw Error(); - }, - }), - typeof Reflect == "object" && Reflect.construct) - ) { - try { - Reflect.construct(P, []); - } catch (dt) { - var J = dt; - } - Reflect.construct(T, [], P); - } else { - try { - P.call(); - } catch (dt) { - J = dt; - } - T.call(P.prototype); - } - else { - try { - throw Error(); - } catch (dt) { - J = dt; - } - T(); - } - } catch (dt) { - if (dt && J && typeof dt.stack == "string") { - for ( - var Q = dt.stack.split(` -`), - he = J.stack.split(` -`), - Oe = Q.length - 1, - et = he.length - 1; - 1 <= Oe && 0 <= et && Q[Oe] !== he[et]; - - ) - et--; - for (; 1 <= Oe && 0 <= et; Oe--, et--) - if (Q[Oe] !== he[et]) { - if (Oe !== 1 || et !== 1) - do - if ((Oe--, et--, 0 > et || Q[Oe] !== he[et])) - return ( - ` -` + Q[Oe].replace(" at new ", " at ") - ); - while (1 <= Oe && 0 <= et); - break; - } - } - } finally { - (zt = !1), (Error.prepareStackTrace = R); - } - return (T = T ? T.displayName || T.name : "") ? wt(T) : ""; - } - var Ht = [], - Ut = -1; - function Kt(T) { - return { current: T }; - } - function Ot(T) { - 0 > Ut || ((T.current = Ht[Ut]), (Ht[Ut] = null), Ut--); - } - function Bt(T, P) { - Ut++, (Ht[Ut] = T.current), (T.current = P); - } - var Et = {}, - Mt = Kt(Et), - gt = Kt(!1), - Pt = Et; - function It(T, P) { - var R = T.type.contextTypes; - if (!R) return Et; - var J = T.stateNode; - if (J && J.__reactInternalMemoizedUnmaskedChildContext === P) - return J.__reactInternalMemoizedMaskedChildContext; - var Q = {}, - he; - for (he in R) Q[he] = P[he]; - return ( - J && - ((T = T.stateNode), - (T.__reactInternalMemoizedUnmaskedChildContext = P), - (T.__reactInternalMemoizedMaskedChildContext = Q)), - Q - ); - } - function yt(T) { - return (T = T.childContextTypes), T != null; - } - function nt() { - Ot(gt), Ot(Mt); - } - function it(T, P, R) { - if (Mt.current !== Et) throw Error(a(168)); - Bt(Mt, P), Bt(gt, R); - } - function _t(T, P, R) { - var J = T.stateNode; - if (((T = P.childContextTypes), typeof J.getChildContext != "function")) - return R; - J = J.getChildContext(); - for (var Q in J) - if (!(Q in T)) throw Error(a(108, l(P) || "Unknown", Q)); - return n({}, R, J); - } - function ht(T) { - return ( - (T = - ((T = T.stateNode) && - T.__reactInternalMemoizedMergedChildContext) || - Et), - (Pt = Mt.current), - Bt(Mt, T), - Bt(gt, gt.current), - !0 - ); - } - function mt(T, P, R) { - var J = T.stateNode; - if (!J) throw Error(a(169)); - R - ? ((T = _t(T, P, Pt)), - (J.__reactInternalMemoizedMergedChildContext = T), - Ot(gt), - Ot(Mt), - Bt(Mt, T)) - : Ot(gt), - Bt(gt, R); - } - var Nt = null, - hr = null, - Yr = o.unstable_now; - Yr(); - var Kr = 0, - or = 8; - function Ce(T) { - if ((1 & T) !== 0) return (or = 15), 1; - if ((2 & T) !== 0) return (or = 14), 2; - if ((4 & T) !== 0) return (or = 13), 4; - var P = 24 & T; - return P !== 0 - ? ((or = 12), P) - : (T & 32) !== 0 - ? ((or = 11), 32) - : ((P = 192 & T), - P !== 0 - ? ((or = 10), P) - : (T & 256) !== 0 - ? ((or = 9), 256) - : ((P = 3584 & T), - P !== 0 - ? ((or = 8), P) - : (T & 4096) !== 0 - ? ((or = 7), 4096) - : ((P = 4186112 & T), - P !== 0 - ? ((or = 6), P) - : ((P = 62914560 & T), - P !== 0 - ? ((or = 5), P) - : T & 67108864 - ? ((or = 4), 67108864) - : (T & 134217728) !== 0 - ? ((or = 3), 134217728) - : ((P = 805306368 & T), - P !== 0 - ? ((or = 2), P) - : (1073741824 & T) !== 0 - ? ((or = 1), 1073741824) - : ((or = 8), T)))))); - } - function mn(T) { - switch (T) { - case 99: - return 15; - case 98: - return 10; - case 97: - case 96: - return 8; - case 95: - return 2; - default: - return 0; - } - } - function ii(T) { - switch (T) { - case 15: - case 14: - return 99; - case 13: - case 12: - case 11: - case 10: - return 98; - case 9: - case 8: - case 7: - case 6: - case 4: - case 5: - return 97; - case 3: - case 2: - case 1: - return 95; - case 0: - return 90; - default: - throw Error(a(358, T)); - } - } - function Tn(T, P) { - var R = T.pendingLanes; - if (R === 0) return (or = 0); - var J = 0, - Q = 0, - he = T.expiredLanes, - Oe = T.suspendedLanes, - et = T.pingedLanes; - if (he !== 0) (J = he), (Q = or = 15); - else if (((he = R & 134217727), he !== 0)) { - var dt = he & ~Oe; - dt !== 0 - ? ((J = Ce(dt)), (Q = or)) - : ((et &= he), et !== 0 && ((J = Ce(et)), (Q = or))); - } else - (he = R & ~Oe), - he !== 0 - ? ((J = Ce(he)), (Q = or)) - : et !== 0 && ((J = Ce(et)), (Q = or)); - if (J === 0) return 0; - if ( - ((J = 31 - qi(J)), - (J = R & (((0 > J ? 0 : 1 << J) << 1) - 1)), - P !== 0 && P !== J && (P & Oe) === 0) - ) { - if ((Ce(P), Q <= or)) return P; - or = Q; - } - if (((P = T.entangledLanes), P !== 0)) - for (T = T.entanglements, P &= J; 0 < P; ) - (R = 31 - qi(P)), (Q = 1 << R), (J |= T[R]), (P &= ~Q); - return J; - } - function cn(T) { - return ( - (T = T.pendingLanes & -1073741825), - T !== 0 ? T : T & 1073741824 ? 1073741824 : 0 - ); - } - function kn(T, P) { - switch (T) { - case 15: - return 1; - case 14: - return 2; - case 12: - return (T = gn(24 & ~P)), T === 0 ? kn(10, P) : T; - case 10: - return (T = gn(192 & ~P)), T === 0 ? kn(8, P) : T; - case 8: - return ( - (T = gn(3584 & ~P)), - T === 0 && ((T = gn(4186112 & ~P)), T === 0 && (T = 512)), - T - ); - case 2: - return (P = gn(805306368 & ~P)), P === 0 && (P = 268435456), P; - } - throw Error(a(358, T)); - } - function gn(T) { - return T & -T; - } - function zo(T) { - for (var P = [], R = 0; 31 > R; R++) P.push(T); - return P; - } - function yi(T, P, R) { - T.pendingLanes |= P; - var J = P - 1; - (T.suspendedLanes &= J), - (T.pingedLanes &= J), - (T = T.eventTimes), - (P = 31 - qi(P)), - (T[P] = R); - } - var qi = Math.clz32 ? Math.clz32 : Xa, - Xo = Math.log, - Yo = Math.LN2; - function Xa(T) { - return T === 0 ? 32 : (31 - ((Xo(T) / Yo) | 0)) | 0; - } - var yu = o.unstable_runWithPriority, - ys = o.unstable_scheduleCallback, - ms = o.unstable_cancelCallback, - uCt = o.unstable_shouldYield, - JCe = o.unstable_requestPaint, - bhe = o.unstable_now, - cCt = o.unstable_getCurrentPriorityLevel, - sW = o.unstable_ImmediatePriority, - $Ce = o.unstable_UserBlockingPriority, - ZCe = o.unstable_NormalPriority, - XCe = o.unstable_LowPriority, - YCe = o.unstable_IdlePriority, - whe = {}, - lCt = JCe !== void 0 ? JCe : function () {}, - r_ = null, - uW = null, - _he = !1, - QCe = bhe(), - Wu = - 1e4 > QCe - ? bhe - : function () { - return bhe() - QCe; - }; - function GB() { - switch (cCt()) { - case sW: - return 99; - case $Ce: - return 98; - case ZCe: - return 97; - case XCe: - return 96; - case YCe: - return 95; - default: - throw Error(a(332)); - } - } - function eRe(T) { - switch (T) { - case 99: - return sW; - case 98: - return $Ce; - case 97: - return ZCe; - case 96: - return XCe; - case 95: - return YCe; - default: - throw Error(a(332)); - } - } - function n_(T, P) { - return (T = eRe(T)), yu(T, P); - } - function tF(T, P, R) { - return (T = eRe(T)), ys(T, P, R); - } - function R0() { - if (uW !== null) { - var T = uW; - (uW = null), ms(T); - } - tRe(); - } - function tRe() { - if (!_he && r_ !== null) { - _he = !0; - var T = 0; - try { - var P = r_; - n_(99, function () { - for (; T < P.length; T++) { - var R = P[T]; - do R = R(!0); - while (R !== null); - } - }), - (r_ = null); - } catch (R) { - throw (r_ !== null && (r_ = r_.slice(T + 1)), ys(sW, R0), R); - } finally { - _he = !1; - } - } - } - var fCt = s.ReactCurrentBatchConfig; - function dCt(T, P) { - return ( - (T === P && (T !== 0 || 1 / T === 1 / P)) || (T !== T && P !== P) - ); - } - var N0 = typeof Object.is == "function" ? Object.is : dCt, - hCt = Object.prototype.hasOwnProperty; - function cW(T, P) { - if (N0(T, P)) return !0; - if ( - typeof T != "object" || - T === null || - typeof P != "object" || - P === null - ) - return !1; - var R = Object.keys(T), - J = Object.keys(P); - if (R.length !== J.length) return !1; - for (J = 0; J < R.length; J++) - if (!hCt.call(P, R[J]) || !N0(T[R[J]], P[R[J]])) return !1; - return !0; - } - function pCt(T) { - switch (T.tag) { - case 5: - return wt(T.type); - case 16: - return wt("Lazy"); - case 13: - return wt("Suspense"); - case 19: - return wt("SuspenseList"); - case 0: - case 2: - case 15: - return (T = jt(T.type, !1)), T; - case 11: - return (T = jt(T.type.render, !1)), T; - case 22: - return (T = jt(T.type._render, !1)), T; - case 1: - return (T = jt(T.type, !0)), T; - default: - return ""; - } - } - function Em(T, P) { - if (T && T.defaultProps) { - (P = n({}, P)), (T = T.defaultProps); - for (var R in T) P[R] === void 0 && (P[R] = T[R]); - return P; - } - return P; - } - var lW = Kt(null), - fW = null, - JB = null, - dW = null; - function xhe() { - dW = JB = fW = null; - } - function rRe(T, P) { - (T = T.type._context), - le - ? (Bt(lW, T._currentValue), (T._currentValue = P)) - : (Bt(lW, T._currentValue2), (T._currentValue2 = P)); - } - function She(T) { - var P = lW.current; - Ot(lW), - (T = T.type._context), - le ? (T._currentValue = P) : (T._currentValue2 = P); - } - function nRe(T, P) { - for (; T !== null; ) { - var R = T.alternate; - if ((T.childLanes & P) === P) { - if (R === null || (R.childLanes & P) === P) break; - R.childLanes |= P; - } else (T.childLanes |= P), R !== null && (R.childLanes |= P); - T = T.return; - } - } - function $B(T, P) { - (fW = T), - (dW = JB = null), - (T = T.dependencies), - T !== null && - T.firstContext !== null && - ((T.lanes & P) !== 0 && (Mm = !0), (T.firstContext = null)); - } - function D0(T, P) { - if (dW !== T && P !== !1 && P !== 0) - if ( - ((typeof P != "number" || P === 1073741823) && - ((dW = T), (P = 1073741823)), - (P = { context: T, observedBits: P, next: null }), - JB === null) - ) { - if (fW === null) throw Error(a(308)); - (JB = P), - (fW.dependencies = { - lanes: 0, - firstContext: P, - responders: null, - }); - } else JB = JB.next = P; - return le ? T._currentValue : T._currentValue2; - } - var yS = !1; - function Ahe(T) { - T.updateQueue = { - baseState: T.memoizedState, - firstBaseUpdate: null, - lastBaseUpdate: null, - shared: { pending: null }, - effects: null, - }; - } - function iRe(T, P) { - (T = T.updateQueue), - P.updateQueue === T && - (P.updateQueue = { - baseState: T.baseState, - firstBaseUpdate: T.firstBaseUpdate, - lastBaseUpdate: T.lastBaseUpdate, - shared: T.shared, - effects: T.effects, - }); - } - function mS(T, P) { - return { - eventTime: T, - lane: P, - tag: 0, - payload: null, - callback: null, - next: null, - }; - } - function gS(T, P) { - if (((T = T.updateQueue), T !== null)) { - T = T.shared; - var R = T.pending; - R === null ? (P.next = P) : ((P.next = R.next), (R.next = P)), - (T.pending = P); - } - } - function oRe(T, P) { - var R = T.updateQueue, - J = T.alternate; - if (J !== null && ((J = J.updateQueue), R === J)) { - var Q = null, - he = null; - if (((R = R.firstBaseUpdate), R !== null)) { - do { - var Oe = { - eventTime: R.eventTime, - lane: R.lane, - tag: R.tag, - payload: R.payload, - callback: R.callback, - next: null, - }; - he === null ? (Q = he = Oe) : (he = he.next = Oe), (R = R.next); - } while (R !== null); - he === null ? (Q = he = P) : (he = he.next = P); - } else Q = he = P; - (R = { - baseState: J.baseState, - firstBaseUpdate: Q, - lastBaseUpdate: he, - shared: J.shared, - effects: J.effects, - }), - (T.updateQueue = R); - return; - } - (T = R.lastBaseUpdate), - T === null ? (R.firstBaseUpdate = P) : (T.next = P), - (R.lastBaseUpdate = P); - } - function rF(T, P, R, J) { - var Q = T.updateQueue; - yS = !1; - var he = Q.firstBaseUpdate, - Oe = Q.lastBaseUpdate, - et = Q.shared.pending; - if (et !== null) { - Q.shared.pending = null; - var dt = et, - Yt = dt.next; - (dt.next = null), Oe === null ? (he = Yt) : (Oe.next = Yt), (Oe = dt); - var br = T.alternate; - if (br !== null) { - br = br.updateQueue; - var Hr = br.lastBaseUpdate; - Hr !== Oe && - (Hr === null ? (br.firstBaseUpdate = Yt) : (Hr.next = Yt), - (br.lastBaseUpdate = dt)); - } - } - if (he !== null) { - (Hr = Q.baseState), (Oe = 0), (br = Yt = dt = null); - do { - et = he.lane; - var ir = he.eventTime; - if ((J & et) === et) { - br !== null && - (br = br.next = - { - eventTime: ir, - lane: 0, - tag: he.tag, - payload: he.payload, - callback: he.callback, - next: null, - }); - e: { - var wo = T, - Qo = he; - switch (((et = P), (ir = R), Qo.tag)) { - case 1: - if (((wo = Qo.payload), typeof wo == "function")) { - Hr = wo.call(ir, Hr, et); - break e; - } - Hr = wo; - break e; - case 3: - wo.flags = (wo.flags & -4097) | 64; - case 0: - if ( - ((wo = Qo.payload), - (et = typeof wo == "function" ? wo.call(ir, Hr, et) : wo), - et == null) - ) - break e; - Hr = n({}, Hr, et); - break e; - case 2: - yS = !0; - } - } - he.callback !== null && - ((T.flags |= 32), - (et = Q.effects), - et === null ? (Q.effects = [he]) : et.push(he)); - } else - (ir = { - eventTime: ir, - lane: et, - tag: he.tag, - payload: he.payload, - callback: he.callback, - next: null, - }), - br === null ? ((Yt = br = ir), (dt = Hr)) : (br = br.next = ir), - (Oe |= et); - if (((he = he.next), he === null)) { - if (((et = Q.shared.pending), et === null)) break; - (he = et.next), - (et.next = null), - (Q.lastBaseUpdate = et), - (Q.shared.pending = null); - } - } while (1); - br === null && (dt = Hr), - (Q.baseState = dt), - (Q.firstBaseUpdate = Yt), - (Q.lastBaseUpdate = br), - (mF |= Oe), - (T.lanes = Oe), - (T.memoizedState = Hr); - } - } - function aRe(T, P, R) { - if (((T = P.effects), (P.effects = null), T !== null)) - for (P = 0; P < T.length; P++) { - var J = T[P], - Q = J.callback; - if (Q !== null) { - if (((J.callback = null), (J = R), typeof Q != "function")) - throw Error(a(191, Q)); - Q.call(J); - } - } - } - var sRe = new i.Component().refs; - function hW(T, P, R, J) { - (P = T.memoizedState), - (R = R(J, P)), - (R = R == null ? P : n({}, P, R)), - (T.memoizedState = R), - T.lanes === 0 && (T.updateQueue.baseState = R); - } - var pW = { - isMounted: function (T) { - return (T = T._reactInternals) ? p(T) === T : !1; - }, - enqueueSetState: function (T, P, R) { - T = T._reactInternals; - var J = yh(), - Q = wS(T), - he = mS(J, Q); - (he.payload = P), - R != null && (he.callback = R), - gS(T, he), - u_(T, Q, J); - }, - enqueueReplaceState: function (T, P, R) { - T = T._reactInternals; - var J = yh(), - Q = wS(T), - he = mS(J, Q); - (he.tag = 1), - (he.payload = P), - R != null && (he.callback = R), - gS(T, he), - u_(T, Q, J); - }, - enqueueForceUpdate: function (T, P) { - T = T._reactInternals; - var R = yh(), - J = wS(T), - Q = mS(R, J); - (Q.tag = 2), P != null && (Q.callback = P), gS(T, Q), u_(T, J, R); - }, - }; - function uRe(T, P, R, J, Q, he, Oe) { - return ( - (T = T.stateNode), - typeof T.shouldComponentUpdate == "function" - ? T.shouldComponentUpdate(J, he, Oe) - : P.prototype && P.prototype.isPureReactComponent - ? !cW(R, J) || !cW(Q, he) - : !0 - ); - } - function cRe(T, P, R) { - var J = !1, - Q = Et, - he = P.contextType; - return ( - typeof he == "object" && he !== null - ? (he = D0(he)) - : ((Q = yt(P) ? Pt : Mt.current), - (J = P.contextTypes), - (he = (J = J != null) ? It(T, Q) : Et)), - (P = new P(R, he)), - (T.memoizedState = - P.state !== null && P.state !== void 0 ? P.state : null), - (P.updater = pW), - (T.stateNode = P), - (P._reactInternals = T), - J && - ((T = T.stateNode), - (T.__reactInternalMemoizedUnmaskedChildContext = Q), - (T.__reactInternalMemoizedMaskedChildContext = he)), - P - ); - } - function lRe(T, P, R, J) { - (T = P.state), - typeof P.componentWillReceiveProps == "function" && - P.componentWillReceiveProps(R, J), - typeof P.UNSAFE_componentWillReceiveProps == "function" && - P.UNSAFE_componentWillReceiveProps(R, J), - P.state !== T && pW.enqueueReplaceState(P, P.state, null); - } - function Ehe(T, P, R, J) { - var Q = T.stateNode; - (Q.props = R), (Q.state = T.memoizedState), (Q.refs = sRe), Ahe(T); - var he = P.contextType; - typeof he == "object" && he !== null - ? (Q.context = D0(he)) - : ((he = yt(P) ? Pt : Mt.current), (Q.context = It(T, he))), - rF(T, R, Q, J), - (Q.state = T.memoizedState), - (he = P.getDerivedStateFromProps), - typeof he == "function" && - (hW(T, P, he, R), (Q.state = T.memoizedState)), - typeof P.getDerivedStateFromProps == "function" || - typeof Q.getSnapshotBeforeUpdate == "function" || - (typeof Q.UNSAFE_componentWillMount != "function" && - typeof Q.componentWillMount != "function") || - ((P = Q.state), - typeof Q.componentWillMount == "function" && Q.componentWillMount(), - typeof Q.UNSAFE_componentWillMount == "function" && - Q.UNSAFE_componentWillMount(), - P !== Q.state && pW.enqueueReplaceState(Q, Q.state, null), - rF(T, R, Q, J), - (Q.state = T.memoizedState)), - typeof Q.componentDidMount == "function" && (T.flags |= 4); - } - var yW = Array.isArray; - function nF(T, P, R) { - if ( - ((T = R.ref), - T !== null && typeof T != "function" && typeof T != "object") - ) { - if (R._owner) { - if (((R = R._owner), R)) { - if (R.tag !== 1) throw Error(a(309)); - var J = R.stateNode; - } - if (!J) throw Error(a(147, T)); - var Q = "" + T; - return P !== null && - P.ref !== null && - typeof P.ref == "function" && - P.ref._stringRef === Q - ? P.ref - : ((P = function (he) { - var Oe = J.refs; - Oe === sRe && (Oe = J.refs = {}), - he === null ? delete Oe[Q] : (Oe[Q] = he); - }), - (P._stringRef = Q), - P); - } - if (typeof T != "string") throw Error(a(284)); - if (!R._owner) throw Error(a(290, T)); - } - return T; - } - function mW(T, P) { - if (T.type !== "textarea") - throw Error( - a( - 31, - Object.prototype.toString.call(P) === "[object Object]" - ? "object with keys {" + Object.keys(P).join(", ") + "}" - : P - ) - ); - } - function fRe(T) { - function P(at, rt) { - if (T) { - var pt = at.lastEffect; - pt !== null - ? ((pt.nextEffect = rt), (at.lastEffect = rt)) - : (at.firstEffect = at.lastEffect = rt), - (rt.nextEffect = null), - (rt.flags = 8); - } - } - function R(at, rt) { - if (!T) return null; - for (; rt !== null; ) P(at, rt), (rt = rt.sibling); - return null; - } - function J(at, rt) { - for (at = new Map(); rt !== null; ) - rt.key !== null ? at.set(rt.key, rt) : at.set(rt.index, rt), - (rt = rt.sibling); - return at; - } - function Q(at, rt) { - return (at = xS(at, rt)), (at.index = 0), (at.sibling = null), at; - } - function he(at, rt, pt) { - return ( - (at.index = pt), - T - ? ((pt = at.alternate), - pt !== null - ? ((pt = pt.index), pt < rt ? ((at.flags = 2), rt) : pt) - : ((at.flags = 2), rt)) - : rt - ); - } - function Oe(at) { - return T && at.alternate === null && (at.flags = 2), at; - } - function et(at, rt, pt, tr) { - return rt === null || rt.tag !== 6 - ? ((rt = hpe(pt, at.mode, tr)), (rt.return = at), rt) - : ((rt = Q(rt, pt)), (rt.return = at), rt); - } - function dt(at, rt, pt, tr) { - return rt !== null && rt.elementType === pt.type - ? ((tr = Q(rt, pt.props)), - (tr.ref = nF(at, rt, pt)), - (tr.return = at), - tr) - : ((tr = HW(pt.type, pt.key, pt.props, null, at.mode, tr)), - (tr.ref = nF(at, rt, pt)), - (tr.return = at), - tr); - } - function Yt(at, rt, pt, tr) { - return rt === null || - rt.tag !== 4 || - rt.stateNode.containerInfo !== pt.containerInfo || - rt.stateNode.implementation !== pt.implementation - ? ((rt = ppe(pt, at.mode, tr)), (rt.return = at), rt) - : ((rt = Q(rt, pt.children || [])), (rt.return = at), rt); - } - function br(at, rt, pt, tr, wr) { - return rt === null || rt.tag !== 7 - ? ((rt = nI(pt, at.mode, tr, wr)), (rt.return = at), rt) - : ((rt = Q(rt, pt)), (rt.return = at), rt); - } - function Hr(at, rt, pt) { - if (typeof rt == "string" || typeof rt == "number") - return (rt = hpe("" + rt, at.mode, pt)), (rt.return = at), rt; - if (typeof rt == "object" && rt !== null) { - switch (rt.$$typeof) { - case c: - return ( - (pt = HW(rt.type, rt.key, rt.props, null, at.mode, pt)), - (pt.ref = nF(at, null, rt)), - (pt.return = at), - pt - ); - case u: - return (rt = ppe(rt, at.mode, pt)), (rt.return = at), rt; - } - if (yW(rt) || A(rt)) - return (rt = nI(rt, at.mode, pt, null)), (rt.return = at), rt; - mW(at, rt); - } - return null; - } - function ir(at, rt, pt, tr) { - var wr = rt !== null ? rt.key : null; - if (typeof pt == "string" || typeof pt == "number") - return wr !== null ? null : et(at, rt, "" + pt, tr); - if (typeof pt == "object" && pt !== null) { - switch (pt.$$typeof) { - case c: - return pt.key === wr - ? pt.type === h - ? br(at, rt, pt.props.children, tr, wr) - : dt(at, rt, pt, tr) - : null; - case u: - return pt.key === wr ? Yt(at, rt, pt, tr) : null; - } - if (yW(pt) || A(pt)) - return wr !== null ? null : br(at, rt, pt, tr, null); - mW(at, pt); - } - return null; - } - function wo(at, rt, pt, tr, wr) { - if (typeof tr == "string" || typeof tr == "number") - return (at = at.get(pt) || null), et(rt, at, "" + tr, wr); - if (typeof tr == "object" && tr !== null) { - switch (tr.$$typeof) { - case c: - return ( - (at = at.get(tr.key === null ? pt : tr.key) || null), - tr.type === h - ? br(rt, at, tr.props.children, wr, tr.key) - : dt(rt, at, tr, wr) - ); - case u: - return ( - (at = at.get(tr.key === null ? pt : tr.key) || null), - Yt(rt, at, tr, wr) - ); - } - if (yW(tr) || A(tr)) - return (at = at.get(pt) || null), br(rt, at, tr, wr, null); - mW(rt, tr); - } - return null; - } - function Qo(at, rt, pt, tr) { - for ( - var wr = null, To = null, Jr = rt, Gi = (rt = 0), gs = null; - Jr !== null && Gi < pt.length; - Gi++ - ) { - Jr.index > Gi ? ((gs = Jr), (Jr = null)) : (gs = Jr.sibling); - var mi = ir(at, Jr, pt[Gi], tr); - if (mi === null) { - Jr === null && (Jr = gs); - break; - } - T && Jr && mi.alternate === null && P(at, Jr), - (rt = he(mi, rt, Gi)), - To === null ? (wr = mi) : (To.sibling = mi), - (To = mi), - (Jr = gs); - } - if (Gi === pt.length) return R(at, Jr), wr; - if (Jr === null) { - for (; Gi < pt.length; Gi++) - (Jr = Hr(at, pt[Gi], tr)), - Jr !== null && - ((rt = he(Jr, rt, Gi)), - To === null ? (wr = Jr) : (To.sibling = Jr), - (To = Jr)); - return wr; - } - for (Jr = J(at, Jr); Gi < pt.length; Gi++) - (gs = wo(Jr, at, Gi, pt[Gi], tr)), - gs !== null && - (T && - gs.alternate !== null && - Jr.delete(gs.key === null ? Gi : gs.key), - (rt = he(gs, rt, Gi)), - To === null ? (wr = gs) : (To.sibling = gs), - (To = gs)); - return ( - T && - Jr.forEach(function (SS) { - return P(at, SS); - }), - wr - ); - } - function z0(at, rt, pt, tr) { - var wr = A(pt); - if (typeof wr != "function") throw Error(a(150)); - if (((pt = wr.call(pt)), pt == null)) throw Error(a(151)); - for ( - var To = (wr = null), - Jr = rt, - Gi = (rt = 0), - gs = null, - mi = pt.next(); - Jr !== null && !mi.done; - Gi++, mi = pt.next() - ) { - Jr.index > Gi ? ((gs = Jr), (Jr = null)) : (gs = Jr.sibling); - var SS = ir(at, Jr, mi.value, tr); - if (SS === null) { - Jr === null && (Jr = gs); - break; - } - T && Jr && SS.alternate === null && P(at, Jr), - (rt = he(SS, rt, Gi)), - To === null ? (wr = SS) : (To.sibling = SS), - (To = SS), - (Jr = gs); - } - if (mi.done) return R(at, Jr), wr; - if (Jr === null) { - for (; !mi.done; Gi++, mi = pt.next()) - (mi = Hr(at, mi.value, tr)), - mi !== null && - ((rt = he(mi, rt, Gi)), - To === null ? (wr = mi) : (To.sibling = mi), - (To = mi)); - return wr; - } - for (Jr = J(at, Jr); !mi.done; Gi++, mi = pt.next()) - (mi = wo(Jr, at, Gi, mi.value, tr)), - mi !== null && - (T && - mi.alternate !== null && - Jr.delete(mi.key === null ? Gi : mi.key), - (rt = he(mi, rt, Gi)), - To === null ? (wr = mi) : (To.sibling = mi), - (To = mi)); - return ( - T && - Jr.forEach(function (KCt) { - return P(at, KCt); - }), - wr - ); - } - return function (at, rt, pt, tr) { - var wr = - typeof pt == "object" && - pt !== null && - pt.type === h && - pt.key === null; - wr && (pt = pt.props.children); - var To = typeof pt == "object" && pt !== null; - if (To) - switch (pt.$$typeof) { - case c: - e: { - for (To = pt.key, wr = rt; wr !== null; ) { - if (wr.key === To) { - switch (wr.tag) { - case 7: - if (pt.type === h) { - R(at, wr.sibling), - (rt = Q(wr, pt.props.children)), - (rt.return = at), - (at = rt); - break e; - } - break; - default: - if (wr.elementType === pt.type) { - R(at, wr.sibling), - (rt = Q(wr, pt.props)), - (rt.ref = nF(at, wr, pt)), - (rt.return = at), - (at = rt); - break e; - } - } - R(at, wr); - break; - } else P(at, wr); - wr = wr.sibling; - } - pt.type === h - ? ((rt = nI(pt.props.children, at.mode, tr, pt.key)), - (rt.return = at), - (at = rt)) - : ((tr = HW(pt.type, pt.key, pt.props, null, at.mode, tr)), - (tr.ref = nF(at, rt, pt)), - (tr.return = at), - (at = tr)); - } - return Oe(at); - case u: - e: { - for (wr = pt.key; rt !== null; ) { - if (rt.key === wr) - if ( - rt.tag === 4 && - rt.stateNode.containerInfo === pt.containerInfo && - rt.stateNode.implementation === pt.implementation - ) { - R(at, rt.sibling), - (rt = Q(rt, pt.children || [])), - (rt.return = at), - (at = rt); - break e; - } else { - R(at, rt); - break; - } - else P(at, rt); - rt = rt.sibling; - } - (rt = ppe(pt, at.mode, tr)), (rt.return = at), (at = rt); - } - return Oe(at); - } - if (typeof pt == "string" || typeof pt == "number") - return ( - (pt = "" + pt), - rt !== null && rt.tag === 6 - ? (R(at, rt.sibling), - (rt = Q(rt, pt)), - (rt.return = at), - (at = rt)) - : (R(at, rt), - (rt = hpe(pt, at.mode, tr)), - (rt.return = at), - (at = rt)), - Oe(at) - ); - if (yW(pt)) return Qo(at, rt, pt, tr); - if (A(pt)) return z0(at, rt, pt, tr); - if ((To && mW(at, pt), typeof pt > "u" && !wr)) - switch (at.tag) { - case 1: - case 22: - case 0: - case 11: - case 15: - throw Error(a(152, l(at.type) || "Component")); - } - return R(at, rt); - }; - } - var gW = fRe(!0), - dRe = fRe(!1), - iF = {}, - F0 = Kt(iF), - oF = Kt(iF), - ZB = Kt(iF); - function Vg(T) { - if (T === iF) throw Error(a(174)); - return T; - } - function Mhe(T, P) { - Bt(ZB, P), Bt(oF, T), Bt(F0, iF), (T = f(P)), Ot(F0), Bt(F0, T); - } - function XB() { - Ot(F0), Ot(oF), Ot(ZB); - } - function hRe(T) { - var P = Vg(ZB.current), - R = Vg(F0.current); - (P = x(R, T.type, P)), R !== P && (Bt(oF, T), Bt(F0, P)); - } - function The(T) { - oF.current === T && (Ot(F0), Ot(oF)); - } - var Oa = Kt(0); - function vW(T) { - for (var P = T; P !== null; ) { - if (P.tag === 13) { - var R = P.memoizedState; - if (R !== null && ((R = R.dehydrated), R === null || re(R) || U(R))) - return P; - } else if (P.tag === 19 && P.memoizedProps.revealOrder !== void 0) { - if ((P.flags & 64) !== 0) return P; - } else if (P.child !== null) { - (P.child.return = P), (P = P.child); - continue; - } - if (P === T) break; - for (; P.sibling === null; ) { - if (P.return === null || P.return === T) return null; - P = P.return; - } - (P.sibling.return = P.return), (P = P.sibling); - } - return null; - } - var i_ = null, - k3 = null, - Wg = !1; - function pRe(T, P) { - var R = q0(5, null, null, 0); - (R.elementType = "DELETED"), - (R.type = "DELETED"), - (R.stateNode = P), - (R.return = T), - (R.flags = 8), - T.lastEffect !== null - ? ((T.lastEffect.nextEffect = R), (T.lastEffect = R)) - : (T.firstEffect = T.lastEffect = R); - } - function yRe(T, P) { - switch (T.tag) { - case 5: - return ( - (P = oe(P, T.type, T.pendingProps)), - P !== null ? ((T.stateNode = P), !0) : !1 - ); - case 6: - return ( - (P = ie(P, T.pendingProps)), - P !== null ? ((T.stateNode = P), !0) : !1 - ); - case 13: - return !1; - default: - return !1; - } - } - function khe(T) { - if (Wg) { - var P = k3; - if (P) { - var R = P; - if (!yRe(T, P)) { - if (((P = se(R)), !P || !yRe(T, P))) { - (T.flags = (T.flags & -1025) | 2), (Wg = !1), (i_ = T); - return; - } - pRe(i_, R); - } - (i_ = T), (k3 = be(P)); - } else (T.flags = (T.flags & -1025) | 2), (Wg = !1), (i_ = T); - } - } - function mRe(T) { - for ( - T = T.return; - T !== null && T.tag !== 5 && T.tag !== 3 && T.tag !== 13; - - ) - T = T.return; - i_ = T; - } - function bW(T) { - if (!ve || T !== i_) return !1; - if (!Wg) return mRe(T), (Wg = !0), !1; - var P = T.type; - if ( - T.tag !== 5 || - (P !== "head" && P !== "body" && !ge(P, T.memoizedProps)) - ) - for (P = k3; P; ) pRe(T, P), (P = se(P)); - if ((mRe(T), T.tag === 13)) { - if (!ve) throw Error(a(316)); - if ( - ((T = T.memoizedState), (T = T !== null ? T.dehydrated : null), !T) - ) - throw Error(a(317)); - k3 = ke(T); - } else k3 = i_ ? se(T.stateNode) : null; - return !0; - } - function Phe() { - ve && ((k3 = i_ = null), (Wg = !1)); - } - var YB = []; - function Ohe() { - for (var T = 0; T < YB.length; T++) { - var P = YB[T]; - le - ? (P._workInProgressVersionPrimary = null) - : (P._workInProgressVersionSecondary = null); - } - YB.length = 0; - } - var aF = s.ReactCurrentDispatcher, - L0 = s.ReactCurrentBatchConfig, - sF = 0, - Ya = null, - Sc = null, - Gu = null, - wW = !1, - uF = !1; - function hh() { - throw Error(a(321)); - } - function Bhe(T, P) { - if (P === null) return !1; - for (var R = 0; R < P.length && R < T.length; R++) - if (!N0(T[R], P[R])) return !1; - return !0; - } - function Ihe(T, P, R, J, Q, he) { - if ( - ((sF = he), - (Ya = P), - (P.memoizedState = null), - (P.updateQueue = null), - (P.lanes = 0), - (aF.current = T === null || T.memoizedState === null ? mCt : gCt), - (T = R(J, Q)), - uF) - ) { - he = 0; - do { - if (((uF = !1), !(25 > he))) throw Error(a(301)); - (he += 1), - (Gu = Sc = null), - (P.updateQueue = null), - (aF.current = vCt), - (T = R(J, Q)); - } while (uF); - } - if ( - ((aF.current = AW), - (P = Sc !== null && Sc.next !== null), - (sF = 0), - (Gu = Sc = Ya = null), - (wW = !1), - P) - ) - throw Error(a(300)); - return T; - } - function P3() { - var T = { - memoizedState: null, - baseState: null, - baseQueue: null, - queue: null, - next: null, - }; - return ( - Gu === null ? (Ya.memoizedState = Gu = T) : (Gu = Gu.next = T), Gu - ); - } - function O3() { - if (Sc === null) { - var T = Ya.alternate; - T = T !== null ? T.memoizedState : null; - } else T = Sc.next; - var P = Gu === null ? Ya.memoizedState : Gu.next; - if (P !== null) (Gu = P), (Sc = T); - else { - if (T === null) throw Error(a(310)); - (Sc = T), - (T = { - memoizedState: Sc.memoizedState, - baseState: Sc.baseState, - baseQueue: Sc.baseQueue, - queue: Sc.queue, - next: null, - }), - Gu === null ? (Ya.memoizedState = Gu = T) : (Gu = Gu.next = T); - } - return Gu; - } - function Gg(T, P) { - return typeof P == "function" ? P(T) : P; - } - function cF(T) { - var P = O3(), - R = P.queue; - if (R === null) throw Error(a(311)); - R.lastRenderedReducer = T; - var J = Sc, - Q = J.baseQueue, - he = R.pending; - if (he !== null) { - if (Q !== null) { - var Oe = Q.next; - (Q.next = he.next), (he.next = Oe); - } - (J.baseQueue = Q = he), (R.pending = null); - } - if (Q !== null) { - (Q = Q.next), (J = J.baseState); - var et = (Oe = he = null), - dt = Q; - do { - var Yt = dt.lane; - if ((sF & Yt) === Yt) - et !== null && - (et = et.next = - { - lane: 0, - action: dt.action, - eagerReducer: dt.eagerReducer, - eagerState: dt.eagerState, - next: null, - }), - (J = dt.eagerReducer === T ? dt.eagerState : T(J, dt.action)); - else { - var br = { - lane: Yt, - action: dt.action, - eagerReducer: dt.eagerReducer, - eagerState: dt.eagerState, - next: null, - }; - et === null ? ((Oe = et = br), (he = J)) : (et = et.next = br), - (Ya.lanes |= Yt), - (mF |= Yt); - } - dt = dt.next; - } while (dt !== null && dt !== Q); - et === null ? (he = J) : (et.next = Oe), - N0(J, P.memoizedState) || (Mm = !0), - (P.memoizedState = J), - (P.baseState = he), - (P.baseQueue = et), - (R.lastRenderedState = J); - } - return [P.memoizedState, R.dispatch]; - } - function lF(T) { - var P = O3(), - R = P.queue; - if (R === null) throw Error(a(311)); - R.lastRenderedReducer = T; - var J = R.dispatch, - Q = R.pending, - he = P.memoizedState; - if (Q !== null) { - R.pending = null; - var Oe = (Q = Q.next); - do (he = T(he, Oe.action)), (Oe = Oe.next); - while (Oe !== Q); - N0(he, P.memoizedState) || (Mm = !0), - (P.memoizedState = he), - P.baseQueue === null && (P.baseState = he), - (R.lastRenderedState = he); - } - return [he, J]; - } - function gRe(T, P, R) { - var J = P._getVersion; - J = J(P._source); - var Q = le - ? P._workInProgressVersionPrimary - : P._workInProgressVersionSecondary; - if ( - (Q !== null - ? (T = Q === J) - : ((T = T.mutableReadLanes), - (T = (sF & T) === T) && - (le - ? (P._workInProgressVersionPrimary = J) - : (P._workInProgressVersionSecondary = J), - YB.push(P))), - T) - ) - return R(P._source); - throw (YB.push(P), Error(a(350))); - } - function vRe(T, P, R, J) { - var Q = Nd; - if (Q === null) throw Error(a(349)); - var he = P._getVersion, - Oe = he(P._source), - et = aF.current, - dt = et.useState(function () { - return gRe(Q, P, R); - }), - Yt = dt[1], - br = dt[0]; - dt = Gu; - var Hr = T.memoizedState, - ir = Hr.refs, - wo = ir.getSnapshot, - Qo = Hr.source; - Hr = Hr.subscribe; - var z0 = Ya; - return ( - (T.memoizedState = { refs: ir, source: P, subscribe: J }), - et.useEffect( - function () { - (ir.getSnapshot = R), (ir.setSnapshot = Yt); - var at = he(P._source); - if (!N0(Oe, at)) { - (at = R(P._source)), - N0(br, at) || - (Yt(at), - (at = wS(z0)), - (Q.mutableReadLanes |= at & Q.pendingLanes)), - (at = Q.mutableReadLanes), - (Q.entangledLanes |= at); - for (var rt = Q.entanglements, pt = at; 0 < pt; ) { - var tr = 31 - qi(pt), - wr = 1 << tr; - (rt[tr] |= at), (pt &= ~wr); - } - } - }, - [R, P, J] - ), - et.useEffect( - function () { - return J(P._source, function () { - var at = ir.getSnapshot, - rt = ir.setSnapshot; - try { - rt(at(P._source)); - var pt = wS(z0); - Q.mutableReadLanes |= pt & Q.pendingLanes; - } catch (tr) { - rt(function () { - throw tr; - }); - } - }); - }, - [P, J] - ), - (N0(wo, R) && N0(Qo, P) && N0(Hr, J)) || - ((T = { - pending: null, - dispatch: null, - lastRenderedReducer: Gg, - lastRenderedState: br, - }), - (T.dispatch = Yt = Dhe.bind(null, Ya, T)), - (dt.queue = T), - (dt.baseQueue = null), - (br = gRe(Q, P, R)), - (dt.memoizedState = dt.baseState = br)), - br - ); - } - function bRe(T, P, R) { - var J = O3(); - return vRe(J, T, P, R); - } - function fF(T) { - var P = P3(); - return ( - typeof T == "function" && (T = T()), - (P.memoizedState = P.baseState = T), - (T = P.queue = - { - pending: null, - dispatch: null, - lastRenderedReducer: Gg, - lastRenderedState: T, - }), - (T = T.dispatch = Dhe.bind(null, Ya, T)), - [P.memoizedState, T] - ); - } - function _W(T, P, R, J) { - return ( - (T = { tag: T, create: P, destroy: R, deps: J, next: null }), - (P = Ya.updateQueue), - P === null - ? ((P = { lastEffect: null }), - (Ya.updateQueue = P), - (P.lastEffect = T.next = T)) - : ((R = P.lastEffect), - R === null - ? (P.lastEffect = T.next = T) - : ((J = R.next), - (R.next = T), - (T.next = J), - (P.lastEffect = T))), - T - ); - } - function wRe(T) { - var P = P3(); - return (T = { current: T }), (P.memoizedState = T); - } - function xW() { - return O3().memoizedState; - } - function Che(T, P, R, J) { - var Q = P3(); - (Ya.flags |= T), - (Q.memoizedState = _W(1 | P, R, void 0, J === void 0 ? null : J)); - } - function Rhe(T, P, R, J) { - var Q = O3(); - J = J === void 0 ? null : J; - var he = void 0; - if (Sc !== null) { - var Oe = Sc.memoizedState; - if (((he = Oe.destroy), J !== null && Bhe(J, Oe.deps))) { - _W(P, R, he, J); - return; - } - } - (Ya.flags |= T), (Q.memoizedState = _W(1 | P, R, he, J)); - } - function _Re(T, P) { - return Che(516, 4, T, P); - } - function SW(T, P) { - return Rhe(516, 4, T, P); - } - function xRe(T, P) { - return Rhe(4, 2, T, P); - } - function SRe(T, P) { - if (typeof P == "function") - return ( - (T = T()), - P(T), - function () { - P(null); - } - ); - if (P != null) - return ( - (T = T()), - (P.current = T), - function () { - P.current = null; - } - ); - } - function ARe(T, P, R) { - return ( - (R = R != null ? R.concat([T]) : null), - Rhe(4, 2, SRe.bind(null, P, T), R) - ); - } - function Nhe() {} - function ERe(T, P) { - var R = O3(); - P = P === void 0 ? null : P; - var J = R.memoizedState; - return J !== null && P !== null && Bhe(P, J[1]) - ? J[0] - : ((R.memoizedState = [T, P]), T); - } - function MRe(T, P) { - var R = O3(); - P = P === void 0 ? null : P; - var J = R.memoizedState; - return J !== null && P !== null && Bhe(P, J[1]) - ? J[0] - : ((T = T()), (R.memoizedState = [T, P]), T); - } - function yCt(T, P) { - var R = GB(); - n_(98 > R ? 98 : R, function () { - T(!0); - }), - n_(97 < R ? 97 : R, function () { - var J = L0.transition; - L0.transition = 1; - try { - T(!1), P(); - } finally { - L0.transition = J; - } - }); - } - function Dhe(T, P, R) { - var J = yh(), - Q = wS(T), - he = { - lane: Q, - action: R, - eagerReducer: null, - eagerState: null, - next: null, - }, - Oe = P.pending; - if ( - (Oe === null ? (he.next = he) : ((he.next = Oe.next), (Oe.next = he)), - (P.pending = he), - (Oe = T.alternate), - T === Ya || (Oe !== null && Oe === Ya)) - ) - uF = wW = !0; - else { - if ( - T.lanes === 0 && - (Oe === null || Oe.lanes === 0) && - ((Oe = P.lastRenderedReducer), Oe !== null) - ) - try { - var et = P.lastRenderedState, - dt = Oe(et, R); - if (((he.eagerReducer = Oe), (he.eagerState = dt), N0(dt, et))) - return; - } catch { - } finally { - } - u_(T, Q, J); - } - } - var AW = { - readContext: D0, - useCallback: hh, - useContext: hh, - useEffect: hh, - useImperativeHandle: hh, - useLayoutEffect: hh, - useMemo: hh, - useReducer: hh, - useRef: hh, - useState: hh, - useDebugValue: hh, - useDeferredValue: hh, - useTransition: hh, - useMutableSource: hh, - useOpaqueIdentifier: hh, - unstable_isNewReconciler: !1, - }, - mCt = { - readContext: D0, - useCallback: function (T, P) { - return (P3().memoizedState = [T, P === void 0 ? null : P]), T; - }, - useContext: D0, - useEffect: _Re, - useImperativeHandle: function (T, P, R) { - return ( - (R = R != null ? R.concat([T]) : null), - Che(4, 2, SRe.bind(null, P, T), R) - ); - }, - useLayoutEffect: function (T, P) { - return Che(4, 2, T, P); - }, - useMemo: function (T, P) { - var R = P3(); - return ( - (P = P === void 0 ? null : P), - (T = T()), - (R.memoizedState = [T, P]), - T - ); - }, - useReducer: function (T, P, R) { - var J = P3(); - return ( - (P = R !== void 0 ? R(P) : P), - (J.memoizedState = J.baseState = P), - (T = J.queue = - { - pending: null, - dispatch: null, - lastRenderedReducer: T, - lastRenderedState: P, - }), - (T = T.dispatch = Dhe.bind(null, Ya, T)), - [J.memoizedState, T] - ); - }, - useRef: wRe, - useState: fF, - useDebugValue: Nhe, - useDeferredValue: function (T) { - var P = fF(T), - R = P[0], - J = P[1]; - return ( - _Re( - function () { - var Q = L0.transition; - L0.transition = 1; - try { - J(T); - } finally { - L0.transition = Q; - } - }, - [T] - ), - R - ); - }, - useTransition: function () { - var T = fF(!1), - P = T[0]; - return (T = yCt.bind(null, T[1])), wRe(T), [T, P]; - }, - useMutableSource: function (T, P, R) { - var J = P3(); - return ( - (J.memoizedState = { - refs: { getSnapshot: P, setSnapshot: null }, - source: T, - subscribe: R, - }), - vRe(J, T, P, R) - ); - }, - useOpaqueIdentifier: function () { - if (Wg) { - var T = !1, - P = me(function () { - throw (T || ((T = !0), R(_e())), Error(a(355))); - }), - R = fF(P)[1]; - return ( - (Ya.mode & 2) === 0 && - ((Ya.flags |= 516), - _W( - 5, - function () { - R(_e()); - }, - void 0, - null - )), - P - ); - } - return (P = _e()), fF(P), P; - }, - unstable_isNewReconciler: !1, - }, - gCt = { - readContext: D0, - useCallback: ERe, - useContext: D0, - useEffect: SW, - useImperativeHandle: ARe, - useLayoutEffect: xRe, - useMemo: MRe, - useReducer: cF, - useRef: xW, - useState: function () { - return cF(Gg); - }, - useDebugValue: Nhe, - useDeferredValue: function (T) { - var P = cF(Gg), - R = P[0], - J = P[1]; - return ( - SW( - function () { - var Q = L0.transition; - L0.transition = 1; - try { - J(T); - } finally { - L0.transition = Q; - } - }, - [T] - ), - R - ); - }, - useTransition: function () { - var T = cF(Gg)[0]; - return [xW().current, T]; - }, - useMutableSource: bRe, - useOpaqueIdentifier: function () { - return cF(Gg)[0]; - }, - unstable_isNewReconciler: !1, - }, - vCt = { - readContext: D0, - useCallback: ERe, - useContext: D0, - useEffect: SW, - useImperativeHandle: ARe, - useLayoutEffect: xRe, - useMemo: MRe, - useReducer: lF, - useRef: xW, - useState: function () { - return lF(Gg); - }, - useDebugValue: Nhe, - useDeferredValue: function (T) { - var P = lF(Gg), - R = P[0], - J = P[1]; - return ( - SW( - function () { - var Q = L0.transition; - L0.transition = 1; - try { - J(T); - } finally { - L0.transition = Q; - } - }, - [T] - ), - R - ); - }, - useTransition: function () { - var T = lF(Gg)[0]; - return [xW().current, T]; - }, - useMutableSource: bRe, - useOpaqueIdentifier: function () { - return lF(Gg)[0]; - }, - unstable_isNewReconciler: !1, - }, - bCt = s.ReactCurrentOwner, - Mm = !1; - function ph(T, P, R, J) { - P.child = T === null ? dRe(P, null, R, J) : gW(P, T.child, R, J); - } - function TRe(T, P, R, J, Q) { - R = R.render; - var he = P.ref; - return ( - $B(P, Q), - (J = Ihe(T, P, R, J, he, Q)), - T !== null && !Mm - ? ((P.updateQueue = T.updateQueue), - (P.flags &= -517), - (T.lanes &= ~Q), - o_(T, P, Q)) - : ((P.flags |= 1), ph(T, P, J, Q), P.child) - ); - } - function kRe(T, P, R, J, Q, he) { - if (T === null) { - var Oe = R.type; - return typeof Oe == "function" && - !fpe(Oe) && - Oe.defaultProps === void 0 && - R.compare === null && - R.defaultProps === void 0 - ? ((P.tag = 15), (P.type = Oe), PRe(T, P, Oe, J, Q, he)) - : ((T = HW(R.type, null, J, P, P.mode, he)), - (T.ref = P.ref), - (T.return = P), - (P.child = T)); - } - return ( - (Oe = T.child), - (Q & he) === 0 && - ((Q = Oe.memoizedProps), - (R = R.compare), - (R = R !== null ? R : cW), - R(Q, J) && T.ref === P.ref) - ? o_(T, P, he) - : ((P.flags |= 1), - (T = xS(Oe, J)), - (T.ref = P.ref), - (T.return = P), - (P.child = T)) - ); - } - function PRe(T, P, R, J, Q, he) { - if (T !== null && cW(T.memoizedProps, J) && T.ref === P.ref) - if (((Mm = !1), (he & Q) !== 0)) (T.flags & 16384) !== 0 && (Mm = !0); - else return (P.lanes = T.lanes), o_(T, P, he); - return Lhe(T, P, R, J, he); - } - function Fhe(T, P, R) { - var J = P.pendingProps, - Q = J.children, - he = T !== null ? T.memoizedState : null; - if (J.mode === "hidden" || J.mode === "unstable-defer-without-hiding") - if ((P.mode & 4) === 0) - (P.memoizedState = { baseLanes: 0 }), jW(P, R); - else if ((R & 1073741824) !== 0) - (P.memoizedState = { baseLanes: 0 }), - jW(P, he !== null ? he.baseLanes : R); - else - return ( - (T = he !== null ? he.baseLanes | R : R), - (P.lanes = P.childLanes = 1073741824), - (P.memoizedState = { baseLanes: T }), - jW(P, T), - null - ); - else - he !== null - ? ((J = he.baseLanes | R), (P.memoizedState = null)) - : (J = R), - jW(P, J); - return ph(T, P, Q, R), P.child; - } - function ORe(T, P) { - var R = P.ref; - ((T === null && R !== null) || (T !== null && T.ref !== R)) && - (P.flags |= 128); - } - function Lhe(T, P, R, J, Q) { - var he = yt(R) ? Pt : Mt.current; - return ( - (he = It(P, he)), - $B(P, Q), - (R = Ihe(T, P, R, J, he, Q)), - T !== null && !Mm - ? ((P.updateQueue = T.updateQueue), - (P.flags &= -517), - (T.lanes &= ~Q), - o_(T, P, Q)) - : ((P.flags |= 1), ph(T, P, R, Q), P.child) - ); - } - function BRe(T, P, R, J, Q) { - if (yt(R)) { - var he = !0; - ht(P); - } else he = !1; - if (($B(P, Q), P.stateNode === null)) - T !== null && - ((T.alternate = null), (P.alternate = null), (P.flags |= 2)), - cRe(P, R, J), - Ehe(P, R, J, Q), - (J = !0); - else if (T === null) { - var Oe = P.stateNode, - et = P.memoizedProps; - Oe.props = et; - var dt = Oe.context, - Yt = R.contextType; - typeof Yt == "object" && Yt !== null - ? (Yt = D0(Yt)) - : ((Yt = yt(R) ? Pt : Mt.current), (Yt = It(P, Yt))); - var br = R.getDerivedStateFromProps, - Hr = - typeof br == "function" || - typeof Oe.getSnapshotBeforeUpdate == "function"; - Hr || - (typeof Oe.UNSAFE_componentWillReceiveProps != "function" && - typeof Oe.componentWillReceiveProps != "function") || - ((et !== J || dt !== Yt) && lRe(P, Oe, J, Yt)), - (yS = !1); - var ir = P.memoizedState; - (Oe.state = ir), - rF(P, J, Oe, Q), - (dt = P.memoizedState), - et !== J || ir !== dt || gt.current || yS - ? (typeof br == "function" && - (hW(P, R, br, J), (dt = P.memoizedState)), - (et = yS || uRe(P, R, et, J, ir, dt, Yt)) - ? (Hr || - (typeof Oe.UNSAFE_componentWillMount != "function" && - typeof Oe.componentWillMount != "function") || - (typeof Oe.componentWillMount == "function" && - Oe.componentWillMount(), - typeof Oe.UNSAFE_componentWillMount == "function" && - Oe.UNSAFE_componentWillMount()), - typeof Oe.componentDidMount == "function" && (P.flags |= 4)) - : (typeof Oe.componentDidMount == "function" && - (P.flags |= 4), - (P.memoizedProps = J), - (P.memoizedState = dt)), - (Oe.props = J), - (Oe.state = dt), - (Oe.context = Yt), - (J = et)) - : (typeof Oe.componentDidMount == "function" && (P.flags |= 4), - (J = !1)); - } else { - (Oe = P.stateNode), - iRe(T, P), - (et = P.memoizedProps), - (Yt = P.type === P.elementType ? et : Em(P.type, et)), - (Oe.props = Yt), - (Hr = P.pendingProps), - (ir = Oe.context), - (dt = R.contextType), - typeof dt == "object" && dt !== null - ? (dt = D0(dt)) - : ((dt = yt(R) ? Pt : Mt.current), (dt = It(P, dt))); - var wo = R.getDerivedStateFromProps; - (br = - typeof wo == "function" || - typeof Oe.getSnapshotBeforeUpdate == "function") || - (typeof Oe.UNSAFE_componentWillReceiveProps != "function" && - typeof Oe.componentWillReceiveProps != "function") || - ((et !== Hr || ir !== dt) && lRe(P, Oe, J, dt)), - (yS = !1), - (ir = P.memoizedState), - (Oe.state = ir), - rF(P, J, Oe, Q); - var Qo = P.memoizedState; - et !== Hr || ir !== Qo || gt.current || yS - ? (typeof wo == "function" && - (hW(P, R, wo, J), (Qo = P.memoizedState)), - (Yt = yS || uRe(P, R, Yt, J, ir, Qo, dt)) - ? (br || - (typeof Oe.UNSAFE_componentWillUpdate != "function" && - typeof Oe.componentWillUpdate != "function") || - (typeof Oe.componentWillUpdate == "function" && - Oe.componentWillUpdate(J, Qo, dt), - typeof Oe.UNSAFE_componentWillUpdate == "function" && - Oe.UNSAFE_componentWillUpdate(J, Qo, dt)), - typeof Oe.componentDidUpdate == "function" && (P.flags |= 4), - typeof Oe.getSnapshotBeforeUpdate == "function" && - (P.flags |= 256)) - : (typeof Oe.componentDidUpdate != "function" || - (et === T.memoizedProps && ir === T.memoizedState) || - (P.flags |= 4), - typeof Oe.getSnapshotBeforeUpdate != "function" || - (et === T.memoizedProps && ir === T.memoizedState) || - (P.flags |= 256), - (P.memoizedProps = J), - (P.memoizedState = Qo)), - (Oe.props = J), - (Oe.state = Qo), - (Oe.context = dt), - (J = Yt)) - : (typeof Oe.componentDidUpdate != "function" || - (et === T.memoizedProps && ir === T.memoizedState) || - (P.flags |= 4), - typeof Oe.getSnapshotBeforeUpdate != "function" || - (et === T.memoizedProps && ir === T.memoizedState) || - (P.flags |= 256), - (J = !1)); - } - return qhe(T, P, R, J, he, Q); - } - function qhe(T, P, R, J, Q, he) { - ORe(T, P); - var Oe = (P.flags & 64) !== 0; - if (!J && !Oe) return Q && mt(P, R, !1), o_(T, P, he); - (J = P.stateNode), (bCt.current = P); - var et = - Oe && typeof R.getDerivedStateFromError != "function" - ? null - : J.render(); - return ( - (P.flags |= 1), - T !== null && Oe - ? ((P.child = gW(P, T.child, null, he)), - (P.child = gW(P, null, et, he))) - : ph(T, P, et, he), - (P.memoizedState = J.state), - Q && mt(P, R, !0), - P.child - ); - } - function IRe(T) { - var P = T.stateNode; - P.pendingContext - ? it(T, P.pendingContext, P.pendingContext !== P.context) - : P.context && it(T, P.context, !1), - Mhe(T, P.containerInfo); - } - var EW = { dehydrated: null, retryLane: 0 }; - function CRe(T, P, R) { - var J = P.pendingProps, - Q = Oa.current, - he = !1, - Oe; - return ( - (Oe = (P.flags & 64) !== 0) || - (Oe = T !== null && T.memoizedState === null ? !1 : (Q & 2) !== 0), - Oe - ? ((he = !0), (P.flags &= -65)) - : (T !== null && T.memoizedState === null) || - J.fallback === void 0 || - J.unstable_avoidThisFallback === !0 || - (Q |= 1), - Bt(Oa, Q & 1), - T === null - ? (J.fallback !== void 0 && khe(P), - (T = J.children), - (Q = J.fallback), - he - ? ((T = RRe(P, T, Q, R)), - (P.child.memoizedState = { baseLanes: R }), - (P.memoizedState = EW), - T) - : typeof J.unstable_expectedLoadTime == "number" - ? ((T = RRe(P, T, Q, R)), - (P.child.memoizedState = { baseLanes: R }), - (P.memoizedState = EW), - (P.lanes = 33554432), - T) - : ((R = dpe({ mode: "visible", children: T }, P.mode, R, null)), - (R.return = P), - (P.child = R))) - : T.memoizedState !== null - ? he - ? ((J = DRe(T, P, J.children, J.fallback, R)), - (he = P.child), - (Q = T.child.memoizedState), - (he.memoizedState = - Q === null - ? { baseLanes: R } - : { baseLanes: Q.baseLanes | R }), - (he.childLanes = T.childLanes & ~R), - (P.memoizedState = EW), - J) - : ((R = NRe(T, P, J.children, R)), (P.memoizedState = null), R) - : he - ? ((J = DRe(T, P, J.children, J.fallback, R)), - (he = P.child), - (Q = T.child.memoizedState), - (he.memoizedState = - Q === null ? { baseLanes: R } : { baseLanes: Q.baseLanes | R }), - (he.childLanes = T.childLanes & ~R), - (P.memoizedState = EW), - J) - : ((R = NRe(T, P, J.children, R)), (P.memoizedState = null), R) - ); - } - function RRe(T, P, R, J) { - var Q = T.mode, - he = T.child; - return ( - (P = { mode: "hidden", children: P }), - (Q & 2) === 0 && he !== null - ? ((he.childLanes = 0), (he.pendingProps = P)) - : (he = dpe(P, Q, 0, null)), - (R = nI(R, Q, J, null)), - (he.return = T), - (R.return = T), - (he.sibling = R), - (T.child = he), - R - ); - } - function NRe(T, P, R, J) { - var Q = T.child; - return ( - (T = Q.sibling), - (R = xS(Q, { mode: "visible", children: R })), - (P.mode & 2) === 0 && (R.lanes = J), - (R.return = P), - (R.sibling = null), - T !== null && - ((T.nextEffect = null), - (T.flags = 8), - (P.firstEffect = P.lastEffect = T)), - (P.child = R) - ); - } - function DRe(T, P, R, J, Q) { - var he = P.mode, - Oe = T.child; - T = Oe.sibling; - var et = { mode: "hidden", children: R }; - return ( - (he & 2) === 0 && P.child !== Oe - ? ((R = P.child), - (R.childLanes = 0), - (R.pendingProps = et), - (Oe = R.lastEffect), - Oe !== null - ? ((P.firstEffect = R.firstEffect), - (P.lastEffect = Oe), - (Oe.nextEffect = null)) - : (P.firstEffect = P.lastEffect = null)) - : (R = xS(Oe, et)), - T !== null - ? (J = xS(T, J)) - : ((J = nI(J, he, Q, null)), (J.flags |= 2)), - (J.return = P), - (R.return = P), - (R.sibling = J), - (P.child = R), - J - ); - } - function FRe(T, P) { - T.lanes |= P; - var R = T.alternate; - R !== null && (R.lanes |= P), nRe(T.return, P); - } - function zhe(T, P, R, J, Q, he) { - var Oe = T.memoizedState; - Oe === null - ? (T.memoizedState = { - isBackwards: P, - rendering: null, - renderingStartTime: 0, - last: J, - tail: R, - tailMode: Q, - lastEffect: he, - }) - : ((Oe.isBackwards = P), - (Oe.rendering = null), - (Oe.renderingStartTime = 0), - (Oe.last = J), - (Oe.tail = R), - (Oe.tailMode = Q), - (Oe.lastEffect = he)); - } - function LRe(T, P, R) { - var J = P.pendingProps, - Q = J.revealOrder, - he = J.tail; - if ((ph(T, P, J.children, R), (J = Oa.current), (J & 2) !== 0)) - (J = (J & 1) | 2), (P.flags |= 64); - else { - if (T !== null && (T.flags & 64) !== 0) - e: for (T = P.child; T !== null; ) { - if (T.tag === 13) T.memoizedState !== null && FRe(T, R); - else if (T.tag === 19) FRe(T, R); - else if (T.child !== null) { - (T.child.return = T), (T = T.child); - continue; - } - if (T === P) break e; - for (; T.sibling === null; ) { - if (T.return === null || T.return === P) break e; - T = T.return; - } - (T.sibling.return = T.return), (T = T.sibling); - } - J &= 1; - } - if ((Bt(Oa, J), (P.mode & 2) === 0)) P.memoizedState = null; - else - switch (Q) { - case "forwards": - for (R = P.child, Q = null; R !== null; ) - (T = R.alternate), - T !== null && vW(T) === null && (Q = R), - (R = R.sibling); - (R = Q), - R === null - ? ((Q = P.child), (P.child = null)) - : ((Q = R.sibling), (R.sibling = null)), - zhe(P, !1, Q, R, he, P.lastEffect); - break; - case "backwards": - for (R = null, Q = P.child, P.child = null; Q !== null; ) { - if (((T = Q.alternate), T !== null && vW(T) === null)) { - P.child = Q; - break; - } - (T = Q.sibling), (Q.sibling = R), (R = Q), (Q = T); - } - zhe(P, !0, R, null, he, P.lastEffect); - break; - case "together": - zhe(P, !1, null, null, void 0, P.lastEffect); - break; - default: - P.memoizedState = null; - } - return P.child; - } - function o_(T, P, R) { - if ( - (T !== null && (P.dependencies = T.dependencies), - (mF |= P.lanes), - (R & P.childLanes) !== 0) - ) { - if (T !== null && P.child !== T.child) throw Error(a(153)); - if (P.child !== null) { - for ( - T = P.child, R = xS(T, T.pendingProps), P.child = R, R.return = P; - T.sibling !== null; - - ) - (T = T.sibling), - (R = R.sibling = xS(T, T.pendingProps)), - (R.return = P); - R.sibling = null; - } - return P.child; - } - return null; - } - function Jg(T) { - T.flags |= 4; - } - var dF, hF, MW, TW; - if (Me) - (dF = function (T, P) { - for (var R = P.child; R !== null; ) { - if (R.tag === 5 || R.tag === 6) G(T, R.stateNode); - else if (R.tag !== 4 && R.child !== null) { - (R.child.return = R), (R = R.child); - continue; - } - if (R === P) break; - for (; R.sibling === null; ) { - if (R.return === null || R.return === P) return; - R = R.return; - } - (R.sibling.return = R.return), (R = R.sibling); - } - }), - (hF = function () {}), - (MW = function (T, P, R, J, Q) { - if (((T = T.memoizedProps), T !== J)) { - var he = P.stateNode, - Oe = Vg(F0.current); - (R = ee(he, R, T, J, Q, Oe)), (P.updateQueue = R) && Jg(P); - } - }), - (TW = function (T, P, R, J) { - R !== J && Jg(P); - }); - else if (de) { - dF = function (T, P, R, J) { - for (var Q = P.child; Q !== null; ) { - if (Q.tag === 5) { - var he = Q.stateNode; - R && J && (he = $e(he, Q.type, Q.memoizedProps, Q)), G(T, he); - } else if (Q.tag === 6) - (he = Q.stateNode), - R && J && (he = tt(he, Q.memoizedProps, Q)), - G(T, he); - else if (Q.tag !== 4) { - if ( - Q.tag === 13 && - (Q.flags & 4) !== 0 && - (he = Q.memoizedState !== null) - ) { - var Oe = Q.child; - if ( - Oe !== null && - (Oe.child !== null && - ((Oe.child.return = Oe), dF(T, Oe, !0, he)), - (he = Oe.sibling), - he !== null) - ) { - (he.return = Q), (Q = he); - continue; - } - } - if (Q.child !== null) { - (Q.child.return = Q), (Q = Q.child); - continue; - } - } - if (Q === P) break; - for (; Q.sibling === null; ) { - if (Q.return === null || Q.return === P) return; - Q = Q.return; - } - (Q.sibling.return = Q.return), (Q = Q.sibling); - } - }; - var qRe = function (T, P, R, J) { - for (var Q = P.child; Q !== null; ) { - if (Q.tag === 5) { - var he = Q.stateNode; - R && J && (he = $e(he, Q.type, Q.memoizedProps, Q)), Xe(T, he); - } else if (Q.tag === 6) - (he = Q.stateNode), - R && J && (he = tt(he, Q.memoizedProps, Q)), - Xe(T, he); - else if (Q.tag !== 4) { - if ( - Q.tag === 13 && - (Q.flags & 4) !== 0 && - (he = Q.memoizedState !== null) - ) { - var Oe = Q.child; - if ( - Oe !== null && - (Oe.child !== null && - ((Oe.child.return = Oe), qRe(T, Oe, !0, he)), - (he = Oe.sibling), - he !== null) - ) { - (he.return = Q), (Q = he); - continue; - } - } - if (Q.child !== null) { - (Q.child.return = Q), (Q = Q.child); - continue; - } - } - if (Q === P) break; - for (; Q.sibling === null; ) { - if (Q.return === null || Q.return === P) return; - Q = Q.return; - } - (Q.sibling.return = Q.return), (Q = Q.sibling); - } - }; - (hF = function (T) { - var P = T.stateNode; - if (T.firstEffect !== null) { - var R = P.containerInfo, - J = lr(R); - qRe(J, T, !1, !1), (P.pendingChildren = J), Jg(T), Ze(R, J); - } - }), - (MW = function (T, P, R, J, Q) { - var he = T.stateNode, - Oe = T.memoizedProps; - if ((T = P.firstEffect === null) && Oe === J) P.stateNode = he; - else { - var et = P.stateNode, - dt = Vg(F0.current), - Yt = null; - Oe !== J && (Yt = ee(et, R, Oe, J, Q, dt)), - T && Yt === null - ? (P.stateNode = he) - : ((he = He(he, Yt, R, Oe, J, P, T, et)), - L(he, R, J, Q, dt) && Jg(P), - (P.stateNode = he), - T ? Jg(P) : dF(he, P, !1, !1)); - } - }), - (TW = function (T, P, R, J) { - R !== J - ? ((T = Vg(ZB.current)), - (R = Vg(F0.current)), - (P.stateNode = fe(J, T, R, P)), - Jg(P)) - : (P.stateNode = T.stateNode); - }); - } else - (hF = function () {}), (MW = function () {}), (TW = function () {}); - function pF(T, P) { - if (!Wg) - switch (T.tailMode) { - case "hidden": - P = T.tail; - for (var R = null; P !== null; ) - P.alternate !== null && (R = P), (P = P.sibling); - R === null ? (T.tail = null) : (R.sibling = null); - break; - case "collapsed": - R = T.tail; - for (var J = null; R !== null; ) - R.alternate !== null && (J = R), (R = R.sibling); - J === null - ? P || T.tail === null - ? (T.tail = null) - : (T.tail.sibling = null) - : (J.sibling = null); - } - } - function wCt(T, P, R) { - var J = P.pendingProps; - switch (P.tag) { - case 2: - case 16: - case 15: - case 0: - case 11: - case 7: - case 8: - case 12: - case 9: - case 14: - return null; - case 1: - return yt(P.type) && nt(), null; - case 3: - return ( - XB(), - Ot(gt), - Ot(Mt), - Ohe(), - (J = P.stateNode), - J.pendingContext && - ((J.context = J.pendingContext), (J.pendingContext = null)), - (T === null || T.child === null) && - (bW(P) ? Jg(P) : J.hydrate || (P.flags |= 256)), - hF(P), - null - ); - case 5: - The(P); - var Q = Vg(ZB.current); - if (((R = P.type), T !== null && P.stateNode != null)) - MW(T, P, R, J, Q), T.ref !== P.ref && (P.flags |= 128); - else { - if (!J) { - if (P.stateNode === null) throw Error(a(166)); - return null; - } - if (((T = Vg(F0.current)), bW(P))) { - if (!ve) throw Error(a(175)); - (T = Qe(P.stateNode, P.type, P.memoizedProps, Q, T, P)), - (P.updateQueue = T), - T !== null && Jg(P); - } else { - var he = B(R, J, Q, T, P); - dF(he, P, !1, !1), - (P.stateNode = he), - L(he, R, J, Q, T) && Jg(P); - } - P.ref !== null && (P.flags |= 128); - } - return null; - case 6: - if (T && P.stateNode != null) TW(T, P, T.memoizedProps, J); - else { - if (typeof J != "string" && P.stateNode === null) - throw Error(a(166)); - if (((T = Vg(ZB.current)), (Q = Vg(F0.current)), bW(P))) { - if (!ve) throw Error(a(176)); - Ae(P.stateNode, P.memoizedProps, P) && Jg(P); - } else P.stateNode = fe(J, T, Q, P); - } - return null; - case 13: - return ( - Ot(Oa), - (J = P.memoizedState), - (P.flags & 64) !== 0 - ? ((P.lanes = R), P) - : ((J = J !== null), - (Q = !1), - T === null - ? P.memoizedProps.fallback !== void 0 && bW(P) - : (Q = T.memoizedState !== null), - J && - !Q && - (P.mode & 2) !== 0 && - ((T === null && - P.memoizedProps.unstable_avoidThisFallback !== !0) || - (Oa.current & 1) !== 0 - ? Ju === 0 && (Ju = 3) - : ((Ju === 0 || Ju === 3) && (Ju = 4), - Nd === null || - ((mF & 134217727) === 0 && (eI & 134217727) === 0) || - tI(Nd, Ac))), - de && J && (P.flags |= 4), - Me && (J || Q) && (P.flags |= 4), - null) - ); - case 4: - return ( - XB(), hF(P), T === null && Be(P.stateNode.containerInfo), null - ); - case 10: - return She(P), null; - case 17: - return yt(P.type) && nt(), null; - case 19: - if ((Ot(Oa), (J = P.memoizedState), J === null)) return null; - if (((Q = (P.flags & 64) !== 0), (he = J.rendering), he === null)) - if (Q) pF(J, !1); - else { - if (Ju !== 0 || (T !== null && (T.flags & 64) !== 0)) - for (T = P.child; T !== null; ) { - if (((he = vW(T)), he !== null)) { - for ( - P.flags |= 64, - pF(J, !1), - T = he.updateQueue, - T !== null && ((P.updateQueue = T), (P.flags |= 4)), - J.lastEffect === null && (P.firstEffect = null), - P.lastEffect = J.lastEffect, - T = R, - J = P.child; - J !== null; - - ) - (Q = J), - (R = T), - (Q.flags &= 2), - (Q.nextEffect = null), - (Q.firstEffect = null), - (Q.lastEffect = null), - (he = Q.alternate), - he === null - ? ((Q.childLanes = 0), - (Q.lanes = R), - (Q.child = null), - (Q.memoizedProps = null), - (Q.memoizedState = null), - (Q.updateQueue = null), - (Q.dependencies = null), - (Q.stateNode = null)) - : ((Q.childLanes = he.childLanes), - (Q.lanes = he.lanes), - (Q.child = he.child), - (Q.memoizedProps = he.memoizedProps), - (Q.memoizedState = he.memoizedState), - (Q.updateQueue = he.updateQueue), - (Q.type = he.type), - (R = he.dependencies), - (Q.dependencies = - R === null - ? null - : { - lanes: R.lanes, - firstContext: R.firstContext, - })), - (J = J.sibling); - return Bt(Oa, (Oa.current & 1) | 2), P.child; - } - T = T.sibling; - } - J.tail !== null && - Wu() > rpe && - ((P.flags |= 64), (Q = !0), pF(J, !1), (P.lanes = 33554432)); - } - else { - if (!Q) - if (((T = vW(he)), T !== null)) { - if ( - ((P.flags |= 64), - (Q = !0), - (T = T.updateQueue), - T !== null && ((P.updateQueue = T), (P.flags |= 4)), - pF(J, !0), - J.tail === null && - J.tailMode === "hidden" && - !he.alternate && - !Wg) - ) - return ( - (P = P.lastEffect = J.lastEffect), - P !== null && (P.nextEffect = null), - null - ); - } else - 2 * Wu() - J.renderingStartTime > rpe && - R !== 1073741824 && - ((P.flags |= 64), - (Q = !0), - pF(J, !1), - (P.lanes = 33554432)); - J.isBackwards - ? ((he.sibling = P.child), (P.child = he)) - : ((T = J.last), - T !== null ? (T.sibling = he) : (P.child = he), - (J.last = he)); - } - return J.tail !== null - ? ((T = J.tail), - (J.rendering = T), - (J.tail = T.sibling), - (J.lastEffect = P.lastEffect), - (J.renderingStartTime = Wu()), - (T.sibling = null), - (P = Oa.current), - Bt(Oa, Q ? (P & 1) | 2 : P & 1), - T) - : null; - case 23: - case 24: - return ( - upe(), - T !== null && - (T.memoizedState !== null) != (P.memoizedState !== null) && - J.mode !== "unstable-defer-without-hiding" && - (P.flags |= 4), - null - ); - } - throw Error(a(156, P.tag)); - } - function _Ct(T) { - switch (T.tag) { - case 1: - yt(T.type) && nt(); - var P = T.flags; - return P & 4096 ? ((T.flags = (P & -4097) | 64), T) : null; - case 3: - if ((XB(), Ot(gt), Ot(Mt), Ohe(), (P = T.flags), (P & 64) !== 0)) - throw Error(a(285)); - return (T.flags = (P & -4097) | 64), T; - case 5: - return The(T), null; - case 13: - return ( - Ot(Oa), - (P = T.flags), - P & 4096 ? ((T.flags = (P & -4097) | 64), T) : null - ); - case 19: - return Ot(Oa), null; - case 4: - return XB(), null; - case 10: - return She(T), null; - case 23: - case 24: - return upe(), null; - default: - return null; - } - } - function jhe(T, P) { - try { - var R = "", - J = P; - do (R += pCt(J)), (J = J.return); - while (J); - var Q = R; - } catch (he) { - Q = - ` -Error generating stack: ` + - he.message + - ` -` + - he.stack; - } - return { value: T, source: P, stack: Q }; - } - function Uhe(T, P) { - try { - console.error(P.value); - } catch (R) { - setTimeout(function () { - throw R; - }); - } - } - var xCt = typeof WeakMap == "function" ? WeakMap : Map; - function zRe(T, P, R) { - (R = mS(-1, R)), (R.tag = 3), (R.payload = { element: null }); - var J = P.value; - return ( - (R.callback = function () { - FW || ((FW = !0), (npe = J)), Uhe(T, P); - }), - R - ); - } - function jRe(T, P, R) { - (R = mS(-1, R)), (R.tag = 3); - var J = T.type.getDerivedStateFromError; - if (typeof J == "function") { - var Q = P.value; - R.payload = function () { - return Uhe(T, P), J(Q); - }; - } - var he = T.stateNode; - return ( - he !== null && - typeof he.componentDidCatch == "function" && - (R.callback = function () { - typeof J != "function" && - ($g === null ? ($g = new Set([this])) : $g.add(this), - Uhe(T, P)); - var Oe = P.stack; - this.componentDidCatch(P.value, { - componentStack: Oe !== null ? Oe : "", - }); - }), - R - ); - } - var SCt = typeof WeakSet == "function" ? WeakSet : Set; - function URe(T) { - var P = T.ref; - if (P !== null) - if (typeof P == "function") - try { - P(null); - } catch (R) { - _S(T, R); - } - else P.current = null; - } - function ACt(T, P) { - switch (P.tag) { - case 0: - case 11: - case 15: - case 22: - return; - case 1: - if (P.flags & 256 && T !== null) { - var R = T.memoizedProps, - J = T.memoizedState; - (T = P.stateNode), - (P = T.getSnapshotBeforeUpdate( - P.elementType === P.type ? R : Em(P.type, R), - J - )), - (T.__reactInternalSnapshotBeforeUpdate = P); - } - return; - case 3: - Me && P.flags & 256 && Fe(P.stateNode.containerInfo); - return; - case 5: - case 6: - case 4: - case 17: - return; - } - throw Error(a(163)); - } - function KRe(T, P) { - if ( - ((P = P.updateQueue), - (P = P !== null ? P.lastEffect : null), - P !== null) - ) { - var R = (P = P.next); - do { - if ((R.tag & T) === T) { - var J = R.destroy; - (R.destroy = void 0), J !== void 0 && J(); - } - R = R.next; - } while (R !== P); - } - } - function ECt(T, P, R) { - switch (R.tag) { - case 0: - case 11: - case 15: - case 22: - if ( - ((P = R.updateQueue), - (P = P !== null ? P.lastEffect : null), - P !== null) - ) { - T = P = P.next; - do { - if ((T.tag & 3) === 3) { - var J = T.create; - T.destroy = J(); - } - T = T.next; - } while (T !== P); - } - if ( - ((P = R.updateQueue), - (P = P !== null ? P.lastEffect : null), - P !== null) - ) { - T = P = P.next; - do { - var Q = T; - (J = Q.next), - (Q = Q.tag), - (Q & 4) !== 0 && (Q & 1) !== 0 && (a7e(R, T), RCt(R, T)), - (T = J); - } while (T !== P); - } - return; - case 1: - (T = R.stateNode), - R.flags & 4 && - (P === null - ? T.componentDidMount() - : ((J = - R.elementType === R.type - ? P.memoizedProps - : Em(R.type, P.memoizedProps)), - T.componentDidUpdate( - J, - P.memoizedState, - T.__reactInternalSnapshotBeforeUpdate - ))), - (P = R.updateQueue), - P !== null && aRe(R, P, T); - return; - case 3: - if (((P = R.updateQueue), P !== null)) { - if (((T = null), R.child !== null)) - switch (R.child.tag) { - case 5: - T = b(R.child.stateNode); - break; - case 1: - T = R.child.stateNode; - } - aRe(R, P, T); - } - return; - case 5: - (T = R.stateNode), - P === null && R.flags & 4 && xe(T, R.type, R.memoizedProps, R); - return; - case 6: - return; - case 4: - return; - case 12: - return; - case 13: - ve && - R.memoizedState === null && - ((R = R.alternate), - R !== null && - ((R = R.memoizedState), - R !== null && ((R = R.dehydrated), R !== null && ut(R)))); - return; - case 19: - case 17: - case 20: - case 21: - case 23: - case 24: - return; - } - throw Error(a(163)); - } - function HRe(T, P) { - if (Me) - for (var R = T; ; ) { - if (R.tag === 5) { - var J = R.stateNode; - P ? At(J) : je(R.stateNode, R.memoizedProps); - } else if (R.tag === 6) - (J = R.stateNode), P ? Ie(J) : qt(J, R.memoizedProps); - else if ( - ((R.tag !== 23 && R.tag !== 24) || - R.memoizedState === null || - R === T) && - R.child !== null - ) { - (R.child.return = R), (R = R.child); - continue; - } - if (R === T) break; - for (; R.sibling === null; ) { - if (R.return === null || R.return === T) return; - R = R.return; - } - (R.sibling.return = R.return), (R = R.sibling); - } - } - function VRe(T, P) { - if (hr && typeof hr.onCommitFiberUnmount == "function") - try { - hr.onCommitFiberUnmount(Nt, P); - } catch {} - switch (P.tag) { - case 0: - case 11: - case 14: - case 15: - case 22: - if ( - ((T = P.updateQueue), - T !== null && ((T = T.lastEffect), T !== null)) - ) { - var R = (T = T.next); - do { - var J = R, - Q = J.destroy; - if (((J = J.tag), Q !== void 0)) - if ((J & 4) !== 0) a7e(P, R); - else { - J = P; - try { - Q(); - } catch (he) { - _S(J, he); - } - } - R = R.next; - } while (R !== T); - } - break; - case 1: - if ( - (URe(P), - (T = P.stateNode), - typeof T.componentWillUnmount == "function") - ) - try { - (T.props = P.memoizedProps), - (T.state = P.memoizedState), - T.componentWillUnmount(); - } catch (he) { - _S(P, he); - } - break; - case 5: - URe(P); - break; - case 4: - Me - ? ZRe(T, P) - : de && - de && - ((P = P.stateNode.containerInfo), (T = lr(P)), Ir(P, T)); - } - } - function WRe(T, P) { - for (var R = P; ; ) - if ((VRe(T, R), R.child === null || (Me && R.tag === 4))) { - if (R === P) break; - for (; R.sibling === null; ) { - if (R.return === null || R.return === P) return; - R = R.return; - } - (R.sibling.return = R.return), (R = R.sibling); - } else (R.child.return = R), (R = R.child); - } - function GRe(T) { - (T.alternate = null), - (T.child = null), - (T.dependencies = null), - (T.firstEffect = null), - (T.lastEffect = null), - (T.memoizedProps = null), - (T.memoizedState = null), - (T.pendingProps = null), - (T.return = null), - (T.updateQueue = null); - } - function JRe(T) { - return T.tag === 5 || T.tag === 3 || T.tag === 4; - } - function $Re(T) { - if (Me) { - e: { - for (var P = T.return; P !== null; ) { - if (JRe(P)) break e; - P = P.return; - } - throw Error(a(160)); - } - var R = P; - switch (((P = R.stateNode), R.tag)) { - case 5: - var J = !1; - break; - case 3: - (P = P.containerInfo), (J = !0); - break; - case 4: - (P = P.containerInfo), (J = !0); - break; - default: - throw Error(a(161)); - } - R.flags & 16 && (Pe(P), (R.flags &= -17)); - e: t: for (R = T; ; ) { - for (; R.sibling === null; ) { - if (R.return === null || JRe(R.return)) { - R = null; - break e; - } - R = R.return; - } - for ( - R.sibling.return = R.return, R = R.sibling; - R.tag !== 5 && R.tag !== 6 && R.tag !== 18; - - ) { - if (R.flags & 2 || R.child === null || R.tag === 4) continue t; - (R.child.return = R), (R = R.child); - } - if (!(R.flags & 2)) { - R = R.stateNode; - break e; - } - } - J ? Khe(T, R, P) : Hhe(T, R, P); - } - } - function Khe(T, P, R) { - var J = T.tag, - Q = J === 5 || J === 6; - if (Q) - (T = Q ? T.stateNode : T.stateNode.instance), - P ? pe(R, T, P) : ze(R, T); - else if (J !== 4 && ((T = T.child), T !== null)) - for (Khe(T, P, R), T = T.sibling; T !== null; ) - Khe(T, P, R), (T = T.sibling); - } - function Hhe(T, P, R) { - var J = T.tag, - Q = J === 5 || J === 6; - if (Q) - (T = Q ? T.stateNode : T.stateNode.instance), - P ? Ke(R, T, P) : ce(R, T); - else if (J !== 4 && ((T = T.child), T !== null)) - for (Hhe(T, P, R), T = T.sibling; T !== null; ) - Hhe(T, P, R), (T = T.sibling); - } - function ZRe(T, P) { - for (var R = P, J = !1, Q, he; ; ) { - if (!J) { - J = R.return; - e: for (;;) { - if (J === null) throw Error(a(160)); - switch (((Q = J.stateNode), J.tag)) { - case 5: - he = !1; - break e; - case 3: - (Q = Q.containerInfo), (he = !0); - break e; - case 4: - (Q = Q.containerInfo), (he = !0); - break e; - } - J = J.return; - } - J = !0; - } - if (R.tag === 5 || R.tag === 6) - WRe(T, R), he ? Se(Q, R.stateNode) : Re(Q, R.stateNode); - else if (R.tag === 4) { - if (R.child !== null) { - (Q = R.stateNode.containerInfo), - (he = !0), - (R.child.return = R), - (R = R.child); - continue; - } - } else if ((VRe(T, R), R.child !== null)) { - (R.child.return = R), (R = R.child); - continue; - } - if (R === P) break; - for (; R.sibling === null; ) { - if (R.return === null || R.return === P) return; - (R = R.return), R.tag === 4 && (J = !1); - } - (R.sibling.return = R.return), (R = R.sibling); - } - } - function Vhe(T, P) { - if (Me) { - switch (P.tag) { - case 0: - case 11: - case 14: - case 15: - case 22: - KRe(3, P); - return; - case 1: - return; - case 5: - var R = P.stateNode; - if (R != null) { - var J = P.memoizedProps; - T = T !== null ? T.memoizedProps : J; - var Q = P.type, - he = P.updateQueue; - (P.updateQueue = null), he !== null && Ft(R, he, Q, T, J, P); - } - return; - case 6: - if (P.stateNode === null) throw Error(a(162)); - (R = P.memoizedProps), - we(P.stateNode, T !== null ? T.memoizedProps : R, R); - return; - case 3: - ve && - ((P = P.stateNode), - P.hydrate && ((P.hydrate = !1), Ct(P.containerInfo))); - return; - case 12: - return; - case 13: - XRe(P), kW(P); - return; - case 19: - kW(P); - return; - case 17: - return; - case 23: - case 24: - HRe(P, P.memoizedState !== null); - return; - } - throw Error(a(163)); - } - switch (P.tag) { - case 0: - case 11: - case 14: - case 15: - case 22: - KRe(3, P); - return; - case 12: - return; - case 13: - XRe(P), kW(P); - return; - case 19: - kW(P); - return; - case 3: - ve && - ((R = P.stateNode), - R.hydrate && ((R.hydrate = !1), Ct(R.containerInfo))); - break; - case 23: - case 24: - return; - } - e: if (de) { - switch (P.tag) { - case 1: - case 5: - case 6: - case 20: - break e; - case 3: - case 4: - (P = P.stateNode), Ir(P.containerInfo, P.pendingChildren); - break e; - } - throw Error(a(163)); - } - } - function XRe(T) { - T.memoizedState !== null && ((tpe = Wu()), Me && HRe(T.child, !0)); - } - function kW(T) { - var P = T.updateQueue; - if (P !== null) { - T.updateQueue = null; - var R = T.stateNode; - R === null && (R = T.stateNode = new SCt()), - P.forEach(function (J) { - var Q = FCt.bind(null, T, J); - R.has(J) || (R.add(J), J.then(Q, Q)); - }); - } - } - function MCt(T, P) { - return T !== null && - ((T = T.memoizedState), T === null || T.dehydrated !== null) - ? ((P = P.memoizedState), P !== null && P.dehydrated === null) - : !1; - } - var PW = 0, - OW = 1, - BW = 2, - IW = 3, - CW = 4; - if (typeof Symbol == "function" && Symbol.for) { - var yF = Symbol.for; - (PW = yF("selector.component")), - (OW = yF("selector.has_pseudo_class")), - (BW = yF("selector.role")), - (IW = yF("selector.test_id")), - (CW = yF("selector.text")); - } - function Whe(T) { - var P = De(T); - if (P != null) { - if (typeof P.memoizedProps["data-testname"] != "string") - throw Error(a(364)); - return P; - } - if (((T = Ve(T)), T === null)) throw Error(a(362)); - return T.stateNode.current; - } - function Ghe(T, P) { - switch (P.$$typeof) { - case PW: - if (T.type === P.value) return !0; - break; - case OW: - e: { - (P = P.value), (T = [T, 0]); - for (var R = 0; R < T.length; ) { - var J = T[R++], - Q = T[R++], - he = P[Q]; - if (J.tag !== 5 || !Ue(J)) { - for (; he != null && Ghe(J, he); ) Q++, (he = P[Q]); - if (Q === P.length) { - P = !0; - break e; - } else - for (J = J.child; J !== null; ) - T.push(J, Q), (J = J.sibling); - } - } - P = !1; - } - return P; - case BW: - if (T.tag === 5 && Y(T.stateNode, P.value)) return !0; - break; - case CW: - if ( - (T.tag === 5 || T.tag === 6) && - ((T = er(T)), T !== null && 0 <= T.indexOf(P.value)) - ) - return !0; - break; - case IW: - if ( - T.tag === 5 && - ((T = T.memoizedProps["data-testname"]), - typeof T == "string" && T.toLowerCase() === P.value.toLowerCase()) - ) - return !0; - break; - default: - throw Error(a(365, P)); - } - return !1; - } - function Jhe(T) { - switch (T.$$typeof) { - case PW: - return "<" + (l(T.value) || "Unknown") + ">"; - case OW: - return ":has(" + (Jhe(T) || "") + ")"; - case BW: - return '[role="' + T.value + '"]'; - case CW: - return '"' + T.value + '"'; - case IW: - return '[data-testname="' + T.value + '"]'; - default: - throw Error(a(365, T)); - } - } - function YRe(T, P) { - var R = []; - T = [T, 0]; - for (var J = 0; J < T.length; ) { - var Q = T[J++], - he = T[J++], - Oe = P[he]; - if (Q.tag !== 5 || !Ue(Q)) { - for (; Oe != null && Ghe(Q, Oe); ) he++, (Oe = P[he]); - if (he === P.length) R.push(Q); - else for (Q = Q.child; Q !== null; ) T.push(Q, he), (Q = Q.sibling); - } - } - return R; - } - function $he(T, P) { - if (!kt) throw Error(a(363)); - (T = Whe(T)), (T = YRe(T, P)), (P = []), (T = Array.from(T)); - for (var R = 0; R < T.length; ) { - var J = T[R++]; - if (J.tag === 5) Ue(J) || P.push(J.stateNode); - else for (J = J.child; J !== null; ) T.push(J), (J = J.sibling); - } - return P; - } - var RW = null; - function TCt(T) { - if (RW === null) - try { - var P = ("require" + Math.random()).slice(0, 7); - RW = (PF && PF[P]).call(PF, "timers").setImmediate; - } catch { - RW = function (J) { - var Q = new MessageChannel(); - (Q.port1.onmessage = J), Q.port2.postMessage(void 0); - }; - } - return RW(T); - } - var kCt = Math.ceil, - NW = s.ReactCurrentDispatcher, - Zhe = s.ReactCurrentOwner, - Xhe = s.IsSomeRendererActing, - Pr = 0, - Nd = null, - Us = null, - Ac = 0, - B3 = 0, - Yhe = Kt(0), - Ju = 0, - DW = null, - QB = 0, - mF = 0, - eI = 0, - Qhe = 0, - epe = null, - tpe = 0, - rpe = 1 / 0; - function vS() { - rpe = Wu() + 500; - } - var ur = null, - FW = !1, - npe = null, - $g = null, - bS = !1, - gF = null, - vF = 90, - ipe = [], - ope = [], - a_ = null, - bF = 0, - ape = null, - LW = -1, - s_ = 0, - qW = 0, - wF = null, - _F = !1; - function yh() { - return (Pr & 48) !== 0 ? Wu() : LW !== -1 ? LW : (LW = Wu()); - } - function wS(T) { - if (((T = T.mode), (T & 2) === 0)) return 1; - if ((T & 4) === 0) return GB() === 99 ? 1 : 2; - if ((s_ === 0 && (s_ = QB), fCt.transition !== 0)) { - qW !== 0 && (qW = epe !== null ? epe.pendingLanes : 0), (T = s_); - var P = 4186112 & ~qW; - return ( - (P &= -P), - P === 0 && - ((T = 4186112 & ~T), (P = T & -T), P === 0 && (P = 8192)), - P - ); - } - return ( - (T = GB()), - (Pr & 4) !== 0 && T === 98 - ? (T = kn(12, s_)) - : ((T = mn(T)), (T = kn(T, s_))), - T - ); - } - function u_(T, P, R) { - if (50 < bF) throw ((bF = 0), (ape = null), Error(a(185))); - if (((T = zW(T, P)), T === null)) return null; - yi(T, P, R), T === Nd && ((eI |= P), Ju === 4 && tI(T, Ac)); - var J = GB(); - P === 1 - ? (Pr & 8) !== 0 && (Pr & 48) === 0 - ? spe(T) - : (Op(T, R), Pr === 0 && (vS(), R0())) - : ((Pr & 4) === 0 || - (J !== 98 && J !== 99) || - (a_ === null ? (a_ = new Set([T])) : a_.add(T)), - Op(T, R)), - (epe = T); - } - function zW(T, P) { - T.lanes |= P; - var R = T.alternate; - for (R !== null && (R.lanes |= P), R = T, T = T.return; T !== null; ) - (T.childLanes |= P), - (R = T.alternate), - R !== null && (R.childLanes |= P), - (R = T), - (T = T.return); - return R.tag === 3 ? R.stateNode : null; - } - function Op(T, P) { - for ( - var R = T.callbackNode, - J = T.suspendedLanes, - Q = T.pingedLanes, - he = T.expirationTimes, - Oe = T.pendingLanes; - 0 < Oe; - - ) { - var et = 31 - qi(Oe), - dt = 1 << et, - Yt = he[et]; - if (Yt === -1) { - if ((dt & J) === 0 || (dt & Q) !== 0) { - (Yt = P), Ce(dt); - var br = or; - he[et] = 10 <= br ? Yt + 250 : 6 <= br ? Yt + 5e3 : -1; - } - } else Yt <= P && (T.expiredLanes |= dt); - Oe &= ~dt; - } - if (((J = Tn(T, T === Nd ? Ac : 0)), (P = or), J === 0)) - R !== null && - (R !== whe && ms(R), - (T.callbackNode = null), - (T.callbackPriority = 0)); - else { - if (R !== null) { - if (T.callbackPriority === P) return; - R !== whe && ms(R); - } - P === 15 - ? ((R = spe.bind(null, T)), - r_ === null ? ((r_ = [R]), (uW = ys(sW, tRe))) : r_.push(R), - (R = whe)) - : P === 14 - ? (R = tF(99, spe.bind(null, T))) - : ((R = ii(P)), (R = tF(R, QRe.bind(null, T)))), - (T.callbackPriority = P), - (T.callbackNode = R); - } - } - function QRe(T) { - if (((LW = -1), (qW = s_ = 0), (Pr & 48) !== 0)) throw Error(a(327)); - var P = T.callbackNode; - if (c_() && T.callbackNode !== P) return null; - var R = Tn(T, T === Nd ? Ac : 0); - if (R === 0) return null; - var J = R, - Q = Pr; - Pr |= 16; - var he = n7e(); - (Nd !== T || Ac !== J) && (vS(), rI(T, J)); - do - try { - BCt(); - break; - } catch (et) { - r7e(T, et); - } - while (1); - if ( - (xhe(), - (NW.current = he), - (Pr = Q), - Us !== null ? (J = 0) : ((Nd = null), (Ac = 0), (J = Ju)), - (QB & eI) !== 0) - ) - rI(T, 0); - else if (J !== 0) { - if ( - (J === 2 && - ((Pr |= 64), - T.hydrate && ((T.hydrate = !1), Fe(T.containerInfo)), - (R = cn(T)), - R !== 0 && (J = xF(T, R))), - J === 1) - ) - throw ((P = DW), rI(T, 0), tI(T, R), Op(T, Wu()), P); - switch ( - ((T.finishedWork = T.current.alternate), (T.finishedLanes = R), J) - ) { - case 0: - case 1: - throw Error(a(345)); - case 2: - I3(T); - break; - case 3: - if ( - (tI(T, R), - (R & 62914560) === R && ((J = tpe + 500 - Wu()), 10 < J)) - ) { - if (Tn(T, 0) !== 0) break; - if (((Q = T.suspendedLanes), (Q & R) !== R)) { - yh(), (T.pingedLanes |= T.suspendedLanes & Q); - break; - } - T.timeoutHandle = V(I3.bind(null, T), J); - break; - } - I3(T); - break; - case 4: - if ((tI(T, R), (R & 4186112) === R)) break; - for (J = T.eventTimes, Q = -1; 0 < R; ) { - var Oe = 31 - qi(R); - (he = 1 << Oe), (Oe = J[Oe]), Oe > Q && (Q = Oe), (R &= ~he); - } - if ( - ((R = Q), - (R = Wu() - R), - (R = - (120 > R - ? 120 - : 480 > R - ? 480 - : 1080 > R - ? 1080 - : 1920 > R - ? 1920 - : 3e3 > R - ? 3e3 - : 4320 > R - ? 4320 - : 1960 * kCt(R / 1960)) - R), - 10 < R) - ) { - T.timeoutHandle = V(I3.bind(null, T), R); - break; - } - I3(T); - break; - case 5: - I3(T); - break; - default: - throw Error(a(329)); - } - } - return Op(T, Wu()), T.callbackNode === P ? QRe.bind(null, T) : null; - } - function tI(T, P) { - for ( - P &= ~Qhe, - P &= ~eI, - T.suspendedLanes |= P, - T.pingedLanes &= ~P, - T = T.expirationTimes; - 0 < P; - - ) { - var R = 31 - qi(P), - J = 1 << R; - (T[R] = -1), (P &= ~J); - } - } - function spe(T) { - if ((Pr & 48) !== 0) throw Error(a(327)); - if ((c_(), T === Nd && (T.expiredLanes & Ac) !== 0)) { - var P = Ac, - R = xF(T, P); - (QB & eI) !== 0 && ((P = Tn(T, P)), (R = xF(T, P))); - } else (P = Tn(T, 0)), (R = xF(T, P)); - if ( - (T.tag !== 0 && - R === 2 && - ((Pr |= 64), - T.hydrate && ((T.hydrate = !1), Fe(T.containerInfo)), - (P = cn(T)), - P !== 0 && (R = xF(T, P))), - R === 1) - ) - throw ((R = DW), rI(T, 0), tI(T, P), Op(T, Wu()), R); - return ( - (T.finishedWork = T.current.alternate), - (T.finishedLanes = P), - I3(T), - Op(T, Wu()), - null - ); - } - function PCt() { - if (a_ !== null) { - var T = a_; - (a_ = null), - T.forEach(function (P) { - (P.expiredLanes |= 24 & P.pendingLanes), Op(P, Wu()); - }); - } - R0(); - } - function e7e(T, P) { - var R = Pr; - Pr |= 1; - try { - return T(P); - } finally { - (Pr = R), Pr === 0 && (vS(), R0()); - } - } - function t7e(T, P) { - var R = Pr; - if ((R & 48) !== 0) return T(P); - Pr |= 1; - try { - if (T) return n_(99, T.bind(null, P)); - } finally { - (Pr = R), R0(); - } - } - function jW(T, P) { - Bt(Yhe, B3), (B3 |= P), (QB |= P); - } - function upe() { - (B3 = Yhe.current), Ot(Yhe); - } - function rI(T, P) { - (T.finishedWork = null), (T.finishedLanes = 0); - var R = T.timeoutHandle; - if ((R !== ae && ((T.timeoutHandle = ae), ye(R)), Us !== null)) - for (R = Us.return; R !== null; ) { - var J = R; - switch (J.tag) { - case 1: - (J = J.type.childContextTypes), J != null && nt(); - break; - case 3: - XB(), Ot(gt), Ot(Mt), Ohe(); - break; - case 5: - The(J); - break; - case 4: - XB(); - break; - case 13: - Ot(Oa); - break; - case 19: - Ot(Oa); - break; - case 10: - She(J); - break; - case 23: - case 24: - upe(); - } - R = R.return; - } - (Nd = T), - (Us = xS(T.current, null)), - (Ac = B3 = QB = P), - (Ju = 0), - (DW = null), - (Qhe = eI = mF = 0); - } - function r7e(T, P) { - do { - var R = Us; - try { - if ((xhe(), (aF.current = AW), wW)) { - for (var J = Ya.memoizedState; J !== null; ) { - var Q = J.queue; - Q !== null && (Q.pending = null), (J = J.next); - } - wW = !1; - } - if ( - ((sF = 0), - (Gu = Sc = Ya = null), - (uF = !1), - (Zhe.current = null), - R === null || R.return === null) - ) { - (Ju = 1), (DW = P), (Us = null); - break; - } - e: { - var he = T, - Oe = R.return, - et = R, - dt = P; - if ( - ((P = Ac), - (et.flags |= 2048), - (et.firstEffect = et.lastEffect = null), - dt !== null && - typeof dt == "object" && - typeof dt.then == "function") - ) { - var Yt = dt; - if ((et.mode & 2) === 0) { - var br = et.alternate; - br - ? ((et.updateQueue = br.updateQueue), - (et.memoizedState = br.memoizedState), - (et.lanes = br.lanes)) - : ((et.updateQueue = null), (et.memoizedState = null)); - } - var Hr = (Oa.current & 1) !== 0, - ir = Oe; - do { - var wo; - if ((wo = ir.tag === 13)) { - var Qo = ir.memoizedState; - if (Qo !== null) wo = Qo.dehydrated !== null; - else { - var z0 = ir.memoizedProps; - wo = - z0.fallback === void 0 - ? !1 - : z0.unstable_avoidThisFallback !== !0 - ? !0 - : !Hr; - } - } - if (wo) { - var at = ir.updateQueue; - if (at === null) { - var rt = new Set(); - rt.add(Yt), (ir.updateQueue = rt); - } else at.add(Yt); - if ((ir.mode & 2) === 0) { - if ( - ((ir.flags |= 64), - (et.flags |= 16384), - (et.flags &= -2981), - et.tag === 1) - ) - if (et.alternate === null) et.tag = 17; - else { - var pt = mS(-1, 1); - (pt.tag = 2), gS(et, pt); - } - et.lanes |= 1; - break e; - } - (dt = void 0), (et = P); - var tr = he.pingCache; - if ( - (tr === null - ? ((tr = he.pingCache = new xCt()), - (dt = new Set()), - tr.set(Yt, dt)) - : ((dt = tr.get(Yt)), - dt === void 0 && ((dt = new Set()), tr.set(Yt, dt))), - !dt.has(et)) - ) { - dt.add(et); - var wr = DCt.bind(null, he, Yt, et); - Yt.then(wr, wr); - } - (ir.flags |= 4096), (ir.lanes = P); - break e; - } - ir = ir.return; - } while (ir !== null); - dt = Error( - (l(et.type) || "A React component") + - ` suspended while rendering, but no fallback UI was specified. - -Add a component higher in the tree to provide a loading indicator or placeholder to display.` - ); - } - Ju !== 5 && (Ju = 2), (dt = jhe(dt, et)), (ir = Oe); - do { - switch (ir.tag) { - case 3: - (he = dt), (ir.flags |= 4096), (P &= -P), (ir.lanes |= P); - var To = zRe(ir, he, P); - oRe(ir, To); - break e; - case 1: - he = dt; - var Jr = ir.type, - Gi = ir.stateNode; - if ( - (ir.flags & 64) === 0 && - (typeof Jr.getDerivedStateFromError == "function" || - (Gi !== null && - typeof Gi.componentDidCatch == "function" && - ($g === null || !$g.has(Gi)))) - ) { - (ir.flags |= 4096), (P &= -P), (ir.lanes |= P); - var gs = jRe(ir, he, P); - oRe(ir, gs); - break e; - } - } - ir = ir.return; - } while (ir !== null); - } - o7e(R); - } catch (mi) { - (P = mi), Us === R && R !== null && (Us = R = R.return); - continue; - } - break; - } while (1); - } - function n7e() { - var T = NW.current; - return (NW.current = AW), T === null ? AW : T; - } - function xF(T, P) { - var R = Pr; - Pr |= 16; - var J = n7e(); - (Nd === T && Ac === P) || rI(T, P); - do - try { - OCt(); - break; - } catch (Q) { - r7e(T, Q); - } - while (1); - if ((xhe(), (Pr = R), (NW.current = J), Us !== null)) - throw Error(a(261)); - return (Nd = null), (Ac = 0), Ju; - } - function OCt() { - for (; Us !== null; ) i7e(Us); - } - function BCt() { - for (; Us !== null && !uCt(); ) i7e(Us); - } - function i7e(T) { - var P = u7e(T.alternate, T, B3); - (T.memoizedProps = T.pendingProps), - P === null ? o7e(T) : (Us = P), - (Zhe.current = null); - } - function o7e(T) { - var P = T; - do { - var R = P.alternate; - if (((T = P.return), (P.flags & 2048) === 0)) { - if (((R = wCt(R, P, B3)), R !== null)) { - Us = R; - return; - } - if ( - ((R = P), - (R.tag !== 24 && R.tag !== 23) || - R.memoizedState === null || - (B3 & 1073741824) !== 0 || - (R.mode & 4) === 0) - ) { - for (var J = 0, Q = R.child; Q !== null; ) - (J |= Q.lanes | Q.childLanes), (Q = Q.sibling); - R.childLanes = J; - } - T !== null && - (T.flags & 2048) === 0 && - (T.firstEffect === null && (T.firstEffect = P.firstEffect), - P.lastEffect !== null && - (T.lastEffect !== null && - (T.lastEffect.nextEffect = P.firstEffect), - (T.lastEffect = P.lastEffect)), - 1 < P.flags && - (T.lastEffect !== null - ? (T.lastEffect.nextEffect = P) - : (T.firstEffect = P), - (T.lastEffect = P))); - } else { - if (((R = _Ct(P)), R !== null)) { - (R.flags &= 2047), (Us = R); - return; - } - T !== null && - ((T.firstEffect = T.lastEffect = null), (T.flags |= 2048)); - } - if (((P = P.sibling), P !== null)) { - Us = P; - return; - } - Us = P = T; - } while (P !== null); - Ju === 0 && (Ju = 5); - } - function I3(T) { - var P = GB(); - return n_(99, ICt.bind(null, T, P)), null; - } - function ICt(T, P) { - do c_(); - while (gF !== null); - if ((Pr & 48) !== 0) throw Error(a(327)); - var R = T.finishedWork; - if (R === null) return null; - if (((T.finishedWork = null), (T.finishedLanes = 0), R === T.current)) - throw Error(a(177)); - T.callbackNode = null; - var J = R.lanes | R.childLanes, - Q = J, - he = T.pendingLanes & ~Q; - (T.pendingLanes = Q), - (T.suspendedLanes = 0), - (T.pingedLanes = 0), - (T.expiredLanes &= Q), - (T.mutableReadLanes &= Q), - (T.entangledLanes &= Q), - (Q = T.entanglements); - for (var Oe = T.eventTimes, et = T.expirationTimes; 0 < he; ) { - var dt = 31 - qi(he), - Yt = 1 << dt; - (Q[dt] = 0), (Oe[dt] = -1), (et[dt] = -1), (he &= ~Yt); - } - if ( - (a_ !== null && (J & 24) === 0 && a_.has(T) && a_.delete(T), - T === Nd && ((Us = Nd = null), (Ac = 0)), - 1 < R.flags - ? R.lastEffect !== null - ? ((R.lastEffect.nextEffect = R), (J = R.firstEffect)) - : (J = R) - : (J = R.firstEffect), - J !== null) - ) { - (Q = Pr), - (Pr |= 32), - (Zhe.current = null), - (wF = C(T.containerInfo)), - (_F = !1), - (ur = J); - do - try { - CCt(); - } catch (rt) { - if (ur === null) throw Error(a(330)); - _S(ur, rt), (ur = ur.nextEffect); - } - while (ur !== null); - (wF = null), (ur = J); - do - try { - for (Oe = T; ur !== null; ) { - var br = ur.flags; - if ((br & 16 && Me && Pe(ur.stateNode), br & 128)) { - var Hr = ur.alternate; - if (Hr !== null) { - var ir = Hr.ref; - ir !== null && - (typeof ir == "function" - ? ir(null) - : (ir.current = null)); - } - } - switch (br & 1038) { - case 2: - $Re(ur), (ur.flags &= -3); - break; - case 6: - $Re(ur), (ur.flags &= -3), Vhe(ur.alternate, ur); - break; - case 1024: - ur.flags &= -1025; - break; - case 1028: - (ur.flags &= -1025), Vhe(ur.alternate, ur); - break; - case 4: - Vhe(ur.alternate, ur); - break; - case 8: - (et = Oe), (he = ur), Me ? ZRe(et, he) : WRe(et, he); - var wo = he.alternate; - GRe(he), wo !== null && GRe(wo); - } - ur = ur.nextEffect; - } - } catch (rt) { - if (ur === null) throw Error(a(330)); - _S(ur, rt), (ur = ur.nextEffect); - } - while (ur !== null); - _F && Ee(), E(T.containerInfo), (T.current = R), (ur = J); - do - try { - for (br = T; ur !== null; ) { - var Qo = ur.flags; - if ((Qo & 36 && ECt(br, ur.alternate, ur), Qo & 128)) { - Hr = void 0; - var z0 = ur.ref; - if (z0 !== null) { - var at = ur.stateNode; - switch (ur.tag) { - case 5: - Hr = b(at); - break; - default: - Hr = at; - } - typeof z0 == "function" ? z0(Hr) : (z0.current = Hr); - } - } - ur = ur.nextEffect; - } - } catch (rt) { - if (ur === null) throw Error(a(330)); - _S(ur, rt), (ur = ur.nextEffect); - } - while (ur !== null); - (ur = null), lCt(), (Pr = Q); - } else T.current = R; - if (bS) (bS = !1), (gF = T), (vF = P); - else - for (ur = J; ur !== null; ) - (P = ur.nextEffect), - (ur.nextEffect = null), - ur.flags & 8 && - ((Qo = ur), (Qo.sibling = null), (Qo.stateNode = null)), - (ur = P); - if ( - ((J = T.pendingLanes), - J === 0 && ($g = null), - J === 1 ? (T === ape ? bF++ : ((bF = 0), (ape = T))) : (bF = 0), - (R = R.stateNode), - hr && typeof hr.onCommitFiberRoot == "function") - ) - try { - hr.onCommitFiberRoot(Nt, R, void 0, (R.current.flags & 64) === 64); - } catch {} - if ((Op(T, Wu()), FW)) throw ((FW = !1), (T = npe), (npe = null), T); - return (Pr & 8) !== 0 || R0(), null; - } - function CCt() { - for (; ur !== null; ) { - var T = ur.alternate; - _F || - wF === null || - ((ur.flags & 8) !== 0 - ? S(ur, wF) && ((_F = !0), Ye()) - : ur.tag === 13 && MCt(T, ur) && S(ur, wF) && ((_F = !0), Ye())); - var P = ur.flags; - (P & 256) !== 0 && ACt(T, ur), - (P & 512) === 0 || - bS || - ((bS = !0), - tF(97, function () { - return c_(), null; - })), - (ur = ur.nextEffect); - } - } - function c_() { - if (vF !== 90) { - var T = 97 < vF ? 97 : vF; - return (vF = 90), n_(T, NCt); - } - return !1; - } - function RCt(T, P) { - ipe.push(P, T), - bS || - ((bS = !0), - tF(97, function () { - return c_(), null; - })); - } - function a7e(T, P) { - ope.push(P, T), - bS || - ((bS = !0), - tF(97, function () { - return c_(), null; - })); - } - function NCt() { - if (gF === null) return !1; - var T = gF; - if (((gF = null), (Pr & 48) !== 0)) throw Error(a(331)); - var P = Pr; - Pr |= 32; - var R = ope; - ope = []; - for (var J = 0; J < R.length; J += 2) { - var Q = R[J], - he = R[J + 1], - Oe = Q.destroy; - if (((Q.destroy = void 0), typeof Oe == "function")) - try { - Oe(); - } catch (dt) { - if (he === null) throw Error(a(330)); - _S(he, dt); - } - } - for (R = ipe, ipe = [], J = 0; J < R.length; J += 2) { - (Q = R[J]), (he = R[J + 1]); - try { - var et = Q.create; - Q.destroy = et(); - } catch (dt) { - if (he === null) throw Error(a(330)); - _S(he, dt); - } - } - for (et = T.current.firstEffect; et !== null; ) - (T = et.nextEffect), - (et.nextEffect = null), - et.flags & 8 && ((et.sibling = null), (et.stateNode = null)), - (et = T); - return (Pr = P), R0(), !0; - } - function s7e(T, P, R) { - (P = jhe(R, P)), - (P = zRe(T, P, 1)), - gS(T, P), - (P = yh()), - (T = zW(T, 1)), - T !== null && (yi(T, 1, P), Op(T, P)); - } - function _S(T, P) { - if (T.tag === 3) s7e(T, T, P); - else - for (var R = T.return; R !== null; ) { - if (R.tag === 3) { - s7e(R, T, P); - break; - } else if (R.tag === 1) { - var J = R.stateNode; - if ( - typeof R.type.getDerivedStateFromError == "function" || - (typeof J.componentDidCatch == "function" && - ($g === null || !$g.has(J))) - ) { - T = jhe(P, T); - var Q = jRe(R, T, 1); - if ((gS(R, Q), (Q = yh()), (R = zW(R, 1)), R !== null)) - yi(R, 1, Q), Op(R, Q); - else if ( - typeof J.componentDidCatch == "function" && - ($g === null || !$g.has(J)) - ) - try { - J.componentDidCatch(P, T); - } catch {} - break; - } - } - R = R.return; - } - } - function DCt(T, P, R) { - var J = T.pingCache; - J !== null && J.delete(P), - (P = yh()), - (T.pingedLanes |= T.suspendedLanes & R), - Nd === T && - (Ac & R) === R && - (Ju === 4 || - (Ju === 3 && (Ac & 62914560) === Ac && 500 > Wu() - tpe) - ? rI(T, 0) - : (Qhe |= R)), - Op(T, P); - } - function FCt(T, P) { - var R = T.stateNode; - R !== null && R.delete(P), - (P = 0), - P === 0 && - ((P = T.mode), - (P & 2) === 0 - ? (P = 1) - : (P & 4) === 0 - ? (P = GB() === 99 ? 1 : 2) - : (s_ === 0 && (s_ = QB), - (P = gn(62914560 & ~s_)), - P === 0 && (P = 4194304))), - (R = yh()), - (T = zW(T, P)), - T !== null && (yi(T, P, R), Op(T, R)); - } - var u7e; - u7e = function (T, P, R) { - var J = P.lanes; - if (T !== null) - if (T.memoizedProps !== P.pendingProps || gt.current) Mm = !0; - else if ((R & J) !== 0) Mm = (T.flags & 16384) !== 0; - else { - switch (((Mm = !1), P.tag)) { - case 3: - IRe(P), Phe(); - break; - case 5: - hRe(P); - break; - case 1: - yt(P.type) && ht(P); - break; - case 4: - Mhe(P, P.stateNode.containerInfo); - break; - case 10: - rRe(P, P.memoizedProps.value); - break; - case 13: - if (P.memoizedState !== null) - return (R & P.child.childLanes) !== 0 - ? CRe(T, P, R) - : (Bt(Oa, Oa.current & 1), - (P = o_(T, P, R)), - P !== null ? P.sibling : null); - Bt(Oa, Oa.current & 1); - break; - case 19: - if (((J = (R & P.childLanes) !== 0), (T.flags & 64) !== 0)) { - if (J) return LRe(T, P, R); - P.flags |= 64; - } - var Q = P.memoizedState; - if ( - (Q !== null && - ((Q.rendering = null), - (Q.tail = null), - (Q.lastEffect = null)), - Bt(Oa, Oa.current), - J) - ) - break; - return null; - case 23: - case 24: - return (P.lanes = 0), Fhe(T, P, R); - } - return o_(T, P, R); - } - else Mm = !1; - switch (((P.lanes = 0), P.tag)) { - case 2: - if ( - ((J = P.type), - T !== null && - ((T.alternate = null), (P.alternate = null), (P.flags |= 2)), - (T = P.pendingProps), - (Q = It(P, Mt.current)), - $B(P, R), - (Q = Ihe(null, P, J, T, Q, R)), - (P.flags |= 1), - typeof Q == "object" && - Q !== null && - typeof Q.render == "function" && - Q.$$typeof === void 0) - ) { - if ( - ((P.tag = 1), - (P.memoizedState = null), - (P.updateQueue = null), - yt(J)) - ) { - var he = !0; - ht(P); - } else he = !1; - (P.memoizedState = - Q.state !== null && Q.state !== void 0 ? Q.state : null), - Ahe(P); - var Oe = J.getDerivedStateFromProps; - typeof Oe == "function" && hW(P, J, Oe, T), - (Q.updater = pW), - (P.stateNode = Q), - (Q._reactInternals = P), - Ehe(P, J, T, R), - (P = qhe(null, P, J, !0, he, R)); - } else (P.tag = 0), ph(null, P, Q, R), (P = P.child); - return P; - case 16: - Q = P.elementType; - e: { - switch ( - (T !== null && - ((T.alternate = null), (P.alternate = null), (P.flags |= 2)), - (T = P.pendingProps), - (he = Q._init), - (Q = he(Q._payload)), - (P.type = Q), - (he = P.tag = qCt(Q)), - (T = Em(Q, T)), - he) - ) { - case 0: - P = Lhe(null, P, Q, T, R); - break e; - case 1: - P = BRe(null, P, Q, T, R); - break e; - case 11: - P = TRe(null, P, Q, T, R); - break e; - case 14: - P = kRe(null, P, Q, Em(Q.type, T), J, R); - break e; - } - throw Error(a(306, Q, "")); - } - return P; - case 0: - return ( - (J = P.type), - (Q = P.pendingProps), - (Q = P.elementType === J ? Q : Em(J, Q)), - Lhe(T, P, J, Q, R) - ); - case 1: - return ( - (J = P.type), - (Q = P.pendingProps), - (Q = P.elementType === J ? Q : Em(J, Q)), - BRe(T, P, J, Q, R) - ); - case 3: - if ((IRe(P), (J = P.updateQueue), T === null || J === null)) - throw Error(a(282)); - if ( - ((J = P.pendingProps), - (Q = P.memoizedState), - (Q = Q !== null ? Q.element : null), - iRe(T, P), - rF(P, J, null, R), - (J = P.memoizedState.element), - J === Q) - ) - Phe(), (P = o_(T, P, R)); - else { - if ( - ((Q = P.stateNode), - (he = Q.hydrate) && - (ve - ? ((k3 = be(P.stateNode.containerInfo)), - (i_ = P), - (he = Wg = !0)) - : (he = !1)), - he) - ) { - if (ve && ((T = Q.mutableSourceEagerHydrationData), T != null)) - for (Q = 0; Q < T.length; Q += 2) - (he = T[Q]), - (Oe = T[Q + 1]), - le - ? (he._workInProgressVersionPrimary = Oe) - : (he._workInProgressVersionSecondary = Oe), - YB.push(he); - for (R = dRe(P, null, J, R), P.child = R; R; ) - (R.flags = (R.flags & -3) | 1024), (R = R.sibling); - } else ph(T, P, J, R), Phe(); - P = P.child; - } - return P; - case 5: - return ( - hRe(P), - T === null && khe(P), - (J = P.type), - (Q = P.pendingProps), - (he = T !== null ? T.memoizedProps : null), - (Oe = Q.children), - ge(J, Q) - ? (Oe = null) - : he !== null && ge(J, he) && (P.flags |= 16), - ORe(T, P), - ph(T, P, Oe, R), - P.child - ); - case 6: - return T === null && khe(P), null; - case 13: - return CRe(T, P, R); - case 4: - return ( - Mhe(P, P.stateNode.containerInfo), - (J = P.pendingProps), - T === null ? (P.child = gW(P, null, J, R)) : ph(T, P, J, R), - P.child - ); - case 11: - return ( - (J = P.type), - (Q = P.pendingProps), - (Q = P.elementType === J ? Q : Em(J, Q)), - TRe(T, P, J, Q, R) - ); - case 7: - return ph(T, P, P.pendingProps, R), P.child; - case 8: - return ph(T, P, P.pendingProps.children, R), P.child; - case 12: - return ph(T, P, P.pendingProps.children, R), P.child; - case 10: - e: { - if ( - ((J = P.type._context), - (Q = P.pendingProps), - (Oe = P.memoizedProps), - (he = Q.value), - rRe(P, he), - Oe !== null) - ) { - var et = Oe.value; - if ( - ((he = N0(et, he) - ? 0 - : (typeof J._calculateChangedBits == "function" - ? J._calculateChangedBits(et, he) - : 1073741823) | 0), - he === 0) - ) { - if (Oe.children === Q.children && !gt.current) { - P = o_(T, P, R); - break e; - } - } else - for ( - et = P.child, et !== null && (et.return = P); - et !== null; - - ) { - var dt = et.dependencies; - if (dt !== null) { - Oe = et.child; - for (var Yt = dt.firstContext; Yt !== null; ) { - if (Yt.context === J && (Yt.observedBits & he) !== 0) { - et.tag === 1 && - ((Yt = mS(-1, R & -R)), (Yt.tag = 2), gS(et, Yt)), - (et.lanes |= R), - (Yt = et.alternate), - Yt !== null && (Yt.lanes |= R), - nRe(et.return, R), - (dt.lanes |= R); - break; - } - Yt = Yt.next; - } - } else - Oe = - et.tag === 10 && et.type === P.type ? null : et.child; - if (Oe !== null) Oe.return = et; - else - for (Oe = et; Oe !== null; ) { - if (Oe === P) { - Oe = null; - break; - } - if (((et = Oe.sibling), et !== null)) { - (et.return = Oe.return), (Oe = et); - break; - } - Oe = Oe.return; - } - et = Oe; - } - } - ph(T, P, Q.children, R), (P = P.child); - } - return P; - case 9: - return ( - (Q = P.type), - (he = P.pendingProps), - (J = he.children), - $B(P, R), - (Q = D0(Q, he.unstable_observedBits)), - (J = J(Q)), - (P.flags |= 1), - ph(T, P, J, R), - P.child - ); - case 14: - return ( - (Q = P.type), - (he = Em(Q, P.pendingProps)), - (he = Em(Q.type, he)), - kRe(T, P, Q, he, J, R) - ); - case 15: - return PRe(T, P, P.type, P.pendingProps, J, R); - case 17: - return ( - (J = P.type), - (Q = P.pendingProps), - (Q = P.elementType === J ? Q : Em(J, Q)), - T !== null && - ((T.alternate = null), (P.alternate = null), (P.flags |= 2)), - (P.tag = 1), - yt(J) ? ((T = !0), ht(P)) : (T = !1), - $B(P, R), - cRe(P, J, Q), - Ehe(P, J, Q, R), - qhe(null, P, J, !0, T, R) - ); - case 19: - return LRe(T, P, R); - case 23: - return Fhe(T, P, R); - case 24: - return Fhe(T, P, R); - } - throw Error(a(156, P.tag)); - }; - var UW = { current: !1 }, - cpe = o.unstable_flushAllWithoutAsserting, - c7e = typeof cpe == "function"; - function lpe() { - if (cpe !== void 0) return cpe(); - for (var T = !1; c_(); ) T = !0; - return T; - } - function l7e(T) { - try { - lpe(), - TCt(function () { - lpe() ? l7e(T) : T(); - }); - } catch (P) { - T(P); - } - } - var KW = 0, - f7e = !1; - function LCt(T, P, R, J) { - (this.tag = T), - (this.key = R), - (this.sibling = - this.child = - this.return = - this.stateNode = - this.type = - this.elementType = - null), - (this.index = 0), - (this.ref = null), - (this.pendingProps = P), - (this.dependencies = - this.memoizedState = - this.updateQueue = - this.memoizedProps = - null), - (this.mode = J), - (this.flags = 0), - (this.lastEffect = this.firstEffect = this.nextEffect = null), - (this.childLanes = this.lanes = 0), - (this.alternate = null); - } - function q0(T, P, R, J) { - return new LCt(T, P, R, J); - } - function fpe(T) { - return (T = T.prototype), !(!T || !T.isReactComponent); - } - function qCt(T) { - if (typeof T == "function") return fpe(T) ? 1 : 0; - if (T != null) { - if (((T = T.$$typeof), T === D)) return 11; - if (T === q) return 14; - } - return 2; - } - function xS(T, P) { - var R = T.alternate; - return ( - R === null - ? ((R = q0(T.tag, P, T.key, T.mode)), - (R.elementType = T.elementType), - (R.type = T.type), - (R.stateNode = T.stateNode), - (R.alternate = T), - (T.alternate = R)) - : ((R.pendingProps = P), - (R.type = T.type), - (R.flags = 0), - (R.nextEffect = null), - (R.firstEffect = null), - (R.lastEffect = null)), - (R.childLanes = T.childLanes), - (R.lanes = T.lanes), - (R.child = T.child), - (R.memoizedProps = T.memoizedProps), - (R.memoizedState = T.memoizedState), - (R.updateQueue = T.updateQueue), - (P = T.dependencies), - (R.dependencies = - P === null - ? null - : { lanes: P.lanes, firstContext: P.firstContext }), - (R.sibling = T.sibling), - (R.index = T.index), - (R.ref = T.ref), - R - ); - } - function HW(T, P, R, J, Q, he) { - var Oe = 2; - if (((J = T), typeof T == "function")) fpe(T) && (Oe = 1); - else if (typeof T == "string") Oe = 5; - else - e: switch (T) { - case h: - return nI(R.children, Q, he, P); - case Z: - (Oe = 8), (Q |= 16); - break; - case w: - (Oe = 8), (Q |= 1); - break; - case M: - return ( - (T = q0(12, R, P, Q | 8)), - (T.elementType = M), - (T.type = M), - (T.lanes = he), - T - ); - case F: - return ( - (T = q0(13, R, P, Q)), - (T.type = F), - (T.elementType = F), - (T.lanes = he), - T - ); - case N: - return ( - (T = q0(19, R, P, Q)), (T.elementType = N), (T.lanes = he), T - ); - case $: - return dpe(R, Q, he, P); - case ue: - return ( - (T = q0(24, R, P, Q)), (T.elementType = ue), (T.lanes = he), T - ); - default: - if (typeof T == "object" && T !== null) - switch (T.$$typeof) { - case k: - Oe = 10; - break e; - case O: - Oe = 9; - break e; - case D: - Oe = 11; - break e; - case q: - Oe = 14; - break e; - case z: - (Oe = 16), (J = null); - break e; - case H: - Oe = 22; - break e; - } - throw Error(a(130, T == null ? T : typeof T, "")); - } - return ( - (P = q0(Oe, R, P, Q)), - (P.elementType = T), - (P.type = J), - (P.lanes = he), - P - ); - } - function nI(T, P, R, J) { - return (T = q0(7, T, J, P)), (T.lanes = R), T; - } - function dpe(T, P, R, J) { - return (T = q0(23, T, J, P)), (T.elementType = $), (T.lanes = R), T; - } - function hpe(T, P, R) { - return (T = q0(6, T, null, P)), (T.lanes = R), T; - } - function ppe(T, P, R) { - return ( - (P = q0(4, T.children !== null ? T.children : [], T.key, P)), - (P.lanes = R), - (P.stateNode = { - containerInfo: T.containerInfo, - pendingChildren: null, - implementation: T.implementation, - }), - P - ); - } - function zCt(T, P, R) { - (this.tag = P), - (this.containerInfo = T), - (this.finishedWork = - this.pingCache = - this.current = - this.pendingChildren = - null), - (this.timeoutHandle = ae), - (this.pendingContext = this.context = null), - (this.hydrate = R), - (this.callbackNode = null), - (this.callbackPriority = 0), - (this.eventTimes = zo(0)), - (this.expirationTimes = zo(-1)), - (this.entangledLanes = - this.finishedLanes = - this.mutableReadLanes = - this.expiredLanes = - this.pingedLanes = - this.suspendedLanes = - this.pendingLanes = - 0), - (this.entanglements = zo(0)), - ve && (this.mutableSourceEagerHydrationData = null); - } - function d7e(T) { - var P = T._reactInternals; - if (P === void 0) - throw typeof T.render == "function" - ? Error(a(188)) - : Error(a(268, Object.keys(T))); - return (T = v(P)), T === null ? null : T.stateNode; - } - function h7e(T, P) { - if (((T = T.memoizedState), T !== null && T.dehydrated !== null)) { - var R = T.retryLane; - T.retryLane = R !== 0 && R < P ? R : P; - } - } - function VW(T, P) { - h7e(T, P), (T = T.alternate) && h7e(T, P); - } - function jCt(T) { - return (T = v(T)), T === null ? null : T.stateNode; - } - function UCt() { - return null; - } - return ( - (r.IsThisRendererActing = UW), - (r.act = function (T) { - function P() { - KW--, (Xhe.current = R), (UW.current = J); - } - f7e === !1 && - ((f7e = !0), - console.error( - "act(...) is not supported in production builds of React, and might not behave as expected." - )), - KW++; - var R = Xhe.current, - J = UW.current; - (Xhe.current = !0), (UW.current = !0); - try { - var Q = e7e(T); - } catch (he) { - throw (P(), he); - } - if (Q !== null && typeof Q == "object" && typeof Q.then == "function") - return { - then: function (he, Oe) { - Q.then( - function () { - 1 < KW || (c7e === !0 && R === !0) - ? (P(), he()) - : l7e(function (et) { - P(), et ? Oe(et) : he(); - }); - }, - function (et) { - P(), Oe(et); - } - ); - }, - }; - try { - KW !== 1 || (c7e !== !1 && R !== !1) || lpe(), P(); - } catch (he) { - throw (P(), he); - } - return { - then: function (he) { - he(); - }, - }; - }), - (r.attemptContinuousHydration = function (T) { - if (T.tag === 13) { - var P = yh(); - u_(T, 67108864, P), VW(T, 67108864); - } - }), - (r.attemptHydrationAtCurrentPriority = function (T) { - if (T.tag === 13) { - var P = yh(), - R = wS(T); - u_(T, R, P), VW(T, R); - } - }), - (r.attemptSynchronousHydration = function (T) { - switch (T.tag) { - case 3: - var P = T.stateNode; - if (P.hydrate) { - var R = Ce(P.pendingLanes); - (P.expiredLanes |= R & P.pendingLanes), - Op(P, Wu()), - (Pr & 48) === 0 && (vS(), R0()); - } - break; - case 13: - var J = yh(); - t7e(function () { - return u_(T, 1, J); - }), - VW(T, 4); - } - }), - (r.attemptUserBlockingHydration = function (T) { - if (T.tag === 13) { - var P = yh(); - u_(T, 4, P), VW(T, 4); - } - }), - (r.batchedEventUpdates = function (T, P) { - var R = Pr; - Pr |= 2; - try { - return T(P); - } finally { - (Pr = R), Pr === 0 && (vS(), R0()); - } - }), - (r.batchedUpdates = e7e), - (r.createComponentSelector = function (T) { - return { $$typeof: PW, value: T }; - }), - (r.createContainer = function (T, P, R) { - return ( - (T = new zCt(T, P, R)), - (P = q0(3, null, null, P === 2 ? 7 : P === 1 ? 3 : 0)), - (T.current = P), - (P.stateNode = T), - Ahe(P), - T - ); - }), - (r.createHasPsuedoClassSelector = function (T) { - return { $$typeof: OW, value: T }; - }), - (r.createPortal = function (T, P, R) { - var J = - 3 < arguments.length && arguments[3] !== void 0 - ? arguments[3] - : null; - return { - $$typeof: u, - key: J == null ? null : "" + J, - children: T, - containerInfo: P, - implementation: R, - }; - }), - (r.createRoleSelector = function (T) { - return { $$typeof: BW, value: T }; - }), - (r.createTestNameSelector = function (T) { - return { $$typeof: IW, value: T }; - }), - (r.createTextSelector = function (T) { - return { $$typeof: CW, value: T }; - }), - (r.deferredUpdates = function (T) { - return n_(97, T); - }), - (r.discreteUpdates = function (T, P, R, J, Q) { - var he = Pr; - Pr |= 4; - try { - return n_(98, T.bind(null, P, R, J, Q)); - } finally { - (Pr = he), Pr === 0 && (vS(), R0()); - } - }), - (r.findAllNodes = $he), - (r.findBoundingRects = function (T, P) { - if (!kt) throw Error(a(363)); - (P = $he(T, P)), (T = []); - for (var R = 0; R < P.length; R++) T.push(We(P[R])); - for (P = T.length - 1; 0 < P; P--) { - R = T[P]; - for ( - var J = R.x, - Q = J + R.width, - he = R.y, - Oe = he + R.height, - et = P - 1; - 0 <= et; - et-- - ) - if (P !== et) { - var dt = T[et], - Yt = dt.x, - br = Yt + dt.width, - Hr = dt.y, - ir = Hr + dt.height; - if (J >= Yt && he >= Hr && Q <= br && Oe <= ir) { - T.splice(P, 1); - break; - } else if ( - J !== Yt || - R.width !== dt.width || - ir < he || - Hr > Oe - ) { - if ( - !(he !== Hr || R.height !== dt.height || br < J || Yt > Q) - ) { - Yt > J && ((dt.width += Yt - J), (dt.x = J)), - br < Q && (dt.width = Q - Yt), - T.splice(P, 1); - break; - } - } else { - Hr > he && ((dt.height += Hr - he), (dt.y = he)), - ir < Oe && (dt.height = Oe - Hr), - T.splice(P, 1); - break; - } - } - } - return T; - }), - (r.findHostInstance = d7e), - (r.findHostInstanceWithNoPortals = function (T) { - return ( - (T = _(T)), - T === null - ? null - : T.tag === 20 - ? T.stateNode.instance - : T.stateNode - ); - }), - (r.findHostInstanceWithWarning = function (T) { - return d7e(T); - }), - (r.flushControlled = function (T) { - var P = Pr; - Pr |= 1; - try { - n_(99, T); - } finally { - (Pr = P), Pr === 0 && (vS(), R0()); - } - }), - (r.flushDiscreteUpdates = function () { - (Pr & 49) === 0 && (PCt(), c_()); - }), - (r.flushPassiveEffects = c_), - (r.flushSync = t7e), - (r.focusWithin = function (T, P) { - if (!kt) throw Error(a(363)); - for ( - T = Whe(T), P = YRe(T, P), P = Array.from(P), T = 0; - T < P.length; - - ) { - var R = P[T++]; - if (!Ue(R)) { - if (R.tag === 5 && W(R.stateNode)) return !0; - for (R = R.child; R !== null; ) P.push(R), (R = R.sibling); - } - } - return !1; - }), - (r.getCurrentUpdateLanePriority = function () { - return Kr; - }), - (r.getFindAllNodesFailureDescription = function (T, P) { - if (!kt) throw Error(a(363)); - var R = 0, - J = []; - T = [Whe(T), 0]; - for (var Q = 0; Q < T.length; ) { - var he = T[Q++], - Oe = T[Q++], - et = P[Oe]; - if ( - (he.tag !== 5 || !Ue(he)) && - (Ghe(he, et) && (J.push(Jhe(et)), Oe++, Oe > R && (R = Oe)), - Oe < P.length) - ) - for (he = he.child; he !== null; ) - T.push(he, Oe), (he = he.sibling); - } - if (R < P.length) { - for (T = []; R < P.length; R++) T.push(Jhe(P[R])); - return ( - `findAllNodes was able to match part of the selector: - ` + - (J.join(" > ") + - ` - -No matching component was found for: - `) + - T.join(" > ") - ); - } - return null; - }), - (r.getPublicRootInstance = function (T) { - if (((T = T.current), !T.child)) return null; - switch (T.child.tag) { - case 5: - return b(T.child.stateNode); - default: - return T.child.stateNode; - } - }), - (r.injectIntoDevTools = function (T) { - if ( - ((T = { - bundleType: T.bundleType, - version: T.version, - rendererPackageName: T.rendererPackageName, - rendererConfig: T.rendererConfig, - overrideHookState: null, - overrideHookStateDeletePath: null, - overrideHookStateRenamePath: null, - overrideProps: null, - overridePropsDeletePath: null, - overridePropsRenamePath: null, - setSuspenseHandler: null, - scheduleUpdate: null, - currentDispatcherRef: s.ReactCurrentDispatcher, - findHostInstanceByFiber: jCt, - findFiberByHostInstance: T.findFiberByHostInstance || UCt, - findHostInstancesForRefresh: null, - scheduleRefresh: null, - scheduleRoot: null, - setRefreshHandler: null, - getCurrentFiber: null, - }), - typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ > "u") - ) - T = !1; - else { - var P = __REACT_DEVTOOLS_GLOBAL_HOOK__; - if (!P.isDisabled && P.supportsFiber) - try { - (Nt = P.inject(T)), (hr = P); - } catch {} - T = !0; - } - return T; - }), - (r.observeVisibleRects = function (T, P, R, J) { - if (!kt) throw Error(a(363)); - T = $he(T, P); - var Q = j(T, R, J).disconnect; - return { - disconnect: function () { - Q(); - }, - }; - }), - (r.registerMutableSourceForHydration = function (T, P) { - var R = P._getVersion; - (R = R(P._source)), - T.mutableSourceEagerHydrationData == null - ? (T.mutableSourceEagerHydrationData = [P, R]) - : T.mutableSourceEagerHydrationData.push(P, R); - }), - (r.runWithPriority = function (T, P) { - var R = Kr; - try { - return (Kr = T), P(); - } finally { - Kr = R; - } - }), - (r.shouldSuspend = function () { - return !1; - }), - (r.unbatchedUpdates = function (T, P) { - var R = Pr; - (Pr &= -2), (Pr |= 8); - try { - return T(P); - } finally { - (Pr = R), Pr === 0 && (vS(), R0()); - } - }), - (r.updateContainer = function (T, P, R, J) { - var Q = P.current, - he = yh(), - Oe = wS(Q); - e: if (R) { - R = R._reactInternals; - t: { - if (p(R) !== R || R.tag !== 1) throw Error(a(170)); - var et = R; - do { - switch (et.tag) { - case 3: - et = et.stateNode.context; - break t; - case 1: - if (yt(et.type)) { - et = - et.stateNode.__reactInternalMemoizedMergedChildContext; - break t; - } - } - et = et.return; - } while (et !== null); - throw Error(a(171)); - } - if (R.tag === 1) { - var dt = R.type; - if (yt(dt)) { - R = _t(R, dt, et); - break e; - } - } - R = et; - } else R = Et; - return ( - P.context === null ? (P.context = R) : (P.pendingContext = R), - (P = mS(he, Oe)), - (P.payload = { element: T }), - (J = J === void 0 ? null : J), - J !== null && (P.callback = J), - gS(Q, P), - u_(Q, Oe, he), - Oe - ); - }), - r - ); - }; - }); - var pNe = I((Oon, hNe) => { - "use strict"; - m(); - g(); - hNe.exports = dNe(); - }); - var lI = I((Bon, Fpe) => { - "use strict"; - m(); - g(); - var u7t = Object.prototype.hasOwnProperty, - Dd = "~"; - function OF() {} - Object.create && - ((OF.prototype = Object.create(null)), new OF().__proto__ || (Dd = !1)); - function c7t(t, e, r) { - (this.fn = t), (this.context = e), (this.once = r || !1); - } - function yNe(t, e, r, n, i) { - if (typeof r != "function") - throw new TypeError("The listener must be a function"); - var o = new c7t(r, n || t, i), - a = Dd ? Dd + e : e; - return ( - t._events[a] - ? t._events[a].fn - ? (t._events[a] = [t._events[a], o]) - : t._events[a].push(o) - : ((t._events[a] = o), t._eventsCount++), - t - ); - } - function uG(t, e) { - --t._eventsCount === 0 ? (t._events = new OF()) : delete t._events[e]; - } - function Mc() { - (this._events = new OF()), (this._eventsCount = 0); - } - Mc.prototype.eventNames = function () { - var e = [], - r, - n; - if (this._eventsCount === 0) return e; - for (n in (r = this._events)) - u7t.call(r, n) && e.push(Dd ? n.slice(1) : n); - return Object.getOwnPropertySymbols - ? e.concat(Object.getOwnPropertySymbols(r)) - : e; - }; - Mc.prototype.listeners = function (e) { - var r = Dd ? Dd + e : e, - n = this._events[r]; - if (!n) return []; - if (n.fn) return [n.fn]; - for (var i = 0, o = n.length, a = new Array(o); i < o; i++) - a[i] = n[i].fn; - return a; - }; - Mc.prototype.listenerCount = function (e) { - var r = Dd ? Dd + e : e, - n = this._events[r]; - return n ? (n.fn ? 1 : n.length) : 0; - }; - Mc.prototype.emit = function (e, r, n, i, o, a) { - var s = Dd ? Dd + e : e; - if (!this._events[s]) return !1; - var c = this._events[s], - u = arguments.length, - h, - w; - if (c.fn) { - switch ((c.once && this.removeListener(e, c.fn, void 0, !0), u)) { - case 1: - return c.fn.call(c.context), !0; - case 2: - return c.fn.call(c.context, r), !0; - case 3: - return c.fn.call(c.context, r, n), !0; - case 4: - return c.fn.call(c.context, r, n, i), !0; - case 5: - return c.fn.call(c.context, r, n, i, o), !0; - case 6: - return c.fn.call(c.context, r, n, i, o, a), !0; - } - for (w = 1, h = new Array(u - 1); w < u; w++) h[w - 1] = arguments[w]; - c.fn.apply(c.context, h); - } else { - var M = c.length, - k; - for (w = 0; w < M; w++) - switch ( - (c[w].once && this.removeListener(e, c[w].fn, void 0, !0), u) - ) { - case 1: - c[w].fn.call(c[w].context); - break; - case 2: - c[w].fn.call(c[w].context, r); - break; - case 3: - c[w].fn.call(c[w].context, r, n); - break; - case 4: - c[w].fn.call(c[w].context, r, n, i); - break; - default: - if (!h) - for (k = 1, h = new Array(u - 1); k < u; k++) - h[k - 1] = arguments[k]; - c[w].fn.apply(c[w].context, h); - } - } - return !0; - }; - Mc.prototype.on = function (e, r, n) { - return yNe(this, e, r, n, !1); - }; - Mc.prototype.once = function (e, r, n) { - return yNe(this, e, r, n, !0); - }; - Mc.prototype.removeListener = function (e, r, n, i) { - var o = Dd ? Dd + e : e; - if (!this._events[o]) return this; - if (!r) return uG(this, o), this; - var a = this._events[o]; - if (a.fn) - a.fn === r && (!i || a.once) && (!n || a.context === n) && uG(this, o); - else { - for (var s = 0, c = [], u = a.length; s < u; s++) - (a[s].fn !== r || (i && !a[s].once) || (n && a[s].context !== n)) && - c.push(a[s]); - c.length ? (this._events[o] = c.length === 1 ? c[0] : c) : uG(this, o); - } - return this; - }; - Mc.prototype.removeAllListeners = function (e) { - var r; - return ( - e - ? ((r = Dd ? Dd + e : e), this._events[r] && uG(this, r)) - : ((this._events = new OF()), (this._eventsCount = 0)), - this - ); - }; - Mc.prototype.off = Mc.prototype.removeListener; - Mc.prototype.addListener = Mc.prototype.on; - Mc.prefixed = Dd; - Mc.EventEmitter = Mc; - typeof Fpe < "u" && (Fpe.exports = Mc); - }); - var vNe = I((gNe) => { - "use strict"; - m(); - g(); - var fI = to(); - function l7t(t, e) { - return (t === e && (t !== 0 || 1 / t === 1 / e)) || (t !== t && e !== e); - } - var f7t = typeof Object.is == "function" ? Object.is : l7t, - d7t = fI.useState, - h7t = fI.useEffect, - p7t = fI.useLayoutEffect, - y7t = fI.useDebugValue; - function m7t(t, e) { - var r = e(), - n = d7t({ inst: { value: r, getSnapshot: e } }), - i = n[0].inst, - o = n[1]; - return ( - p7t( - function () { - (i.value = r), (i.getSnapshot = e), qpe(i) && o({ inst: i }); - }, - [t, r, e] - ), - h7t( - function () { - return ( - qpe(i) && o({ inst: i }), - t(function () { - qpe(i) && o({ inst: i }); - }) - ); - }, - [t] - ), - y7t(r), - r - ); - } - function qpe(t) { - var e = t.getSnapshot; - t = t.value; - try { - var r = e(); - return !f7t(t, r); - } catch { - return !0; - } - } - function g7t(t, e) { - return e(); - } - var v7t = - typeof window > "u" || - typeof window.document > "u" || - typeof window.document.createElement > "u" - ? g7t - : m7t; - gNe.useSyncExternalStore = - fI.useSyncExternalStore !== void 0 ? fI.useSyncExternalStore : v7t; - }); - var wNe = I((Non, bNe) => { - "use strict"; - m(); - g(); - bNe.exports = vNe(); - }); - var xNe = I((_Ne) => { - "use strict"; - m(); - g(); - var lG = to(), - b7t = wNe(); - function w7t(t, e) { - return (t === e && (t !== 0 || 1 / t === 1 / e)) || (t !== t && e !== e); - } - var _7t = typeof Object.is == "function" ? Object.is : w7t, - x7t = b7t.useSyncExternalStore, - S7t = lG.useRef, - A7t = lG.useEffect, - E7t = lG.useMemo, - M7t = lG.useDebugValue; - _Ne.useSyncExternalStoreWithSelector = function (t, e, r, n, i) { - var o = S7t(null); - if (o.current === null) { - var a = { hasValue: !1, value: null }; - o.current = a; - } else a = o.current; - o = E7t( - function () { - function c(k) { - if (!u) { - if (((u = !0), (h = k), (k = n(k)), i !== void 0 && a.hasValue)) { - var O = a.value; - if (i(O, k)) return (w = O); - } - return (w = k); - } - if (((O = w), _7t(h, k))) return O; - var D = n(k); - return i !== void 0 && i(O, D) ? O : ((h = k), (w = D)); - } - var u = !1, - h, - w, - M = r === void 0 ? null : r; - return [ - function () { - return c(e()); - }, - M === null - ? void 0 - : function () { - return c(M()); - }, - ]; - }, - [e, r, n, i] - ); - var s = x7t(t, o[0], o[1]); - return ( - A7t( - function () { - (a.hasValue = !0), (a.value = s); - }, - [s] - ), - M7t(s), - s - ); - }; - }); - var ANe = I((Fon, SNe) => { - "use strict"; - m(); - g(); - SNe.exports = xNe(); - }); - function BF() { - if ( - !fG && - ((fG = - (typeof crypto < "u" && - crypto.getRandomValues && - crypto.getRandomValues.bind(crypto)) || - (typeof msCrypto < "u" && - typeof msCrypto.getRandomValues == "function" && - msCrypto.getRandomValues.bind(msCrypto))), - !fG) - ) - throw new Error( - "crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported" - ); - return fG(O7t); - } - var fG, - O7t, - jpe = vs(() => { - m(); - g(); - O7t = new Uint8Array(16); - }); - var PNe, - ONe = vs(() => { - m(); - g(); - PNe = - /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i; - }); - function B7t(t) { - return typeof t == "string" && PNe.test(t); - } - var TS, - IF = vs(() => { - m(); - g(); - ONe(); - TS = B7t; - }); - function I7t(t) { - var e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 0, - r = ( - $u[t[e + 0]] + - $u[t[e + 1]] + - $u[t[e + 2]] + - $u[t[e + 3]] + - "-" + - $u[t[e + 4]] + - $u[t[e + 5]] + - "-" + - $u[t[e + 6]] + - $u[t[e + 7]] + - "-" + - $u[t[e + 8]] + - $u[t[e + 9]] + - "-" + - $u[t[e + 10]] + - $u[t[e + 11]] + - $u[t[e + 12]] + - $u[t[e + 13]] + - $u[t[e + 14]] + - $u[t[e + 15]] - ).toLowerCase(); - if (!TS(r)) throw TypeError("Stringified UUID is invalid"); - return r; - } - var $u, - dG, - kS, - CF = vs(() => { - m(); - g(); - IF(); - $u = []; - for (dG = 0; dG < 256; ++dG) $u.push((dG + 256).toString(16).substr(1)); - kS = I7t; - }); - function C7t(t, e, r) { - var n = (e && r) || 0, - i = e || new Array(16); - t = t || {}; - var o = t.node || BNe, - a = t.clockseq !== void 0 ? t.clockseq : Upe; - if (o == null || a == null) { - var s = t.random || (t.rng || BF)(); - o == null && (o = BNe = [s[0] | 1, s[1], s[2], s[3], s[4], s[5]]), - a == null && (a = Upe = ((s[6] << 8) | s[7]) & 16383); - } - var c = t.msecs !== void 0 ? t.msecs : Date.now(), - u = t.nsecs !== void 0 ? t.nsecs : Hpe + 1, - h = c - Kpe + (u - Hpe) / 1e4; - if ( - (h < 0 && t.clockseq === void 0 && (a = (a + 1) & 16383), - (h < 0 || c > Kpe) && t.nsecs === void 0 && (u = 0), - u >= 1e4) - ) - throw new Error("uuid.v1(): Can't create more than 10M uuids/sec"); - (Kpe = c), (Hpe = u), (Upe = a), (c += 122192928e5); - var w = ((c & 268435455) * 1e4 + u) % 4294967296; - (i[n++] = (w >>> 24) & 255), - (i[n++] = (w >>> 16) & 255), - (i[n++] = (w >>> 8) & 255), - (i[n++] = w & 255); - var M = ((c / 4294967296) * 1e4) & 268435455; - (i[n++] = (M >>> 8) & 255), - (i[n++] = M & 255), - (i[n++] = ((M >>> 24) & 15) | 16), - (i[n++] = (M >>> 16) & 255), - (i[n++] = (a >>> 8) | 128), - (i[n++] = a & 255); - for (var k = 0; k < 6; ++k) i[n + k] = o[k]; - return e || kS(i); - } - var BNe, - Upe, - Kpe, - Hpe, - INe, - CNe = vs(() => { - m(); - g(); - jpe(); - CF(); - (Kpe = 0), (Hpe = 0); - INe = C7t; - }); - function R7t(t) { - if (!TS(t)) throw TypeError("Invalid UUID"); - var e, - r = new Uint8Array(16); - return ( - (r[0] = (e = parseInt(t.slice(0, 8), 16)) >>> 24), - (r[1] = (e >>> 16) & 255), - (r[2] = (e >>> 8) & 255), - (r[3] = e & 255), - (r[4] = (e = parseInt(t.slice(9, 13), 16)) >>> 8), - (r[5] = e & 255), - (r[6] = (e = parseInt(t.slice(14, 18), 16)) >>> 8), - (r[7] = e & 255), - (r[8] = (e = parseInt(t.slice(19, 23), 16)) >>> 8), - (r[9] = e & 255), - (r[10] = ((e = parseInt(t.slice(24, 36), 16)) / 1099511627776) & 255), - (r[11] = (e / 4294967296) & 255), - (r[12] = (e >>> 24) & 255), - (r[13] = (e >>> 16) & 255), - (r[14] = (e >>> 8) & 255), - (r[15] = e & 255), - r - ); - } - var hG, - Vpe = vs(() => { - m(); - g(); - IF(); - hG = R7t; - }); - function N7t(t) { - t = unescape(encodeURIComponent(t)); - for (var e = [], r = 0; r < t.length; ++r) e.push(t.charCodeAt(r)); - return e; - } - function pG(t, e, r) { - function n(i, o, a, s) { - if ( - (typeof i == "string" && (i = N7t(i)), - typeof o == "string" && (o = hG(o)), - o.length !== 16) - ) - throw TypeError( - "Namespace must be array-like (16 iterable integer values, 0-255)" - ); - var c = new Uint8Array(16 + i.length); - if ( - (c.set(o), - c.set(i, o.length), - (c = r(c)), - (c[6] = (c[6] & 15) | e), - (c[8] = (c[8] & 63) | 128), - a) - ) { - s = s || 0; - for (var u = 0; u < 16; ++u) a[s + u] = c[u]; - return a; - } - return kS(c); - } - try { - n.name = t; - } catch {} - return (n.DNS = D7t), (n.URL = F7t), n; - } - var D7t, - F7t, - Wpe = vs(() => { - m(); - g(); - CF(); - Vpe(); - (D7t = "6ba7b810-9dad-11d1-80b4-00c04fd430c8"), - (F7t = "6ba7b811-9dad-11d1-80b4-00c04fd430c8"); - }); - function L7t(t) { - if (typeof t == "string") { - var e = unescape(encodeURIComponent(t)); - t = new Uint8Array(e.length); - for (var r = 0; r < e.length; ++r) t[r] = e.charCodeAt(r); - } - return q7t(z7t(j7t(t), t.length * 8)); - } - function q7t(t) { - for ( - var e = [], r = t.length * 32, n = "0123456789abcdef", i = 0; - i < r; - i += 8 - ) { - var o = (t[i >> 5] >>> i % 32) & 255, - a = parseInt(n.charAt((o >>> 4) & 15) + n.charAt(o & 15), 16); - e.push(a); - } - return e; - } - function RNe(t) { - return (((t + 64) >>> 9) << 4) + 14 + 1; - } - function z7t(t, e) { - (t[e >> 5] |= 128 << e % 32), (t[RNe(e) - 1] = e); - for ( - var r = 1732584193, n = -271733879, i = -1732584194, o = 271733878, a = 0; - a < t.length; - a += 16 - ) { - var s = r, - c = n, - u = i, - h = o; - (r = Tc(r, n, i, o, t[a], 7, -680876936)), - (o = Tc(o, r, n, i, t[a + 1], 12, -389564586)), - (i = Tc(i, o, r, n, t[a + 2], 17, 606105819)), - (n = Tc(n, i, o, r, t[a + 3], 22, -1044525330)), - (r = Tc(r, n, i, o, t[a + 4], 7, -176418897)), - (o = Tc(o, r, n, i, t[a + 5], 12, 1200080426)), - (i = Tc(i, o, r, n, t[a + 6], 17, -1473231341)), - (n = Tc(n, i, o, r, t[a + 7], 22, -45705983)), - (r = Tc(r, n, i, o, t[a + 8], 7, 1770035416)), - (o = Tc(o, r, n, i, t[a + 9], 12, -1958414417)), - (i = Tc(i, o, r, n, t[a + 10], 17, -42063)), - (n = Tc(n, i, o, r, t[a + 11], 22, -1990404162)), - (r = Tc(r, n, i, o, t[a + 12], 7, 1804603682)), - (o = Tc(o, r, n, i, t[a + 13], 12, -40341101)), - (i = Tc(i, o, r, n, t[a + 14], 17, -1502002290)), - (n = Tc(n, i, o, r, t[a + 15], 22, 1236535329)), - (r = kc(r, n, i, o, t[a + 1], 5, -165796510)), - (o = kc(o, r, n, i, t[a + 6], 9, -1069501632)), - (i = kc(i, o, r, n, t[a + 11], 14, 643717713)), - (n = kc(n, i, o, r, t[a], 20, -373897302)), - (r = kc(r, n, i, o, t[a + 5], 5, -701558691)), - (o = kc(o, r, n, i, t[a + 10], 9, 38016083)), - (i = kc(i, o, r, n, t[a + 15], 14, -660478335)), - (n = kc(n, i, o, r, t[a + 4], 20, -405537848)), - (r = kc(r, n, i, o, t[a + 9], 5, 568446438)), - (o = kc(o, r, n, i, t[a + 14], 9, -1019803690)), - (i = kc(i, o, r, n, t[a + 3], 14, -187363961)), - (n = kc(n, i, o, r, t[a + 8], 20, 1163531501)), - (r = kc(r, n, i, o, t[a + 13], 5, -1444681467)), - (o = kc(o, r, n, i, t[a + 2], 9, -51403784)), - (i = kc(i, o, r, n, t[a + 7], 14, 1735328473)), - (n = kc(n, i, o, r, t[a + 12], 20, -1926607734)), - (r = Pc(r, n, i, o, t[a + 5], 4, -378558)), - (o = Pc(o, r, n, i, t[a + 8], 11, -2022574463)), - (i = Pc(i, o, r, n, t[a + 11], 16, 1839030562)), - (n = Pc(n, i, o, r, t[a + 14], 23, -35309556)), - (r = Pc(r, n, i, o, t[a + 1], 4, -1530992060)), - (o = Pc(o, r, n, i, t[a + 4], 11, 1272893353)), - (i = Pc(i, o, r, n, t[a + 7], 16, -155497632)), - (n = Pc(n, i, o, r, t[a + 10], 23, -1094730640)), - (r = Pc(r, n, i, o, t[a + 13], 4, 681279174)), - (o = Pc(o, r, n, i, t[a], 11, -358537222)), - (i = Pc(i, o, r, n, t[a + 3], 16, -722521979)), - (n = Pc(n, i, o, r, t[a + 6], 23, 76029189)), - (r = Pc(r, n, i, o, t[a + 9], 4, -640364487)), - (o = Pc(o, r, n, i, t[a + 12], 11, -421815835)), - (i = Pc(i, o, r, n, t[a + 15], 16, 530742520)), - (n = Pc(n, i, o, r, t[a + 2], 23, -995338651)), - (r = Oc(r, n, i, o, t[a], 6, -198630844)), - (o = Oc(o, r, n, i, t[a + 7], 10, 1126891415)), - (i = Oc(i, o, r, n, t[a + 14], 15, -1416354905)), - (n = Oc(n, i, o, r, t[a + 5], 21, -57434055)), - (r = Oc(r, n, i, o, t[a + 12], 6, 1700485571)), - (o = Oc(o, r, n, i, t[a + 3], 10, -1894986606)), - (i = Oc(i, o, r, n, t[a + 10], 15, -1051523)), - (n = Oc(n, i, o, r, t[a + 1], 21, -2054922799)), - (r = Oc(r, n, i, o, t[a + 8], 6, 1873313359)), - (o = Oc(o, r, n, i, t[a + 15], 10, -30611744)), - (i = Oc(i, o, r, n, t[a + 6], 15, -1560198380)), - (n = Oc(n, i, o, r, t[a + 13], 21, 1309151649)), - (r = Oc(r, n, i, o, t[a + 4], 6, -145523070)), - (o = Oc(o, r, n, i, t[a + 11], 10, -1120210379)), - (i = Oc(i, o, r, n, t[a + 2], 15, 718787259)), - (n = Oc(n, i, o, r, t[a + 9], 21, -343485551)), - (r = PS(r, s)), - (n = PS(n, c)), - (i = PS(i, u)), - (o = PS(o, h)); - } - return [r, n, i, o]; - } - function j7t(t) { - if (t.length === 0) return []; - for ( - var e = t.length * 8, r = new Uint32Array(RNe(e)), n = 0; - n < e; - n += 8 - ) - r[n >> 5] |= (t[n / 8] & 255) << n % 32; - return r; - } - function PS(t, e) { - var r = (t & 65535) + (e & 65535), - n = (t >> 16) + (e >> 16) + (r >> 16); - return (n << 16) | (r & 65535); - } - function U7t(t, e) { - return (t << e) | (t >>> (32 - e)); - } - function yG(t, e, r, n, i, o) { - return PS(U7t(PS(PS(e, t), PS(n, o)), i), r); - } - function Tc(t, e, r, n, i, o, a) { - return yG((e & r) | (~e & n), t, e, i, o, a); - } - function kc(t, e, r, n, i, o, a) { - return yG((e & n) | (r & ~n), t, e, i, o, a); - } - function Pc(t, e, r, n, i, o, a) { - return yG(e ^ r ^ n, t, e, i, o, a); - } - function Oc(t, e, r, n, i, o, a) { - return yG(r ^ (e | ~n), t, e, i, o, a); - } - var NNe, - DNe = vs(() => { - m(); - g(); - NNe = L7t; - }); - var K7t, - FNe, - LNe = vs(() => { - m(); - g(); - Wpe(); - DNe(); - (K7t = pG("v3", 48, NNe)), (FNe = K7t); - }); - function H7t(t, e, r) { - t = t || {}; - var n = t.random || (t.rng || BF)(); - if (((n[6] = (n[6] & 15) | 64), (n[8] = (n[8] & 63) | 128), e)) { - r = r || 0; - for (var i = 0; i < 16; ++i) e[r + i] = n[i]; - return e; - } - return kS(n); - } - var qNe, - zNe = vs(() => { - m(); - g(); - jpe(); - CF(); - qNe = H7t; - }); - function V7t(t, e, r, n) { - switch (t) { - case 0: - return (e & r) ^ (~e & n); - case 1: - return e ^ r ^ n; - case 2: - return (e & r) ^ (e & n) ^ (r & n); - case 3: - return e ^ r ^ n; - } - } - function Gpe(t, e) { - return (t << e) | (t >>> (32 - e)); - } - function W7t(t) { - var e = [1518500249, 1859775393, 2400959708, 3395469782], - r = [1732584193, 4023233417, 2562383102, 271733878, 3285377520]; - if (typeof t == "string") { - var n = unescape(encodeURIComponent(t)); - t = []; - for (var i = 0; i < n.length; ++i) t.push(n.charCodeAt(i)); - } else Array.isArray(t) || (t = Array.prototype.slice.call(t)); - t.push(128); - for ( - var o = t.length / 4 + 2, a = Math.ceil(o / 16), s = new Array(a), c = 0; - c < a; - ++c - ) { - for (var u = new Uint32Array(16), h = 0; h < 16; ++h) - u[h] = - (t[c * 64 + h * 4] << 24) | - (t[c * 64 + h * 4 + 1] << 16) | - (t[c * 64 + h * 4 + 2] << 8) | - t[c * 64 + h * 4 + 3]; - s[c] = u; - } - (s[a - 1][14] = ((t.length - 1) * 8) / Math.pow(2, 32)), - (s[a - 1][14] = Math.floor(s[a - 1][14])), - (s[a - 1][15] = ((t.length - 1) * 8) & 4294967295); - for (var w = 0; w < a; ++w) { - for (var M = new Uint32Array(80), k = 0; k < 16; ++k) M[k] = s[w][k]; - for (var O = 16; O < 80; ++O) - M[O] = Gpe(M[O - 3] ^ M[O - 8] ^ M[O - 14] ^ M[O - 16], 1); - for ( - var D = r[0], F = r[1], N = r[2], q = r[3], z = r[4], H = 0; - H < 80; - ++H - ) { - var Z = Math.floor(H / 20), - $ = (Gpe(D, 5) + V7t(Z, F, N, q) + z + e[Z] + M[H]) >>> 0; - (z = q), (q = N), (N = Gpe(F, 30) >>> 0), (F = D), (D = $); - } - (r[0] = (r[0] + D) >>> 0), - (r[1] = (r[1] + F) >>> 0), - (r[2] = (r[2] + N) >>> 0), - (r[3] = (r[3] + q) >>> 0), - (r[4] = (r[4] + z) >>> 0); - } - return [ - (r[0] >> 24) & 255, - (r[0] >> 16) & 255, - (r[0] >> 8) & 255, - r[0] & 255, - (r[1] >> 24) & 255, - (r[1] >> 16) & 255, - (r[1] >> 8) & 255, - r[1] & 255, - (r[2] >> 24) & 255, - (r[2] >> 16) & 255, - (r[2] >> 8) & 255, - r[2] & 255, - (r[3] >> 24) & 255, - (r[3] >> 16) & 255, - (r[3] >> 8) & 255, - r[3] & 255, - (r[4] >> 24) & 255, - (r[4] >> 16) & 255, - (r[4] >> 8) & 255, - r[4] & 255, - ]; - } - var jNe, - UNe = vs(() => { - m(); - g(); - jNe = W7t; - }); - var G7t, - KNe, - HNe = vs(() => { - m(); - g(); - Wpe(); - UNe(); - (G7t = pG("v5", 80, jNe)), (KNe = G7t); - }); - var VNe, - WNe = vs(() => { - m(); - g(); - VNe = "00000000-0000-0000-0000-000000000000"; - }); - function J7t(t) { - if (!TS(t)) throw TypeError("Invalid UUID"); - return parseInt(t.substr(14, 1), 16); - } - var GNe, - JNe = vs(() => { - m(); - g(); - IF(); - GNe = J7t; - }); - var Jpe = {}; - y7e(Jpe, { - NIL: () => VNe, - parse: () => hG, - stringify: () => kS, - v1: () => INe, - v3: () => FNe, - v4: () => qNe, - v5: () => KNe, - validate: () => TS, - version: () => GNe, - }); - var $pe = vs(() => { - m(); - g(); - CNe(); - LNe(); - zNe(); - HNe(); - WNe(); - JNe(); - IF(); - CF(); - Vpe(); - }); - var n9e = I((RF) => { - "use strict"; - m(); - g(); - SF(); - var eNt = to(), - t9e = 60103; - RF.Fragment = 60107; - typeof Symbol == "function" && - Symbol.for && - ((Xpe = Symbol.for), - (t9e = Xpe("react.element")), - (RF.Fragment = Xpe("react.fragment"))); - var Xpe, - tNt = - eNt.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED - .ReactCurrentOwner, - rNt = Object.prototype.hasOwnProperty, - nNt = { key: !0, ref: !0, __self: !0, __source: !0 }; - function r9e(t, e, r) { - var n, - i = {}, - o = null, - a = null; - r !== void 0 && (o = "" + r), - e.key !== void 0 && (o = "" + e.key), - e.ref !== void 0 && (a = e.ref); - for (n in e) rNt.call(e, n) && !nNt.hasOwnProperty(n) && (i[n] = e[n]); - if (t && t.defaultProps) - for (n in ((e = t.defaultProps), e)) i[n] === void 0 && (i[n] = e[n]); - return { - $$typeof: t9e, - type: t, - key: o, - ref: a, - props: i, - _owner: tNt.current, - }; - } - RF.jsx = r9e; - RF.jsxs = r9e; - }); - var OS = I((Van, i9e) => { - "use strict"; - m(); - g(); - i9e.exports = n9e(); - }); - var SLe = I(($0) => { - "use strict"; - m(); - g(); - var xJ = to(), - ea = SF(), - gu = Dpe(); - function Vt(t) { - for ( - var e = "https://reactjs.org/docs/error-decoder.html?invariant=" + t, - r = 1; - r < arguments.length; - r++ - ) - e += "&args[]=" + encodeURIComponent(arguments[r]); - return ( - "Minified React error #" + - t + - "; visit " + - e + - " for the full message or use the non-minified dev environment for full errors and additional helpful warnings." - ); - } - if (!xJ) throw Error(Vt(227)); - var ZDe = new Set(), - gL = {}; - function J3(t, e) { - CI(t, e), CI(t + "Capture", e); - } - function CI(t, e) { - for (gL[t] = e, t = 0; t < e.length; t++) ZDe.add(e[t]); - } - var x_ = !( - typeof window > "u" || - typeof window.document > "u" || - typeof window.document.createElement > "u" - ), - n9t = - /^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/, - L9e = Object.prototype.hasOwnProperty, - q9e = {}, - z9e = {}; - function i9t(t) { - return L9e.call(z9e, t) - ? !0 - : L9e.call(q9e, t) - ? !1 - : n9t.test(t) - ? (z9e[t] = !0) - : ((q9e[t] = !0), !1); - } - function o9t(t, e, r, n) { - if (r !== null && r.type === 0) return !1; - switch (typeof e) { - case "function": - case "symbol": - return !0; - case "boolean": - return n - ? !1 - : r !== null - ? !r.acceptsBooleans - : ((t = t.toLowerCase().slice(0, 5)), - t !== "data-" && t !== "aria-"); - default: - return !1; - } - } - function a9t(t, e, r, n) { - if (e === null || typeof e > "u" || o9t(t, e, r, n)) return !0; - if (n) return !1; - if (r !== null) - switch (r.type) { - case 3: - return !e; - case 4: - return e === !1; - case 5: - return isNaN(e); - case 6: - return isNaN(e) || 1 > e; - } - return !1; - } - function qd(t, e, r, n, i, o, a) { - (this.acceptsBooleans = e === 2 || e === 3 || e === 4), - (this.attributeName = n), - (this.attributeNamespace = i), - (this.mustUseProperty = r), - (this.propertyName = t), - (this.type = e), - (this.sanitizeURL = o), - (this.removeEmptyString = a); - } - var Yu = {}; - "children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style" - .split(" ") - .forEach(function (t) { - Yu[t] = new qd(t, 0, !1, t, null, !1, !1); - }); - [ - ["acceptCharset", "accept-charset"], - ["className", "class"], - ["htmlFor", "for"], - ["httpEquiv", "http-equiv"], - ].forEach(function (t) { - var e = t[0]; - Yu[e] = new qd(e, 1, !1, t[1], null, !1, !1); - }); - ["contentEditable", "draggable", "spellCheck", "value"].forEach(function ( - t - ) { - Yu[t] = new qd(t, 2, !1, t.toLowerCase(), null, !1, !1); - }); - [ - "autoReverse", - "externalResourcesRequired", - "focusable", - "preserveAlpha", - ].forEach(function (t) { - Yu[t] = new qd(t, 2, !1, t, null, !1, !1); - }); - "allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope" - .split(" ") - .forEach(function (t) { - Yu[t] = new qd(t, 3, !1, t.toLowerCase(), null, !1, !1); - }); - ["checked", "multiple", "muted", "selected"].forEach(function (t) { - Yu[t] = new qd(t, 3, !0, t, null, !1, !1); - }); - ["capture", "download"].forEach(function (t) { - Yu[t] = new qd(t, 4, !1, t, null, !1, !1); - }); - ["cols", "rows", "size", "span"].forEach(function (t) { - Yu[t] = new qd(t, 6, !1, t, null, !1, !1); - }); - ["rowSpan", "start"].forEach(function (t) { - Yu[t] = new qd(t, 5, !1, t.toLowerCase(), null, !1, !1); - }); - var hye = /[\-:]([a-z])/g; - function pye(t) { - return t[1].toUpperCase(); - } - "accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height" - .split(" ") - .forEach(function (t) { - var e = t.replace(hye, pye); - Yu[e] = new qd(e, 1, !1, t, null, !1, !1); - }); - "xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type" - .split(" ") - .forEach(function (t) { - var e = t.replace(hye, pye); - Yu[e] = new qd(e, 1, !1, t, "http://www.w3.org/1999/xlink", !1, !1); - }); - ["xml:base", "xml:lang", "xml:space"].forEach(function (t) { - var e = t.replace(hye, pye); - Yu[e] = new qd( - e, - 1, - !1, - t, - "http://www.w3.org/XML/1998/namespace", - !1, - !1 - ); - }); - ["tabIndex", "crossOrigin"].forEach(function (t) { - Yu[t] = new qd(t, 1, !1, t.toLowerCase(), null, !1, !1); - }); - Yu.xlinkHref = new qd( - "xlinkHref", - 1, - !1, - "xlink:href", - "http://www.w3.org/1999/xlink", - !0, - !1 - ); - ["src", "href", "action", "formAction"].forEach(function (t) { - Yu[t] = new qd(t, 1, !1, t.toLowerCase(), null, !0, !0); - }); - function yye(t, e, r, n) { - var i = Yu.hasOwnProperty(e) ? Yu[e] : null, - o = - i !== null - ? i.type === 0 - : n - ? !1 - : !( - !(2 < e.length) || - (e[0] !== "o" && e[0] !== "O") || - (e[1] !== "n" && e[1] !== "N") - ); - o || - (a9t(e, r, i, n) && (r = null), - n || i === null - ? i9t(e) && - (r === null ? t.removeAttribute(e) : t.setAttribute(e, "" + r)) - : i.mustUseProperty - ? (t[i.propertyName] = r === null ? (i.type === 3 ? !1 : "") : r) - : ((e = i.attributeName), - (n = i.attributeNamespace), - r === null - ? t.removeAttribute(e) - : ((i = i.type), - (r = i === 3 || (i === 4 && r === !0) ? "" : "" + r), - n ? t.setAttributeNS(n, e, r) : t.setAttribute(e, r)))); - } - var $3 = xJ.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, - eL = 60103, - q3 = 60106, - IS = 60107, - mye = 60108, - oL = 60114, - gye = 60109, - vye = 60110, - SJ = 60112, - aL = 60113, - QG = 60120, - AJ = 60115, - bye = 60116, - wye = 60121, - _ye = 60128, - XDe = 60129, - xye = 60130, - T0e = 60131; - typeof Symbol == "function" && - Symbol.for && - ((Ks = Symbol.for), - (eL = Ks("react.element")), - (q3 = Ks("react.portal")), - (IS = Ks("react.fragment")), - (mye = Ks("react.strict_mode")), - (oL = Ks("react.profiler")), - (gye = Ks("react.provider")), - (vye = Ks("react.context")), - (SJ = Ks("react.forward_ref")), - (aL = Ks("react.suspense")), - (QG = Ks("react.suspense_list")), - (AJ = Ks("react.memo")), - (bye = Ks("react.lazy")), - (wye = Ks("react.block")), - Ks("react.scope"), - (_ye = Ks("react.opaque.id")), - (XDe = Ks("react.debug_trace_mode")), - (xye = Ks("react.offscreen")), - (T0e = Ks("react.legacy_hidden"))); - var Ks, - j9e = typeof Symbol == "function" && Symbol.iterator; - function UF(t) { - return t === null || typeof t != "object" - ? null - : ((t = (j9e && t[j9e]) || t["@@iterator"]), - typeof t == "function" ? t : null); - } - var o0e; - function tL(t) { - if (o0e === void 0) - try { - throw Error(); - } catch (r) { - var e = r.stack.trim().match(/\n( *(at )?)/); - o0e = (e && e[1]) || ""; - } - return ( - ` -` + - o0e + - t - ); - } - var a0e = !1; - function OG(t, e) { - if (!t || a0e) return ""; - a0e = !0; - var r = Error.prepareStackTrace; - Error.prepareStackTrace = void 0; - try { - if (e) - if ( - ((e = function () { - throw Error(); - }), - Object.defineProperty(e.prototype, "props", { - set: function () { - throw Error(); - }, - }), - typeof Reflect == "object" && Reflect.construct) - ) { - try { - Reflect.construct(e, []); - } catch (c) { - var n = c; - } - Reflect.construct(t, [], e); - } else { - try { - e.call(); - } catch (c) { - n = c; - } - t.call(e.prototype); - } - else { - try { - throw Error(); - } catch (c) { - n = c; - } - t(); - } - } catch (c) { - if (c && n && typeof c.stack == "string") { - for ( - var i = c.stack.split(` -`), - o = n.stack.split(` -`), - a = i.length - 1, - s = o.length - 1; - 1 <= a && 0 <= s && i[a] !== o[s]; - - ) - s--; - for (; 1 <= a && 0 <= s; a--, s--) - if (i[a] !== o[s]) { - if (a !== 1 || s !== 1) - do - if ((a--, s--, 0 > s || i[a] !== o[s])) - return ( - ` -` + i[a].replace(" at new ", " at ") - ); - while (1 <= a && 0 <= s); - break; - } - } - } finally { - (a0e = !1), (Error.prepareStackTrace = r); - } - return (t = t ? t.displayName || t.name : "") ? tL(t) : ""; - } - function s9t(t) { - switch (t.tag) { - case 5: - return tL(t.type); - case 16: - return tL("Lazy"); - case 13: - return tL("Suspense"); - case 19: - return tL("SuspenseList"); - case 0: - case 2: - case 15: - return (t = OG(t.type, !1)), t; - case 11: - return (t = OG(t.type.render, !1)), t; - case 22: - return (t = OG(t.type._render, !1)), t; - case 1: - return (t = OG(t.type, !0)), t; - default: - return ""; - } - } - function SI(t) { - if (t == null) return null; - if (typeof t == "function") return t.displayName || t.name || null; - if (typeof t == "string") return t; - switch (t) { - case IS: - return "Fragment"; - case q3: - return "Portal"; - case oL: - return "Profiler"; - case mye: - return "StrictMode"; - case aL: - return "Suspense"; - case QG: - return "SuspenseList"; - } - if (typeof t == "object") - switch (t.$$typeof) { - case vye: - return (t.displayName || "Context") + ".Consumer"; - case gye: - return (t._context.displayName || "Context") + ".Provider"; - case SJ: - var e = t.render; - return ( - (e = e.displayName || e.name || ""), - t.displayName || - (e !== "" ? "ForwardRef(" + e + ")" : "ForwardRef") - ); - case AJ: - return SI(t.type); - case wye: - return SI(t._render); - case bye: - (e = t._payload), (t = t._init); - try { - return SI(t(e)); - } catch {} - } - return null; - } - function HS(t) { - switch (typeof t) { - case "boolean": - case "number": - case "object": - case "string": - case "undefined": - return t; - default: - return ""; - } - } - function YDe(t) { - var e = t.type; - return ( - (t = t.nodeName) && - t.toLowerCase() === "input" && - (e === "checkbox" || e === "radio") - ); - } - function u9t(t) { - var e = YDe(t) ? "checked" : "value", - r = Object.getOwnPropertyDescriptor(t.constructor.prototype, e), - n = "" + t[e]; - if ( - !t.hasOwnProperty(e) && - typeof r < "u" && - typeof r.get == "function" && - typeof r.set == "function" - ) { - var i = r.get, - o = r.set; - return ( - Object.defineProperty(t, e, { - configurable: !0, - get: function () { - return i.call(this); - }, - set: function (a) { - (n = "" + a), o.call(this, a); - }, - }), - Object.defineProperty(t, e, { enumerable: r.enumerable }), - { - getValue: function () { - return n; - }, - setValue: function (a) { - n = "" + a; - }, - stopTracking: function () { - (t._valueTracker = null), delete t[e]; - }, - } - ); - } - } - function BG(t) { - t._valueTracker || (t._valueTracker = u9t(t)); - } - function QDe(t) { - if (!t) return !1; - var e = t._valueTracker; - if (!e) return !0; - var r = e.getValue(), - n = ""; - return ( - t && (n = YDe(t) ? (t.checked ? "true" : "false") : t.value), - (t = n), - t !== r ? (e.setValue(t), !0) : !1 - ); - } - function eJ(t) { - if ( - ((t = t || (typeof document < "u" ? document : void 0)), typeof t > "u") - ) - return null; - try { - return t.activeElement || t.body; - } catch { - return t.body; - } - } - function k0e(t, e) { - var r = e.checked; - return ea({}, e, { - defaultChecked: void 0, - defaultValue: void 0, - value: void 0, - checked: r ?? t._wrapperState.initialChecked, - }); - } - function U9e(t, e) { - var r = e.defaultValue == null ? "" : e.defaultValue, - n = e.checked != null ? e.checked : e.defaultChecked; - (r = HS(e.value != null ? e.value : r)), - (t._wrapperState = { - initialChecked: n, - initialValue: r, - controlled: - e.type === "checkbox" || e.type === "radio" - ? e.checked != null - : e.value != null, - }); - } - function eFe(t, e) { - (e = e.checked), e != null && yye(t, "checked", e, !1); - } - function P0e(t, e) { - eFe(t, e); - var r = HS(e.value), - n = e.type; - if (r != null) - n === "number" - ? ((r === 0 && t.value === "") || t.value != r) && (t.value = "" + r) - : t.value !== "" + r && (t.value = "" + r); - else if (n === "submit" || n === "reset") { - t.removeAttribute("value"); - return; - } - e.hasOwnProperty("value") - ? O0e(t, e.type, r) - : e.hasOwnProperty("defaultValue") && - O0e(t, e.type, HS(e.defaultValue)), - e.checked == null && - e.defaultChecked != null && - (t.defaultChecked = !!e.defaultChecked); - } - function K9e(t, e, r) { - if (e.hasOwnProperty("value") || e.hasOwnProperty("defaultValue")) { - var n = e.type; - if ( - !( - (n !== "submit" && n !== "reset") || - (e.value !== void 0 && e.value !== null) - ) - ) - return; - (e = "" + t._wrapperState.initialValue), - r || e === t.value || (t.value = e), - (t.defaultValue = e); - } - (r = t.name), - r !== "" && (t.name = ""), - (t.defaultChecked = !!t._wrapperState.initialChecked), - r !== "" && (t.name = r); - } - function O0e(t, e, r) { - (e !== "number" || eJ(t.ownerDocument) !== t) && - (r == null - ? (t.defaultValue = "" + t._wrapperState.initialValue) - : t.defaultValue !== "" + r && (t.defaultValue = "" + r)); - } - function c9t(t) { - var e = ""; - return ( - xJ.Children.forEach(t, function (r) { - r != null && (e += r); - }), - e - ); - } - function B0e(t, e) { - return ( - (t = ea({ children: void 0 }, e)), - (e = c9t(e.children)) && (t.children = e), - t - ); - } - function AI(t, e, r, n) { - if (((t = t.options), e)) { - e = {}; - for (var i = 0; i < r.length; i++) e["$" + r[i]] = !0; - for (r = 0; r < t.length; r++) - (i = e.hasOwnProperty("$" + t[r].value)), - t[r].selected !== i && (t[r].selected = i), - i && n && (t[r].defaultSelected = !0); - } else { - for (r = "" + HS(r), e = null, i = 0; i < t.length; i++) { - if (t[i].value === r) { - (t[i].selected = !0), n && (t[i].defaultSelected = !0); - return; - } - e !== null || t[i].disabled || (e = t[i]); - } - e !== null && (e.selected = !0); - } - } - function I0e(t, e) { - if (e.dangerouslySetInnerHTML != null) throw Error(Vt(91)); - return ea({}, e, { - value: void 0, - defaultValue: void 0, - children: "" + t._wrapperState.initialValue, - }); - } - function H9e(t, e) { - var r = e.value; - if (r == null) { - if (((r = e.children), (e = e.defaultValue), r != null)) { - if (e != null) throw Error(Vt(92)); - if (Array.isArray(r)) { - if (!(1 >= r.length)) throw Error(Vt(93)); - r = r[0]; - } - e = r; - } - e == null && (e = ""), (r = e); - } - t._wrapperState = { initialValue: HS(r) }; - } - function tFe(t, e) { - var r = HS(e.value), - n = HS(e.defaultValue); - r != null && - ((r = "" + r), - r !== t.value && (t.value = r), - e.defaultValue == null && t.defaultValue !== r && (t.defaultValue = r)), - n != null && (t.defaultValue = "" + n); - } - function V9e(t) { - var e = t.textContent; - e === t._wrapperState.initialValue && - e !== "" && - e !== null && - (t.value = e); - } - var C0e = { - html: "http://www.w3.org/1999/xhtml", - mathml: "http://www.w3.org/1998/Math/MathML", - svg: "http://www.w3.org/2000/svg", - }; - function rFe(t) { - switch (t) { - case "svg": - return "http://www.w3.org/2000/svg"; - case "math": - return "http://www.w3.org/1998/Math/MathML"; - default: - return "http://www.w3.org/1999/xhtml"; - } - } - function R0e(t, e) { - return t == null || t === "http://www.w3.org/1999/xhtml" - ? rFe(e) - : t === "http://www.w3.org/2000/svg" && e === "foreignObject" - ? "http://www.w3.org/1999/xhtml" - : t; - } - var IG, - nFe = (function (t) { - return typeof MSApp < "u" && MSApp.execUnsafeLocalFunction - ? function (e, r, n, i) { - MSApp.execUnsafeLocalFunction(function () { - return t(e, r, n, i); - }); - } - : t; - })(function (t, e) { - if (t.namespaceURI !== C0e.svg || "innerHTML" in t) t.innerHTML = e; - else { - for ( - IG = IG || document.createElement("div"), - IG.innerHTML = "" + e.valueOf().toString() + "", - e = IG.firstChild; - t.firstChild; - - ) - t.removeChild(t.firstChild); - for (; e.firstChild; ) t.appendChild(e.firstChild); - } - }); - function vL(t, e) { - if (e) { - var r = t.firstChild; - if (r && r === t.lastChild && r.nodeType === 3) { - r.nodeValue = e; - return; - } - } - t.textContent = e; - } - var sL = { - animationIterationCount: !0, - borderImageOutset: !0, - borderImageSlice: !0, - borderImageWidth: !0, - boxFlex: !0, - boxFlexGroup: !0, - boxOrdinalGroup: !0, - columnCount: !0, - columns: !0, - flex: !0, - flexGrow: !0, - flexPositive: !0, - flexShrink: !0, - flexNegative: !0, - flexOrder: !0, - gridArea: !0, - gridRow: !0, - gridRowEnd: !0, - gridRowSpan: !0, - gridRowStart: !0, - gridColumn: !0, - gridColumnEnd: !0, - gridColumnSpan: !0, - gridColumnStart: !0, - fontWeight: !0, - lineClamp: !0, - lineHeight: !0, - opacity: !0, - order: !0, - orphans: !0, - tabSize: !0, - widows: !0, - zIndex: !0, - zoom: !0, - fillOpacity: !0, - floodOpacity: !0, - stopOpacity: !0, - strokeDasharray: !0, - strokeDashoffset: !0, - strokeMiterlimit: !0, - strokeOpacity: !0, - strokeWidth: !0, - }, - l9t = ["Webkit", "ms", "Moz", "O"]; - Object.keys(sL).forEach(function (t) { - l9t.forEach(function (e) { - (e = e + t.charAt(0).toUpperCase() + t.substring(1)), (sL[e] = sL[t]); - }); - }); - function iFe(t, e, r) { - return e == null || typeof e == "boolean" || e === "" - ? "" - : r || - typeof e != "number" || - e === 0 || - (sL.hasOwnProperty(t) && sL[t]) - ? ("" + e).trim() - : e + "px"; - } - function oFe(t, e) { - t = t.style; - for (var r in e) - if (e.hasOwnProperty(r)) { - var n = r.indexOf("--") === 0, - i = iFe(r, e[r], n); - r === "float" && (r = "cssFloat"), - n ? t.setProperty(r, i) : (t[r] = i); - } - } - var f9t = ea( - { menuitem: !0 }, - { - area: !0, - base: !0, - br: !0, - col: !0, - embed: !0, - hr: !0, - img: !0, - input: !0, - keygen: !0, - link: !0, - meta: !0, - param: !0, - source: !0, - track: !0, - wbr: !0, - } - ); - function N0e(t, e) { - if (e) { - if (f9t[t] && (e.children != null || e.dangerouslySetInnerHTML != null)) - throw Error(Vt(137, t)); - if (e.dangerouslySetInnerHTML != null) { - if (e.children != null) throw Error(Vt(60)); - if ( - !( - typeof e.dangerouslySetInnerHTML == "object" && - "__html" in e.dangerouslySetInnerHTML - ) - ) - throw Error(Vt(61)); - } - if (e.style != null && typeof e.style != "object") throw Error(Vt(62)); - } - } - function D0e(t, e) { - if (t.indexOf("-") === -1) return typeof e.is == "string"; - switch (t) { - case "annotation-xml": - case "color-profile": - case "font-face": - case "font-face-src": - case "font-face-uri": - case "font-face-format": - case "font-face-name": - case "missing-glyph": - return !1; - default: - return !0; - } - } - function Sye(t) { - return ( - (t = t.target || t.srcElement || window), - t.correspondingUseElement && (t = t.correspondingUseElement), - t.nodeType === 3 ? t.parentNode : t - ); - } - var F0e = null, - EI = null, - MI = null; - function W9e(t) { - if ((t = IL(t))) { - if (typeof F0e != "function") throw Error(Vt(280)); - var e = t.stateNode; - e && ((e = OJ(e)), F0e(t.stateNode, t.type, e)); - } - } - function aFe(t) { - EI ? (MI ? MI.push(t) : (MI = [t])) : (EI = t); - } - function sFe() { - if (EI) { - var t = EI, - e = MI; - if (((MI = EI = null), W9e(t), e)) - for (t = 0; t < e.length; t++) W9e(e[t]); - } - } - function Aye(t, e) { - return t(e); - } - function uFe(t, e, r, n, i) { - return t(e, r, n, i); - } - function Eye() {} - var cFe = Aye, - z3 = !1, - s0e = !1; - function Mye() { - (EI !== null || MI !== null) && (Eye(), sFe()); - } - function d9t(t, e, r) { - if (s0e) return t(e, r); - s0e = !0; - try { - return cFe(t, e, r); - } finally { - (s0e = !1), Mye(); - } - } - function bL(t, e) { - var r = t.stateNode; - if (r === null) return null; - var n = OJ(r); - if (n === null) return null; - r = n[e]; - e: switch (e) { - case "onClick": - case "onClickCapture": - case "onDoubleClick": - case "onDoubleClickCapture": - case "onMouseDown": - case "onMouseDownCapture": - case "onMouseMove": - case "onMouseMoveCapture": - case "onMouseUp": - case "onMouseUpCapture": - case "onMouseEnter": - (n = !n.disabled) || - ((t = t.type), - (n = !( - t === "button" || - t === "input" || - t === "select" || - t === "textarea" - ))), - (t = !n); - break e; - default: - t = !1; - } - if (t) return null; - if (r && typeof r != "function") throw Error(Vt(231, e, typeof r)); - return r; - } - var L0e = !1; - if (x_) - try { - (hI = {}), - Object.defineProperty(hI, "passive", { - get: function () { - L0e = !0; - }, - }), - window.addEventListener("test", hI, hI), - window.removeEventListener("test", hI, hI); - } catch { - L0e = !1; - } - var hI; - function h9t(t, e, r, n, i, o, a, s, c) { - var u = Array.prototype.slice.call(arguments, 3); - try { - e.apply(r, u); - } catch (h) { - this.onError(h); - } - } - var uL = !1, - tJ = null, - rJ = !1, - q0e = null, - p9t = { - onError: function (t) { - (uL = !0), (tJ = t); - }, - }; - function y9t(t, e, r, n, i, o, a, s, c) { - (uL = !1), (tJ = null), h9t.apply(p9t, arguments); - } - function m9t(t, e, r, n, i, o, a, s, c) { - if ((y9t.apply(this, arguments), uL)) { - if (uL) { - var u = tJ; - (uL = !1), (tJ = null); - } else throw Error(Vt(198)); - rJ || ((rJ = !0), (q0e = u)); - } - } - function Z3(t) { - var e = t, - r = t; - if (t.alternate) for (; e.return; ) e = e.return; - else { - t = e; - do (e = t), (e.flags & 1026) !== 0 && (r = e.return), (t = e.return); - while (t); - } - return e.tag === 3 ? r : null; - } - function lFe(t) { - if (t.tag === 13) { - var e = t.memoizedState; - if ( - (e === null && - ((t = t.alternate), t !== null && (e = t.memoizedState)), - e !== null) - ) - return e.dehydrated; - } - return null; - } - function G9e(t) { - if (Z3(t) !== t) throw Error(Vt(188)); - } - function g9t(t) { - var e = t.alternate; - if (!e) { - if (((e = Z3(t)), e === null)) throw Error(Vt(188)); - return e !== t ? null : t; - } - for (var r = t, n = e; ; ) { - var i = r.return; - if (i === null) break; - var o = i.alternate; - if (o === null) { - if (((n = i.return), n !== null)) { - r = n; - continue; - } - break; - } - if (i.child === o.child) { - for (o = i.child; o; ) { - if (o === r) return G9e(i), t; - if (o === n) return G9e(i), e; - o = o.sibling; - } - throw Error(Vt(188)); - } - if (r.return !== n.return) (r = i), (n = o); - else { - for (var a = !1, s = i.child; s; ) { - if (s === r) { - (a = !0), (r = i), (n = o); - break; - } - if (s === n) { - (a = !0), (n = i), (r = o); - break; - } - s = s.sibling; - } - if (!a) { - for (s = o.child; s; ) { - if (s === r) { - (a = !0), (r = o), (n = i); - break; - } - if (s === n) { - (a = !0), (n = o), (r = i); - break; - } - s = s.sibling; - } - if (!a) throw Error(Vt(189)); - } - } - if (r.alternate !== n) throw Error(Vt(190)); - } - if (r.tag !== 3) throw Error(Vt(188)); - return r.stateNode.current === r ? t : e; - } - function fFe(t) { - if (((t = g9t(t)), !t)) return null; - for (var e = t; ; ) { - if (e.tag === 5 || e.tag === 6) return e; - if (e.child) (e.child.return = e), (e = e.child); - else { - if (e === t) break; - for (; !e.sibling; ) { - if (!e.return || e.return === t) return null; - e = e.return; - } - (e.sibling.return = e.return), (e = e.sibling); - } - } - return null; - } - function J9e(t, e) { - for (var r = t.alternate; e !== null; ) { - if (e === t || e === r) return !0; - e = e.return; - } - return !1; - } - var dFe, - Tye, - hFe, - pFe, - z0e = !1, - Qg = [], - DS = null, - FS = null, - LS = null, - wL = new Map(), - _L = new Map(), - KF = [], - $9e = - "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split( - " " - ); - function j0e(t, e, r, n, i) { - return { - blockedOn: t, - domEventName: e, - eventSystemFlags: r | 16, - nativeEvent: i, - targetContainers: [n], - }; - } - function Z9e(t, e) { - switch (t) { - case "focusin": - case "focusout": - DS = null; - break; - case "dragenter": - case "dragleave": - FS = null; - break; - case "mouseover": - case "mouseout": - LS = null; - break; - case "pointerover": - case "pointerout": - wL.delete(e.pointerId); - break; - case "gotpointercapture": - case "lostpointercapture": - _L.delete(e.pointerId); - } - } - function HF(t, e, r, n, i, o) { - return t === null || t.nativeEvent !== o - ? ((t = j0e(e, r, n, i, o)), - e !== null && ((e = IL(e)), e !== null && Tye(e)), - t) - : ((t.eventSystemFlags |= n), - (e = t.targetContainers), - i !== null && e.indexOf(i) === -1 && e.push(i), - t); - } - function v9t(t, e, r, n, i) { - switch (e) { - case "focusin": - return (DS = HF(DS, t, e, r, n, i)), !0; - case "dragenter": - return (FS = HF(FS, t, e, r, n, i)), !0; - case "mouseover": - return (LS = HF(LS, t, e, r, n, i)), !0; - case "pointerover": - var o = i.pointerId; - return wL.set(o, HF(wL.get(o) || null, t, e, r, n, i)), !0; - case "gotpointercapture": - return ( - (o = i.pointerId), - _L.set(o, HF(_L.get(o) || null, t, e, r, n, i)), - !0 - ); - } - return !1; - } - function b9t(t) { - var e = j3(t.target); - if (e !== null) { - var r = Z3(e); - if (r !== null) { - if (((e = r.tag), e === 13)) { - if (((e = lFe(r)), e !== null)) { - (t.blockedOn = e), - pFe(t.lanePriority, function () { - gu.unstable_runWithPriority(t.priority, function () { - hFe(r); - }); - }); - return; - } - } else if (e === 3 && r.stateNode.hydrate) { - t.blockedOn = r.tag === 3 ? r.stateNode.containerInfo : null; - return; - } - } - } - t.blockedOn = null; - } - function KG(t) { - if (t.blockedOn !== null) return !1; - for (var e = t.targetContainers; 0 < e.length; ) { - var r = Bye(t.domEventName, t.eventSystemFlags, e[0], t.nativeEvent); - if (r !== null) - return (e = IL(r)), e !== null && Tye(e), (t.blockedOn = r), !1; - e.shift(); - } - return !0; - } - function X9e(t, e, r) { - KG(t) && r.delete(e); - } - function w9t() { - for (z0e = !1; 0 < Qg.length; ) { - var t = Qg[0]; - if (t.blockedOn !== null) { - (t = IL(t.blockedOn)), t !== null && dFe(t); - break; - } - for (var e = t.targetContainers; 0 < e.length; ) { - var r = Bye(t.domEventName, t.eventSystemFlags, e[0], t.nativeEvent); - if (r !== null) { - t.blockedOn = r; - break; - } - e.shift(); - } - t.blockedOn === null && Qg.shift(); - } - DS !== null && KG(DS) && (DS = null), - FS !== null && KG(FS) && (FS = null), - LS !== null && KG(LS) && (LS = null), - wL.forEach(X9e), - _L.forEach(X9e); - } - function VF(t, e) { - t.blockedOn === e && - ((t.blockedOn = null), - z0e || - ((z0e = !0), - gu.unstable_scheduleCallback(gu.unstable_NormalPriority, w9t))); - } - function yFe(t) { - function e(i) { - return VF(i, t); - } - if (0 < Qg.length) { - VF(Qg[0], t); - for (var r = 1; r < Qg.length; r++) { - var n = Qg[r]; - n.blockedOn === t && (n.blockedOn = null); - } - } - for ( - DS !== null && VF(DS, t), - FS !== null && VF(FS, t), - LS !== null && VF(LS, t), - wL.forEach(e), - _L.forEach(e), - r = 0; - r < KF.length; - r++ - ) - (n = KF[r]), n.blockedOn === t && (n.blockedOn = null); - for (; 0 < KF.length && ((r = KF[0]), r.blockedOn === null); ) - b9t(r), r.blockedOn === null && KF.shift(); - } - function CG(t, e) { - var r = {}; - return ( - (r[t.toLowerCase()] = e.toLowerCase()), - (r["Webkit" + t] = "webkit" + e), - (r["Moz" + t] = "moz" + e), - r - ); - } - var gI = { - animationend: CG("Animation", "AnimationEnd"), - animationiteration: CG("Animation", "AnimationIteration"), - animationstart: CG("Animation", "AnimationStart"), - transitionend: CG("Transition", "TransitionEnd"), - }, - u0e = {}, - mFe = {}; - x_ && - ((mFe = document.createElement("div").style), - "AnimationEvent" in window || - (delete gI.animationend.animation, - delete gI.animationiteration.animation, - delete gI.animationstart.animation), - "TransitionEvent" in window || delete gI.transitionend.transition); - function EJ(t) { - if (u0e[t]) return u0e[t]; - if (!gI[t]) return t; - var e = gI[t], - r; - for (r in e) if (e.hasOwnProperty(r) && r in mFe) return (u0e[t] = e[r]); - return t; - } - var gFe = EJ("animationend"), - vFe = EJ("animationiteration"), - bFe = EJ("animationstart"), - wFe = EJ("transitionend"), - _Fe = new Map(), - kye = new Map(), - _9t = [ - "abort", - "abort", - gFe, - "animationEnd", - vFe, - "animationIteration", - bFe, - "animationStart", - "canplay", - "canPlay", - "canplaythrough", - "canPlayThrough", - "durationchange", - "durationChange", - "emptied", - "emptied", - "encrypted", - "encrypted", - "ended", - "ended", - "error", - "error", - "gotpointercapture", - "gotPointerCapture", - "load", - "load", - "loadeddata", - "loadedData", - "loadedmetadata", - "loadedMetadata", - "loadstart", - "loadStart", - "lostpointercapture", - "lostPointerCapture", - "playing", - "playing", - "progress", - "progress", - "seeking", - "seeking", - "stalled", - "stalled", - "suspend", - "suspend", - "timeupdate", - "timeUpdate", - wFe, - "transitionEnd", - "waiting", - "waiting", - ]; - function Pye(t, e) { - for (var r = 0; r < t.length; r += 2) { - var n = t[r], - i = t[r + 1]; - (i = "on" + (i[0].toUpperCase() + i.slice(1))), - kye.set(n, e), - _Fe.set(n, i), - J3(i, [n]); - } - } - var x9t = gu.unstable_now; - x9t(); - var Po = 8; - function yI(t) { - if ((1 & t) !== 0) return (Po = 15), 1; - if ((2 & t) !== 0) return (Po = 14), 2; - if ((4 & t) !== 0) return (Po = 13), 4; - var e = 24 & t; - return e !== 0 - ? ((Po = 12), e) - : (t & 32) !== 0 - ? ((Po = 11), 32) - : ((e = 192 & t), - e !== 0 - ? ((Po = 10), e) - : (t & 256) !== 0 - ? ((Po = 9), 256) - : ((e = 3584 & t), - e !== 0 - ? ((Po = 8), e) - : (t & 4096) !== 0 - ? ((Po = 7), 4096) - : ((e = 4186112 & t), - e !== 0 - ? ((Po = 6), e) - : ((e = 62914560 & t), - e !== 0 - ? ((Po = 5), e) - : t & 67108864 - ? ((Po = 4), 67108864) - : (t & 134217728) !== 0 - ? ((Po = 3), 134217728) - : ((e = 805306368 & t), - e !== 0 - ? ((Po = 2), e) - : (1073741824 & t) !== 0 - ? ((Po = 1), 1073741824) - : ((Po = 8), t)))))); - } - function S9t(t) { - switch (t) { - case 99: - return 15; - case 98: - return 10; - case 97: - case 96: - return 8; - case 95: - return 2; - default: - return 0; - } - } - function A9t(t) { - switch (t) { - case 15: - case 14: - return 99; - case 13: - case 12: - case 11: - case 10: - return 98; - case 9: - case 8: - case 7: - case 6: - case 4: - case 5: - return 97; - case 3: - case 2: - case 1: - return 95; - case 0: - return 90; - default: - throw Error(Vt(358, t)); - } - } - function xL(t, e) { - var r = t.pendingLanes; - if (r === 0) return (Po = 0); - var n = 0, - i = 0, - o = t.expiredLanes, - a = t.suspendedLanes, - s = t.pingedLanes; - if (o !== 0) (n = o), (i = Po = 15); - else if (((o = r & 134217727), o !== 0)) { - var c = o & ~a; - c !== 0 - ? ((n = yI(c)), (i = Po)) - : ((s &= o), s !== 0 && ((n = yI(s)), (i = Po))); - } else - (o = r & ~a), - o !== 0 - ? ((n = yI(o)), (i = Po)) - : s !== 0 && ((n = yI(s)), (i = Po)); - if (n === 0) return 0; - if ( - ((n = 31 - VS(n)), - (n = r & (((0 > n ? 0 : 1 << n) << 1) - 1)), - e !== 0 && e !== n && (e & a) === 0) - ) { - if ((yI(e), i <= Po)) return e; - Po = i; - } - if (((e = t.entangledLanes), e !== 0)) - for (t = t.entanglements, e &= n; 0 < e; ) - (r = 31 - VS(e)), (i = 1 << r), (n |= t[r]), (e &= ~i); - return n; - } - function xFe(t) { - return ( - (t = t.pendingLanes & -1073741825), - t !== 0 ? t : t & 1073741824 ? 1073741824 : 0 - ); - } - function nJ(t, e) { - switch (t) { - case 15: - return 1; - case 14: - return 2; - case 12: - return (t = mI(24 & ~e)), t === 0 ? nJ(10, e) : t; - case 10: - return (t = mI(192 & ~e)), t === 0 ? nJ(8, e) : t; - case 8: - return ( - (t = mI(3584 & ~e)), - t === 0 && ((t = mI(4186112 & ~e)), t === 0 && (t = 512)), - t - ); - case 2: - return (e = mI(805306368 & ~e)), e === 0 && (e = 268435456), e; - } - throw Error(Vt(358, t)); - } - function mI(t) { - return t & -t; - } - function c0e(t) { - for (var e = [], r = 0; 31 > r; r++) e.push(t); - return e; - } - function MJ(t, e, r) { - t.pendingLanes |= e; - var n = e - 1; - (t.suspendedLanes &= n), - (t.pingedLanes &= n), - (t = t.eventTimes), - (e = 31 - VS(e)), - (t[e] = r); - } - var VS = Math.clz32 ? Math.clz32 : T9t, - E9t = Math.log, - M9t = Math.LN2; - function T9t(t) { - return t === 0 ? 32 : (31 - ((E9t(t) / M9t) | 0)) | 0; - } - var k9t = gu.unstable_UserBlockingPriority, - P9t = gu.unstable_runWithPriority, - HG = !0; - function O9t(t, e, r, n) { - z3 || Eye(); - var i = Oye, - o = z3; - z3 = !0; - try { - uFe(i, t, e, r, n); - } finally { - (z3 = o) || Mye(); - } - } - function B9t(t, e, r, n) { - P9t(k9t, Oye.bind(null, t, e, r, n)); - } - function Oye(t, e, r, n) { - if (HG) { - var i; - if ((i = (e & 4) === 0) && 0 < Qg.length && -1 < $9e.indexOf(t)) - (t = j0e(null, t, e, r, n)), Qg.push(t); - else { - var o = Bye(t, e, r, n); - if (o === null) i && Z9e(t, n); - else { - if (i) { - if (-1 < $9e.indexOf(t)) { - (t = j0e(o, t, e, r, n)), Qg.push(t); - return; - } - if (v9t(o, t, e, r, n)) return; - Z9e(t, n); - } - NFe(t, e, n, null, r); - } - } - } - } - function Bye(t, e, r, n) { - var i = Sye(n); - if (((i = j3(i)), i !== null)) { - var o = Z3(i); - if (o === null) i = null; - else { - var a = o.tag; - if (a === 13) { - if (((i = lFe(o)), i !== null)) return i; - i = null; - } else if (a === 3) { - if (o.stateNode.hydrate) - return o.tag === 3 ? o.stateNode.containerInfo : null; - i = null; - } else o !== i && (i = null); - } - } - return NFe(t, e, n, i, r), null; - } - var CS = null, - Iye = null, - VG = null; - function SFe() { - if (VG) return VG; - var t, - e = Iye, - r = e.length, - n, - i = "value" in CS ? CS.value : CS.textContent, - o = i.length; - for (t = 0; t < r && e[t] === i[t]; t++); - var a = r - t; - for (n = 1; n <= a && e[r - n] === i[o - n]; n++); - return (VG = i.slice(t, 1 < n ? 1 - n : void 0)); - } - function WG(t) { - var e = t.keyCode; - return ( - "charCode" in t - ? ((t = t.charCode), t === 0 && e === 13 && (t = 13)) - : (t = e), - t === 10 && (t = 13), - 32 <= t || t === 13 ? t : 0 - ); - } - function RG() { - return !0; - } - function Y9e() { - return !1; - } - function Ip(t) { - function e(r, n, i, o, a) { - (this._reactName = r), - (this._targetInst = i), - (this.type = n), - (this.nativeEvent = o), - (this.target = a), - (this.currentTarget = null); - for (var s in t) - t.hasOwnProperty(s) && ((r = t[s]), (this[s] = r ? r(o) : o[s])); - return ( - (this.isDefaultPrevented = ( - o.defaultPrevented != null - ? o.defaultPrevented - : o.returnValue === !1 - ) - ? RG - : Y9e), - (this.isPropagationStopped = Y9e), - this - ); - } - return ( - ea(e.prototype, { - preventDefault: function () { - this.defaultPrevented = !0; - var r = this.nativeEvent; - r && - (r.preventDefault - ? r.preventDefault() - : typeof r.returnValue != "unknown" && (r.returnValue = !1), - (this.isDefaultPrevented = RG)); - }, - stopPropagation: function () { - var r = this.nativeEvent; - r && - (r.stopPropagation - ? r.stopPropagation() - : typeof r.cancelBubble != "unknown" && (r.cancelBubble = !0), - (this.isPropagationStopped = RG)); - }, - persist: function () {}, - isPersistent: RG, - }), - e - ); - } - var FI = { - eventPhase: 0, - bubbles: 0, - cancelable: 0, - timeStamp: function (t) { - return t.timeStamp || Date.now(); - }, - defaultPrevented: 0, - isTrusted: 0, - }, - Cye = Ip(FI), - BL = ea({}, FI, { view: 0, detail: 0 }), - I9t = Ip(BL), - l0e, - f0e, - WF, - TJ = ea({}, BL, { - screenX: 0, - screenY: 0, - clientX: 0, - clientY: 0, - pageX: 0, - pageY: 0, - ctrlKey: 0, - shiftKey: 0, - altKey: 0, - metaKey: 0, - getModifierState: Rye, - button: 0, - buttons: 0, - relatedTarget: function (t) { - return t.relatedTarget === void 0 - ? t.fromElement === t.srcElement - ? t.toElement - : t.fromElement - : t.relatedTarget; - }, - movementX: function (t) { - return "movementX" in t - ? t.movementX - : (t !== WF && - (WF && t.type === "mousemove" - ? ((l0e = t.screenX - WF.screenX), - (f0e = t.screenY - WF.screenY)) - : (f0e = l0e = 0), - (WF = t)), - l0e); - }, - movementY: function (t) { - return "movementY" in t ? t.movementY : f0e; - }, - }), - Q9e = Ip(TJ), - C9t = ea({}, TJ, { dataTransfer: 0 }), - R9t = Ip(C9t), - N9t = ea({}, BL, { relatedTarget: 0 }), - d0e = Ip(N9t), - D9t = ea({}, FI, { animationName: 0, elapsedTime: 0, pseudoElement: 0 }), - F9t = Ip(D9t), - L9t = ea({}, FI, { - clipboardData: function (t) { - return "clipboardData" in t ? t.clipboardData : window.clipboardData; - }, - }), - q9t = Ip(L9t), - z9t = ea({}, FI, { data: 0 }), - eDe = Ip(z9t), - j9t = { - Esc: "Escape", - Spacebar: " ", - Left: "ArrowLeft", - Up: "ArrowUp", - Right: "ArrowRight", - Down: "ArrowDown", - Del: "Delete", - Win: "OS", - Menu: "ContextMenu", - Apps: "ContextMenu", - Scroll: "ScrollLock", - MozPrintableKey: "Unidentified", - }, - U9t = { - 8: "Backspace", - 9: "Tab", - 12: "Clear", - 13: "Enter", - 16: "Shift", - 17: "Control", - 18: "Alt", - 19: "Pause", - 20: "CapsLock", - 27: "Escape", - 32: " ", - 33: "PageUp", - 34: "PageDown", - 35: "End", - 36: "Home", - 37: "ArrowLeft", - 38: "ArrowUp", - 39: "ArrowRight", - 40: "ArrowDown", - 45: "Insert", - 46: "Delete", - 112: "F1", - 113: "F2", - 114: "F3", - 115: "F4", - 116: "F5", - 117: "F6", - 118: "F7", - 119: "F8", - 120: "F9", - 121: "F10", - 122: "F11", - 123: "F12", - 144: "NumLock", - 145: "ScrollLock", - 224: "Meta", - }, - K9t = { - Alt: "altKey", - Control: "ctrlKey", - Meta: "metaKey", - Shift: "shiftKey", - }; - function H9t(t) { - var e = this.nativeEvent; - return e.getModifierState - ? e.getModifierState(t) - : (t = K9t[t]) - ? !!e[t] - : !1; - } - function Rye() { - return H9t; - } - var V9t = ea({}, BL, { - key: function (t) { - if (t.key) { - var e = j9t[t.key] || t.key; - if (e !== "Unidentified") return e; - } - return t.type === "keypress" - ? ((t = WG(t)), t === 13 ? "Enter" : String.fromCharCode(t)) - : t.type === "keydown" || t.type === "keyup" - ? U9t[t.keyCode] || "Unidentified" - : ""; - }, - code: 0, - location: 0, - ctrlKey: 0, - shiftKey: 0, - altKey: 0, - metaKey: 0, - repeat: 0, - locale: 0, - getModifierState: Rye, - charCode: function (t) { - return t.type === "keypress" ? WG(t) : 0; - }, - keyCode: function (t) { - return t.type === "keydown" || t.type === "keyup" ? t.keyCode : 0; - }, - which: function (t) { - return t.type === "keypress" - ? WG(t) - : t.type === "keydown" || t.type === "keyup" - ? t.keyCode - : 0; - }, - }), - W9t = Ip(V9t), - G9t = ea({}, TJ, { - pointerId: 0, - width: 0, - height: 0, - pressure: 0, - tangentialPressure: 0, - tiltX: 0, - tiltY: 0, - twist: 0, - pointerType: 0, - isPrimary: 0, - }), - tDe = Ip(G9t), - J9t = ea({}, BL, { - touches: 0, - targetTouches: 0, - changedTouches: 0, - altKey: 0, - metaKey: 0, - ctrlKey: 0, - shiftKey: 0, - getModifierState: Rye, - }), - $9t = Ip(J9t), - Z9t = ea({}, FI, { propertyName: 0, elapsedTime: 0, pseudoElement: 0 }), - X9t = Ip(Z9t), - Y9t = ea({}, TJ, { - deltaX: function (t) { - return "deltaX" in t - ? t.deltaX - : "wheelDeltaX" in t - ? -t.wheelDeltaX - : 0; - }, - deltaY: function (t) { - return "deltaY" in t - ? t.deltaY - : "wheelDeltaY" in t - ? -t.wheelDeltaY - : "wheelDelta" in t - ? -t.wheelDelta - : 0; - }, - deltaZ: 0, - deltaMode: 0, - }), - Q9t = Ip(Y9t), - eDt = [9, 13, 27, 32], - Nye = x_ && "CompositionEvent" in window, - cL = null; - x_ && "documentMode" in document && (cL = document.documentMode); - var tDt = x_ && "TextEvent" in window && !cL, - AFe = x_ && (!Nye || (cL && 8 < cL && 11 >= cL)), - rDe = String.fromCharCode(32), - nDe = !1; - function EFe(t, e) { - switch (t) { - case "keyup": - return eDt.indexOf(e.keyCode) !== -1; - case "keydown": - return e.keyCode !== 229; - case "keypress": - case "mousedown": - case "focusout": - return !0; - default: - return !1; - } - } - function MFe(t) { - return ( - (t = t.detail), typeof t == "object" && "data" in t ? t.data : null - ); - } - var vI = !1; - function rDt(t, e) { - switch (t) { - case "compositionend": - return MFe(e); - case "keypress": - return e.which !== 32 ? null : ((nDe = !0), rDe); - case "textInput": - return (t = e.data), t === rDe && nDe ? null : t; - default: - return null; - } - } - function nDt(t, e) { - if (vI) - return t === "compositionend" || (!Nye && EFe(t, e)) - ? ((t = SFe()), (VG = Iye = CS = null), (vI = !1), t) - : null; - switch (t) { - case "paste": - return null; - case "keypress": - if ( - !(e.ctrlKey || e.altKey || e.metaKey) || - (e.ctrlKey && e.altKey) - ) { - if (e.char && 1 < e.char.length) return e.char; - if (e.which) return String.fromCharCode(e.which); - } - return null; - case "compositionend": - return AFe && e.locale !== "ko" ? null : e.data; - default: - return null; - } - } - var iDt = { - color: !0, - date: !0, - datetime: !0, - "datetime-local": !0, - email: !0, - month: !0, - number: !0, - password: !0, - range: !0, - search: !0, - tel: !0, - text: !0, - time: !0, - url: !0, - week: !0, - }; - function iDe(t) { - var e = t && t.nodeName && t.nodeName.toLowerCase(); - return e === "input" ? !!iDt[t.type] : e === "textarea"; - } - function TFe(t, e, r, n) { - aFe(n), - (e = iJ(e, "onChange")), - 0 < e.length && - ((r = new Cye("onChange", "change", null, r, n)), - t.push({ event: r, listeners: e })); - } - var lL = null, - SL = null; - function oDt(t) { - IFe(t, 0); - } - function kJ(t) { - var e = wI(t); - if (QDe(e)) return t; - } - function aDt(t, e) { - if (t === "change") return e; - } - var kFe = !1; - x_ && - (x_ - ? ((DG = "oninput" in document), - DG || - ((h0e = document.createElement("div")), - h0e.setAttribute("oninput", "return;"), - (DG = typeof h0e.oninput == "function")), - (NG = DG)) - : (NG = !1), - (kFe = NG && (!document.documentMode || 9 < document.documentMode))); - var NG, DG, h0e; - function oDe() { - lL && (lL.detachEvent("onpropertychange", PFe), (SL = lL = null)); - } - function PFe(t) { - if (t.propertyName === "value" && kJ(SL)) { - var e = []; - if ((TFe(e, SL, t, Sye(t)), (t = oDt), z3)) t(e); - else { - z3 = !0; - try { - Aye(t, e); - } finally { - (z3 = !1), Mye(); - } - } - } - } - function sDt(t, e, r) { - t === "focusin" - ? (oDe(), (lL = e), (SL = r), lL.attachEvent("onpropertychange", PFe)) - : t === "focusout" && oDe(); - } - function uDt(t) { - if (t === "selectionchange" || t === "keyup" || t === "keydown") - return kJ(SL); - } - function cDt(t, e) { - if (t === "click") return kJ(e); - } - function lDt(t, e) { - if (t === "input" || t === "change") return kJ(e); - } - function fDt(t, e) { - return (t === e && (t !== 0 || 1 / t === 1 / e)) || (t !== t && e !== e); - } - var H0 = typeof Object.is == "function" ? Object.is : fDt, - dDt = Object.prototype.hasOwnProperty; - function AL(t, e) { - if (H0(t, e)) return !0; - if ( - typeof t != "object" || - t === null || - typeof e != "object" || - e === null - ) - return !1; - var r = Object.keys(t), - n = Object.keys(e); - if (r.length !== n.length) return !1; - for (n = 0; n < r.length; n++) - if (!dDt.call(e, r[n]) || !H0(t[r[n]], e[r[n]])) return !1; - return !0; - } - function aDe(t) { - for (; t && t.firstChild; ) t = t.firstChild; - return t; - } - function sDe(t, e) { - var r = aDe(t); - t = 0; - for (var n; r; ) { - if (r.nodeType === 3) { - if (((n = t + r.textContent.length), t <= e && n >= e)) - return { node: r, offset: e - t }; - t = n; - } - e: { - for (; r; ) { - if (r.nextSibling) { - r = r.nextSibling; - break e; - } - r = r.parentNode; - } - r = void 0; - } - r = aDe(r); - } - } - function OFe(t, e) { - return t && e - ? t === e - ? !0 - : t && t.nodeType === 3 - ? !1 - : e && e.nodeType === 3 - ? OFe(t, e.parentNode) - : "contains" in t - ? t.contains(e) - : t.compareDocumentPosition - ? !!(t.compareDocumentPosition(e) & 16) - : !1 - : !1; - } - function uDe() { - for (var t = window, e = eJ(); e instanceof t.HTMLIFrameElement; ) { - try { - var r = typeof e.contentWindow.location.href == "string"; - } catch { - r = !1; - } - if (r) t = e.contentWindow; - else break; - e = eJ(t.document); - } - return e; - } - function U0e(t) { - var e = t && t.nodeName && t.nodeName.toLowerCase(); - return ( - e && - ((e === "input" && - (t.type === "text" || - t.type === "search" || - t.type === "tel" || - t.type === "url" || - t.type === "password")) || - e === "textarea" || - t.contentEditable === "true") - ); - } - var hDt = x_ && "documentMode" in document && 11 >= document.documentMode, - bI = null, - K0e = null, - fL = null, - H0e = !1; - function cDe(t, e, r) { - var n = - r.window === r ? r.document : r.nodeType === 9 ? r : r.ownerDocument; - H0e || - bI == null || - bI !== eJ(n) || - ((n = bI), - "selectionStart" in n && U0e(n) - ? (n = { start: n.selectionStart, end: n.selectionEnd }) - : ((n = ( - (n.ownerDocument && n.ownerDocument.defaultView) || - window - ).getSelection()), - (n = { - anchorNode: n.anchorNode, - anchorOffset: n.anchorOffset, - focusNode: n.focusNode, - focusOffset: n.focusOffset, - })), - (fL && AL(fL, n)) || - ((fL = n), - (n = iJ(K0e, "onSelect")), - 0 < n.length && - ((e = new Cye("onSelect", "select", null, e, r)), - t.push({ event: e, listeners: n }), - (e.target = bI)))); - } - Pye( - "cancel cancel click click close close contextmenu contextMenu copy copy cut cut auxclick auxClick dblclick doubleClick dragend dragEnd dragstart dragStart drop drop focusin focus focusout blur input input invalid invalid keydown keyDown keypress keyPress keyup keyUp mousedown mouseDown mouseup mouseUp paste paste pause pause play play pointercancel pointerCancel pointerdown pointerDown pointerup pointerUp ratechange rateChange reset reset seeked seeked submit submit touchcancel touchCancel touchend touchEnd touchstart touchStart volumechange volumeChange".split( - " " - ), - 0 - ); - Pye( - "drag drag dragenter dragEnter dragexit dragExit dragleave dragLeave dragover dragOver mousemove mouseMove mouseout mouseOut mouseover mouseOver pointermove pointerMove pointerout pointerOut pointerover pointerOver scroll scroll toggle toggle touchmove touchMove wheel wheel".split( - " " - ), - 1 - ); - Pye(_9t, 2); - for ( - p0e = - "change selectionchange textInput compositionstart compositionend compositionupdate".split( - " " - ), - FG = 0; - FG < p0e.length; - FG++ - ) - kye.set(p0e[FG], 0); - var p0e, FG; - CI("onMouseEnter", ["mouseout", "mouseover"]); - CI("onMouseLeave", ["mouseout", "mouseover"]); - CI("onPointerEnter", ["pointerout", "pointerover"]); - CI("onPointerLeave", ["pointerout", "pointerover"]); - J3( - "onChange", - "change click focusin focusout input keydown keyup selectionchange".split( - " " - ) - ); - J3( - "onSelect", - "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split( - " " - ) - ); - J3("onBeforeInput", ["compositionend", "keypress", "textInput", "paste"]); - J3( - "onCompositionEnd", - "compositionend focusout keydown keypress keyup mousedown".split(" ") - ); - J3( - "onCompositionStart", - "compositionstart focusout keydown keypress keyup mousedown".split(" ") - ); - J3( - "onCompositionUpdate", - "compositionupdate focusout keydown keypress keyup mousedown".split(" ") - ); - var rL = - "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange seeked seeking stalled suspend timeupdate volumechange waiting".split( - " " - ), - BFe = new Set( - "cancel close invalid load scroll toggle".split(" ").concat(rL) - ); - function lDe(t, e, r) { - var n = t.type || "unknown-event"; - (t.currentTarget = r), m9t(n, e, void 0, t), (t.currentTarget = null); - } - function IFe(t, e) { - e = (e & 4) !== 0; - for (var r = 0; r < t.length; r++) { - var n = t[r], - i = n.event; - n = n.listeners; - e: { - var o = void 0; - if (e) - for (var a = n.length - 1; 0 <= a; a--) { - var s = n[a], - c = s.instance, - u = s.currentTarget; - if (((s = s.listener), c !== o && i.isPropagationStopped())) - break e; - lDe(i, s, u), (o = c); - } - else - for (a = 0; a < n.length; a++) { - if ( - ((s = n[a]), - (c = s.instance), - (u = s.currentTarget), - (s = s.listener), - c !== o && i.isPropagationStopped()) - ) - break e; - lDe(i, s, u), (o = c); - } - } - } - if (rJ) throw ((t = q0e), (rJ = !1), (q0e = null), t); - } - function Uo(t, e) { - var r = FFe(e), - n = t + "__bubble"; - r.has(n) || (RFe(e, t, 2, !1), r.add(n)); - } - var fDe = "_reactListening" + Math.random().toString(36).slice(2); - function CFe(t) { - t[fDe] || - ((t[fDe] = !0), - ZDe.forEach(function (e) { - BFe.has(e) || dDe(e, !1, t, null), dDe(e, !0, t, null); - })); - } - function dDe(t, e, r, n) { - var i = - 4 < arguments.length && arguments[4] !== void 0 ? arguments[4] : 0, - o = r; - if ( - (t === "selectionchange" && r.nodeType !== 9 && (o = r.ownerDocument), - n !== null && !e && BFe.has(t)) - ) { - if (t !== "scroll") return; - (i |= 2), (o = n); - } - var a = FFe(o), - s = t + "__" + (e ? "capture" : "bubble"); - a.has(s) || (e && (i |= 4), RFe(o, t, i, e), a.add(s)); - } - function RFe(t, e, r, n) { - var i = kye.get(e); - switch (i === void 0 ? 2 : i) { - case 0: - i = O9t; - break; - case 1: - i = B9t; - break; - default: - i = Oye; - } - (r = i.bind(null, e, r, t)), - (i = void 0), - !L0e || - (e !== "touchstart" && e !== "touchmove" && e !== "wheel") || - (i = !0), - n - ? i !== void 0 - ? t.addEventListener(e, r, { capture: !0, passive: i }) - : t.addEventListener(e, r, !0) - : i !== void 0 - ? t.addEventListener(e, r, { passive: i }) - : t.addEventListener(e, r, !1); - } - function NFe(t, e, r, n, i) { - var o = n; - if ((e & 1) === 0 && (e & 2) === 0 && n !== null) - e: for (;;) { - if (n === null) return; - var a = n.tag; - if (a === 3 || a === 4) { - var s = n.stateNode.containerInfo; - if (s === i || (s.nodeType === 8 && s.parentNode === i)) break; - if (a === 4) - for (a = n.return; a !== null; ) { - var c = a.tag; - if ( - (c === 3 || c === 4) && - ((c = a.stateNode.containerInfo), - c === i || (c.nodeType === 8 && c.parentNode === i)) - ) - return; - a = a.return; - } - for (; s !== null; ) { - if (((a = j3(s)), a === null)) return; - if (((c = a.tag), c === 5 || c === 6)) { - n = o = a; - continue e; - } - s = s.parentNode; - } - } - n = n.return; - } - d9t(function () { - var u = o, - h = Sye(r), - w = []; - e: { - var M = _Fe.get(t); - if (M !== void 0) { - var k = Cye, - O = t; - switch (t) { - case "keypress": - if (WG(r) === 0) break e; - case "keydown": - case "keyup": - k = W9t; - break; - case "focusin": - (O = "focus"), (k = d0e); - break; - case "focusout": - (O = "blur"), (k = d0e); - break; - case "beforeblur": - case "afterblur": - k = d0e; - break; - case "click": - if (r.button === 2) break e; - case "auxclick": - case "dblclick": - case "mousedown": - case "mousemove": - case "mouseup": - case "mouseout": - case "mouseover": - case "contextmenu": - k = Q9e; - break; - case "drag": - case "dragend": - case "dragenter": - case "dragexit": - case "dragleave": - case "dragover": - case "dragstart": - case "drop": - k = R9t; - break; - case "touchcancel": - case "touchend": - case "touchmove": - case "touchstart": - k = $9t; - break; - case gFe: - case vFe: - case bFe: - k = F9t; - break; - case wFe: - k = X9t; - break; - case "scroll": - k = I9t; - break; - case "wheel": - k = Q9t; - break; - case "copy": - case "cut": - case "paste": - k = q9t; - break; - case "gotpointercapture": - case "lostpointercapture": - case "pointercancel": - case "pointerdown": - case "pointermove": - case "pointerout": - case "pointerover": - case "pointerup": - k = tDe; - } - var D = (e & 4) !== 0, - F = !D && t === "scroll", - N = D ? (M !== null ? M + "Capture" : null) : M; - D = []; - for (var q = u, z; q !== null; ) { - z = q; - var H = z.stateNode; - if ( - (z.tag === 5 && - H !== null && - ((z = H), - N !== null && - ((H = bL(q, N)), H != null && D.push(EL(q, H, z)))), - F) - ) - break; - q = q.return; - } - 0 < D.length && - ((M = new k(M, O, null, r, h)), - w.push({ event: M, listeners: D })); - } - } - if ((e & 7) === 0) { - e: { - if ( - ((M = t === "mouseover" || t === "pointerover"), - (k = t === "mouseout" || t === "pointerout"), - M && - (e & 16) === 0 && - (O = r.relatedTarget || r.fromElement) && - (j3(O) || O[LI])) - ) - break e; - if ( - (k || M) && - ((M = - h.window === h - ? h - : (M = h.ownerDocument) - ? M.defaultView || M.parentWindow - : window), - k - ? ((O = r.relatedTarget || r.toElement), - (k = u), - (O = O ? j3(O) : null), - O !== null && - ((F = Z3(O)), O !== F || (O.tag !== 5 && O.tag !== 6)) && - (O = null)) - : ((k = null), (O = u)), - k !== O) - ) { - if ( - ((D = Q9e), - (H = "onMouseLeave"), - (N = "onMouseEnter"), - (q = "mouse"), - (t === "pointerout" || t === "pointerover") && - ((D = tDe), - (H = "onPointerLeave"), - (N = "onPointerEnter"), - (q = "pointer")), - (F = k == null ? M : wI(k)), - (z = O == null ? M : wI(O)), - (M = new D(H, q + "leave", k, r, h)), - (M.target = F), - (M.relatedTarget = z), - (H = null), - j3(h) === u && - ((D = new D(N, q + "enter", O, r, h)), - (D.target = z), - (D.relatedTarget = F), - (H = D)), - (F = H), - k && O) - ) - t: { - for (D = k, N = O, q = 0, z = D; z; z = pI(z)) q++; - for (z = 0, H = N; H; H = pI(H)) z++; - for (; 0 < q - z; ) (D = pI(D)), q--; - for (; 0 < z - q; ) (N = pI(N)), z--; - for (; q--; ) { - if (D === N || (N !== null && D === N.alternate)) break t; - (D = pI(D)), (N = pI(N)); - } - D = null; - } - else D = null; - k !== null && hDe(w, M, k, D, !1), - O !== null && F !== null && hDe(w, F, O, D, !0); - } - } - e: { - if ( - ((M = u ? wI(u) : window), - (k = M.nodeName && M.nodeName.toLowerCase()), - k === "select" || (k === "input" && M.type === "file")) - ) - var Z = aDt; - else if (iDe(M)) - if (kFe) Z = lDt; - else { - Z = uDt; - var $ = sDt; - } - else - (k = M.nodeName) && - k.toLowerCase() === "input" && - (M.type === "checkbox" || M.type === "radio") && - (Z = cDt); - if (Z && (Z = Z(t, u))) { - TFe(w, Z, r, h); - break e; - } - $ && $(t, M, u), - t === "focusout" && - ($ = M._wrapperState) && - $.controlled && - M.type === "number" && - O0e(M, "number", M.value); - } - switch ((($ = u ? wI(u) : window), t)) { - case "focusin": - (iDe($) || $.contentEditable === "true") && - ((bI = $), (K0e = u), (fL = null)); - break; - case "focusout": - fL = K0e = bI = null; - break; - case "mousedown": - H0e = !0; - break; - case "contextmenu": - case "mouseup": - case "dragend": - (H0e = !1), cDe(w, r, h); - break; - case "selectionchange": - if (hDt) break; - case "keydown": - case "keyup": - cDe(w, r, h); - } - var ue; - if (Nye) - e: { - switch (t) { - case "compositionstart": - var te = "onCompositionStart"; - break e; - case "compositionend": - te = "onCompositionEnd"; - break e; - case "compositionupdate": - te = "onCompositionUpdate"; - break e; - } - te = void 0; - } - else - vI - ? EFe(t, r) && (te = "onCompositionEnd") - : t === "keydown" && - r.keyCode === 229 && - (te = "onCompositionStart"); - te && - (AFe && - r.locale !== "ko" && - (vI || te !== "onCompositionStart" - ? te === "onCompositionEnd" && vI && (ue = SFe()) - : ((CS = h), - (Iye = "value" in CS ? CS.value : CS.textContent), - (vI = !0))), - ($ = iJ(u, te)), - 0 < $.length && - ((te = new eDe(te, t, null, r, h)), - w.push({ event: te, listeners: $ }), - ue - ? (te.data = ue) - : ((ue = MFe(r)), ue !== null && (te.data = ue)))), - (ue = tDt ? rDt(t, r) : nDt(t, r)) && - ((u = iJ(u, "onBeforeInput")), - 0 < u.length && - ((h = new eDe("onBeforeInput", "beforeinput", null, r, h)), - w.push({ event: h, listeners: u }), - (h.data = ue))); - } - IFe(w, e); - }); - } - function EL(t, e, r) { - return { instance: t, listener: e, currentTarget: r }; - } - function iJ(t, e) { - for (var r = e + "Capture", n = []; t !== null; ) { - var i = t, - o = i.stateNode; - i.tag === 5 && - o !== null && - ((i = o), - (o = bL(t, r)), - o != null && n.unshift(EL(t, o, i)), - (o = bL(t, e)), - o != null && n.push(EL(t, o, i))), - (t = t.return); - } - return n; - } - function pI(t) { - if (t === null) return null; - do t = t.return; - while (t && t.tag !== 5); - return t || null; - } - function hDe(t, e, r, n, i) { - for (var o = e._reactName, a = []; r !== null && r !== n; ) { - var s = r, - c = s.alternate, - u = s.stateNode; - if (c !== null && c === n) break; - s.tag === 5 && - u !== null && - ((s = u), - i - ? ((c = bL(r, o)), c != null && a.unshift(EL(r, c, s))) - : i || ((c = bL(r, o)), c != null && a.push(EL(r, c, s)))), - (r = r.return); - } - a.length !== 0 && t.push({ event: e, listeners: a }); - } - function oJ() {} - var y0e = null, - m0e = null; - function DFe(t, e) { - switch (t) { - case "button": - case "input": - case "select": - case "textarea": - return !!e.autoFocus; - } - return !1; - } - function V0e(t, e) { - return ( - t === "textarea" || - t === "option" || - t === "noscript" || - typeof e.children == "string" || - typeof e.children == "number" || - (typeof e.dangerouslySetInnerHTML == "object" && - e.dangerouslySetInnerHTML !== null && - e.dangerouslySetInnerHTML.__html != null) - ); - } - var pDe = typeof setTimeout == "function" ? setTimeout : void 0, - pDt = typeof clearTimeout == "function" ? clearTimeout : void 0; - function Dye(t) { - t.nodeType === 1 - ? (t.textContent = "") - : t.nodeType === 9 && ((t = t.body), t != null && (t.textContent = "")); - } - function TI(t) { - for (; t != null; t = t.nextSibling) { - var e = t.nodeType; - if (e === 1 || e === 3) break; - } - return t; - } - function yDe(t) { - t = t.previousSibling; - for (var e = 0; t; ) { - if (t.nodeType === 8) { - var r = t.data; - if (r === "$" || r === "$!" || r === "$?") { - if (e === 0) return t; - e--; - } else r === "/$" && e++; - } - t = t.previousSibling; - } - return null; - } - var g0e = 0; - function yDt(t) { - return { $$typeof: _ye, toString: t, valueOf: t }; - } - var PJ = Math.random().toString(36).slice(2), - RS = "__reactFiber$" + PJ, - aJ = "__reactProps$" + PJ, - LI = "__reactContainer$" + PJ, - mDe = "__reactEvents$" + PJ; - function j3(t) { - var e = t[RS]; - if (e) return e; - for (var r = t.parentNode; r; ) { - if ((e = r[LI] || r[RS])) { - if ( - ((r = e.alternate), - e.child !== null || (r !== null && r.child !== null)) - ) - for (t = yDe(t); t !== null; ) { - if ((r = t[RS])) return r; - t = yDe(t); - } - return e; - } - (t = r), (r = t.parentNode); - } - return null; - } - function IL(t) { - return ( - (t = t[RS] || t[LI]), - !t || (t.tag !== 5 && t.tag !== 6 && t.tag !== 13 && t.tag !== 3) - ? null - : t - ); - } - function wI(t) { - if (t.tag === 5 || t.tag === 6) return t.stateNode; - throw Error(Vt(33)); - } - function OJ(t) { - return t[aJ] || null; - } - function FFe(t) { - var e = t[mDe]; - return e === void 0 && (e = t[mDe] = new Set()), e; - } - var W0e = [], - _I = -1; - function $S(t) { - return { current: t }; - } - function Ko(t) { - 0 > _I || ((t.current = W0e[_I]), (W0e[_I] = null), _I--); - } - function Ia(t, e) { - _I++, (W0e[_I] = t.current), (t.current = e); - } - var WS = {}, - Rc = $S(WS), - _h = $S(!1), - V3 = WS; - function RI(t, e) { - var r = t.type.contextTypes; - if (!r) return WS; - var n = t.stateNode; - if (n && n.__reactInternalMemoizedUnmaskedChildContext === e) - return n.__reactInternalMemoizedMaskedChildContext; - var i = {}, - o; - for (o in r) i[o] = e[o]; - return ( - n && - ((t = t.stateNode), - (t.__reactInternalMemoizedUnmaskedChildContext = e), - (t.__reactInternalMemoizedMaskedChildContext = i)), - i - ); - } - function xh(t) { - return (t = t.childContextTypes), t != null; - } - function sJ() { - Ko(_h), Ko(Rc); - } - function gDe(t, e, r) { - if (Rc.current !== WS) throw Error(Vt(168)); - Ia(Rc, e), Ia(_h, r); - } - function LFe(t, e, r) { - var n = t.stateNode; - if (((t = e.childContextTypes), typeof n.getChildContext != "function")) - return r; - n = n.getChildContext(); - for (var i in n) - if (!(i in t)) throw Error(Vt(108, SI(e) || "Unknown", i)); - return ea({}, r, n); - } - function GG(t) { - return ( - (t = - ((t = t.stateNode) && t.__reactInternalMemoizedMergedChildContext) || - WS), - (V3 = Rc.current), - Ia(Rc, t), - Ia(_h, _h.current), - !0 - ); - } - function vDe(t, e, r) { - var n = t.stateNode; - if (!n) throw Error(Vt(169)); - r - ? ((t = LFe(t, e, V3)), - (n.__reactInternalMemoizedMergedChildContext = t), - Ko(_h), - Ko(Rc), - Ia(Rc, t)) - : Ko(_h), - Ia(_h, r); - } - var Fye = null, - H3 = null, - mDt = gu.unstable_runWithPriority, - Lye = gu.unstable_scheduleCallback, - G0e = gu.unstable_cancelCallback, - gDt = gu.unstable_shouldYield, - bDe = gu.unstable_requestPaint, - J0e = gu.unstable_now, - vDt = gu.unstable_getCurrentPriorityLevel, - BJ = gu.unstable_ImmediatePriority, - qFe = gu.unstable_UserBlockingPriority, - zFe = gu.unstable_NormalPriority, - jFe = gu.unstable_LowPriority, - UFe = gu.unstable_IdlePriority, - v0e = {}, - bDt = bDe !== void 0 ? bDe : function () {}, - g_ = null, - JG = null, - b0e = !1, - wDe = J0e(), - Ic = - 1e4 > wDe - ? J0e - : function () { - return J0e() - wDe; - }; - function NI() { - switch (vDt()) { - case BJ: - return 99; - case qFe: - return 98; - case zFe: - return 97; - case jFe: - return 96; - case UFe: - return 95; - default: - throw Error(Vt(332)); - } - } - function KFe(t) { - switch (t) { - case 99: - return BJ; - case 98: - return qFe; - case 97: - return zFe; - case 96: - return jFe; - case 95: - return UFe; - default: - throw Error(Vt(332)); - } - } - function W3(t, e) { - return (t = KFe(t)), mDt(t, e); - } - function ML(t, e, r) { - return (t = KFe(t)), Lye(t, e, r); - } - function iv() { - if (JG !== null) { - var t = JG; - (JG = null), G0e(t); - } - HFe(); - } - function HFe() { - if (!b0e && g_ !== null) { - b0e = !0; - var t = 0; - try { - var e = g_; - W3(99, function () { - for (; t < e.length; t++) { - var r = e[t]; - do r = r(!0); - while (r !== null); - } - }), - (g_ = null); - } catch (r) { - throw (g_ !== null && (g_ = g_.slice(t + 1)), Lye(BJ, iv), r); - } finally { - b0e = !1; - } - } - } - var wDt = $3.ReactCurrentBatchConfig; - function Pm(t, e) { - if (t && t.defaultProps) { - (e = ea({}, e)), (t = t.defaultProps); - for (var r in t) e[r] === void 0 && (e[r] = t[r]); - return e; - } - return e; - } - var uJ = $S(null), - cJ = null, - xI = null, - lJ = null; - function qye() { - lJ = xI = cJ = null; - } - function zye(t) { - var e = uJ.current; - Ko(uJ), (t.type._context._currentValue = e); - } - function VFe(t, e) { - for (; t !== null; ) { - var r = t.alternate; - if ((t.childLanes & e) === e) { - if (r === null || (r.childLanes & e) === e) break; - r.childLanes |= e; - } else (t.childLanes |= e), r !== null && (r.childLanes |= e); - t = t.return; - } - } - function kI(t, e) { - (cJ = t), - (lJ = xI = null), - (t = t.dependencies), - t !== null && - t.firstContext !== null && - ((t.lanes & e) !== 0 && (Om = !0), (t.firstContext = null)); - } - function G0(t, e) { - if (lJ !== t && e !== !1 && e !== 0) - if ( - ((typeof e != "number" || e === 1073741823) && - ((lJ = t), (e = 1073741823)), - (e = { context: t, observedBits: e, next: null }), - xI === null) - ) { - if (cJ === null) throw Error(Vt(308)); - (xI = e), - (cJ.dependencies = { lanes: 0, firstContext: e, responders: null }); - } else xI = xI.next = e; - return t._currentValue; - } - var BS = !1; - function jye(t) { - t.updateQueue = { - baseState: t.memoizedState, - firstBaseUpdate: null, - lastBaseUpdate: null, - shared: { pending: null }, - effects: null, - }; - } - function WFe(t, e) { - (t = t.updateQueue), - e.updateQueue === t && - (e.updateQueue = { - baseState: t.baseState, - firstBaseUpdate: t.firstBaseUpdate, - lastBaseUpdate: t.lastBaseUpdate, - shared: t.shared, - effects: t.effects, - }); - } - function qS(t, e) { - return { - eventTime: t, - lane: e, - tag: 0, - payload: null, - callback: null, - next: null, - }; - } - function zS(t, e) { - if (((t = t.updateQueue), t !== null)) { - t = t.shared; - var r = t.pending; - r === null ? (e.next = e) : ((e.next = r.next), (r.next = e)), - (t.pending = e); - } - } - function _De(t, e) { - var r = t.updateQueue, - n = t.alternate; - if (n !== null && ((n = n.updateQueue), r === n)) { - var i = null, - o = null; - if (((r = r.firstBaseUpdate), r !== null)) { - do { - var a = { - eventTime: r.eventTime, - lane: r.lane, - tag: r.tag, - payload: r.payload, - callback: r.callback, - next: null, - }; - o === null ? (i = o = a) : (o = o.next = a), (r = r.next); - } while (r !== null); - o === null ? (i = o = e) : (o = o.next = e); - } else i = o = e; - (r = { - baseState: n.baseState, - firstBaseUpdate: i, - lastBaseUpdate: o, - shared: n.shared, - effects: n.effects, - }), - (t.updateQueue = r); - return; - } - (t = r.lastBaseUpdate), - t === null ? (r.firstBaseUpdate = e) : (t.next = e), - (r.lastBaseUpdate = e); - } - function TL(t, e, r, n) { - var i = t.updateQueue; - BS = !1; - var o = i.firstBaseUpdate, - a = i.lastBaseUpdate, - s = i.shared.pending; - if (s !== null) { - i.shared.pending = null; - var c = s, - u = c.next; - (c.next = null), a === null ? (o = u) : (a.next = u), (a = c); - var h = t.alternate; - if (h !== null) { - h = h.updateQueue; - var w = h.lastBaseUpdate; - w !== a && - (w === null ? (h.firstBaseUpdate = u) : (w.next = u), - (h.lastBaseUpdate = c)); - } - } - if (o !== null) { - (w = i.baseState), (a = 0), (h = u = c = null); - do { - s = o.lane; - var M = o.eventTime; - if ((n & s) === s) { - h !== null && - (h = h.next = - { - eventTime: M, - lane: 0, - tag: o.tag, - payload: o.payload, - callback: o.callback, - next: null, - }); - e: { - var k = t, - O = o; - switch (((s = e), (M = r), O.tag)) { - case 1: - if (((k = O.payload), typeof k == "function")) { - w = k.call(M, w, s); - break e; - } - w = k; - break e; - case 3: - k.flags = (k.flags & -4097) | 64; - case 0: - if ( - ((k = O.payload), - (s = typeof k == "function" ? k.call(M, w, s) : k), - s == null) - ) - break e; - w = ea({}, w, s); - break e; - case 2: - BS = !0; - } - } - o.callback !== null && - ((t.flags |= 32), - (s = i.effects), - s === null ? (i.effects = [o]) : s.push(o)); - } else - (M = { - eventTime: M, - lane: s, - tag: o.tag, - payload: o.payload, - callback: o.callback, - next: null, - }), - h === null ? ((u = h = M), (c = w)) : (h = h.next = M), - (a |= s); - if (((o = o.next), o === null)) { - if (((s = i.shared.pending), s === null)) break; - (o = s.next), - (s.next = null), - (i.lastBaseUpdate = s), - (i.shared.pending = null); - } - } while (1); - h === null && (c = w), - (i.baseState = c), - (i.firstBaseUpdate = u), - (i.lastBaseUpdate = h), - (RL |= a), - (t.lanes = a), - (t.memoizedState = w); - } - } - function xDe(t, e, r) { - if (((t = e.effects), (e.effects = null), t !== null)) - for (e = 0; e < t.length; e++) { - var n = t[e], - i = n.callback; - if (i !== null) { - if (((n.callback = null), (n = r), typeof i != "function")) - throw Error(Vt(191, i)); - i.call(n); - } - } - } - var GFe = new xJ.Component().refs; - function fJ(t, e, r, n) { - (e = t.memoizedState), - (r = r(n, e)), - (r = r == null ? e : ea({}, e, r)), - (t.memoizedState = r), - t.lanes === 0 && (t.updateQueue.baseState = r); - } - var IJ = { - isMounted: function (t) { - return (t = t._reactInternals) ? Z3(t) === t : !1; - }, - enqueueSetState: function (t, e, r) { - t = t._reactInternals; - var n = Bp(), - i = jS(t), - o = qS(n, i); - (o.payload = e), r != null && (o.callback = r), zS(t, o), US(t, i, n); - }, - enqueueReplaceState: function (t, e, r) { - t = t._reactInternals; - var n = Bp(), - i = jS(t), - o = qS(n, i); - (o.tag = 1), - (o.payload = e), - r != null && (o.callback = r), - zS(t, o), - US(t, i, n); - }, - enqueueForceUpdate: function (t, e) { - t = t._reactInternals; - var r = Bp(), - n = jS(t), - i = qS(r, n); - (i.tag = 2), e != null && (i.callback = e), zS(t, i), US(t, n, r); - }, - }; - function SDe(t, e, r, n, i, o, a) { - return ( - (t = t.stateNode), - typeof t.shouldComponentUpdate == "function" - ? t.shouldComponentUpdate(n, o, a) - : e.prototype && e.prototype.isPureReactComponent - ? !AL(r, n) || !AL(i, o) - : !0 - ); - } - function JFe(t, e, r) { - var n = !1, - i = WS, - o = e.contextType; - return ( - typeof o == "object" && o !== null - ? (o = G0(o)) - : ((i = xh(e) ? V3 : Rc.current), - (n = e.contextTypes), - (o = (n = n != null) ? RI(t, i) : WS)), - (e = new e(r, o)), - (t.memoizedState = - e.state !== null && e.state !== void 0 ? e.state : null), - (e.updater = IJ), - (t.stateNode = e), - (e._reactInternals = t), - n && - ((t = t.stateNode), - (t.__reactInternalMemoizedUnmaskedChildContext = i), - (t.__reactInternalMemoizedMaskedChildContext = o)), - e - ); - } - function ADe(t, e, r, n) { - (t = e.state), - typeof e.componentWillReceiveProps == "function" && - e.componentWillReceiveProps(r, n), - typeof e.UNSAFE_componentWillReceiveProps == "function" && - e.UNSAFE_componentWillReceiveProps(r, n), - e.state !== t && IJ.enqueueReplaceState(e, e.state, null); - } - function $0e(t, e, r, n) { - var i = t.stateNode; - (i.props = r), (i.state = t.memoizedState), (i.refs = GFe), jye(t); - var o = e.contextType; - typeof o == "object" && o !== null - ? (i.context = G0(o)) - : ((o = xh(e) ? V3 : Rc.current), (i.context = RI(t, o))), - TL(t, r, i, n), - (i.state = t.memoizedState), - (o = e.getDerivedStateFromProps), - typeof o == "function" && (fJ(t, e, o, r), (i.state = t.memoizedState)), - typeof e.getDerivedStateFromProps == "function" || - typeof i.getSnapshotBeforeUpdate == "function" || - (typeof i.UNSAFE_componentWillMount != "function" && - typeof i.componentWillMount != "function") || - ((e = i.state), - typeof i.componentWillMount == "function" && i.componentWillMount(), - typeof i.UNSAFE_componentWillMount == "function" && - i.UNSAFE_componentWillMount(), - e !== i.state && IJ.enqueueReplaceState(i, i.state, null), - TL(t, r, i, n), - (i.state = t.memoizedState)), - typeof i.componentDidMount == "function" && (t.flags |= 4); - } - var LG = Array.isArray; - function GF(t, e, r) { - if ( - ((t = r.ref), - t !== null && typeof t != "function" && typeof t != "object") - ) { - if (r._owner) { - if (((r = r._owner), r)) { - if (r.tag !== 1) throw Error(Vt(309)); - var n = r.stateNode; - } - if (!n) throw Error(Vt(147, t)); - var i = "" + t; - return e !== null && - e.ref !== null && - typeof e.ref == "function" && - e.ref._stringRef === i - ? e.ref - : ((e = function (o) { - var a = n.refs; - a === GFe && (a = n.refs = {}), - o === null ? delete a[i] : (a[i] = o); - }), - (e._stringRef = i), - e); - } - if (typeof t != "string") throw Error(Vt(284)); - if (!r._owner) throw Error(Vt(290, t)); - } - return t; - } - function qG(t, e) { - if (t.type !== "textarea") - throw Error( - Vt( - 31, - Object.prototype.toString.call(e) === "[object Object]" - ? "object with keys {" + Object.keys(e).join(", ") + "}" - : e - ) - ); - } - function $Fe(t) { - function e(F, N) { - if (t) { - var q = F.lastEffect; - q !== null - ? ((q.nextEffect = N), (F.lastEffect = N)) - : (F.firstEffect = F.lastEffect = N), - (N.nextEffect = null), - (N.flags = 8); - } - } - function r(F, N) { - if (!t) return null; - for (; N !== null; ) e(F, N), (N = N.sibling); - return null; - } - function n(F, N) { - for (F = new Map(); N !== null; ) - N.key !== null ? F.set(N.key, N) : F.set(N.index, N), (N = N.sibling); - return F; - } - function i(F, N) { - return (F = JS(F, N)), (F.index = 0), (F.sibling = null), F; - } - function o(F, N, q) { - return ( - (F.index = q), - t - ? ((q = F.alternate), - q !== null - ? ((q = q.index), q < N ? ((F.flags = 2), N) : q) - : ((F.flags = 2), N)) - : N - ); - } - function a(F) { - return t && F.alternate === null && (F.flags = 2), F; - } - function s(F, N, q, z) { - return N === null || N.tag !== 6 - ? ((N = A0e(q, F.mode, z)), (N.return = F), N) - : ((N = i(N, q)), (N.return = F), N); - } - function c(F, N, q, z) { - return N !== null && N.elementType === q.type - ? ((z = i(N, q.props)), (z.ref = GF(F, N, q)), (z.return = F), z) - : ((z = YG(q.type, q.key, q.props, null, F.mode, z)), - (z.ref = GF(F, N, q)), - (z.return = F), - z); - } - function u(F, N, q, z) { - return N === null || - N.tag !== 4 || - N.stateNode.containerInfo !== q.containerInfo || - N.stateNode.implementation !== q.implementation - ? ((N = E0e(q, F.mode, z)), (N.return = F), N) - : ((N = i(N, q.children || [])), (N.return = F), N); - } - function h(F, N, q, z, H) { - return N === null || N.tag !== 7 - ? ((N = II(q, F.mode, z, H)), (N.return = F), N) - : ((N = i(N, q)), (N.return = F), N); - } - function w(F, N, q) { - if (typeof N == "string" || typeof N == "number") - return (N = A0e("" + N, F.mode, q)), (N.return = F), N; - if (typeof N == "object" && N !== null) { - switch (N.$$typeof) { - case eL: - return ( - (q = YG(N.type, N.key, N.props, null, F.mode, q)), - (q.ref = GF(F, null, N)), - (q.return = F), - q - ); - case q3: - return (N = E0e(N, F.mode, q)), (N.return = F), N; - } - if (LG(N) || UF(N)) - return (N = II(N, F.mode, q, null)), (N.return = F), N; - qG(F, N); - } - return null; - } - function M(F, N, q, z) { - var H = N !== null ? N.key : null; - if (typeof q == "string" || typeof q == "number") - return H !== null ? null : s(F, N, "" + q, z); - if (typeof q == "object" && q !== null) { - switch (q.$$typeof) { - case eL: - return q.key === H - ? q.type === IS - ? h(F, N, q.props.children, z, H) - : c(F, N, q, z) - : null; - case q3: - return q.key === H ? u(F, N, q, z) : null; - } - if (LG(q) || UF(q)) return H !== null ? null : h(F, N, q, z, null); - qG(F, q); - } - return null; - } - function k(F, N, q, z, H) { - if (typeof z == "string" || typeof z == "number") - return (F = F.get(q) || null), s(N, F, "" + z, H); - if (typeof z == "object" && z !== null) { - switch (z.$$typeof) { - case eL: - return ( - (F = F.get(z.key === null ? q : z.key) || null), - z.type === IS - ? h(N, F, z.props.children, H, z.key) - : c(N, F, z, H) - ); - case q3: - return ( - (F = F.get(z.key === null ? q : z.key) || null), u(N, F, z, H) - ); - } - if (LG(z) || UF(z)) - return (F = F.get(q) || null), h(N, F, z, H, null); - qG(N, z); - } - return null; - } - function O(F, N, q, z) { - for ( - var H = null, Z = null, $ = N, ue = (N = 0), te = null; - $ !== null && ue < q.length; - ue++ - ) { - $.index > ue ? ((te = $), ($ = null)) : (te = $.sibling); - var ne = M(F, $, q[ue], z); - if (ne === null) { - $ === null && ($ = te); - break; - } - t && $ && ne.alternate === null && e(F, $), - (N = o(ne, N, ue)), - Z === null ? (H = ne) : (Z.sibling = ne), - (Z = ne), - ($ = te); - } - if (ue === q.length) return r(F, $), H; - if ($ === null) { - for (; ue < q.length; ue++) - ($ = w(F, q[ue], z)), - $ !== null && - ((N = o($, N, ue)), - Z === null ? (H = $) : (Z.sibling = $), - (Z = $)); - return H; - } - for ($ = n(F, $); ue < q.length; ue++) - (te = k($, F, ue, q[ue], z)), - te !== null && - (t && - te.alternate !== null && - $.delete(te.key === null ? ue : te.key), - (N = o(te, N, ue)), - Z === null ? (H = te) : (Z.sibling = te), - (Z = te)); - return ( - t && - $.forEach(function (A) { - return e(F, A); - }), - H - ); - } - function D(F, N, q, z) { - var H = UF(q); - if (typeof H != "function") throw Error(Vt(150)); - if (((q = H.call(q)), q == null)) throw Error(Vt(151)); - for ( - var Z = (H = null), $ = N, ue = (N = 0), te = null, ne = q.next(); - $ !== null && !ne.done; - ue++, ne = q.next() - ) { - $.index > ue ? ((te = $), ($ = null)) : (te = $.sibling); - var A = M(F, $, ne.value, z); - if (A === null) { - $ === null && ($ = te); - break; - } - t && $ && A.alternate === null && e(F, $), - (N = o(A, N, ue)), - Z === null ? (H = A) : (Z.sibling = A), - (Z = A), - ($ = te); - } - if (ne.done) return r(F, $), H; - if ($ === null) { - for (; !ne.done; ue++, ne = q.next()) - (ne = w(F, ne.value, z)), - ne !== null && - ((N = o(ne, N, ue)), - Z === null ? (H = ne) : (Z.sibling = ne), - (Z = ne)); - return H; - } - for ($ = n(F, $); !ne.done; ue++, ne = q.next()) - (ne = k($, F, ue, ne.value, z)), - ne !== null && - (t && - ne.alternate !== null && - $.delete(ne.key === null ? ue : ne.key), - (N = o(ne, N, ue)), - Z === null ? (H = ne) : (Z.sibling = ne), - (Z = ne)); - return ( - t && - $.forEach(function (l) { - return e(F, l); - }), - H - ); - } - return function (F, N, q, z) { - var H = - typeof q == "object" && q !== null && q.type === IS && q.key === null; - H && (q = q.props.children); - var Z = typeof q == "object" && q !== null; - if (Z) - switch (q.$$typeof) { - case eL: - e: { - for (Z = q.key, H = N; H !== null; ) { - if (H.key === Z) { - switch (H.tag) { - case 7: - if (q.type === IS) { - r(F, H.sibling), - (N = i(H, q.props.children)), - (N.return = F), - (F = N); - break e; - } - break; - default: - if (H.elementType === q.type) { - r(F, H.sibling), - (N = i(H, q.props)), - (N.ref = GF(F, H, q)), - (N.return = F), - (F = N); - break e; - } - } - r(F, H); - break; - } else e(F, H); - H = H.sibling; - } - q.type === IS - ? ((N = II(q.props.children, F.mode, z, q.key)), - (N.return = F), - (F = N)) - : ((z = YG(q.type, q.key, q.props, null, F.mode, z)), - (z.ref = GF(F, N, q)), - (z.return = F), - (F = z)); - } - return a(F); - case q3: - e: { - for (H = q.key; N !== null; ) { - if (N.key === H) - if ( - N.tag === 4 && - N.stateNode.containerInfo === q.containerInfo && - N.stateNode.implementation === q.implementation - ) { - r(F, N.sibling), - (N = i(N, q.children || [])), - (N.return = F), - (F = N); - break e; - } else { - r(F, N); - break; - } - else e(F, N); - N = N.sibling; - } - (N = E0e(q, F.mode, z)), (N.return = F), (F = N); - } - return a(F); - } - if (typeof q == "string" || typeof q == "number") - return ( - (q = "" + q), - N !== null && N.tag === 6 - ? (r(F, N.sibling), (N = i(N, q)), (N.return = F), (F = N)) - : (r(F, N), (N = A0e(q, F.mode, z)), (N.return = F), (F = N)), - a(F) - ); - if (LG(q)) return O(F, N, q, z); - if (UF(q)) return D(F, N, q, z); - if ((Z && qG(F, q), typeof q > "u" && !H)) - switch (F.tag) { - case 1: - case 22: - case 0: - case 11: - case 15: - throw Error(Vt(152, SI(F.type) || "Component")); - } - return r(F, N); - }; - } - var dJ = $Fe(!0), - ZFe = $Fe(!1), - CL = {}, - rv = $S(CL), - kL = $S(CL), - PL = $S(CL); - function U3(t) { - if (t === CL) throw Error(Vt(174)); - return t; - } - function Z0e(t, e) { - switch ((Ia(PL, e), Ia(kL, t), Ia(rv, CL), (t = e.nodeType), t)) { - case 9: - case 11: - e = (e = e.documentElement) ? e.namespaceURI : R0e(null, ""); - break; - default: - (t = t === 8 ? e.parentNode : e), - (e = t.namespaceURI || null), - (t = t.tagName), - (e = R0e(e, t)); - } - Ko(rv), Ia(rv, e); - } - function DI() { - Ko(rv), Ko(kL), Ko(PL); - } - function EDe(t) { - U3(PL.current); - var e = U3(rv.current), - r = R0e(e, t.type); - e !== r && (Ia(kL, t), Ia(rv, r)); - } - function Uye(t) { - kL.current === t && (Ko(rv), Ko(kL)); - } - var Ba = $S(0); - function hJ(t) { - for (var e = t; e !== null; ) { - if (e.tag === 13) { - var r = e.memoizedState; - if ( - r !== null && - ((r = r.dehydrated), - r === null || r.data === "$?" || r.data === "$!") - ) - return e; - } else if (e.tag === 19 && e.memoizedProps.revealOrder !== void 0) { - if ((e.flags & 64) !== 0) return e; - } else if (e.child !== null) { - (e.child.return = e), (e = e.child); - continue; - } - if (e === t) break; - for (; e.sibling === null; ) { - if (e.return === null || e.return === t) return null; - e = e.return; - } - (e.sibling.return = e.return), (e = e.sibling); - } - return null; - } - var b_ = null, - NS = null, - nv = !1; - function XFe(t, e) { - var r = V0(5, null, null, 0); - (r.elementType = "DELETED"), - (r.type = "DELETED"), - (r.stateNode = e), - (r.return = t), - (r.flags = 8), - t.lastEffect !== null - ? ((t.lastEffect.nextEffect = r), (t.lastEffect = r)) - : (t.firstEffect = t.lastEffect = r); - } - function MDe(t, e) { - switch (t.tag) { - case 5: - var r = t.type; - return ( - (e = - e.nodeType !== 1 || r.toLowerCase() !== e.nodeName.toLowerCase() - ? null - : e), - e !== null ? ((t.stateNode = e), !0) : !1 - ); - case 6: - return ( - (e = t.pendingProps === "" || e.nodeType !== 3 ? null : e), - e !== null ? ((t.stateNode = e), !0) : !1 - ); - case 13: - return !1; - default: - return !1; - } - } - function X0e(t) { - if (nv) { - var e = NS; - if (e) { - var r = e; - if (!MDe(t, e)) { - if (((e = TI(r.nextSibling)), !e || !MDe(t, e))) { - (t.flags = (t.flags & -1025) | 2), (nv = !1), (b_ = t); - return; - } - XFe(b_, r); - } - (b_ = t), (NS = TI(e.firstChild)); - } else (t.flags = (t.flags & -1025) | 2), (nv = !1), (b_ = t); - } - } - function TDe(t) { - for ( - t = t.return; - t !== null && t.tag !== 5 && t.tag !== 3 && t.tag !== 13; - - ) - t = t.return; - b_ = t; - } - function zG(t) { - if (t !== b_) return !1; - if (!nv) return TDe(t), (nv = !0), !1; - var e = t.type; - if ( - t.tag !== 5 || - (e !== "head" && e !== "body" && !V0e(e, t.memoizedProps)) - ) - for (e = NS; e; ) XFe(t, e), (e = TI(e.nextSibling)); - if ((TDe(t), t.tag === 13)) { - if (((t = t.memoizedState), (t = t !== null ? t.dehydrated : null), !t)) - throw Error(Vt(317)); - e: { - for (t = t.nextSibling, e = 0; t; ) { - if (t.nodeType === 8) { - var r = t.data; - if (r === "/$") { - if (e === 0) { - NS = TI(t.nextSibling); - break e; - } - e--; - } else (r !== "$" && r !== "$!" && r !== "$?") || e++; - } - t = t.nextSibling; - } - NS = null; - } - } else NS = b_ ? TI(t.stateNode.nextSibling) : null; - return !0; - } - function w0e() { - (NS = b_ = null), (nv = !1); - } - var PI = []; - function Kye() { - for (var t = 0; t < PI.length; t++) - PI[t]._workInProgressVersionPrimary = null; - PI.length = 0; - } - var dL = $3.ReactCurrentDispatcher, - W0 = $3.ReactCurrentBatchConfig, - OL = 0, - Qa = null, - Bc = null, - Zu = null, - pJ = !1, - hL = !1; - function bh() { - throw Error(Vt(321)); - } - function Hye(t, e) { - if (e === null) return !1; - for (var r = 0; r < e.length && r < t.length; r++) - if (!H0(t[r], e[r])) return !1; - return !0; - } - function Vye(t, e, r, n, i, o) { - if ( - ((OL = o), - (Qa = e), - (e.memoizedState = null), - (e.updateQueue = null), - (e.lanes = 0), - (dL.current = t === null || t.memoizedState === null ? xDt : SDt), - (t = r(n, i)), - hL) - ) { - o = 0; - do { - if (((hL = !1), !(25 > o))) throw Error(Vt(301)); - (o += 1), - (Zu = Bc = null), - (e.updateQueue = null), - (dL.current = ADt), - (t = r(n, i)); - } while (hL); - } - if ( - ((dL.current = vJ), - (e = Bc !== null && Bc.next !== null), - (OL = 0), - (Zu = Bc = Qa = null), - (pJ = !1), - e) - ) - throw Error(Vt(300)); - return t; - } - function K3() { - var t = { - memoizedState: null, - baseState: null, - baseQueue: null, - queue: null, - next: null, - }; - return Zu === null ? (Qa.memoizedState = Zu = t) : (Zu = Zu.next = t), Zu; - } - function X3() { - if (Bc === null) { - var t = Qa.alternate; - t = t !== null ? t.memoizedState : null; - } else t = Bc.next; - var e = Zu === null ? Qa.memoizedState : Zu.next; - if (e !== null) (Zu = e), (Bc = t); - else { - if (t === null) throw Error(Vt(310)); - (Bc = t), - (t = { - memoizedState: Bc.memoizedState, - baseState: Bc.baseState, - baseQueue: Bc.baseQueue, - queue: Bc.queue, - next: null, - }), - Zu === null ? (Qa.memoizedState = Zu = t) : (Zu = Zu.next = t); - } - return Zu; - } - function ev(t, e) { - return typeof e == "function" ? e(t) : e; - } - function JF(t) { - var e = X3(), - r = e.queue; - if (r === null) throw Error(Vt(311)); - r.lastRenderedReducer = t; - var n = Bc, - i = n.baseQueue, - o = r.pending; - if (o !== null) { - if (i !== null) { - var a = i.next; - (i.next = o.next), (o.next = a); - } - (n.baseQueue = i = o), (r.pending = null); - } - if (i !== null) { - (i = i.next), (n = n.baseState); - var s = (a = o = null), - c = i; - do { - var u = c.lane; - if ((OL & u) === u) - s !== null && - (s = s.next = - { - lane: 0, - action: c.action, - eagerReducer: c.eagerReducer, - eagerState: c.eagerState, - next: null, - }), - (n = c.eagerReducer === t ? c.eagerState : t(n, c.action)); - else { - var h = { - lane: u, - action: c.action, - eagerReducer: c.eagerReducer, - eagerState: c.eagerState, - next: null, - }; - s === null ? ((a = s = h), (o = n)) : (s = s.next = h), - (Qa.lanes |= u), - (RL |= u); - } - c = c.next; - } while (c !== null && c !== i); - s === null ? (o = n) : (s.next = a), - H0(n, e.memoizedState) || (Om = !0), - (e.memoizedState = n), - (e.baseState = o), - (e.baseQueue = s), - (r.lastRenderedState = n); - } - return [e.memoizedState, r.dispatch]; - } - function $F(t) { - var e = X3(), - r = e.queue; - if (r === null) throw Error(Vt(311)); - r.lastRenderedReducer = t; - var n = r.dispatch, - i = r.pending, - o = e.memoizedState; - if (i !== null) { - r.pending = null; - var a = (i = i.next); - do (o = t(o, a.action)), (a = a.next); - while (a !== i); - H0(o, e.memoizedState) || (Om = !0), - (e.memoizedState = o), - e.baseQueue === null && (e.baseState = o), - (r.lastRenderedState = o); - } - return [o, n]; - } - function kDe(t, e, r) { - var n = e._getVersion; - n = n(e._source); - var i = e._workInProgressVersionPrimary; - if ( - (i !== null - ? (t = i === n) - : ((t = t.mutableReadLanes), - (t = (OL & t) === t) && - ((e._workInProgressVersionPrimary = n), PI.push(e))), - t) - ) - return r(e._source); - throw (PI.push(e), Error(Vt(350))); - } - function YFe(t, e, r, n) { - var i = Ld; - if (i === null) throw Error(Vt(349)); - var o = e._getVersion, - a = o(e._source), - s = dL.current, - c = s.useState(function () { - return kDe(i, e, r); - }), - u = c[1], - h = c[0]; - c = Zu; - var w = t.memoizedState, - M = w.refs, - k = M.getSnapshot, - O = w.source; - w = w.subscribe; - var D = Qa; - return ( - (t.memoizedState = { refs: M, source: e, subscribe: n }), - s.useEffect( - function () { - (M.getSnapshot = r), (M.setSnapshot = u); - var F = o(e._source); - if (!H0(a, F)) { - (F = r(e._source)), - H0(h, F) || - (u(F), - (F = jS(D)), - (i.mutableReadLanes |= F & i.pendingLanes)), - (F = i.mutableReadLanes), - (i.entangledLanes |= F); - for (var N = i.entanglements, q = F; 0 < q; ) { - var z = 31 - VS(q), - H = 1 << z; - (N[z] |= F), (q &= ~H); - } - } - }, - [r, e, n] - ), - s.useEffect( - function () { - return n(e._source, function () { - var F = M.getSnapshot, - N = M.setSnapshot; - try { - N(F(e._source)); - var q = jS(D); - i.mutableReadLanes |= q & i.pendingLanes; - } catch (z) { - N(function () { - throw z; - }); - } - }); - }, - [e, n] - ), - (H0(k, r) && H0(O, e) && H0(w, n)) || - ((t = { - pending: null, - dispatch: null, - lastRenderedReducer: ev, - lastRenderedState: h, - }), - (t.dispatch = u = Jye.bind(null, Qa, t)), - (c.queue = t), - (c.baseQueue = null), - (h = kDe(i, e, r)), - (c.memoizedState = c.baseState = h)), - h - ); - } - function QFe(t, e, r) { - var n = X3(); - return YFe(n, t, e, r); - } - function ZF(t) { - var e = K3(); - return ( - typeof t == "function" && (t = t()), - (e.memoizedState = e.baseState = t), - (t = e.queue = - { - pending: null, - dispatch: null, - lastRenderedReducer: ev, - lastRenderedState: t, - }), - (t = t.dispatch = Jye.bind(null, Qa, t)), - [e.memoizedState, t] - ); - } - function yJ(t, e, r, n) { - return ( - (t = { tag: t, create: e, destroy: r, deps: n, next: null }), - (e = Qa.updateQueue), - e === null - ? ((e = { lastEffect: null }), - (Qa.updateQueue = e), - (e.lastEffect = t.next = t)) - : ((r = e.lastEffect), - r === null - ? (e.lastEffect = t.next = t) - : ((n = r.next), (r.next = t), (t.next = n), (e.lastEffect = t))), - t - ); - } - function PDe(t) { - var e = K3(); - return (t = { current: t }), (e.memoizedState = t); - } - function mJ() { - return X3().memoizedState; - } - function Y0e(t, e, r, n) { - var i = K3(); - (Qa.flags |= t), - (i.memoizedState = yJ(1 | e, r, void 0, n === void 0 ? null : n)); - } - function Wye(t, e, r, n) { - var i = X3(); - n = n === void 0 ? null : n; - var o = void 0; - if (Bc !== null) { - var a = Bc.memoizedState; - if (((o = a.destroy), n !== null && Hye(n, a.deps))) { - yJ(e, r, o, n); - return; - } - } - (Qa.flags |= t), (i.memoizedState = yJ(1 | e, r, o, n)); - } - function ODe(t, e) { - return Y0e(516, 4, t, e); - } - function gJ(t, e) { - return Wye(516, 4, t, e); - } - function eLe(t, e) { - return Wye(4, 2, t, e); - } - function tLe(t, e) { - if (typeof e == "function") - return ( - (t = t()), - e(t), - function () { - e(null); - } - ); - if (e != null) - return ( - (t = t()), - (e.current = t), - function () { - e.current = null; - } - ); - } - function rLe(t, e, r) { - return ( - (r = r != null ? r.concat([t]) : null), - Wye(4, 2, tLe.bind(null, e, t), r) - ); - } - function Gye() {} - function nLe(t, e) { - var r = X3(); - e = e === void 0 ? null : e; - var n = r.memoizedState; - return n !== null && e !== null && Hye(e, n[1]) - ? n[0] - : ((r.memoizedState = [t, e]), t); - } - function iLe(t, e) { - var r = X3(); - e = e === void 0 ? null : e; - var n = r.memoizedState; - return n !== null && e !== null && Hye(e, n[1]) - ? n[0] - : ((t = t()), (r.memoizedState = [t, e]), t); - } - function _Dt(t, e) { - var r = NI(); - W3(98 > r ? 98 : r, function () { - t(!0); - }), - W3(97 < r ? 97 : r, function () { - var n = W0.transition; - W0.transition = 1; - try { - t(!1), e(); - } finally { - W0.transition = n; - } - }); - } - function Jye(t, e, r) { - var n = Bp(), - i = jS(t), - o = { - lane: i, - action: r, - eagerReducer: null, - eagerState: null, - next: null, - }, - a = e.pending; - if ( - (a === null ? (o.next = o) : ((o.next = a.next), (a.next = o)), - (e.pending = o), - (a = t.alternate), - t === Qa || (a !== null && a === Qa)) - ) - hL = pJ = !0; - else { - if ( - t.lanes === 0 && - (a === null || a.lanes === 0) && - ((a = e.lastRenderedReducer), a !== null) - ) - try { - var s = e.lastRenderedState, - c = a(s, r); - if (((o.eagerReducer = a), (o.eagerState = c), H0(c, s))) return; - } catch { - } finally { - } - US(t, i, n); - } - } - var vJ = { - readContext: G0, - useCallback: bh, - useContext: bh, - useEffect: bh, - useImperativeHandle: bh, - useLayoutEffect: bh, - useMemo: bh, - useReducer: bh, - useRef: bh, - useState: bh, - useDebugValue: bh, - useDeferredValue: bh, - useTransition: bh, - useMutableSource: bh, - useOpaqueIdentifier: bh, - unstable_isNewReconciler: !1, - }, - xDt = { - readContext: G0, - useCallback: function (t, e) { - return (K3().memoizedState = [t, e === void 0 ? null : e]), t; - }, - useContext: G0, - useEffect: ODe, - useImperativeHandle: function (t, e, r) { - return ( - (r = r != null ? r.concat([t]) : null), - Y0e(4, 2, tLe.bind(null, e, t), r) - ); - }, - useLayoutEffect: function (t, e) { - return Y0e(4, 2, t, e); - }, - useMemo: function (t, e) { - var r = K3(); - return ( - (e = e === void 0 ? null : e), - (t = t()), - (r.memoizedState = [t, e]), - t - ); - }, - useReducer: function (t, e, r) { - var n = K3(); - return ( - (e = r !== void 0 ? r(e) : e), - (n.memoizedState = n.baseState = e), - (t = n.queue = - { - pending: null, - dispatch: null, - lastRenderedReducer: t, - lastRenderedState: e, - }), - (t = t.dispatch = Jye.bind(null, Qa, t)), - [n.memoizedState, t] - ); - }, - useRef: PDe, - useState: ZF, - useDebugValue: Gye, - useDeferredValue: function (t) { - var e = ZF(t), - r = e[0], - n = e[1]; - return ( - ODe( - function () { - var i = W0.transition; - W0.transition = 1; - try { - n(t); - } finally { - W0.transition = i; - } - }, - [t] - ), - r - ); - }, - useTransition: function () { - var t = ZF(!1), - e = t[0]; - return (t = _Dt.bind(null, t[1])), PDe(t), [t, e]; - }, - useMutableSource: function (t, e, r) { - var n = K3(); - return ( - (n.memoizedState = { - refs: { getSnapshot: e, setSnapshot: null }, - source: t, - subscribe: r, - }), - YFe(n, t, e, r) - ); - }, - useOpaqueIdentifier: function () { - if (nv) { - var t = !1, - e = yDt(function () { - throw ( - (t || ((t = !0), r("r:" + (g0e++).toString(36))), - Error(Vt(355))) - ); - }), - r = ZF(e)[1]; - return ( - (Qa.mode & 2) === 0 && - ((Qa.flags |= 516), - yJ( - 5, - function () { - r("r:" + (g0e++).toString(36)); - }, - void 0, - null - )), - e - ); - } - return (e = "r:" + (g0e++).toString(36)), ZF(e), e; - }, - unstable_isNewReconciler: !1, - }, - SDt = { - readContext: G0, - useCallback: nLe, - useContext: G0, - useEffect: gJ, - useImperativeHandle: rLe, - useLayoutEffect: eLe, - useMemo: iLe, - useReducer: JF, - useRef: mJ, - useState: function () { - return JF(ev); - }, - useDebugValue: Gye, - useDeferredValue: function (t) { - var e = JF(ev), - r = e[0], - n = e[1]; - return ( - gJ( - function () { - var i = W0.transition; - W0.transition = 1; - try { - n(t); - } finally { - W0.transition = i; - } - }, - [t] - ), - r - ); - }, - useTransition: function () { - var t = JF(ev)[0]; - return [mJ().current, t]; - }, - useMutableSource: QFe, - useOpaqueIdentifier: function () { - return JF(ev)[0]; - }, - unstable_isNewReconciler: !1, - }, - ADt = { - readContext: G0, - useCallback: nLe, - useContext: G0, - useEffect: gJ, - useImperativeHandle: rLe, - useLayoutEffect: eLe, - useMemo: iLe, - useReducer: $F, - useRef: mJ, - useState: function () { - return $F(ev); - }, - useDebugValue: Gye, - useDeferredValue: function (t) { - var e = $F(ev), - r = e[0], - n = e[1]; - return ( - gJ( - function () { - var i = W0.transition; - W0.transition = 1; - try { - n(t); - } finally { - W0.transition = i; - } - }, - [t] - ), - r - ); - }, - useTransition: function () { - var t = $F(ev)[0]; - return [mJ().current, t]; - }, - useMutableSource: QFe, - useOpaqueIdentifier: function () { - return $F(ev)[0]; - }, - unstable_isNewReconciler: !1, - }, - EDt = $3.ReactCurrentOwner, - Om = !1; - function wh(t, e, r, n) { - e.child = t === null ? ZFe(e, null, r, n) : dJ(e, t.child, r, n); - } - function BDe(t, e, r, n, i) { - r = r.render; - var o = e.ref; - return ( - kI(e, i), - (n = Vye(t, e, r, n, o, i)), - t !== null && !Om - ? ((e.updateQueue = t.updateQueue), - (e.flags &= -517), - (t.lanes &= ~i), - w_(t, e, i)) - : ((e.flags |= 1), wh(t, e, n, i), e.child) - ); - } - function IDe(t, e, r, n, i, o) { - if (t === null) { - var a = r.type; - return typeof a == "function" && - !eme(a) && - a.defaultProps === void 0 && - r.compare === null && - r.defaultProps === void 0 - ? ((e.tag = 15), (e.type = a), oLe(t, e, a, n, i, o)) - : ((t = YG(r.type, null, n, e, e.mode, o)), - (t.ref = e.ref), - (t.return = e), - (e.child = t)); - } - return ( - (a = t.child), - (i & o) === 0 && - ((i = a.memoizedProps), - (r = r.compare), - (r = r !== null ? r : AL), - r(i, n) && t.ref === e.ref) - ? w_(t, e, o) - : ((e.flags |= 1), - (t = JS(a, n)), - (t.ref = e.ref), - (t.return = e), - (e.child = t)) - ); - } - function oLe(t, e, r, n, i, o) { - if (t !== null && AL(t.memoizedProps, n) && t.ref === e.ref) - if (((Om = !1), (o & i) !== 0)) (t.flags & 16384) !== 0 && (Om = !0); - else return (e.lanes = t.lanes), w_(t, e, o); - return Q0e(t, e, r, n, o); - } - function _0e(t, e, r) { - var n = e.pendingProps, - i = n.children, - o = t !== null ? t.memoizedState : null; - if (n.mode === "hidden" || n.mode === "unstable-defer-without-hiding") - if ((e.mode & 4) === 0) (e.memoizedState = { baseLanes: 0 }), UG(e, r); - else if ((r & 1073741824) !== 0) - (e.memoizedState = { baseLanes: 0 }), - UG(e, o !== null ? o.baseLanes : r); - else - return ( - (t = o !== null ? o.baseLanes | r : r), - (e.lanes = e.childLanes = 1073741824), - (e.memoizedState = { baseLanes: t }), - UG(e, t), - null - ); - else - o !== null - ? ((n = o.baseLanes | r), (e.memoizedState = null)) - : (n = r), - UG(e, n); - return wh(t, e, i, r), e.child; - } - function aLe(t, e) { - var r = e.ref; - ((t === null && r !== null) || (t !== null && t.ref !== r)) && - (e.flags |= 128); - } - function Q0e(t, e, r, n, i) { - var o = xh(r) ? V3 : Rc.current; - return ( - (o = RI(e, o)), - kI(e, i), - (r = Vye(t, e, r, n, o, i)), - t !== null && !Om - ? ((e.updateQueue = t.updateQueue), - (e.flags &= -517), - (t.lanes &= ~i), - w_(t, e, i)) - : ((e.flags |= 1), wh(t, e, r, i), e.child) - ); - } - function CDe(t, e, r, n, i) { - if (xh(r)) { - var o = !0; - GG(e); - } else o = !1; - if ((kI(e, i), e.stateNode === null)) - t !== null && - ((t.alternate = null), (e.alternate = null), (e.flags |= 2)), - JFe(e, r, n), - $0e(e, r, n, i), - (n = !0); - else if (t === null) { - var a = e.stateNode, - s = e.memoizedProps; - a.props = s; - var c = a.context, - u = r.contextType; - typeof u == "object" && u !== null - ? (u = G0(u)) - : ((u = xh(r) ? V3 : Rc.current), (u = RI(e, u))); - var h = r.getDerivedStateFromProps, - w = - typeof h == "function" || - typeof a.getSnapshotBeforeUpdate == "function"; - w || - (typeof a.UNSAFE_componentWillReceiveProps != "function" && - typeof a.componentWillReceiveProps != "function") || - ((s !== n || c !== u) && ADe(e, a, n, u)), - (BS = !1); - var M = e.memoizedState; - (a.state = M), - TL(e, n, a, i), - (c = e.memoizedState), - s !== n || M !== c || _h.current || BS - ? (typeof h == "function" && - (fJ(e, r, h, n), (c = e.memoizedState)), - (s = BS || SDe(e, r, s, n, M, c, u)) - ? (w || - (typeof a.UNSAFE_componentWillMount != "function" && - typeof a.componentWillMount != "function") || - (typeof a.componentWillMount == "function" && - a.componentWillMount(), - typeof a.UNSAFE_componentWillMount == "function" && - a.UNSAFE_componentWillMount()), - typeof a.componentDidMount == "function" && (e.flags |= 4)) - : (typeof a.componentDidMount == "function" && (e.flags |= 4), - (e.memoizedProps = n), - (e.memoizedState = c)), - (a.props = n), - (a.state = c), - (a.context = u), - (n = s)) - : (typeof a.componentDidMount == "function" && (e.flags |= 4), - (n = !1)); - } else { - (a = e.stateNode), - WFe(t, e), - (s = e.memoizedProps), - (u = e.type === e.elementType ? s : Pm(e.type, s)), - (a.props = u), - (w = e.pendingProps), - (M = a.context), - (c = r.contextType), - typeof c == "object" && c !== null - ? (c = G0(c)) - : ((c = xh(r) ? V3 : Rc.current), (c = RI(e, c))); - var k = r.getDerivedStateFromProps; - (h = - typeof k == "function" || - typeof a.getSnapshotBeforeUpdate == "function") || - (typeof a.UNSAFE_componentWillReceiveProps != "function" && - typeof a.componentWillReceiveProps != "function") || - ((s !== w || M !== c) && ADe(e, a, n, c)), - (BS = !1), - (M = e.memoizedState), - (a.state = M), - TL(e, n, a, i); - var O = e.memoizedState; - s !== w || M !== O || _h.current || BS - ? (typeof k == "function" && (fJ(e, r, k, n), (O = e.memoizedState)), - (u = BS || SDe(e, r, u, n, M, O, c)) - ? (h || - (typeof a.UNSAFE_componentWillUpdate != "function" && - typeof a.componentWillUpdate != "function") || - (typeof a.componentWillUpdate == "function" && - a.componentWillUpdate(n, O, c), - typeof a.UNSAFE_componentWillUpdate == "function" && - a.UNSAFE_componentWillUpdate(n, O, c)), - typeof a.componentDidUpdate == "function" && (e.flags |= 4), - typeof a.getSnapshotBeforeUpdate == "function" && - (e.flags |= 256)) - : (typeof a.componentDidUpdate != "function" || - (s === t.memoizedProps && M === t.memoizedState) || - (e.flags |= 4), - typeof a.getSnapshotBeforeUpdate != "function" || - (s === t.memoizedProps && M === t.memoizedState) || - (e.flags |= 256), - (e.memoizedProps = n), - (e.memoizedState = O)), - (a.props = n), - (a.state = O), - (a.context = c), - (n = u)) - : (typeof a.componentDidUpdate != "function" || - (s === t.memoizedProps && M === t.memoizedState) || - (e.flags |= 4), - typeof a.getSnapshotBeforeUpdate != "function" || - (s === t.memoizedProps && M === t.memoizedState) || - (e.flags |= 256), - (n = !1)); - } - return eye(t, e, r, n, o, i); - } - function eye(t, e, r, n, i, o) { - aLe(t, e); - var a = (e.flags & 64) !== 0; - if (!n && !a) return i && vDe(e, r, !1), w_(t, e, o); - (n = e.stateNode), (EDt.current = e); - var s = - a && typeof r.getDerivedStateFromError != "function" - ? null - : n.render(); - return ( - (e.flags |= 1), - t !== null && a - ? ((e.child = dJ(e, t.child, null, o)), (e.child = dJ(e, null, s, o))) - : wh(t, e, s, o), - (e.memoizedState = n.state), - i && vDe(e, r, !0), - e.child - ); - } - function RDe(t) { - var e = t.stateNode; - e.pendingContext - ? gDe(t, e.pendingContext, e.pendingContext !== e.context) - : e.context && gDe(t, e.context, !1), - Z0e(t, e.containerInfo); - } - var jG = { dehydrated: null, retryLane: 0 }; - function NDe(t, e, r) { - var n = e.pendingProps, - i = Ba.current, - o = !1, - a; - return ( - (a = (e.flags & 64) !== 0) || - (a = t !== null && t.memoizedState === null ? !1 : (i & 2) !== 0), - a - ? ((o = !0), (e.flags &= -65)) - : (t !== null && t.memoizedState === null) || - n.fallback === void 0 || - n.unstable_avoidThisFallback === !0 || - (i |= 1), - Ia(Ba, i & 1), - t === null - ? (n.fallback !== void 0 && X0e(e), - (t = n.children), - (i = n.fallback), - o - ? ((t = DDe(e, t, i, r)), - (e.child.memoizedState = { baseLanes: r }), - (e.memoizedState = jG), - t) - : typeof n.unstable_expectedLoadTime == "number" - ? ((t = DDe(e, t, i, r)), - (e.child.memoizedState = { baseLanes: r }), - (e.memoizedState = jG), - (e.lanes = 33554432), - t) - : ((r = tme({ mode: "visible", children: t }, e.mode, r, null)), - (r.return = e), - (e.child = r))) - : t.memoizedState !== null - ? o - ? ((n = LDe(t, e, n.children, n.fallback, r)), - (o = e.child), - (i = t.child.memoizedState), - (o.memoizedState = - i === null ? { baseLanes: r } : { baseLanes: i.baseLanes | r }), - (o.childLanes = t.childLanes & ~r), - (e.memoizedState = jG), - n) - : ((r = FDe(t, e, n.children, r)), (e.memoizedState = null), r) - : o - ? ((n = LDe(t, e, n.children, n.fallback, r)), - (o = e.child), - (i = t.child.memoizedState), - (o.memoizedState = - i === null ? { baseLanes: r } : { baseLanes: i.baseLanes | r }), - (o.childLanes = t.childLanes & ~r), - (e.memoizedState = jG), - n) - : ((r = FDe(t, e, n.children, r)), (e.memoizedState = null), r) - ); - } - function DDe(t, e, r, n) { - var i = t.mode, - o = t.child; - return ( - (e = { mode: "hidden", children: e }), - (i & 2) === 0 && o !== null - ? ((o.childLanes = 0), (o.pendingProps = e)) - : (o = tme(e, i, 0, null)), - (r = II(r, i, n, null)), - (o.return = t), - (r.return = t), - (o.sibling = r), - (t.child = o), - r - ); - } - function FDe(t, e, r, n) { - var i = t.child; - return ( - (t = i.sibling), - (r = JS(i, { mode: "visible", children: r })), - (e.mode & 2) === 0 && (r.lanes = n), - (r.return = e), - (r.sibling = null), - t !== null && - ((t.nextEffect = null), - (t.flags = 8), - (e.firstEffect = e.lastEffect = t)), - (e.child = r) - ); - } - function LDe(t, e, r, n, i) { - var o = e.mode, - a = t.child; - t = a.sibling; - var s = { mode: "hidden", children: r }; - return ( - (o & 2) === 0 && e.child !== a - ? ((r = e.child), - (r.childLanes = 0), - (r.pendingProps = s), - (a = r.lastEffect), - a !== null - ? ((e.firstEffect = r.firstEffect), - (e.lastEffect = a), - (a.nextEffect = null)) - : (e.firstEffect = e.lastEffect = null)) - : (r = JS(a, s)), - t !== null ? (n = JS(t, n)) : ((n = II(n, o, i, null)), (n.flags |= 2)), - (n.return = e), - (r.return = e), - (r.sibling = n), - (e.child = r), - n - ); - } - function qDe(t, e) { - t.lanes |= e; - var r = t.alternate; - r !== null && (r.lanes |= e), VFe(t.return, e); - } - function x0e(t, e, r, n, i, o) { - var a = t.memoizedState; - a === null - ? (t.memoizedState = { - isBackwards: e, - rendering: null, - renderingStartTime: 0, - last: n, - tail: r, - tailMode: i, - lastEffect: o, - }) - : ((a.isBackwards = e), - (a.rendering = null), - (a.renderingStartTime = 0), - (a.last = n), - (a.tail = r), - (a.tailMode = i), - (a.lastEffect = o)); - } - function zDe(t, e, r) { - var n = e.pendingProps, - i = n.revealOrder, - o = n.tail; - if ((wh(t, e, n.children, r), (n = Ba.current), (n & 2) !== 0)) - (n = (n & 1) | 2), (e.flags |= 64); - else { - if (t !== null && (t.flags & 64) !== 0) - e: for (t = e.child; t !== null; ) { - if (t.tag === 13) t.memoizedState !== null && qDe(t, r); - else if (t.tag === 19) qDe(t, r); - else if (t.child !== null) { - (t.child.return = t), (t = t.child); - continue; - } - if (t === e) break e; - for (; t.sibling === null; ) { - if (t.return === null || t.return === e) break e; - t = t.return; - } - (t.sibling.return = t.return), (t = t.sibling); - } - n &= 1; - } - if ((Ia(Ba, n), (e.mode & 2) === 0)) e.memoizedState = null; - else - switch (i) { - case "forwards": - for (r = e.child, i = null; r !== null; ) - (t = r.alternate), - t !== null && hJ(t) === null && (i = r), - (r = r.sibling); - (r = i), - r === null - ? ((i = e.child), (e.child = null)) - : ((i = r.sibling), (r.sibling = null)), - x0e(e, !1, i, r, o, e.lastEffect); - break; - case "backwards": - for (r = null, i = e.child, e.child = null; i !== null; ) { - if (((t = i.alternate), t !== null && hJ(t) === null)) { - e.child = i; - break; - } - (t = i.sibling), (i.sibling = r), (r = i), (i = t); - } - x0e(e, !0, r, null, o, e.lastEffect); - break; - case "together": - x0e(e, !1, null, null, void 0, e.lastEffect); - break; - default: - e.memoizedState = null; - } - return e.child; - } - function w_(t, e, r) { - if ( - (t !== null && (e.dependencies = t.dependencies), - (RL |= e.lanes), - (r & e.childLanes) !== 0) - ) { - if (t !== null && e.child !== t.child) throw Error(Vt(153)); - if (e.child !== null) { - for ( - t = e.child, r = JS(t, t.pendingProps), e.child = r, r.return = e; - t.sibling !== null; - - ) - (t = t.sibling), - (r = r.sibling = JS(t, t.pendingProps)), - (r.return = e); - r.sibling = null; - } - return e.child; - } - return null; - } - var sLe, tye, uLe, cLe; - sLe = function (t, e) { - for (var r = e.child; r !== null; ) { - if (r.tag === 5 || r.tag === 6) t.appendChild(r.stateNode); - else if (r.tag !== 4 && r.child !== null) { - (r.child.return = r), (r = r.child); - continue; - } - if (r === e) break; - for (; r.sibling === null; ) { - if (r.return === null || r.return === e) return; - r = r.return; - } - (r.sibling.return = r.return), (r = r.sibling); - } - }; - tye = function () {}; - uLe = function (t, e, r, n) { - var i = t.memoizedProps; - if (i !== n) { - (t = e.stateNode), U3(rv.current); - var o = null; - switch (r) { - case "input": - (i = k0e(t, i)), (n = k0e(t, n)), (o = []); - break; - case "option": - (i = B0e(t, i)), (n = B0e(t, n)), (o = []); - break; - case "select": - (i = ea({}, i, { value: void 0 })), - (n = ea({}, n, { value: void 0 })), - (o = []); - break; - case "textarea": - (i = I0e(t, i)), (n = I0e(t, n)), (o = []); - break; - default: - typeof i.onClick != "function" && - typeof n.onClick == "function" && - (t.onclick = oJ); - } - N0e(r, n); - var a; - r = null; - for (u in i) - if (!n.hasOwnProperty(u) && i.hasOwnProperty(u) && i[u] != null) - if (u === "style") { - var s = i[u]; - for (a in s) s.hasOwnProperty(a) && (r || (r = {}), (r[a] = "")); - } else - u !== "dangerouslySetInnerHTML" && - u !== "children" && - u !== "suppressContentEditableWarning" && - u !== "suppressHydrationWarning" && - u !== "autoFocus" && - (gL.hasOwnProperty(u) - ? o || (o = []) - : (o = o || []).push(u, null)); - for (u in n) { - var c = n[u]; - if ( - ((s = i?.[u]), - n.hasOwnProperty(u) && c !== s && (c != null || s != null)) - ) - if (u === "style") - if (s) { - for (a in s) - !s.hasOwnProperty(a) || - (c && c.hasOwnProperty(a)) || - (r || (r = {}), (r[a] = "")); - for (a in c) - c.hasOwnProperty(a) && - s[a] !== c[a] && - (r || (r = {}), (r[a] = c[a])); - } else r || (o || (o = []), o.push(u, r)), (r = c); - else - u === "dangerouslySetInnerHTML" - ? ((c = c ? c.__html : void 0), - (s = s ? s.__html : void 0), - c != null && s !== c && (o = o || []).push(u, c)) - : u === "children" - ? (typeof c != "string" && typeof c != "number") || - (o = o || []).push(u, "" + c) - : u !== "suppressContentEditableWarning" && - u !== "suppressHydrationWarning" && - (gL.hasOwnProperty(u) - ? (c != null && u === "onScroll" && Uo("scroll", t), - o || s === c || (o = [])) - : typeof c == "object" && c !== null && c.$$typeof === _ye - ? c.toString() - : (o = o || []).push(u, c)); - } - r && (o = o || []).push("style", r); - var u = o; - (e.updateQueue = u) && (e.flags |= 4); - } - }; - cLe = function (t, e, r, n) { - r !== n && (e.flags |= 4); - }; - function XF(t, e) { - if (!nv) - switch (t.tailMode) { - case "hidden": - e = t.tail; - for (var r = null; e !== null; ) - e.alternate !== null && (r = e), (e = e.sibling); - r === null ? (t.tail = null) : (r.sibling = null); - break; - case "collapsed": - r = t.tail; - for (var n = null; r !== null; ) - r.alternate !== null && (n = r), (r = r.sibling); - n === null - ? e || t.tail === null - ? (t.tail = null) - : (t.tail.sibling = null) - : (n.sibling = null); - } - } - function MDt(t, e, r) { - var n = e.pendingProps; - switch (e.tag) { - case 2: - case 16: - case 15: - case 0: - case 11: - case 7: - case 8: - case 12: - case 9: - case 14: - return null; - case 1: - return xh(e.type) && sJ(), null; - case 3: - return ( - DI(), - Ko(_h), - Ko(Rc), - Kye(), - (n = e.stateNode), - n.pendingContext && - ((n.context = n.pendingContext), (n.pendingContext = null)), - (t === null || t.child === null) && - (zG(e) ? (e.flags |= 4) : n.hydrate || (e.flags |= 256)), - tye(e), - null - ); - case 5: - Uye(e); - var i = U3(PL.current); - if (((r = e.type), t !== null && e.stateNode != null)) - uLe(t, e, r, n, i), t.ref !== e.ref && (e.flags |= 128); - else { - if (!n) { - if (e.stateNode === null) throw Error(Vt(166)); - return null; - } - if (((t = U3(rv.current)), zG(e))) { - (n = e.stateNode), (r = e.type); - var o = e.memoizedProps; - switch (((n[RS] = e), (n[aJ] = o), r)) { - case "dialog": - Uo("cancel", n), Uo("close", n); - break; - case "iframe": - case "object": - case "embed": - Uo("load", n); - break; - case "video": - case "audio": - for (t = 0; t < rL.length; t++) Uo(rL[t], n); - break; - case "source": - Uo("error", n); - break; - case "img": - case "image": - case "link": - Uo("error", n), Uo("load", n); - break; - case "details": - Uo("toggle", n); - break; - case "input": - U9e(n, o), Uo("invalid", n); - break; - case "select": - (n._wrapperState = { wasMultiple: !!o.multiple }), - Uo("invalid", n); - break; - case "textarea": - H9e(n, o), Uo("invalid", n); - } - N0e(r, o), (t = null); - for (var a in o) - o.hasOwnProperty(a) && - ((i = o[a]), - a === "children" - ? typeof i == "string" - ? n.textContent !== i && (t = ["children", i]) - : typeof i == "number" && - n.textContent !== "" + i && - (t = ["children", "" + i]) - : gL.hasOwnProperty(a) && - i != null && - a === "onScroll" && - Uo("scroll", n)); - switch (r) { - case "input": - BG(n), K9e(n, o, !0); - break; - case "textarea": - BG(n), V9e(n); - break; - case "select": - case "option": - break; - default: - typeof o.onClick == "function" && (n.onclick = oJ); - } - (n = t), (e.updateQueue = n), n !== null && (e.flags |= 4); - } else { - switch ( - ((a = i.nodeType === 9 ? i : i.ownerDocument), - t === C0e.html && (t = rFe(r)), - t === C0e.html - ? r === "script" - ? ((t = a.createElement("div")), - (t.innerHTML = ""), - (t = t.removeChild(t.firstChild))) - : typeof n.is == "string" - ? (t = a.createElement(r, { is: n.is })) - : ((t = a.createElement(r)), - r === "select" && - ((a = t), - n.multiple - ? (a.multiple = !0) - : n.size && (a.size = n.size))) - : (t = a.createElementNS(t, r)), - (t[RS] = e), - (t[aJ] = n), - sLe(t, e, !1, !1), - (e.stateNode = t), - (a = D0e(r, n)), - r) - ) { - case "dialog": - Uo("cancel", t), Uo("close", t), (i = n); - break; - case "iframe": - case "object": - case "embed": - Uo("load", t), (i = n); - break; - case "video": - case "audio": - for (i = 0; i < rL.length; i++) Uo(rL[i], t); - i = n; - break; - case "source": - Uo("error", t), (i = n); - break; - case "img": - case "image": - case "link": - Uo("error", t), Uo("load", t), (i = n); - break; - case "details": - Uo("toggle", t), (i = n); - break; - case "input": - U9e(t, n), (i = k0e(t, n)), Uo("invalid", t); - break; - case "option": - i = B0e(t, n); - break; - case "select": - (t._wrapperState = { wasMultiple: !!n.multiple }), - (i = ea({}, n, { value: void 0 })), - Uo("invalid", t); - break; - case "textarea": - H9e(t, n), (i = I0e(t, n)), Uo("invalid", t); - break; - default: - i = n; - } - N0e(r, i); - var s = i; - for (o in s) - if (s.hasOwnProperty(o)) { - var c = s[o]; - o === "style" - ? oFe(t, c) - : o === "dangerouslySetInnerHTML" - ? ((c = c ? c.__html : void 0), c != null && nFe(t, c)) - : o === "children" - ? typeof c == "string" - ? (r !== "textarea" || c !== "") && vL(t, c) - : typeof c == "number" && vL(t, "" + c) - : o !== "suppressContentEditableWarning" && - o !== "suppressHydrationWarning" && - o !== "autoFocus" && - (gL.hasOwnProperty(o) - ? c != null && o === "onScroll" && Uo("scroll", t) - : c != null && yye(t, o, c, a)); - } - switch (r) { - case "input": - BG(t), K9e(t, n, !1); - break; - case "textarea": - BG(t), V9e(t); - break; - case "option": - n.value != null && t.setAttribute("value", "" + HS(n.value)); - break; - case "select": - (t.multiple = !!n.multiple), - (o = n.value), - o != null - ? AI(t, !!n.multiple, o, !1) - : n.defaultValue != null && - AI(t, !!n.multiple, n.defaultValue, !0); - break; - default: - typeof i.onClick == "function" && (t.onclick = oJ); - } - DFe(r, n) && (e.flags |= 4); - } - e.ref !== null && (e.flags |= 128); - } - return null; - case 6: - if (t && e.stateNode != null) cLe(t, e, t.memoizedProps, n); - else { - if (typeof n != "string" && e.stateNode === null) - throw Error(Vt(166)); - (r = U3(PL.current)), - U3(rv.current), - zG(e) - ? ((n = e.stateNode), - (r = e.memoizedProps), - (n[RS] = e), - n.nodeValue !== r && (e.flags |= 4)) - : ((n = (r.nodeType === 9 ? r : r.ownerDocument).createTextNode( - n - )), - (n[RS] = e), - (e.stateNode = n)); - } - return null; - case 13: - return ( - Ko(Ba), - (n = e.memoizedState), - (e.flags & 64) !== 0 - ? ((e.lanes = r), e) - : ((n = n !== null), - (r = !1), - t === null - ? e.memoizedProps.fallback !== void 0 && zG(e) - : (r = t.memoizedState !== null), - n && - !r && - (e.mode & 2) !== 0 && - ((t === null && - e.memoizedProps.unstable_avoidThisFallback !== !0) || - (Ba.current & 1) !== 0 - ? Xu === 0 && (Xu = 3) - : ((Xu === 0 || Xu === 3) && (Xu = 4), - Ld === null || - ((RL & 134217727) === 0 && (zI & 134217727) === 0) || - OI(Ld, Cc))), - (n || r) && (e.flags |= 4), - null) - ); - case 4: - return ( - DI(), tye(e), t === null && CFe(e.stateNode.containerInfo), null - ); - case 10: - return zye(e), null; - case 17: - return xh(e.type) && sJ(), null; - case 19: - if ((Ko(Ba), (n = e.memoizedState), n === null)) return null; - if (((o = (e.flags & 64) !== 0), (a = n.rendering), a === null)) - if (o) XF(n, !1); - else { - if (Xu !== 0 || (t !== null && (t.flags & 64) !== 0)) - for (t = e.child; t !== null; ) { - if (((a = hJ(t)), a !== null)) { - for ( - e.flags |= 64, - XF(n, !1), - o = a.updateQueue, - o !== null && ((e.updateQueue = o), (e.flags |= 4)), - n.lastEffect === null && (e.firstEffect = null), - e.lastEffect = n.lastEffect, - n = r, - r = e.child; - r !== null; - - ) - (o = r), - (t = n), - (o.flags &= 2), - (o.nextEffect = null), - (o.firstEffect = null), - (o.lastEffect = null), - (a = o.alternate), - a === null - ? ((o.childLanes = 0), - (o.lanes = t), - (o.child = null), - (o.memoizedProps = null), - (o.memoizedState = null), - (o.updateQueue = null), - (o.dependencies = null), - (o.stateNode = null)) - : ((o.childLanes = a.childLanes), - (o.lanes = a.lanes), - (o.child = a.child), - (o.memoizedProps = a.memoizedProps), - (o.memoizedState = a.memoizedState), - (o.updateQueue = a.updateQueue), - (o.type = a.type), - (t = a.dependencies), - (o.dependencies = - t === null - ? null - : { - lanes: t.lanes, - firstContext: t.firstContext, - })), - (r = r.sibling); - return Ia(Ba, (Ba.current & 1) | 2), e.child; - } - t = t.sibling; - } - n.tail !== null && - Ic() > sye && - ((e.flags |= 64), (o = !0), XF(n, !1), (e.lanes = 33554432)); - } - else { - if (!o) - if (((t = hJ(a)), t !== null)) { - if ( - ((e.flags |= 64), - (o = !0), - (r = t.updateQueue), - r !== null && ((e.updateQueue = r), (e.flags |= 4)), - XF(n, !0), - n.tail === null && - n.tailMode === "hidden" && - !a.alternate && - !nv) - ) - return ( - (e = e.lastEffect = n.lastEffect), - e !== null && (e.nextEffect = null), - null - ); - } else - 2 * Ic() - n.renderingStartTime > sye && - r !== 1073741824 && - ((e.flags |= 64), (o = !0), XF(n, !1), (e.lanes = 33554432)); - n.isBackwards - ? ((a.sibling = e.child), (e.child = a)) - : ((r = n.last), - r !== null ? (r.sibling = a) : (e.child = a), - (n.last = a)); - } - return n.tail !== null - ? ((r = n.tail), - (n.rendering = r), - (n.tail = r.sibling), - (n.lastEffect = e.lastEffect), - (n.renderingStartTime = Ic()), - (r.sibling = null), - (e = Ba.current), - Ia(Ba, o ? (e & 1) | 2 : e & 1), - r) - : null; - case 23: - case 24: - return ( - Qye(), - t !== null && - (t.memoizedState !== null) != (e.memoizedState !== null) && - n.mode !== "unstable-defer-without-hiding" && - (e.flags |= 4), - null - ); - } - throw Error(Vt(156, e.tag)); - } - function TDt(t) { - switch (t.tag) { - case 1: - xh(t.type) && sJ(); - var e = t.flags; - return e & 4096 ? ((t.flags = (e & -4097) | 64), t) : null; - case 3: - if ((DI(), Ko(_h), Ko(Rc), Kye(), (e = t.flags), (e & 64) !== 0)) - throw Error(Vt(285)); - return (t.flags = (e & -4097) | 64), t; - case 5: - return Uye(t), null; - case 13: - return ( - Ko(Ba), - (e = t.flags), - e & 4096 ? ((t.flags = (e & -4097) | 64), t) : null - ); - case 19: - return Ko(Ba), null; - case 4: - return DI(), null; - case 10: - return zye(t), null; - case 23: - case 24: - return Qye(), null; - default: - return null; - } - } - function $ye(t, e) { - try { - var r = "", - n = e; - do (r += s9t(n)), (n = n.return); - while (n); - var i = r; - } catch (o) { - i = - ` -Error generating stack: ` + - o.message + - ` -` + - o.stack; - } - return { value: t, source: e, stack: i }; - } - function rye(t, e) { - try { - console.error(e.value); - } catch (r) { - setTimeout(function () { - throw r; - }); - } - } - var kDt = typeof WeakMap == "function" ? WeakMap : Map; - function lLe(t, e, r) { - (r = qS(-1, r)), (r.tag = 3), (r.payload = { element: null }); - var n = e.value; - return ( - (r.callback = function () { - wJ || ((wJ = !0), (uye = n)), rye(t, e); - }), - r - ); - } - function fLe(t, e, r) { - (r = qS(-1, r)), (r.tag = 3); - var n = t.type.getDerivedStateFromError; - if (typeof n == "function") { - var i = e.value; - r.payload = function () { - return rye(t, e), n(i); - }; - } - var o = t.stateNode; - return ( - o !== null && - typeof o.componentDidCatch == "function" && - (r.callback = function () { - typeof n != "function" && - (tv === null ? (tv = new Set([this])) : tv.add(this), rye(t, e)); - var a = e.stack; - this.componentDidCatch(e.value, { - componentStack: a !== null ? a : "", - }); - }), - r - ); - } - var PDt = typeof WeakSet == "function" ? WeakSet : Set; - function jDe(t) { - var e = t.ref; - if (e !== null) - if (typeof e == "function") - try { - e(null); - } catch (r) { - KS(t, r); - } - else e.current = null; - } - function ODt(t, e) { - switch (e.tag) { - case 0: - case 11: - case 15: - case 22: - return; - case 1: - if (e.flags & 256 && t !== null) { - var r = t.memoizedProps, - n = t.memoizedState; - (t = e.stateNode), - (e = t.getSnapshotBeforeUpdate( - e.elementType === e.type ? r : Pm(e.type, r), - n - )), - (t.__reactInternalSnapshotBeforeUpdate = e); - } - return; - case 3: - e.flags & 256 && Dye(e.stateNode.containerInfo); - return; - case 5: - case 6: - case 4: - case 17: - return; - } - throw Error(Vt(163)); - } - function BDt(t, e, r) { - switch (r.tag) { - case 0: - case 11: - case 15: - case 22: - if ( - ((e = r.updateQueue), - (e = e !== null ? e.lastEffect : null), - e !== null) - ) { - t = e = e.next; - do { - if ((t.tag & 3) === 3) { - var n = t.create; - t.destroy = n(); - } - t = t.next; - } while (t !== e); - } - if ( - ((e = r.updateQueue), - (e = e !== null ? e.lastEffect : null), - e !== null) - ) { - t = e = e.next; - do { - var i = t; - (n = i.next), - (i = i.tag), - (i & 4) !== 0 && (i & 1) !== 0 && (wLe(r, t), qDt(r, t)), - (t = n); - } while (t !== e); - } - return; - case 1: - (t = r.stateNode), - r.flags & 4 && - (e === null - ? t.componentDidMount() - : ((n = - r.elementType === r.type - ? e.memoizedProps - : Pm(r.type, e.memoizedProps)), - t.componentDidUpdate( - n, - e.memoizedState, - t.__reactInternalSnapshotBeforeUpdate - ))), - (e = r.updateQueue), - e !== null && xDe(r, e, t); - return; - case 3: - if (((e = r.updateQueue), e !== null)) { - if (((t = null), r.child !== null)) - switch (r.child.tag) { - case 5: - t = r.child.stateNode; - break; - case 1: - t = r.child.stateNode; - } - xDe(r, e, t); - } - return; - case 5: - (t = r.stateNode), - e === null && - r.flags & 4 && - DFe(r.type, r.memoizedProps) && - t.focus(); - return; - case 6: - return; - case 4: - return; - case 12: - return; - case 13: - r.memoizedState === null && - ((r = r.alternate), - r !== null && - ((r = r.memoizedState), - r !== null && ((r = r.dehydrated), r !== null && yFe(r)))); - return; - case 19: - case 17: - case 20: - case 21: - case 23: - case 24: - return; - } - throw Error(Vt(163)); - } - function UDe(t, e) { - for (var r = t; ; ) { - if (r.tag === 5) { - var n = r.stateNode; - if (e) - (n = n.style), - typeof n.setProperty == "function" - ? n.setProperty("display", "none", "important") - : (n.display = "none"); - else { - n = r.stateNode; - var i = r.memoizedProps.style; - (i = i != null && i.hasOwnProperty("display") ? i.display : null), - (n.style.display = iFe("display", i)); - } - } else if (r.tag === 6) - r.stateNode.nodeValue = e ? "" : r.memoizedProps; - else if ( - ((r.tag !== 23 && r.tag !== 24) || - r.memoizedState === null || - r === t) && - r.child !== null - ) { - (r.child.return = r), (r = r.child); - continue; - } - if (r === t) break; - for (; r.sibling === null; ) { - if (r.return === null || r.return === t) return; - r = r.return; - } - (r.sibling.return = r.return), (r = r.sibling); - } - } - function KDe(t, e) { - if (H3 && typeof H3.onCommitFiberUnmount == "function") - try { - H3.onCommitFiberUnmount(Fye, e); - } catch {} - switch (e.tag) { - case 0: - case 11: - case 14: - case 15: - case 22: - if ( - ((t = e.updateQueue), - t !== null && ((t = t.lastEffect), t !== null)) - ) { - var r = (t = t.next); - do { - var n = r, - i = n.destroy; - if (((n = n.tag), i !== void 0)) - if ((n & 4) !== 0) wLe(e, r); - else { - n = e; - try { - i(); - } catch (o) { - KS(n, o); - } - } - r = r.next; - } while (r !== t); - } - break; - case 1: - if ( - (jDe(e), - (t = e.stateNode), - typeof t.componentWillUnmount == "function") - ) - try { - (t.props = e.memoizedProps), - (t.state = e.memoizedState), - t.componentWillUnmount(); - } catch (o) { - KS(e, o); - } - break; - case 5: - jDe(e); - break; - case 4: - dLe(t, e); - } - } - function HDe(t) { - (t.alternate = null), - (t.child = null), - (t.dependencies = null), - (t.firstEffect = null), - (t.lastEffect = null), - (t.memoizedProps = null), - (t.memoizedState = null), - (t.pendingProps = null), - (t.return = null), - (t.updateQueue = null); - } - function VDe(t) { - return t.tag === 5 || t.tag === 3 || t.tag === 4; - } - function WDe(t) { - e: { - for (var e = t.return; e !== null; ) { - if (VDe(e)) break e; - e = e.return; - } - throw Error(Vt(160)); - } - var r = e; - switch (((e = r.stateNode), r.tag)) { - case 5: - var n = !1; - break; - case 3: - (e = e.containerInfo), (n = !0); - break; - case 4: - (e = e.containerInfo), (n = !0); - break; - default: - throw Error(Vt(161)); - } - r.flags & 16 && (vL(e, ""), (r.flags &= -17)); - e: t: for (r = t; ; ) { - for (; r.sibling === null; ) { - if (r.return === null || VDe(r.return)) { - r = null; - break e; - } - r = r.return; - } - for ( - r.sibling.return = r.return, r = r.sibling; - r.tag !== 5 && r.tag !== 6 && r.tag !== 18; - - ) { - if (r.flags & 2 || r.child === null || r.tag === 4) continue t; - (r.child.return = r), (r = r.child); - } - if (!(r.flags & 2)) { - r = r.stateNode; - break e; - } - } - n ? nye(t, r, e) : iye(t, r, e); - } - function nye(t, e, r) { - var n = t.tag, - i = n === 5 || n === 6; - if (i) - (t = i ? t.stateNode : t.stateNode.instance), - e - ? r.nodeType === 8 - ? r.parentNode.insertBefore(t, e) - : r.insertBefore(t, e) - : (r.nodeType === 8 - ? ((e = r.parentNode), e.insertBefore(t, r)) - : ((e = r), e.appendChild(t)), - (r = r._reactRootContainer), - r != null || e.onclick !== null || (e.onclick = oJ)); - else if (n !== 4 && ((t = t.child), t !== null)) - for (nye(t, e, r), t = t.sibling; t !== null; ) - nye(t, e, r), (t = t.sibling); - } - function iye(t, e, r) { - var n = t.tag, - i = n === 5 || n === 6; - if (i) - (t = i ? t.stateNode : t.stateNode.instance), - e ? r.insertBefore(t, e) : r.appendChild(t); - else if (n !== 4 && ((t = t.child), t !== null)) - for (iye(t, e, r), t = t.sibling; t !== null; ) - iye(t, e, r), (t = t.sibling); - } - function dLe(t, e) { - for (var r = e, n = !1, i, o; ; ) { - if (!n) { - n = r.return; - e: for (;;) { - if (n === null) throw Error(Vt(160)); - switch (((i = n.stateNode), n.tag)) { - case 5: - o = !1; - break e; - case 3: - (i = i.containerInfo), (o = !0); - break e; - case 4: - (i = i.containerInfo), (o = !0); - break e; - } - n = n.return; - } - n = !0; - } - if (r.tag === 5 || r.tag === 6) { - e: for (var a = t, s = r, c = s; ; ) - if ((KDe(a, c), c.child !== null && c.tag !== 4)) - (c.child.return = c), (c = c.child); - else { - if (c === s) break e; - for (; c.sibling === null; ) { - if (c.return === null || c.return === s) break e; - c = c.return; - } - (c.sibling.return = c.return), (c = c.sibling); - } - o - ? ((a = i), - (s = r.stateNode), - a.nodeType === 8 ? a.parentNode.removeChild(s) : a.removeChild(s)) - : i.removeChild(r.stateNode); - } else if (r.tag === 4) { - if (r.child !== null) { - (i = r.stateNode.containerInfo), - (o = !0), - (r.child.return = r), - (r = r.child); - continue; - } - } else if ((KDe(t, r), r.child !== null)) { - (r.child.return = r), (r = r.child); - continue; - } - if (r === e) break; - for (; r.sibling === null; ) { - if (r.return === null || r.return === e) return; - (r = r.return), r.tag === 4 && (n = !1); - } - (r.sibling.return = r.return), (r = r.sibling); - } - } - function S0e(t, e) { - switch (e.tag) { - case 0: - case 11: - case 14: - case 15: - case 22: - var r = e.updateQueue; - if (((r = r !== null ? r.lastEffect : null), r !== null)) { - var n = (r = r.next); - do - (n.tag & 3) === 3 && - ((t = n.destroy), (n.destroy = void 0), t !== void 0 && t()), - (n = n.next); - while (n !== r); - } - return; - case 1: - return; - case 5: - if (((r = e.stateNode), r != null)) { - n = e.memoizedProps; - var i = t !== null ? t.memoizedProps : n; - t = e.type; - var o = e.updateQueue; - if (((e.updateQueue = null), o !== null)) { - for ( - r[aJ] = n, - t === "input" && - n.type === "radio" && - n.name != null && - eFe(r, n), - D0e(t, i), - e = D0e(t, n), - i = 0; - i < o.length; - i += 2 - ) { - var a = o[i], - s = o[i + 1]; - a === "style" - ? oFe(r, s) - : a === "dangerouslySetInnerHTML" - ? nFe(r, s) - : a === "children" - ? vL(r, s) - : yye(r, a, s, e); - } - switch (t) { - case "input": - P0e(r, n); - break; - case "textarea": - tFe(r, n); - break; - case "select": - (t = r._wrapperState.wasMultiple), - (r._wrapperState.wasMultiple = !!n.multiple), - (o = n.value), - o != null - ? AI(r, !!n.multiple, o, !1) - : t !== !!n.multiple && - (n.defaultValue != null - ? AI(r, !!n.multiple, n.defaultValue, !0) - : AI(r, !!n.multiple, n.multiple ? [] : "", !1)); - } - } - } - return; - case 6: - if (e.stateNode === null) throw Error(Vt(162)); - e.stateNode.nodeValue = e.memoizedProps; - return; - case 3: - (r = e.stateNode), - r.hydrate && ((r.hydrate = !1), yFe(r.containerInfo)); - return; - case 12: - return; - case 13: - e.memoizedState !== null && ((Yye = Ic()), UDe(e.child, !0)), GDe(e); - return; - case 19: - GDe(e); - return; - case 17: - return; - case 23: - case 24: - UDe(e, e.memoizedState !== null); - return; - } - throw Error(Vt(163)); - } - function GDe(t) { - var e = t.updateQueue; - if (e !== null) { - t.updateQueue = null; - var r = t.stateNode; - r === null && (r = t.stateNode = new PDt()), - e.forEach(function (n) { - var i = UDt.bind(null, t, n); - r.has(n) || (r.add(n), n.then(i, i)); - }); - } - } - function IDt(t, e) { - return t !== null && - ((t = t.memoizedState), t === null || t.dehydrated !== null) - ? ((e = e.memoizedState), e !== null && e.dehydrated === null) - : !1; - } - var CDt = Math.ceil, - bJ = $3.ReactCurrentDispatcher, - Zye = $3.ReactCurrentOwner, - Vr = 0, - Ld = null, - Hs = null, - Cc = 0, - G3 = 0, - oye = $S(0), - Xu = 0, - CJ = null, - qI = 0, - RL = 0, - zI = 0, - Xye = 0, - aye = null, - Yye = 0, - sye = 1 / 0; - function jI() { - sye = Ic() + 500; - } - var cr = null, - wJ = !1, - uye = null, - tv = null, - GS = !1, - pL = null, - nL = 90, - cye = [], - lye = [], - __ = null, - yL = 0, - fye = null, - $G = -1, - v_ = 0, - ZG = 0, - mL = null, - XG = !1; - function Bp() { - return (Vr & 48) !== 0 ? Ic() : $G !== -1 ? $G : ($G = Ic()); - } - function jS(t) { - if (((t = t.mode), (t & 2) === 0)) return 1; - if ((t & 4) === 0) return NI() === 99 ? 1 : 2; - if ((v_ === 0 && (v_ = qI), wDt.transition !== 0)) { - ZG !== 0 && (ZG = aye !== null ? aye.pendingLanes : 0), (t = v_); - var e = 4186112 & ~ZG; - return ( - (e &= -e), - e === 0 && ((t = 4186112 & ~t), (e = t & -t), e === 0 && (e = 8192)), - e - ); - } - return ( - (t = NI()), - (Vr & 4) !== 0 && t === 98 - ? (t = nJ(12, v_)) - : ((t = S9t(t)), (t = nJ(t, v_))), - t - ); - } - function US(t, e, r) { - if (50 < yL) throw ((yL = 0), (fye = null), Error(Vt(185))); - if (((t = RJ(t, e)), t === null)) return null; - MJ(t, e, r), t === Ld && ((zI |= e), Xu === 4 && OI(t, Cc)); - var n = NI(); - e === 1 - ? (Vr & 8) !== 0 && (Vr & 48) === 0 - ? dye(t) - : (J0(t, r), Vr === 0 && (jI(), iv())) - : ((Vr & 4) === 0 || - (n !== 98 && n !== 99) || - (__ === null ? (__ = new Set([t])) : __.add(t)), - J0(t, r)), - (aye = t); - } - function RJ(t, e) { - t.lanes |= e; - var r = t.alternate; - for (r !== null && (r.lanes |= e), r = t, t = t.return; t !== null; ) - (t.childLanes |= e), - (r = t.alternate), - r !== null && (r.childLanes |= e), - (r = t), - (t = t.return); - return r.tag === 3 ? r.stateNode : null; - } - function J0(t, e) { - for ( - var r = t.callbackNode, - n = t.suspendedLanes, - i = t.pingedLanes, - o = t.expirationTimes, - a = t.pendingLanes; - 0 < a; - - ) { - var s = 31 - VS(a), - c = 1 << s, - u = o[s]; - if (u === -1) { - if ((c & n) === 0 || (c & i) !== 0) { - (u = e), yI(c); - var h = Po; - o[s] = 10 <= h ? u + 250 : 6 <= h ? u + 5e3 : -1; - } - } else u <= e && (t.expiredLanes |= c); - a &= ~c; - } - if (((n = xL(t, t === Ld ? Cc : 0)), (e = Po), n === 0)) - r !== null && - (r !== v0e && G0e(r), - (t.callbackNode = null), - (t.callbackPriority = 0)); - else { - if (r !== null) { - if (t.callbackPriority === e) return; - r !== v0e && G0e(r); - } - e === 15 - ? ((r = dye.bind(null, t)), - g_ === null ? ((g_ = [r]), (JG = Lye(BJ, HFe))) : g_.push(r), - (r = v0e)) - : e === 14 - ? (r = ML(99, dye.bind(null, t))) - : ((r = A9t(e)), (r = ML(r, hLe.bind(null, t)))), - (t.callbackPriority = e), - (t.callbackNode = r); - } - } - function hLe(t) { - if ((($G = -1), (ZG = v_ = 0), (Vr & 48) !== 0)) throw Error(Vt(327)); - var e = t.callbackNode; - if (ZS() && t.callbackNode !== e) return null; - var r = xL(t, t === Ld ? Cc : 0); - if (r === 0) return null; - var n = r, - i = Vr; - Vr |= 16; - var o = gLe(); - (Ld !== t || Cc !== n) && (jI(), BI(t, n)); - do - try { - DDt(); - break; - } catch (s) { - mLe(t, s); - } - while (1); - if ( - (qye(), - (bJ.current = o), - (Vr = i), - Hs !== null ? (n = 0) : ((Ld = null), (Cc = 0), (n = Xu)), - (qI & zI) !== 0) - ) - BI(t, 0); - else if (n !== 0) { - if ( - (n === 2 && - ((Vr |= 64), - t.hydrate && ((t.hydrate = !1), Dye(t.containerInfo)), - (r = xFe(t)), - r !== 0 && (n = iL(t, r))), - n === 1) - ) - throw ((e = CJ), BI(t, 0), OI(t, r), J0(t, Ic()), e); - switch ( - ((t.finishedWork = t.current.alternate), (t.finishedLanes = r), n) - ) { - case 0: - case 1: - throw Error(Vt(345)); - case 2: - L3(t); - break; - case 3: - if ( - (OI(t, r), - (r & 62914560) === r && ((n = Yye + 500 - Ic()), 10 < n)) - ) { - if (xL(t, 0) !== 0) break; - if (((i = t.suspendedLanes), (i & r) !== r)) { - Bp(), (t.pingedLanes |= t.suspendedLanes & i); - break; - } - t.timeoutHandle = pDe(L3.bind(null, t), n); - break; - } - L3(t); - break; - case 4: - if ((OI(t, r), (r & 4186112) === r)) break; - for (n = t.eventTimes, i = -1; 0 < r; ) { - var a = 31 - VS(r); - (o = 1 << a), (a = n[a]), a > i && (i = a), (r &= ~o); - } - if ( - ((r = i), - (r = Ic() - r), - (r = - (120 > r - ? 120 - : 480 > r - ? 480 - : 1080 > r - ? 1080 - : 1920 > r - ? 1920 - : 3e3 > r - ? 3e3 - : 4320 > r - ? 4320 - : 1960 * CDt(r / 1960)) - r), - 10 < r) - ) { - t.timeoutHandle = pDe(L3.bind(null, t), r); - break; - } - L3(t); - break; - case 5: - L3(t); - break; - default: - throw Error(Vt(329)); - } - } - return J0(t, Ic()), t.callbackNode === e ? hLe.bind(null, t) : null; - } - function OI(t, e) { - for ( - e &= ~Xye, - e &= ~zI, - t.suspendedLanes |= e, - t.pingedLanes &= ~e, - t = t.expirationTimes; - 0 < e; - - ) { - var r = 31 - VS(e), - n = 1 << r; - (t[r] = -1), (e &= ~n); - } - } - function dye(t) { - if ((Vr & 48) !== 0) throw Error(Vt(327)); - if ((ZS(), t === Ld && (t.expiredLanes & Cc) !== 0)) { - var e = Cc, - r = iL(t, e); - (qI & zI) !== 0 && ((e = xL(t, e)), (r = iL(t, e))); - } else (e = xL(t, 0)), (r = iL(t, e)); - if ( - (t.tag !== 0 && - r === 2 && - ((Vr |= 64), - t.hydrate && ((t.hydrate = !1), Dye(t.containerInfo)), - (e = xFe(t)), - e !== 0 && (r = iL(t, e))), - r === 1) - ) - throw ((r = CJ), BI(t, 0), OI(t, e), J0(t, Ic()), r); - return ( - (t.finishedWork = t.current.alternate), - (t.finishedLanes = e), - L3(t), - J0(t, Ic()), - null - ); - } - function RDt() { - if (__ !== null) { - var t = __; - (__ = null), - t.forEach(function (e) { - (e.expiredLanes |= 24 & e.pendingLanes), J0(e, Ic()); - }); - } - iv(); - } - function pLe(t, e) { - var r = Vr; - Vr |= 1; - try { - return t(e); - } finally { - (Vr = r), Vr === 0 && (jI(), iv()); - } - } - function yLe(t, e) { - var r = Vr; - (Vr &= -2), (Vr |= 8); - try { - return t(e); - } finally { - (Vr = r), Vr === 0 && (jI(), iv()); - } - } - function UG(t, e) { - Ia(oye, G3), (G3 |= e), (qI |= e); - } - function Qye() { - (G3 = oye.current), Ko(oye); - } - function BI(t, e) { - (t.finishedWork = null), (t.finishedLanes = 0); - var r = t.timeoutHandle; - if ((r !== -1 && ((t.timeoutHandle = -1), pDt(r)), Hs !== null)) - for (r = Hs.return; r !== null; ) { - var n = r; - switch (n.tag) { - case 1: - (n = n.type.childContextTypes), n != null && sJ(); - break; - case 3: - DI(), Ko(_h), Ko(Rc), Kye(); - break; - case 5: - Uye(n); - break; - case 4: - DI(); - break; - case 13: - Ko(Ba); - break; - case 19: - Ko(Ba); - break; - case 10: - zye(n); - break; - case 23: - case 24: - Qye(); - } - r = r.return; - } - (Ld = t), - (Hs = JS(t.current, null)), - (Cc = G3 = qI = e), - (Xu = 0), - (CJ = null), - (Xye = zI = RL = 0); - } - function mLe(t, e) { - do { - var r = Hs; - try { - if ((qye(), (dL.current = vJ), pJ)) { - for (var n = Qa.memoizedState; n !== null; ) { - var i = n.queue; - i !== null && (i.pending = null), (n = n.next); - } - pJ = !1; - } - if ( - ((OL = 0), - (Zu = Bc = Qa = null), - (hL = !1), - (Zye.current = null), - r === null || r.return === null) - ) { - (Xu = 1), (CJ = e), (Hs = null); - break; - } - e: { - var o = t, - a = r.return, - s = r, - c = e; - if ( - ((e = Cc), - (s.flags |= 2048), - (s.firstEffect = s.lastEffect = null), - c !== null && typeof c == "object" && typeof c.then == "function") - ) { - var u = c; - if ((s.mode & 2) === 0) { - var h = s.alternate; - h - ? ((s.updateQueue = h.updateQueue), - (s.memoizedState = h.memoizedState), - (s.lanes = h.lanes)) - : ((s.updateQueue = null), (s.memoizedState = null)); - } - var w = (Ba.current & 1) !== 0, - M = a; - do { - var k; - if ((k = M.tag === 13)) { - var O = M.memoizedState; - if (O !== null) k = O.dehydrated !== null; - else { - var D = M.memoizedProps; - k = - D.fallback === void 0 - ? !1 - : D.unstable_avoidThisFallback !== !0 - ? !0 - : !w; - } - } - if (k) { - var F = M.updateQueue; - if (F === null) { - var N = new Set(); - N.add(u), (M.updateQueue = N); - } else F.add(u); - if ((M.mode & 2) === 0) { - if ( - ((M.flags |= 64), - (s.flags |= 16384), - (s.flags &= -2981), - s.tag === 1) - ) - if (s.alternate === null) s.tag = 17; - else { - var q = qS(-1, 1); - (q.tag = 2), zS(s, q); - } - s.lanes |= 1; - break e; - } - (c = void 0), (s = e); - var z = o.pingCache; - if ( - (z === null - ? ((z = o.pingCache = new kDt()), - (c = new Set()), - z.set(u, c)) - : ((c = z.get(u)), - c === void 0 && ((c = new Set()), z.set(u, c))), - !c.has(s)) - ) { - c.add(s); - var H = jDt.bind(null, o, u, s); - u.then(H, H); - } - (M.flags |= 4096), (M.lanes = e); - break e; - } - M = M.return; - } while (M !== null); - c = Error( - (SI(s.type) || "A React component") + - ` suspended while rendering, but no fallback UI was specified. - -Add a component higher in the tree to provide a loading indicator or placeholder to display.` - ); - } - Xu !== 5 && (Xu = 2), (c = $ye(c, s)), (M = a); - do { - switch (M.tag) { - case 3: - (o = c), (M.flags |= 4096), (e &= -e), (M.lanes |= e); - var Z = lLe(M, o, e); - _De(M, Z); - break e; - case 1: - o = c; - var $ = M.type, - ue = M.stateNode; - if ( - (M.flags & 64) === 0 && - (typeof $.getDerivedStateFromError == "function" || - (ue !== null && - typeof ue.componentDidCatch == "function" && - (tv === null || !tv.has(ue)))) - ) { - (M.flags |= 4096), (e &= -e), (M.lanes |= e); - var te = fLe(M, o, e); - _De(M, te); - break e; - } - } - M = M.return; - } while (M !== null); - } - bLe(r); - } catch (ne) { - (e = ne), Hs === r && r !== null && (Hs = r = r.return); - continue; - } - break; - } while (1); - } - function gLe() { - var t = bJ.current; - return (bJ.current = vJ), t === null ? vJ : t; - } - function iL(t, e) { - var r = Vr; - Vr |= 16; - var n = gLe(); - (Ld === t && Cc === e) || BI(t, e); - do - try { - NDt(); - break; - } catch (i) { - mLe(t, i); - } - while (1); - if ((qye(), (Vr = r), (bJ.current = n), Hs !== null)) - throw Error(Vt(261)); - return (Ld = null), (Cc = 0), Xu; - } - function NDt() { - for (; Hs !== null; ) vLe(Hs); - } - function DDt() { - for (; Hs !== null && !gDt(); ) vLe(Hs); - } - function vLe(t) { - var e = _Le(t.alternate, t, G3); - (t.memoizedProps = t.pendingProps), - e === null ? bLe(t) : (Hs = e), - (Zye.current = null); - } - function bLe(t) { - var e = t; - do { - var r = e.alternate; - if (((t = e.return), (e.flags & 2048) === 0)) { - if (((r = MDt(r, e, G3)), r !== null)) { - Hs = r; - return; - } - if ( - ((r = e), - (r.tag !== 24 && r.tag !== 23) || - r.memoizedState === null || - (G3 & 1073741824) !== 0 || - (r.mode & 4) === 0) - ) { - for (var n = 0, i = r.child; i !== null; ) - (n |= i.lanes | i.childLanes), (i = i.sibling); - r.childLanes = n; - } - t !== null && - (t.flags & 2048) === 0 && - (t.firstEffect === null && (t.firstEffect = e.firstEffect), - e.lastEffect !== null && - (t.lastEffect !== null && - (t.lastEffect.nextEffect = e.firstEffect), - (t.lastEffect = e.lastEffect)), - 1 < e.flags && - (t.lastEffect !== null - ? (t.lastEffect.nextEffect = e) - : (t.firstEffect = e), - (t.lastEffect = e))); - } else { - if (((r = TDt(e)), r !== null)) { - (r.flags &= 2047), (Hs = r); - return; - } - t !== null && - ((t.firstEffect = t.lastEffect = null), (t.flags |= 2048)); - } - if (((e = e.sibling), e !== null)) { - Hs = e; - return; - } - Hs = e = t; - } while (e !== null); - Xu === 0 && (Xu = 5); - } - function L3(t) { - var e = NI(); - return W3(99, FDt.bind(null, t, e)), null; - } - function FDt(t, e) { - do ZS(); - while (pL !== null); - if ((Vr & 48) !== 0) throw Error(Vt(327)); - var r = t.finishedWork; - if (r === null) return null; - if (((t.finishedWork = null), (t.finishedLanes = 0), r === t.current)) - throw Error(Vt(177)); - t.callbackNode = null; - var n = r.lanes | r.childLanes, - i = n, - o = t.pendingLanes & ~i; - (t.pendingLanes = i), - (t.suspendedLanes = 0), - (t.pingedLanes = 0), - (t.expiredLanes &= i), - (t.mutableReadLanes &= i), - (t.entangledLanes &= i), - (i = t.entanglements); - for (var a = t.eventTimes, s = t.expirationTimes; 0 < o; ) { - var c = 31 - VS(o), - u = 1 << c; - (i[c] = 0), (a[c] = -1), (s[c] = -1), (o &= ~u); - } - if ( - (__ !== null && (n & 24) === 0 && __.has(t) && __.delete(t), - t === Ld && ((Hs = Ld = null), (Cc = 0)), - 1 < r.flags - ? r.lastEffect !== null - ? ((r.lastEffect.nextEffect = r), (n = r.firstEffect)) - : (n = r) - : (n = r.firstEffect), - n !== null) - ) { - if ( - ((i = Vr), - (Vr |= 32), - (Zye.current = null), - (y0e = HG), - (a = uDe()), - U0e(a)) - ) { - if ("selectionStart" in a) - s = { start: a.selectionStart, end: a.selectionEnd }; - else - e: if ( - ((s = ((s = a.ownerDocument) && s.defaultView) || window), - (u = s.getSelection && s.getSelection()) && u.rangeCount !== 0) - ) { - (s = u.anchorNode), - (o = u.anchorOffset), - (c = u.focusNode), - (u = u.focusOffset); - try { - s.nodeType, c.nodeType; - } catch { - s = null; - break e; - } - var h = 0, - w = -1, - M = -1, - k = 0, - O = 0, - D = a, - F = null; - t: for (;;) { - for ( - var N; - D !== s || (o !== 0 && D.nodeType !== 3) || (w = h + o), - D !== c || (u !== 0 && D.nodeType !== 3) || (M = h + u), - D.nodeType === 3 && (h += D.nodeValue.length), - (N = D.firstChild) !== null; - - ) - (F = D), (D = N); - for (;;) { - if (D === a) break t; - if ( - (F === s && ++k === o && (w = h), - F === c && ++O === u && (M = h), - (N = D.nextSibling) !== null) - ) - break; - (D = F), (F = D.parentNode); - } - D = N; - } - s = w === -1 || M === -1 ? null : { start: w, end: M }; - } else s = null; - s = s || { start: 0, end: 0 }; - } else s = null; - (m0e = { focusedElem: a, selectionRange: s }), - (HG = !1), - (mL = null), - (XG = !1), - (cr = n); - do - try { - LDt(); - } catch (ne) { - if (cr === null) throw Error(Vt(330)); - KS(cr, ne), (cr = cr.nextEffect); - } - while (cr !== null); - (mL = null), (cr = n); - do - try { - for (a = t; cr !== null; ) { - var q = cr.flags; - if ((q & 16 && vL(cr.stateNode, ""), q & 128)) { - var z = cr.alternate; - if (z !== null) { - var H = z.ref; - H !== null && - (typeof H == "function" ? H(null) : (H.current = null)); - } - } - switch (q & 1038) { - case 2: - WDe(cr), (cr.flags &= -3); - break; - case 6: - WDe(cr), (cr.flags &= -3), S0e(cr.alternate, cr); - break; - case 1024: - cr.flags &= -1025; - break; - case 1028: - (cr.flags &= -1025), S0e(cr.alternate, cr); - break; - case 4: - S0e(cr.alternate, cr); - break; - case 8: - (s = cr), dLe(a, s); - var Z = s.alternate; - HDe(s), Z !== null && HDe(Z); - } - cr = cr.nextEffect; - } - } catch (ne) { - if (cr === null) throw Error(Vt(330)); - KS(cr, ne), (cr = cr.nextEffect); - } - while (cr !== null); - if ( - ((H = m0e), - (z = uDe()), - (q = H.focusedElem), - (a = H.selectionRange), - z !== q && - q && - q.ownerDocument && - OFe(q.ownerDocument.documentElement, q)) - ) { - for ( - a !== null && - U0e(q) && - ((z = a.start), - (H = a.end), - H === void 0 && (H = z), - ("selectionStart" in q) - ? ((q.selectionStart = z), - (q.selectionEnd = Math.min(H, q.value.length))) - : ((H = - ((z = q.ownerDocument || document) && z.defaultView) || - window), - H.getSelection && - ((H = H.getSelection()), - (s = q.textContent.length), - (Z = Math.min(a.start, s)), - (a = a.end === void 0 ? Z : Math.min(a.end, s)), - !H.extend && Z > a && ((s = a), (a = Z), (Z = s)), - (s = sDe(q, Z)), - (o = sDe(q, a)), - s && - o && - (H.rangeCount !== 1 || - H.anchorNode !== s.node || - H.anchorOffset !== s.offset || - H.focusNode !== o.node || - H.focusOffset !== o.offset) && - ((z = z.createRange()), - z.setStart(s.node, s.offset), - H.removeAllRanges(), - Z > a - ? (H.addRange(z), H.extend(o.node, o.offset)) - : (z.setEnd(o.node, o.offset), H.addRange(z)))))), - z = [], - H = q; - (H = H.parentNode); - - ) - H.nodeType === 1 && - z.push({ element: H, left: H.scrollLeft, top: H.scrollTop }); - for ( - typeof q.focus == "function" && q.focus(), q = 0; - q < z.length; - q++ - ) - (H = z[q]), - (H.element.scrollLeft = H.left), - (H.element.scrollTop = H.top); - } - (HG = !!y0e), (m0e = y0e = null), (t.current = r), (cr = n); - do - try { - for (q = t; cr !== null; ) { - var $ = cr.flags; - if (($ & 36 && BDt(q, cr.alternate, cr), $ & 128)) { - z = void 0; - var ue = cr.ref; - if (ue !== null) { - var te = cr.stateNode; - switch (cr.tag) { - case 5: - z = te; - break; - default: - z = te; - } - typeof ue == "function" ? ue(z) : (ue.current = z); - } - } - cr = cr.nextEffect; - } - } catch (ne) { - if (cr === null) throw Error(Vt(330)); - KS(cr, ne), (cr = cr.nextEffect); - } - while (cr !== null); - (cr = null), bDt(), (Vr = i); - } else t.current = r; - if (GS) (GS = !1), (pL = t), (nL = e); - else - for (cr = n; cr !== null; ) - (e = cr.nextEffect), - (cr.nextEffect = null), - cr.flags & 8 && - (($ = cr), ($.sibling = null), ($.stateNode = null)), - (cr = e); - if ( - ((n = t.pendingLanes), - n === 0 && (tv = null), - n === 1 ? (t === fye ? yL++ : ((yL = 0), (fye = t))) : (yL = 0), - (r = r.stateNode), - H3 && typeof H3.onCommitFiberRoot == "function") - ) - try { - H3.onCommitFiberRoot(Fye, r, void 0, (r.current.flags & 64) === 64); - } catch {} - if ((J0(t, Ic()), wJ)) throw ((wJ = !1), (t = uye), (uye = null), t); - return (Vr & 8) !== 0 || iv(), null; - } - function LDt() { - for (; cr !== null; ) { - var t = cr.alternate; - XG || - mL === null || - ((cr.flags & 8) !== 0 - ? J9e(cr, mL) && (XG = !0) - : cr.tag === 13 && IDt(t, cr) && J9e(cr, mL) && (XG = !0)); - var e = cr.flags; - (e & 256) !== 0 && ODt(t, cr), - (e & 512) === 0 || - GS || - ((GS = !0), - ML(97, function () { - return ZS(), null; - })), - (cr = cr.nextEffect); - } - } - function ZS() { - if (nL !== 90) { - var t = 97 < nL ? 97 : nL; - return (nL = 90), W3(t, zDt); - } - return !1; - } - function qDt(t, e) { - cye.push(e, t), - GS || - ((GS = !0), - ML(97, function () { - return ZS(), null; - })); - } - function wLe(t, e) { - lye.push(e, t), - GS || - ((GS = !0), - ML(97, function () { - return ZS(), null; - })); - } - function zDt() { - if (pL === null) return !1; - var t = pL; - if (((pL = null), (Vr & 48) !== 0)) throw Error(Vt(331)); - var e = Vr; - Vr |= 32; - var r = lye; - lye = []; - for (var n = 0; n < r.length; n += 2) { - var i = r[n], - o = r[n + 1], - a = i.destroy; - if (((i.destroy = void 0), typeof a == "function")) - try { - a(); - } catch (c) { - if (o === null) throw Error(Vt(330)); - KS(o, c); - } - } - for (r = cye, cye = [], n = 0; n < r.length; n += 2) { - (i = r[n]), (o = r[n + 1]); - try { - var s = i.create; - i.destroy = s(); - } catch (c) { - if (o === null) throw Error(Vt(330)); - KS(o, c); - } - } - for (s = t.current.firstEffect; s !== null; ) - (t = s.nextEffect), - (s.nextEffect = null), - s.flags & 8 && ((s.sibling = null), (s.stateNode = null)), - (s = t); - return (Vr = e), iv(), !0; - } - function JDe(t, e, r) { - (e = $ye(r, e)), - (e = lLe(t, e, 1)), - zS(t, e), - (e = Bp()), - (t = RJ(t, 1)), - t !== null && (MJ(t, 1, e), J0(t, e)); - } - function KS(t, e) { - if (t.tag === 3) JDe(t, t, e); - else - for (var r = t.return; r !== null; ) { - if (r.tag === 3) { - JDe(r, t, e); - break; - } else if (r.tag === 1) { - var n = r.stateNode; - if ( - typeof r.type.getDerivedStateFromError == "function" || - (typeof n.componentDidCatch == "function" && - (tv === null || !tv.has(n))) - ) { - t = $ye(e, t); - var i = fLe(r, t, 1); - if ((zS(r, i), (i = Bp()), (r = RJ(r, 1)), r !== null)) - MJ(r, 1, i), J0(r, i); - else if ( - typeof n.componentDidCatch == "function" && - (tv === null || !tv.has(n)) - ) - try { - n.componentDidCatch(e, t); - } catch {} - break; - } - } - r = r.return; - } - } - function jDt(t, e, r) { - var n = t.pingCache; - n !== null && n.delete(e), - (e = Bp()), - (t.pingedLanes |= t.suspendedLanes & r), - Ld === t && - (Cc & r) === r && - (Xu === 4 || (Xu === 3 && (Cc & 62914560) === Cc && 500 > Ic() - Yye) - ? BI(t, 0) - : (Xye |= r)), - J0(t, e); - } - function UDt(t, e) { - var r = t.stateNode; - r !== null && r.delete(e), - (e = 0), - e === 0 && - ((e = t.mode), - (e & 2) === 0 - ? (e = 1) - : (e & 4) === 0 - ? (e = NI() === 99 ? 1 : 2) - : (v_ === 0 && (v_ = qI), - (e = mI(62914560 & ~v_)), - e === 0 && (e = 4194304))), - (r = Bp()), - (t = RJ(t, e)), - t !== null && (MJ(t, e, r), J0(t, r)); - } - var _Le; - _Le = function (t, e, r) { - var n = e.lanes; - if (t !== null) - if (t.memoizedProps !== e.pendingProps || _h.current) Om = !0; - else if ((r & n) !== 0) Om = (t.flags & 16384) !== 0; - else { - switch (((Om = !1), e.tag)) { - case 3: - RDe(e), w0e(); - break; - case 5: - EDe(e); - break; - case 1: - xh(e.type) && GG(e); - break; - case 4: - Z0e(e, e.stateNode.containerInfo); - break; - case 10: - n = e.memoizedProps.value; - var i = e.type._context; - Ia(uJ, i._currentValue), (i._currentValue = n); - break; - case 13: - if (e.memoizedState !== null) - return (r & e.child.childLanes) !== 0 - ? NDe(t, e, r) - : (Ia(Ba, Ba.current & 1), - (e = w_(t, e, r)), - e !== null ? e.sibling : null); - Ia(Ba, Ba.current & 1); - break; - case 19: - if (((n = (r & e.childLanes) !== 0), (t.flags & 64) !== 0)) { - if (n) return zDe(t, e, r); - e.flags |= 64; - } - if ( - ((i = e.memoizedState), - i !== null && - ((i.rendering = null), - (i.tail = null), - (i.lastEffect = null)), - Ia(Ba, Ba.current), - n) - ) - break; - return null; - case 23: - case 24: - return (e.lanes = 0), _0e(t, e, r); - } - return w_(t, e, r); - } - else Om = !1; - switch (((e.lanes = 0), e.tag)) { - case 2: - if ( - ((n = e.type), - t !== null && - ((t.alternate = null), (e.alternate = null), (e.flags |= 2)), - (t = e.pendingProps), - (i = RI(e, Rc.current)), - kI(e, r), - (i = Vye(null, e, n, t, i, r)), - (e.flags |= 1), - typeof i == "object" && - i !== null && - typeof i.render == "function" && - i.$$typeof === void 0) - ) { - if ( - ((e.tag = 1), - (e.memoizedState = null), - (e.updateQueue = null), - xh(n)) - ) { - var o = !0; - GG(e); - } else o = !1; - (e.memoizedState = - i.state !== null && i.state !== void 0 ? i.state : null), - jye(e); - var a = n.getDerivedStateFromProps; - typeof a == "function" && fJ(e, n, a, t), - (i.updater = IJ), - (e.stateNode = i), - (i._reactInternals = e), - $0e(e, n, t, r), - (e = eye(null, e, n, !0, o, r)); - } else (e.tag = 0), wh(null, e, i, r), (e = e.child); - return e; - case 16: - i = e.elementType; - e: { - switch ( - (t !== null && - ((t.alternate = null), (e.alternate = null), (e.flags |= 2)), - (t = e.pendingProps), - (o = i._init), - (i = o(i._payload)), - (e.type = i), - (o = e.tag = HDt(i)), - (t = Pm(i, t)), - o) - ) { - case 0: - e = Q0e(null, e, i, t, r); - break e; - case 1: - e = CDe(null, e, i, t, r); - break e; - case 11: - e = BDe(null, e, i, t, r); - break e; - case 14: - e = IDe(null, e, i, Pm(i.type, t), n, r); - break e; - } - throw Error(Vt(306, i, "")); - } - return e; - case 0: - return ( - (n = e.type), - (i = e.pendingProps), - (i = e.elementType === n ? i : Pm(n, i)), - Q0e(t, e, n, i, r) - ); - case 1: - return ( - (n = e.type), - (i = e.pendingProps), - (i = e.elementType === n ? i : Pm(n, i)), - CDe(t, e, n, i, r) - ); - case 3: - if ((RDe(e), (n = e.updateQueue), t === null || n === null)) - throw Error(Vt(282)); - if ( - ((n = e.pendingProps), - (i = e.memoizedState), - (i = i !== null ? i.element : null), - WFe(t, e), - TL(e, n, null, r), - (n = e.memoizedState.element), - n === i) - ) - w0e(), (e = w_(t, e, r)); - else { - if ( - ((i = e.stateNode), - (o = i.hydrate) && - ((NS = TI(e.stateNode.containerInfo.firstChild)), - (b_ = e), - (o = nv = !0)), - o) - ) { - if (((t = i.mutableSourceEagerHydrationData), t != null)) - for (i = 0; i < t.length; i += 2) - (o = t[i]), - (o._workInProgressVersionPrimary = t[i + 1]), - PI.push(o); - for (r = ZFe(e, null, n, r), e.child = r; r; ) - (r.flags = (r.flags & -3) | 1024), (r = r.sibling); - } else wh(t, e, n, r), w0e(); - e = e.child; - } - return e; - case 5: - return ( - EDe(e), - t === null && X0e(e), - (n = e.type), - (i = e.pendingProps), - (o = t !== null ? t.memoizedProps : null), - (a = i.children), - V0e(n, i) ? (a = null) : o !== null && V0e(n, o) && (e.flags |= 16), - aLe(t, e), - wh(t, e, a, r), - e.child - ); - case 6: - return t === null && X0e(e), null; - case 13: - return NDe(t, e, r); - case 4: - return ( - Z0e(e, e.stateNode.containerInfo), - (n = e.pendingProps), - t === null ? (e.child = dJ(e, null, n, r)) : wh(t, e, n, r), - e.child - ); - case 11: - return ( - (n = e.type), - (i = e.pendingProps), - (i = e.elementType === n ? i : Pm(n, i)), - BDe(t, e, n, i, r) - ); - case 7: - return wh(t, e, e.pendingProps, r), e.child; - case 8: - return wh(t, e, e.pendingProps.children, r), e.child; - case 12: - return wh(t, e, e.pendingProps.children, r), e.child; - case 10: - e: { - (n = e.type._context), - (i = e.pendingProps), - (a = e.memoizedProps), - (o = i.value); - var s = e.type._context; - if ((Ia(uJ, s._currentValue), (s._currentValue = o), a !== null)) - if ( - ((s = a.value), - (o = H0(s, o) - ? 0 - : (typeof n._calculateChangedBits == "function" - ? n._calculateChangedBits(s, o) - : 1073741823) | 0), - o === 0) - ) { - if (a.children === i.children && !_h.current) { - e = w_(t, e, r); - break e; - } - } else - for (s = e.child, s !== null && (s.return = e); s !== null; ) { - var c = s.dependencies; - if (c !== null) { - a = s.child; - for (var u = c.firstContext; u !== null; ) { - if (u.context === n && (u.observedBits & o) !== 0) { - s.tag === 1 && - ((u = qS(-1, r & -r)), (u.tag = 2), zS(s, u)), - (s.lanes |= r), - (u = s.alternate), - u !== null && (u.lanes |= r), - VFe(s.return, r), - (c.lanes |= r); - break; - } - u = u.next; - } - } else a = s.tag === 10 && s.type === e.type ? null : s.child; - if (a !== null) a.return = s; - else - for (a = s; a !== null; ) { - if (a === e) { - a = null; - break; - } - if (((s = a.sibling), s !== null)) { - (s.return = a.return), (a = s); - break; - } - a = a.return; - } - s = a; - } - wh(t, e, i.children, r), (e = e.child); - } - return e; - case 9: - return ( - (i = e.type), - (o = e.pendingProps), - (n = o.children), - kI(e, r), - (i = G0(i, o.unstable_observedBits)), - (n = n(i)), - (e.flags |= 1), - wh(t, e, n, r), - e.child - ); - case 14: - return ( - (i = e.type), - (o = Pm(i, e.pendingProps)), - (o = Pm(i.type, o)), - IDe(t, e, i, o, n, r) - ); - case 15: - return oLe(t, e, e.type, e.pendingProps, n, r); - case 17: - return ( - (n = e.type), - (i = e.pendingProps), - (i = e.elementType === n ? i : Pm(n, i)), - t !== null && - ((t.alternate = null), (e.alternate = null), (e.flags |= 2)), - (e.tag = 1), - xh(n) ? ((t = !0), GG(e)) : (t = !1), - kI(e, r), - JFe(e, n, i), - $0e(e, n, i, r), - eye(null, e, n, !0, t, r) - ); - case 19: - return zDe(t, e, r); - case 23: - return _0e(t, e, r); - case 24: - return _0e(t, e, r); - } - throw Error(Vt(156, e.tag)); - }; - function KDt(t, e, r, n) { - (this.tag = t), - (this.key = r), - (this.sibling = - this.child = - this.return = - this.stateNode = - this.type = - this.elementType = - null), - (this.index = 0), - (this.ref = null), - (this.pendingProps = e), - (this.dependencies = - this.memoizedState = - this.updateQueue = - this.memoizedProps = - null), - (this.mode = n), - (this.flags = 0), - (this.lastEffect = this.firstEffect = this.nextEffect = null), - (this.childLanes = this.lanes = 0), - (this.alternate = null); - } - function V0(t, e, r, n) { - return new KDt(t, e, r, n); - } - function eme(t) { - return (t = t.prototype), !(!t || !t.isReactComponent); - } - function HDt(t) { - if (typeof t == "function") return eme(t) ? 1 : 0; - if (t != null) { - if (((t = t.$$typeof), t === SJ)) return 11; - if (t === AJ) return 14; - } - return 2; - } - function JS(t, e) { - var r = t.alternate; - return ( - r === null - ? ((r = V0(t.tag, e, t.key, t.mode)), - (r.elementType = t.elementType), - (r.type = t.type), - (r.stateNode = t.stateNode), - (r.alternate = t), - (t.alternate = r)) - : ((r.pendingProps = e), - (r.type = t.type), - (r.flags = 0), - (r.nextEffect = null), - (r.firstEffect = null), - (r.lastEffect = null)), - (r.childLanes = t.childLanes), - (r.lanes = t.lanes), - (r.child = t.child), - (r.memoizedProps = t.memoizedProps), - (r.memoizedState = t.memoizedState), - (r.updateQueue = t.updateQueue), - (e = t.dependencies), - (r.dependencies = - e === null ? null : { lanes: e.lanes, firstContext: e.firstContext }), - (r.sibling = t.sibling), - (r.index = t.index), - (r.ref = t.ref), - r - ); - } - function YG(t, e, r, n, i, o) { - var a = 2; - if (((n = t), typeof t == "function")) eme(t) && (a = 1); - else if (typeof t == "string") a = 5; - else - e: switch (t) { - case IS: - return II(r.children, i, o, e); - case XDe: - (a = 8), (i |= 16); - break; - case mye: - (a = 8), (i |= 1); - break; - case oL: - return ( - (t = V0(12, r, e, i | 8)), - (t.elementType = oL), - (t.type = oL), - (t.lanes = o), - t - ); - case aL: - return ( - (t = V0(13, r, e, i)), - (t.type = aL), - (t.elementType = aL), - (t.lanes = o), - t - ); - case QG: - return ( - (t = V0(19, r, e, i)), (t.elementType = QG), (t.lanes = o), t - ); - case xye: - return tme(r, i, o, e); - case T0e: - return ( - (t = V0(24, r, e, i)), (t.elementType = T0e), (t.lanes = o), t - ); - default: - if (typeof t == "object" && t !== null) - switch (t.$$typeof) { - case gye: - a = 10; - break e; - case vye: - a = 9; - break e; - case SJ: - a = 11; - break e; - case AJ: - a = 14; - break e; - case bye: - (a = 16), (n = null); - break e; - case wye: - a = 22; - break e; - } - throw Error(Vt(130, t == null ? t : typeof t, "")); - } - return ( - (e = V0(a, r, e, i)), - (e.elementType = t), - (e.type = n), - (e.lanes = o), - e - ); - } - function II(t, e, r, n) { - return (t = V0(7, t, n, e)), (t.lanes = r), t; - } - function tme(t, e, r, n) { - return (t = V0(23, t, n, e)), (t.elementType = xye), (t.lanes = r), t; - } - function A0e(t, e, r) { - return (t = V0(6, t, null, e)), (t.lanes = r), t; - } - function E0e(t, e, r) { - return ( - (e = V0(4, t.children !== null ? t.children : [], t.key, e)), - (e.lanes = r), - (e.stateNode = { - containerInfo: t.containerInfo, - pendingChildren: null, - implementation: t.implementation, - }), - e - ); - } - function VDt(t, e, r) { - (this.tag = e), - (this.containerInfo = t), - (this.finishedWork = - this.pingCache = - this.current = - this.pendingChildren = - null), - (this.timeoutHandle = -1), - (this.pendingContext = this.context = null), - (this.hydrate = r), - (this.callbackNode = null), - (this.callbackPriority = 0), - (this.eventTimes = c0e(0)), - (this.expirationTimes = c0e(-1)), - (this.entangledLanes = - this.finishedLanes = - this.mutableReadLanes = - this.expiredLanes = - this.pingedLanes = - this.suspendedLanes = - this.pendingLanes = - 0), - (this.entanglements = c0e(0)), - (this.mutableSourceEagerHydrationData = null); - } - function WDt(t, e, r) { - var n = - 3 < arguments.length && arguments[3] !== void 0 ? arguments[3] : null; - return { - $$typeof: q3, - key: n == null ? null : "" + n, - children: t, - containerInfo: e, - implementation: r, - }; - } - function _J(t, e, r, n) { - var i = e.current, - o = Bp(), - a = jS(i); - e: if (r) { - r = r._reactInternals; - t: { - if (Z3(r) !== r || r.tag !== 1) throw Error(Vt(170)); - var s = r; - do { - switch (s.tag) { - case 3: - s = s.stateNode.context; - break t; - case 1: - if (xh(s.type)) { - s = s.stateNode.__reactInternalMemoizedMergedChildContext; - break t; - } - } - s = s.return; - } while (s !== null); - throw Error(Vt(171)); - } - if (r.tag === 1) { - var c = r.type; - if (xh(c)) { - r = LFe(r, c, s); - break e; - } - } - r = s; - } else r = WS; - return ( - e.context === null ? (e.context = r) : (e.pendingContext = r), - (e = qS(o, a)), - (e.payload = { element: t }), - (n = n === void 0 ? null : n), - n !== null && (e.callback = n), - zS(i, e), - US(i, a, o), - a - ); - } - function M0e(t) { - if (((t = t.current), !t.child)) return null; - switch (t.child.tag) { - case 5: - return t.child.stateNode; - default: - return t.child.stateNode; - } - } - function $De(t, e) { - if (((t = t.memoizedState), t !== null && t.dehydrated !== null)) { - var r = t.retryLane; - t.retryLane = r !== 0 && r < e ? r : e; - } - } - function rme(t, e) { - $De(t, e), (t = t.alternate) && $De(t, e); - } - function GDt() { - return null; - } - function nme(t, e, r) { - var n = - (r != null && - r.hydrationOptions != null && - r.hydrationOptions.mutableSources) || - null; - if ( - ((r = new VDt(t, e, r != null && r.hydrate === !0)), - (e = V0(3, null, null, e === 2 ? 7 : e === 1 ? 3 : 0)), - (r.current = e), - (e.stateNode = r), - jye(e), - (t[LI] = r.current), - CFe(t.nodeType === 8 ? t.parentNode : t), - n) - ) - for (t = 0; t < n.length; t++) { - e = n[t]; - var i = e._getVersion; - (i = i(e._source)), - r.mutableSourceEagerHydrationData == null - ? (r.mutableSourceEagerHydrationData = [e, i]) - : r.mutableSourceEagerHydrationData.push(e, i); - } - this._internalRoot = r; - } - nme.prototype.render = function (t) { - _J(t, this._internalRoot, null, null); - }; - nme.prototype.unmount = function () { - var t = this._internalRoot, - e = t.containerInfo; - _J(null, t, null, function () { - e[LI] = null; - }); - }; - function NL(t) { - return !( - !t || - (t.nodeType !== 1 && - t.nodeType !== 9 && - t.nodeType !== 11 && - (t.nodeType !== 8 || t.nodeValue !== " react-mount-point-unstable ")) - ); - } - function JDt(t, e) { - if ( - (e || - ((e = t - ? t.nodeType === 9 - ? t.documentElement - : t.firstChild - : null), - (e = !(!e || e.nodeType !== 1 || !e.hasAttribute("data-reactroot")))), - !e) - ) - for (var r; (r = t.lastChild); ) t.removeChild(r); - return new nme(t, 0, e ? { hydrate: !0 } : void 0); - } - function NJ(t, e, r, n, i) { - var o = r._reactRootContainer; - if (o) { - var a = o._internalRoot; - if (typeof i == "function") { - var s = i; - i = function () { - var u = M0e(a); - s.call(u); - }; - } - _J(e, a, t, i); - } else { - if ( - ((o = r._reactRootContainer = JDt(r, n)), - (a = o._internalRoot), - typeof i == "function") - ) { - var c = i; - i = function () { - var u = M0e(a); - c.call(u); - }; - } - yLe(function () { - _J(e, a, t, i); - }); - } - return M0e(a); - } - dFe = function (t) { - if (t.tag === 13) { - var e = Bp(); - US(t, 4, e), rme(t, 4); - } - }; - Tye = function (t) { - if (t.tag === 13) { - var e = Bp(); - US(t, 67108864, e), rme(t, 67108864); - } - }; - hFe = function (t) { - if (t.tag === 13) { - var e = Bp(), - r = jS(t); - US(t, r, e), rme(t, r); - } - }; - pFe = function (t, e) { - return e(); - }; - F0e = function (t, e, r) { - switch (e) { - case "input": - if ((P0e(t, r), (e = r.name), r.type === "radio" && e != null)) { - for (r = t; r.parentNode; ) r = r.parentNode; - for ( - r = r.querySelectorAll( - "input[name=" + JSON.stringify("" + e) + '][type="radio"]' - ), - e = 0; - e < r.length; - e++ - ) { - var n = r[e]; - if (n !== t && n.form === t.form) { - var i = OJ(n); - if (!i) throw Error(Vt(90)); - QDe(n), P0e(n, i); - } - } - } - break; - case "textarea": - tFe(t, r); - break; - case "select": - (e = r.value), e != null && AI(t, !!r.multiple, e, !1); - } - }; - Aye = pLe; - uFe = function (t, e, r, n, i) { - var o = Vr; - Vr |= 4; - try { - return W3(98, t.bind(null, e, r, n, i)); - } finally { - (Vr = o), Vr === 0 && (jI(), iv()); - } - }; - Eye = function () { - (Vr & 49) === 0 && (RDt(), ZS()); - }; - cFe = function (t, e) { - var r = Vr; - Vr |= 2; - try { - return t(e); - } finally { - (Vr = r), Vr === 0 && (jI(), iv()); - } - }; - function xLe(t, e) { - var r = - 2 < arguments.length && arguments[2] !== void 0 ? arguments[2] : null; - if (!NL(e)) throw Error(Vt(200)); - return WDt(t, e, null, r); - } - var $Dt = { Events: [IL, wI, OJ, aFe, sFe, ZS, { current: !1 }] }, - YF = { - findFiberByHostInstance: j3, - bundleType: 0, - version: "17.0.2", - rendererPackageName: "react-dom", - }, - ZDt = { - bundleType: YF.bundleType, - version: YF.version, - rendererPackageName: YF.rendererPackageName, - rendererConfig: YF.rendererConfig, - overrideHookState: null, - overrideHookStateDeletePath: null, - overrideHookStateRenamePath: null, - overrideProps: null, - overridePropsDeletePath: null, - overridePropsRenamePath: null, - setSuspenseHandler: null, - scheduleUpdate: null, - currentDispatcherRef: $3.ReactCurrentDispatcher, - findHostInstanceByFiber: function (t) { - return (t = fFe(t)), t === null ? null : t.stateNode; - }, - findFiberByHostInstance: YF.findFiberByHostInstance || GDt, - findHostInstancesForRefresh: null, - scheduleRefresh: null, - scheduleRoot: null, - setRefreshHandler: null, - getCurrentFiber: null, - }; - if ( - typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && - ((QF = __REACT_DEVTOOLS_GLOBAL_HOOK__), - !QF.isDisabled && QF.supportsFiber) - ) - try { - (Fye = QF.inject(ZDt)), (H3 = QF); - } catch {} - var QF; - $0.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = $Dt; - $0.createPortal = xLe; - $0.findDOMNode = function (t) { - if (t == null) return null; - if (t.nodeType === 1) return t; - var e = t._reactInternals; - if (e === void 0) - throw typeof t.render == "function" - ? Error(Vt(188)) - : Error(Vt(268, Object.keys(t))); - return (t = fFe(e)), (t = t === null ? null : t.stateNode), t; - }; - $0.flushSync = function (t, e) { - var r = Vr; - if ((r & 48) !== 0) return t(e); - Vr |= 1; - try { - if (t) return W3(99, t.bind(null, e)); - } finally { - (Vr = r), iv(); - } - }; - $0.hydrate = function (t, e, r) { - if (!NL(e)) throw Error(Vt(200)); - return NJ(null, t, e, !0, r); - }; - $0.render = function (t, e, r) { - if (!NL(e)) throw Error(Vt(200)); - return NJ(null, t, e, !1, r); - }; - $0.unmountComponentAtNode = function (t) { - if (!NL(t)) throw Error(Vt(40)); - return t._reactRootContainer - ? (yLe(function () { - NJ(null, null, t, !1, function () { - (t._reactRootContainer = null), (t[LI] = null); - }); - }), - !0) - : !1; - }; - $0.unstable_batchedUpdates = pLe; - $0.unstable_createPortal = function (t, e) { - return xLe( - t, - e, - 2 < arguments.length && arguments[2] !== void 0 ? arguments[2] : null - ); - }; - $0.unstable_renderSubtreeIntoContainer = function (t, e, r, n) { - if (!NL(r)) throw Error(Vt(200)); - if (t == null || t._reactInternals === void 0) throw Error(Vt(38)); - return NJ(t, e, r, !1, n); - }; - $0.version = "17.0.2"; - }); - var MLe = I((oun, ELe) => { - "use strict"; - m(); - g(); - function ALe() { - if ( - !( - typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ > "u" || - typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE != "function" - ) - ) - try { - __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(ALe); - } catch (t) { - console.error(t); - } - } - ALe(), (ELe.exports = SLe()); - }); - var QI = I((S$) => { - "use strict"; - m(); - g(); - S$.byteLength = BKt; - S$.toByteArray = CKt; - S$.fromByteArray = DKt; - var sv = [], - Z0 = [], - OKt = typeof Uint8Array < "u" ? Uint8Array : Array, - jme = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; - for (iM = 0, hze = jme.length; iM < hze; ++iM) - (sv[iM] = jme[iM]), (Z0[jme.charCodeAt(iM)] = iM); - var iM, hze; - Z0["-".charCodeAt(0)] = 62; - Z0["_".charCodeAt(0)] = 63; - function pze(t) { - var e = t.length; - if (e % 4 > 0) - throw new Error("Invalid string. Length must be a multiple of 4"); - var r = t.indexOf("="); - r === -1 && (r = e); - var n = r === e ? 0 : 4 - (r % 4); - return [r, n]; - } - function BKt(t) { - var e = pze(t), - r = e[0], - n = e[1]; - return ((r + n) * 3) / 4 - n; - } - function IKt(t, e, r) { - return ((e + r) * 3) / 4 - r; - } - function CKt(t) { - var e, - r = pze(t), - n = r[0], - i = r[1], - o = new OKt(IKt(t, n, i)), - a = 0, - s = i > 0 ? n - 4 : n, - c; - for (c = 0; c < s; c += 4) - (e = - (Z0[t.charCodeAt(c)] << 18) | - (Z0[t.charCodeAt(c + 1)] << 12) | - (Z0[t.charCodeAt(c + 2)] << 6) | - Z0[t.charCodeAt(c + 3)]), - (o[a++] = (e >> 16) & 255), - (o[a++] = (e >> 8) & 255), - (o[a++] = e & 255); - return ( - i === 2 && - ((e = (Z0[t.charCodeAt(c)] << 2) | (Z0[t.charCodeAt(c + 1)] >> 4)), - (o[a++] = e & 255)), - i === 1 && - ((e = - (Z0[t.charCodeAt(c)] << 10) | - (Z0[t.charCodeAt(c + 1)] << 4) | - (Z0[t.charCodeAt(c + 2)] >> 2)), - (o[a++] = (e >> 8) & 255), - (o[a++] = e & 255)), - o - ); - } - function RKt(t) { - return ( - sv[(t >> 18) & 63] + sv[(t >> 12) & 63] + sv[(t >> 6) & 63] + sv[t & 63] - ); - } - function NKt(t, e, r) { - for (var n, i = [], o = e; o < r; o += 3) - (n = - ((t[o] << 16) & 16711680) + - ((t[o + 1] << 8) & 65280) + - (t[o + 2] & 255)), - i.push(RKt(n)); - return i.join(""); - } - function DKt(t) { - for ( - var e, r = t.length, n = r % 3, i = [], o = 16383, a = 0, s = r - n; - a < s; - a += o - ) - i.push(NKt(t, a, a + o > s ? s : a + o)); - return ( - n === 1 - ? ((e = t[r - 1]), i.push(sv[e >> 2] + sv[(e << 4) & 63] + "==")) - : n === 2 && - ((e = (t[r - 2] << 8) + t[r - 1]), - i.push(sv[e >> 10] + sv[(e >> 4) & 63] + sv[(e << 2) & 63] + "=")), - i.join("") - ); - } - }); - var yze = I((Ume) => { - m(); - g(); - Ume.read = function (t, e, r, n, i) { - var o, - a, - s = i * 8 - n - 1, - c = (1 << s) - 1, - u = c >> 1, - h = -7, - w = r ? i - 1 : 0, - M = r ? -1 : 1, - k = t[e + w]; - for ( - w += M, o = k & ((1 << -h) - 1), k >>= -h, h += s; - h > 0; - o = o * 256 + t[e + w], w += M, h -= 8 - ); - for ( - a = o & ((1 << -h) - 1), o >>= -h, h += n; - h > 0; - a = a * 256 + t[e + w], w += M, h -= 8 - ); - if (o === 0) o = 1 - u; - else { - if (o === c) return a ? NaN : (k ? -1 : 1) * (1 / 0); - (a = a + Math.pow(2, n)), (o = o - u); - } - return (k ? -1 : 1) * a * Math.pow(2, o - n); - }; - Ume.write = function (t, e, r, n, i, o) { - var a, - s, - c, - u = o * 8 - i - 1, - h = (1 << u) - 1, - w = h >> 1, - M = i === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, - k = n ? 0 : o - 1, - O = n ? 1 : -1, - D = e < 0 || (e === 0 && 1 / e < 0) ? 1 : 0; - for ( - e = Math.abs(e), - isNaN(e) || e === 1 / 0 - ? ((s = isNaN(e) ? 1 : 0), (a = h)) - : ((a = Math.floor(Math.log(e) / Math.LN2)), - e * (c = Math.pow(2, -a)) < 1 && (a--, (c *= 2)), - a + w >= 1 ? (e += M / c) : (e += M * Math.pow(2, 1 - w)), - e * c >= 2 && (a++, (c /= 2)), - a + w >= h - ? ((s = 0), (a = h)) - : a + w >= 1 - ? ((s = (e * c - 1) * Math.pow(2, i)), (a = a + w)) - : ((s = e * Math.pow(2, w - 1) * Math.pow(2, i)), (a = 0))); - i >= 8; - t[r + k] = s & 255, k += O, s /= 256, i -= 8 - ); - for ( - a = (a << i) | s, u += i; - u > 0; - t[r + k] = a & 255, k += O, a /= 256, u -= 8 - ); - t[r + k - O] |= D * 128; - }; - }); - var Qr = I((t5) => { - "use strict"; - m(); - g(); - var Kme = QI(), - e5 = yze(), - mze = - typeof Symbol == "function" && typeof Symbol.for == "function" - ? Symbol.for("nodejs.util.inspect.custom") - : null; - t5.Buffer = bt; - t5.SlowBuffer = UKt; - t5.INSPECT_MAX_BYTES = 50; - var A$ = 2147483647; - t5.kMaxLength = A$; - bt.TYPED_ARRAY_SUPPORT = FKt(); - !bt.TYPED_ARRAY_SUPPORT && - typeof console < "u" && - 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 FKt() { - try { - var t = new Uint8Array(1), - e = { - foo: function () { - return 42; - }, - }; - return ( - Object.setPrototypeOf(e, Uint8Array.prototype), - Object.setPrototypeOf(t, e), - t.foo() === 42 - ); - } catch { - return !1; - } - } - Object.defineProperty(bt.prototype, "parent", { - enumerable: !0, - get: function () { - if (!!bt.isBuffer(this)) return this.buffer; - }, - }); - Object.defineProperty(bt.prototype, "offset", { - enumerable: !0, - get: function () { - if (!!bt.isBuffer(this)) return this.byteOffset; - }, - }); - function A_(t) { - if (t > A$) - throw new RangeError( - 'The value "' + t + '" is invalid for option "size"' - ); - var e = new Uint8Array(t); - return Object.setPrototypeOf(e, bt.prototype), e; - } - function bt(t, e, r) { - if (typeof t == "number") { - if (typeof e == "string") - throw new TypeError( - 'The "string" argument must be of type string. Received type number' - ); - return Gme(t); - } - return bze(t, e, r); - } - bt.poolSize = 8192; - function bze(t, e, r) { - if (typeof t == "string") return qKt(t, e); - if (ArrayBuffer.isView(t)) return zKt(t); - if (t == null) - throw new TypeError( - "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + - typeof t - ); - if ( - uv(t, ArrayBuffer) || - (t && uv(t.buffer, ArrayBuffer)) || - (typeof SharedArrayBuffer < "u" && - (uv(t, SharedArrayBuffer) || (t && uv(t.buffer, SharedArrayBuffer)))) - ) - return Vme(t, e, r); - if (typeof t == "number") - throw new TypeError( - 'The "value" argument must not be of type number. Received type number' - ); - var n = t.valueOf && t.valueOf(); - if (n != null && n !== t) return bt.from(n, e, r); - var i = jKt(t); - if (i) return i; - if ( - typeof Symbol < "u" && - Symbol.toPrimitive != null && - typeof t[Symbol.toPrimitive] == "function" - ) - return bt.from(t[Symbol.toPrimitive]("string"), e, r); - throw new TypeError( - "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + - typeof t - ); - } - bt.from = function (t, e, r) { - return bze(t, e, r); - }; - Object.setPrototypeOf(bt.prototype, Uint8Array.prototype); - Object.setPrototypeOf(bt, Uint8Array); - function wze(t) { - if (typeof t != "number") - throw new TypeError('"size" argument must be of type number'); - if (t < 0) - throw new RangeError( - 'The value "' + t + '" is invalid for option "size"' - ); - } - function LKt(t, e, r) { - return ( - wze(t), - t <= 0 - ? A_(t) - : e !== void 0 - ? typeof r == "string" - ? A_(t).fill(e, r) - : A_(t).fill(e) - : A_(t) - ); - } - bt.alloc = function (t, e, r) { - return LKt(t, e, r); - }; - function Gme(t) { - return wze(t), A_(t < 0 ? 0 : Jme(t) | 0); - } - bt.allocUnsafe = function (t) { - return Gme(t); - }; - bt.allocUnsafeSlow = function (t) { - return Gme(t); - }; - function qKt(t, e) { - if ( - ((typeof e != "string" || e === "") && (e = "utf8"), !bt.isEncoding(e)) - ) - throw new TypeError("Unknown encoding: " + e); - var r = _ze(t, e) | 0, - n = A_(r), - i = n.write(t, e); - return i !== r && (n = n.slice(0, i)), n; - } - function Hme(t) { - for ( - var e = t.length < 0 ? 0 : Jme(t.length) | 0, r = A_(e), n = 0; - n < e; - n += 1 - ) - r[n] = t[n] & 255; - return r; - } - function zKt(t) { - if (uv(t, Uint8Array)) { - var e = new Uint8Array(t); - return Vme(e.buffer, e.byteOffset, e.byteLength); - } - return Hme(t); - } - function Vme(t, e, r) { - if (e < 0 || t.byteLength < e) - throw new RangeError('"offset" is outside of buffer bounds'); - if (t.byteLength < e + (r || 0)) - throw new RangeError('"length" is outside of buffer bounds'); - var n; - return ( - e === void 0 && r === void 0 - ? (n = new Uint8Array(t)) - : r === void 0 - ? (n = new Uint8Array(t, e)) - : (n = new Uint8Array(t, e, r)), - Object.setPrototypeOf(n, bt.prototype), - n - ); - } - function jKt(t) { - if (bt.isBuffer(t)) { - var e = Jme(t.length) | 0, - r = A_(e); - return r.length === 0 || t.copy(r, 0, 0, e), r; - } - if (t.length !== void 0) - return typeof t.length != "number" || $me(t.length) ? A_(0) : Hme(t); - if (t.type === "Buffer" && Array.isArray(t.data)) return Hme(t.data); - } - function Jme(t) { - if (t >= A$) - throw new RangeError( - "Attempt to allocate Buffer larger than maximum size: 0x" + - A$.toString(16) + - " bytes" - ); - return t | 0; - } - function UKt(t) { - return +t != t && (t = 0), bt.alloc(+t); - } - bt.isBuffer = function (e) { - return e != null && e._isBuffer === !0 && e !== bt.prototype; - }; - bt.compare = function (e, r) { - if ( - (uv(e, Uint8Array) && (e = bt.from(e, e.offset, e.byteLength)), - uv(r, Uint8Array) && (r = bt.from(r, r.offset, r.byteLength)), - !bt.isBuffer(e) || !bt.isBuffer(r)) - ) - throw new TypeError( - 'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array' - ); - if (e === r) return 0; - for ( - var n = e.length, i = r.length, o = 0, a = Math.min(n, i); - o < a; - ++o - ) - if (e[o] !== r[o]) { - (n = e[o]), (i = r[o]); - break; - } - return n < i ? -1 : i < n ? 1 : 0; - }; - bt.isEncoding = function (e) { - switch (String(e).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 !0; - default: - return !1; - } - }; - bt.concat = function (e, r) { - if (!Array.isArray(e)) - throw new TypeError('"list" argument must be an Array of Buffers'); - if (e.length === 0) return bt.alloc(0); - var n; - if (r === void 0) for (r = 0, n = 0; n < e.length; ++n) r += e[n].length; - var i = bt.allocUnsafe(r), - o = 0; - for (n = 0; n < e.length; ++n) { - var a = e[n]; - if (uv(a, Uint8Array)) - o + a.length > i.length - ? bt.from(a).copy(i, o) - : Uint8Array.prototype.set.call(i, a, o); - else if (bt.isBuffer(a)) a.copy(i, o); - else throw new TypeError('"list" argument must be an Array of Buffers'); - o += a.length; - } - return i; - }; - function _ze(t, e) { - if (bt.isBuffer(t)) return t.length; - if (ArrayBuffer.isView(t) || uv(t, ArrayBuffer)) return t.byteLength; - if (typeof t != "string") - throw new TypeError( - 'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + - typeof t - ); - var r = t.length, - n = arguments.length > 2 && arguments[2] === !0; - if (!n && r === 0) return 0; - for (var i = !1; ; ) - switch (e) { - case "ascii": - case "latin1": - case "binary": - return r; - case "utf8": - case "utf-8": - return Wme(t).length; - case "ucs2": - case "ucs-2": - case "utf16le": - case "utf-16le": - return r * 2; - case "hex": - return r >>> 1; - case "base64": - return Tze(t).length; - default: - if (i) return n ? -1 : Wme(t).length; - (e = ("" + e).toLowerCase()), (i = !0); - } - } - bt.byteLength = _ze; - function KKt(t, e, r) { - var n = !1; - if ( - ((e === void 0 || e < 0) && (e = 0), - e > this.length || - ((r === void 0 || r > this.length) && (r = this.length), r <= 0) || - ((r >>>= 0), (e >>>= 0), r <= e)) - ) - return ""; - for (t || (t = "utf8"); ; ) - switch (t) { - case "hex": - return QKt(this, e, r); - case "utf8": - case "utf-8": - return Sze(this, e, r); - case "ascii": - return XKt(this, e, r); - case "latin1": - case "binary": - return YKt(this, e, r); - case "base64": - return $Kt(this, e, r); - case "ucs2": - case "ucs-2": - case "utf16le": - case "utf-16le": - return eHt(this, e, r); - default: - if (n) throw new TypeError("Unknown encoding: " + t); - (t = (t + "").toLowerCase()), (n = !0); - } - } - bt.prototype._isBuffer = !0; - function oM(t, e, r) { - var n = t[e]; - (t[e] = t[r]), (t[r] = n); - } - bt.prototype.swap16 = function () { - var e = this.length; - if (e % 2 !== 0) - throw new RangeError("Buffer size must be a multiple of 16-bits"); - for (var r = 0; r < e; r += 2) oM(this, r, r + 1); - return this; - }; - bt.prototype.swap32 = function () { - var e = this.length; - if (e % 4 !== 0) - throw new RangeError("Buffer size must be a multiple of 32-bits"); - for (var r = 0; r < e; r += 4) oM(this, r, r + 3), oM(this, r + 1, r + 2); - return this; - }; - bt.prototype.swap64 = function () { - var e = this.length; - if (e % 8 !== 0) - throw new RangeError("Buffer size must be a multiple of 64-bits"); - for (var r = 0; r < e; r += 8) - oM(this, r, r + 7), - oM(this, r + 1, r + 6), - oM(this, r + 2, r + 5), - oM(this, r + 3, r + 4); - return this; - }; - bt.prototype.toString = function () { - var e = this.length; - return e === 0 - ? "" - : arguments.length === 0 - ? Sze(this, 0, e) - : KKt.apply(this, arguments); - }; - bt.prototype.toLocaleString = bt.prototype.toString; - bt.prototype.equals = function (e) { - if (!bt.isBuffer(e)) throw new TypeError("Argument must be a Buffer"); - return this === e ? !0 : bt.compare(this, e) === 0; - }; - bt.prototype.inspect = function () { - var e = "", - r = t5.INSPECT_MAX_BYTES; - return ( - (e = this.toString("hex", 0, r) - .replace(/(.{2})/g, "$1 ") - .trim()), - this.length > r && (e += " ... "), - "" - ); - }; - mze && (bt.prototype[mze] = bt.prototype.inspect); - bt.prototype.compare = function (e, r, n, i, o) { - if ( - (uv(e, Uint8Array) && (e = bt.from(e, e.offset, e.byteLength)), - !bt.isBuffer(e)) - ) - throw new TypeError( - 'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + - typeof e - ); - if ( - (r === void 0 && (r = 0), - n === void 0 && (n = e ? e.length : 0), - i === void 0 && (i = 0), - o === void 0 && (o = this.length), - r < 0 || n > e.length || i < 0 || o > this.length) - ) - throw new RangeError("out of range index"); - if (i >= o && r >= n) return 0; - if (i >= o) return -1; - if (r >= n) return 1; - if (((r >>>= 0), (n >>>= 0), (i >>>= 0), (o >>>= 0), this === e)) - return 0; - for ( - var a = o - i, - s = n - r, - c = Math.min(a, s), - u = this.slice(i, o), - h = e.slice(r, n), - w = 0; - w < c; - ++w - ) - if (u[w] !== h[w]) { - (a = u[w]), (s = h[w]); - break; - } - return a < s ? -1 : s < a ? 1 : 0; - }; - function xze(t, e, r, n, i) { - if (t.length === 0) return -1; - if ( - (typeof r == "string" - ? ((n = r), (r = 0)) - : r > 2147483647 - ? (r = 2147483647) - : r < -2147483648 && (r = -2147483648), - (r = +r), - $me(r) && (r = i ? 0 : t.length - 1), - r < 0 && (r = t.length + r), - r >= t.length) - ) { - if (i) return -1; - r = t.length - 1; - } else if (r < 0) - if (i) r = 0; - else return -1; - if ((typeof e == "string" && (e = bt.from(e, n)), bt.isBuffer(e))) - return e.length === 0 ? -1 : gze(t, e, r, n, i); - if (typeof e == "number") - return ( - (e = e & 255), - typeof Uint8Array.prototype.indexOf == "function" - ? i - ? Uint8Array.prototype.indexOf.call(t, e, r) - : Uint8Array.prototype.lastIndexOf.call(t, e, r) - : gze(t, [e], r, n, i) - ); - throw new TypeError("val must be string, number or Buffer"); - } - function gze(t, e, r, n, i) { - var o = 1, - a = t.length, - s = e.length; - if ( - n !== void 0 && - ((n = String(n).toLowerCase()), - n === "ucs2" || n === "ucs-2" || n === "utf16le" || n === "utf-16le") - ) { - if (t.length < 2 || e.length < 2) return -1; - (o = 2), (a /= 2), (s /= 2), (r /= 2); - } - function c(k, O) { - return o === 1 ? k[O] : k.readUInt16BE(O * o); - } - var u; - if (i) { - var h = -1; - for (u = r; u < a; u++) - if (c(t, u) === c(e, h === -1 ? 0 : u - h)) { - if ((h === -1 && (h = u), u - h + 1 === s)) return h * o; - } else h !== -1 && (u -= u - h), (h = -1); - } else - for (r + s > a && (r = a - s), u = r; u >= 0; u--) { - for (var w = !0, M = 0; M < s; M++) - if (c(t, u + M) !== c(e, M)) { - w = !1; - break; - } - if (w) return u; - } - return -1; - } - bt.prototype.includes = function (e, r, n) { - return this.indexOf(e, r, n) !== -1; - }; - bt.prototype.indexOf = function (e, r, n) { - return xze(this, e, r, n, !0); - }; - bt.prototype.lastIndexOf = function (e, r, n) { - return xze(this, e, r, n, !1); - }; - function HKt(t, e, r, n) { - r = Number(r) || 0; - var i = t.length - r; - n ? ((n = Number(n)), n > i && (n = i)) : (n = i); - var o = e.length; - n > o / 2 && (n = o / 2); - for (var a = 0; a < n; ++a) { - var s = parseInt(e.substr(a * 2, 2), 16); - if ($me(s)) return a; - t[r + a] = s; - } - return a; - } - function VKt(t, e, r, n) { - return E$(Wme(e, t.length - r), t, r, n); - } - function WKt(t, e, r, n) { - return E$(nHt(e), t, r, n); - } - function GKt(t, e, r, n) { - return E$(Tze(e), t, r, n); - } - function JKt(t, e, r, n) { - return E$(iHt(e, t.length - r), t, r, n); - } - bt.prototype.write = function (e, r, n, i) { - if (r === void 0) (i = "utf8"), (n = this.length), (r = 0); - else if (n === void 0 && typeof r == "string") - (i = r), (n = this.length), (r = 0); - else if (isFinite(r)) - (r = r >>> 0), - isFinite(n) - ? ((n = n >>> 0), i === void 0 && (i = "utf8")) - : ((i = n), (n = void 0)); - else - throw new Error( - "Buffer.write(string, encoding, offset[, length]) is no longer supported" - ); - var o = this.length - r; - if ( - ((n === void 0 || n > o) && (n = o), - (e.length > 0 && (n < 0 || r < 0)) || r > this.length) - ) - throw new RangeError("Attempt to write outside buffer bounds"); - i || (i = "utf8"); - for (var a = !1; ; ) - switch (i) { - case "hex": - return HKt(this, e, r, n); - case "utf8": - case "utf-8": - return VKt(this, e, r, n); - case "ascii": - case "latin1": - case "binary": - return WKt(this, e, r, n); - case "base64": - return GKt(this, e, r, n); - case "ucs2": - case "ucs-2": - case "utf16le": - case "utf-16le": - return JKt(this, e, r, n); - default: - if (a) throw new TypeError("Unknown encoding: " + i); - (i = ("" + i).toLowerCase()), (a = !0); - } - }; - bt.prototype.toJSON = function () { - return { - type: "Buffer", - data: Array.prototype.slice.call(this._arr || this, 0), - }; - }; - function $Kt(t, e, r) { - return e === 0 && r === t.length - ? Kme.fromByteArray(t) - : Kme.fromByteArray(t.slice(e, r)); - } - function Sze(t, e, r) { - r = Math.min(t.length, r); - for (var n = [], i = e; i < r; ) { - var o = t[i], - a = null, - s = o > 239 ? 4 : o > 223 ? 3 : o > 191 ? 2 : 1; - if (i + s <= r) { - var c, u, h, w; - switch (s) { - case 1: - o < 128 && (a = o); - break; - case 2: - (c = t[i + 1]), - (c & 192) === 128 && - ((w = ((o & 31) << 6) | (c & 63)), w > 127 && (a = w)); - break; - case 3: - (c = t[i + 1]), - (u = t[i + 2]), - (c & 192) === 128 && - (u & 192) === 128 && - ((w = ((o & 15) << 12) | ((c & 63) << 6) | (u & 63)), - w > 2047 && (w < 55296 || w > 57343) && (a = w)); - break; - case 4: - (c = t[i + 1]), - (u = t[i + 2]), - (h = t[i + 3]), - (c & 192) === 128 && - (u & 192) === 128 && - (h & 192) === 128 && - ((w = - ((o & 15) << 18) | - ((c & 63) << 12) | - ((u & 63) << 6) | - (h & 63)), - w > 65535 && w < 1114112 && (a = w)); - } - } - a === null - ? ((a = 65533), (s = 1)) - : a > 65535 && - ((a -= 65536), - n.push(((a >>> 10) & 1023) | 55296), - (a = 56320 | (a & 1023))), - n.push(a), - (i += s); - } - return ZKt(n); - } - var vze = 4096; - function ZKt(t) { - var e = t.length; - if (e <= vze) return String.fromCharCode.apply(String, t); - for (var r = "", n = 0; n < e; ) - r += String.fromCharCode.apply(String, t.slice(n, (n += vze))); - return r; - } - function XKt(t, e, r) { - var n = ""; - r = Math.min(t.length, r); - for (var i = e; i < r; ++i) n += String.fromCharCode(t[i] & 127); - return n; - } - function YKt(t, e, r) { - var n = ""; - r = Math.min(t.length, r); - for (var i = e; i < r; ++i) n += String.fromCharCode(t[i]); - return n; - } - function QKt(t, e, r) { - var n = t.length; - (!e || e < 0) && (e = 0), (!r || r < 0 || r > n) && (r = n); - for (var i = "", o = e; o < r; ++o) i += oHt[t[o]]; - return i; - } - function eHt(t, e, r) { - for (var n = t.slice(e, r), i = "", o = 0; o < n.length - 1; o += 2) - i += String.fromCharCode(n[o] + n[o + 1] * 256); - return i; - } - bt.prototype.slice = function (e, r) { - var n = this.length; - (e = ~~e), - (r = r === void 0 ? n : ~~r), - e < 0 ? ((e += n), e < 0 && (e = 0)) : e > n && (e = n), - r < 0 ? ((r += n), r < 0 && (r = 0)) : r > n && (r = n), - r < e && (r = e); - var i = this.subarray(e, r); - return Object.setPrototypeOf(i, bt.prototype), i; - }; - function vu(t, e, r) { - if (t % 1 !== 0 || t < 0) throw new RangeError("offset is not uint"); - if (t + e > r) - throw new RangeError("Trying to access beyond buffer length"); - } - bt.prototype.readUintLE = bt.prototype.readUIntLE = function (e, r, n) { - (e = e >>> 0), (r = r >>> 0), n || vu(e, r, this.length); - for (var i = this[e], o = 1, a = 0; ++a < r && (o *= 256); ) - i += this[e + a] * o; - return i; - }; - bt.prototype.readUintBE = bt.prototype.readUIntBE = function (e, r, n) { - (e = e >>> 0), (r = r >>> 0), n || vu(e, r, this.length); - for (var i = this[e + --r], o = 1; r > 0 && (o *= 256); ) - i += this[e + --r] * o; - return i; - }; - bt.prototype.readUint8 = bt.prototype.readUInt8 = function (e, r) { - return (e = e >>> 0), r || vu(e, 1, this.length), this[e]; - }; - bt.prototype.readUint16LE = bt.prototype.readUInt16LE = function (e, r) { - return ( - (e = e >>> 0), r || vu(e, 2, this.length), this[e] | (this[e + 1] << 8) - ); - }; - bt.prototype.readUint16BE = bt.prototype.readUInt16BE = function (e, r) { - return ( - (e = e >>> 0), r || vu(e, 2, this.length), (this[e] << 8) | this[e + 1] - ); - }; - bt.prototype.readUint32LE = bt.prototype.readUInt32LE = function (e, r) { - return ( - (e = e >>> 0), - r || vu(e, 4, this.length), - (this[e] | (this[e + 1] << 8) | (this[e + 2] << 16)) + - this[e + 3] * 16777216 - ); - }; - bt.prototype.readUint32BE = bt.prototype.readUInt32BE = function (e, r) { - return ( - (e = e >>> 0), - r || vu(e, 4, this.length), - this[e] * 16777216 + - ((this[e + 1] << 16) | (this[e + 2] << 8) | this[e + 3]) - ); - }; - bt.prototype.readIntLE = function (e, r, n) { - (e = e >>> 0), (r = r >>> 0), n || vu(e, r, this.length); - for (var i = this[e], o = 1, a = 0; ++a < r && (o *= 256); ) - i += this[e + a] * o; - return (o *= 128), i >= o && (i -= Math.pow(2, 8 * r)), i; - }; - bt.prototype.readIntBE = function (e, r, n) { - (e = e >>> 0), (r = r >>> 0), n || vu(e, r, this.length); - for (var i = r, o = 1, a = this[e + --i]; i > 0 && (o *= 256); ) - a += this[e + --i] * o; - return (o *= 128), a >= o && (a -= Math.pow(2, 8 * r)), a; - }; - bt.prototype.readInt8 = function (e, r) { - return ( - (e = e >>> 0), - r || vu(e, 1, this.length), - this[e] & 128 ? (255 - this[e] + 1) * -1 : this[e] - ); - }; - bt.prototype.readInt16LE = function (e, r) { - (e = e >>> 0), r || vu(e, 2, this.length); - var n = this[e] | (this[e + 1] << 8); - return n & 32768 ? n | 4294901760 : n; - }; - bt.prototype.readInt16BE = function (e, r) { - (e = e >>> 0), r || vu(e, 2, this.length); - var n = this[e + 1] | (this[e] << 8); - return n & 32768 ? n | 4294901760 : n; - }; - bt.prototype.readInt32LE = function (e, r) { - return ( - (e = e >>> 0), - r || vu(e, 4, this.length), - this[e] | (this[e + 1] << 8) | (this[e + 2] << 16) | (this[e + 3] << 24) - ); - }; - bt.prototype.readInt32BE = function (e, r) { - return ( - (e = e >>> 0), - r || vu(e, 4, this.length), - (this[e] << 24) | (this[e + 1] << 16) | (this[e + 2] << 8) | this[e + 3] - ); - }; - bt.prototype.readFloatLE = function (e, r) { - return ( - (e = e >>> 0), r || vu(e, 4, this.length), e5.read(this, e, !0, 23, 4) - ); - }; - bt.prototype.readFloatBE = function (e, r) { - return ( - (e = e >>> 0), r || vu(e, 4, this.length), e5.read(this, e, !1, 23, 4) - ); - }; - bt.prototype.readDoubleLE = function (e, r) { - return ( - (e = e >>> 0), r || vu(e, 8, this.length), e5.read(this, e, !0, 52, 8) - ); - }; - bt.prototype.readDoubleBE = function (e, r) { - return ( - (e = e >>> 0), r || vu(e, 8, this.length), e5.read(this, e, !1, 52, 8) - ); - }; - function Th(t, e, r, n, i, o) { - if (!bt.isBuffer(t)) - throw new TypeError('"buffer" argument must be a Buffer instance'); - if (e > i || e < o) - throw new RangeError('"value" argument is out of bounds'); - if (r + n > t.length) throw new RangeError("Index out of range"); - } - bt.prototype.writeUintLE = bt.prototype.writeUIntLE = function ( - e, - r, - n, - i - ) { - if (((e = +e), (r = r >>> 0), (n = n >>> 0), !i)) { - var o = Math.pow(2, 8 * n) - 1; - Th(this, e, r, n, o, 0); - } - var a = 1, - s = 0; - for (this[r] = e & 255; ++s < n && (a *= 256); ) - this[r + s] = (e / a) & 255; - return r + n; - }; - bt.prototype.writeUintBE = bt.prototype.writeUIntBE = function ( - e, - r, - n, - i - ) { - if (((e = +e), (r = r >>> 0), (n = n >>> 0), !i)) { - var o = Math.pow(2, 8 * n) - 1; - Th(this, e, r, n, o, 0); - } - var a = n - 1, - s = 1; - for (this[r + a] = e & 255; --a >= 0 && (s *= 256); ) - this[r + a] = (e / s) & 255; - return r + n; - }; - bt.prototype.writeUint8 = bt.prototype.writeUInt8 = function (e, r, n) { - return ( - (e = +e), - (r = r >>> 0), - n || Th(this, e, r, 1, 255, 0), - (this[r] = e & 255), - r + 1 - ); - }; - bt.prototype.writeUint16LE = bt.prototype.writeUInt16LE = function ( - e, - r, - n - ) { - return ( - (e = +e), - (r = r >>> 0), - n || Th(this, e, r, 2, 65535, 0), - (this[r] = e & 255), - (this[r + 1] = e >>> 8), - r + 2 - ); - }; - bt.prototype.writeUint16BE = bt.prototype.writeUInt16BE = function ( - e, - r, - n - ) { - return ( - (e = +e), - (r = r >>> 0), - n || Th(this, e, r, 2, 65535, 0), - (this[r] = e >>> 8), - (this[r + 1] = e & 255), - r + 2 - ); - }; - bt.prototype.writeUint32LE = bt.prototype.writeUInt32LE = function ( - e, - r, - n - ) { - return ( - (e = +e), - (r = r >>> 0), - n || Th(this, e, r, 4, 4294967295, 0), - (this[r + 3] = e >>> 24), - (this[r + 2] = e >>> 16), - (this[r + 1] = e >>> 8), - (this[r] = e & 255), - r + 4 - ); - }; - bt.prototype.writeUint32BE = bt.prototype.writeUInt32BE = function ( - e, - r, - n - ) { - return ( - (e = +e), - (r = r >>> 0), - n || Th(this, e, r, 4, 4294967295, 0), - (this[r] = e >>> 24), - (this[r + 1] = e >>> 16), - (this[r + 2] = e >>> 8), - (this[r + 3] = e & 255), - r + 4 - ); - }; - bt.prototype.writeIntLE = function (e, r, n, i) { - if (((e = +e), (r = r >>> 0), !i)) { - var o = Math.pow(2, 8 * n - 1); - Th(this, e, r, n, o - 1, -o); - } - var a = 0, - s = 1, - c = 0; - for (this[r] = e & 255; ++a < n && (s *= 256); ) - e < 0 && c === 0 && this[r + a - 1] !== 0 && (c = 1), - (this[r + a] = (((e / s) >> 0) - c) & 255); - return r + n; - }; - bt.prototype.writeIntBE = function (e, r, n, i) { - if (((e = +e), (r = r >>> 0), !i)) { - var o = Math.pow(2, 8 * n - 1); - Th(this, e, r, n, o - 1, -o); - } - var a = n - 1, - s = 1, - c = 0; - for (this[r + a] = e & 255; --a >= 0 && (s *= 256); ) - e < 0 && c === 0 && this[r + a + 1] !== 0 && (c = 1), - (this[r + a] = (((e / s) >> 0) - c) & 255); - return r + n; - }; - bt.prototype.writeInt8 = function (e, r, n) { - return ( - (e = +e), - (r = r >>> 0), - n || Th(this, e, r, 1, 127, -128), - e < 0 && (e = 255 + e + 1), - (this[r] = e & 255), - r + 1 - ); - }; - bt.prototype.writeInt16LE = function (e, r, n) { - return ( - (e = +e), - (r = r >>> 0), - n || Th(this, e, r, 2, 32767, -32768), - (this[r] = e & 255), - (this[r + 1] = e >>> 8), - r + 2 - ); - }; - bt.prototype.writeInt16BE = function (e, r, n) { - return ( - (e = +e), - (r = r >>> 0), - n || Th(this, e, r, 2, 32767, -32768), - (this[r] = e >>> 8), - (this[r + 1] = e & 255), - r + 2 - ); - }; - bt.prototype.writeInt32LE = function (e, r, n) { - return ( - (e = +e), - (r = r >>> 0), - n || Th(this, e, r, 4, 2147483647, -2147483648), - (this[r] = e & 255), - (this[r + 1] = e >>> 8), - (this[r + 2] = e >>> 16), - (this[r + 3] = e >>> 24), - r + 4 - ); - }; - bt.prototype.writeInt32BE = function (e, r, n) { - return ( - (e = +e), - (r = r >>> 0), - n || Th(this, e, r, 4, 2147483647, -2147483648), - e < 0 && (e = 4294967295 + e + 1), - (this[r] = e >>> 24), - (this[r + 1] = e >>> 16), - (this[r + 2] = e >>> 8), - (this[r + 3] = e & 255), - r + 4 - ); - }; - function Aze(t, e, r, n, i, o) { - if (r + n > t.length) throw new RangeError("Index out of range"); - if (r < 0) throw new RangeError("Index out of range"); - } - function Eze(t, e, r, n, i) { - return ( - (e = +e), - (r = r >>> 0), - i || Aze(t, e, r, 4, 34028234663852886e22, -34028234663852886e22), - e5.write(t, e, r, n, 23, 4), - r + 4 - ); - } - bt.prototype.writeFloatLE = function (e, r, n) { - return Eze(this, e, r, !0, n); - }; - bt.prototype.writeFloatBE = function (e, r, n) { - return Eze(this, e, r, !1, n); - }; - function Mze(t, e, r, n, i) { - return ( - (e = +e), - (r = r >>> 0), - i || Aze(t, e, r, 8, 17976931348623157e292, -17976931348623157e292), - e5.write(t, e, r, n, 52, 8), - r + 8 - ); - } - bt.prototype.writeDoubleLE = function (e, r, n) { - return Mze(this, e, r, !0, n); - }; - bt.prototype.writeDoubleBE = function (e, r, n) { - return Mze(this, e, r, !1, n); - }; - bt.prototype.copy = function (e, r, n, i) { - if (!bt.isBuffer(e)) throw new TypeError("argument should be a Buffer"); - if ( - (n || (n = 0), - !i && i !== 0 && (i = this.length), - r >= e.length && (r = e.length), - r || (r = 0), - i > 0 && i < n && (i = n), - i === n || e.length === 0 || this.length === 0) - ) - return 0; - if (r < 0) throw new RangeError("targetStart out of bounds"); - if (n < 0 || n >= this.length) throw new RangeError("Index out of range"); - if (i < 0) throw new RangeError("sourceEnd out of bounds"); - i > this.length && (i = this.length), - e.length - r < i - n && (i = e.length - r + n); - var o = i - n; - return ( - this === e && typeof Uint8Array.prototype.copyWithin == "function" - ? this.copyWithin(r, n, i) - : Uint8Array.prototype.set.call(e, this.subarray(n, i), r), - o - ); - }; - bt.prototype.fill = function (e, r, n, i) { - if (typeof e == "string") { - if ( - (typeof r == "string" - ? ((i = r), (r = 0), (n = this.length)) - : typeof n == "string" && ((i = n), (n = this.length)), - i !== void 0 && typeof i != "string") - ) - throw new TypeError("encoding must be a string"); - if (typeof i == "string" && !bt.isEncoding(i)) - throw new TypeError("Unknown encoding: " + i); - if (e.length === 1) { - var o = e.charCodeAt(0); - ((i === "utf8" && o < 128) || i === "latin1") && (e = o); - } - } else - typeof e == "number" - ? (e = e & 255) - : typeof e == "boolean" && (e = Number(e)); - if (r < 0 || this.length < r || this.length < n) - throw new RangeError("Out of range index"); - if (n <= r) return this; - (r = r >>> 0), (n = n === void 0 ? this.length : n >>> 0), e || (e = 0); - var a; - if (typeof e == "number") for (a = r; a < n; ++a) this[a] = e; - else { - var s = bt.isBuffer(e) ? e : bt.from(e, i), - c = s.length; - if (c === 0) - throw new TypeError( - 'The value "' + e + '" is invalid for argument "value"' - ); - for (a = 0; a < n - r; ++a) this[a + r] = s[a % c]; - } - return this; - }; - var tHt = /[^+/0-9A-Za-z-_]/g; - function rHt(t) { - if ( - ((t = t.split("=")[0]), (t = t.trim().replace(tHt, "")), t.length < 2) - ) - return ""; - for (; t.length % 4 !== 0; ) t = t + "="; - return t; - } - function Wme(t, e) { - e = e || 1 / 0; - for (var r, n = t.length, i = null, o = [], a = 0; a < n; ++a) { - if (((r = t.charCodeAt(a)), r > 55295 && r < 57344)) { - if (!i) { - if (r > 56319) { - (e -= 3) > -1 && o.push(239, 191, 189); - continue; - } else if (a + 1 === n) { - (e -= 3) > -1 && o.push(239, 191, 189); - continue; - } - i = r; - continue; - } - if (r < 56320) { - (e -= 3) > -1 && o.push(239, 191, 189), (i = r); - continue; - } - r = (((i - 55296) << 10) | (r - 56320)) + 65536; - } else i && (e -= 3) > -1 && o.push(239, 191, 189); - if (((i = null), r < 128)) { - if ((e -= 1) < 0) break; - o.push(r); - } else if (r < 2048) { - if ((e -= 2) < 0) break; - o.push((r >> 6) | 192, (r & 63) | 128); - } else if (r < 65536) { - if ((e -= 3) < 0) break; - o.push((r >> 12) | 224, ((r >> 6) & 63) | 128, (r & 63) | 128); - } else if (r < 1114112) { - if ((e -= 4) < 0) break; - o.push( - (r >> 18) | 240, - ((r >> 12) & 63) | 128, - ((r >> 6) & 63) | 128, - (r & 63) | 128 - ); - } else throw new Error("Invalid code point"); - } - return o; - } - function nHt(t) { - for (var e = [], r = 0; r < t.length; ++r) e.push(t.charCodeAt(r) & 255); - return e; - } - function iHt(t, e) { - for (var r, n, i, o = [], a = 0; a < t.length && !((e -= 2) < 0); ++a) - (r = t.charCodeAt(a)), - (n = r >> 8), - (i = r % 256), - o.push(i), - o.push(n); - return o; - } - function Tze(t) { - return Kme.toByteArray(rHt(t)); - } - function E$(t, e, r, n) { - for (var i = 0; i < n && !(i + r >= e.length || i >= t.length); ++i) - e[i + r] = t[i]; - return i; - } - function uv(t, e) { - return ( - t instanceof e || - (t != null && - t.constructor != null && - t.constructor.name != null && - t.constructor.name === e.name) - ); - } - function $me(t) { - return t !== t; - } - var oHt = (function () { - for (var t = "0123456789abcdef", e = new Array(256), r = 0; r < 16; ++r) - for (var n = r * 16, i = 0; i < 16; ++i) e[n + i] = t[r] + t[i]; - return e; - })(); - }); - var T$ = I((zd) => { - "use strict"; - m(); - g(); - Object.defineProperty(zd, "__esModule", { value: !0 }); - zd.output = zd.exists = zd.hash = zd.bytes = zd.bool = zd.number = void 0; - function M$(t) { - if (!Number.isSafeInteger(t) || t < 0) - throw new Error(`Wrong positive integer: ${t}`); - } - zd.number = M$; - function kze(t) { - if (typeof t != "boolean") throw new Error(`Expected boolean, not ${t}`); - } - zd.bool = kze; - function Zme(t, ...e) { - if (!(t instanceof Uint8Array)) - throw new TypeError("Expected Uint8Array"); - if (e.length > 0 && !e.includes(t.length)) - throw new TypeError( - `Expected Uint8Array of length ${e}, not of length=${t.length}` - ); - } - zd.bytes = Zme; - function Pze(t) { - if (typeof t != "function" || typeof t.create != "function") - throw new Error("Hash should be wrapped by utils.wrapConstructor"); - M$(t.outputLen), M$(t.blockLen); - } - zd.hash = Pze; - function Oze(t, e = !0) { - if (t.destroyed) throw new Error("Hash instance has been destroyed"); - if (e && t.finished) - throw new Error("Hash#digest() has already been called"); - } - zd.exists = Oze; - function Bze(t, e) { - Zme(t); - let r = e.outputLen; - if (t.length < r) - throw new Error( - `digestInto() expects output buffer of length at least ${r}` - ); - } - zd.output = Bze; - var aHt = { - number: M$, - bool: kze, - bytes: Zme, - hash: Pze, - exists: Oze, - output: Bze, - }; - zd.default = aHt; - }); - var Ize = I((k$) => { - "use strict"; - m(); - g(); - Object.defineProperty(k$, "__esModule", { value: !0 }); - k$.crypto = void 0; - k$.crypto = { - node: void 0, - web: typeof self == "object" && "crypto" in self ? self.crypto : void 0, - }; - }); - var r5 = I((Cn) => { - "use strict"; - m(); - g(); - Object.defineProperty(Cn, "__esModule", { value: !0 }); - Cn.randomBytes = - Cn.wrapConstructorWithOpts = - Cn.wrapConstructor = - Cn.checkOpts = - Cn.Hash = - Cn.concatBytes = - Cn.toBytes = - Cn.utf8ToBytes = - Cn.asyncLoop = - Cn.nextTick = - Cn.hexToBytes = - Cn.bytesToHex = - Cn.isLE = - Cn.rotr = - Cn.createView = - Cn.u32 = - Cn.u8 = - void 0; - var P$ = Ize(), - sHt = (t) => new Uint8Array(t.buffer, t.byteOffset, t.byteLength); - Cn.u8 = sHt; - var uHt = (t) => - new Uint32Array(t.buffer, t.byteOffset, Math.floor(t.byteLength / 4)); - Cn.u32 = uHt; - var cHt = (t) => new DataView(t.buffer, t.byteOffset, t.byteLength); - Cn.createView = cHt; - var lHt = (t, e) => (t << (32 - e)) | (t >>> e); - Cn.rotr = lHt; - Cn.isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68; - if (!Cn.isLE) - throw new Error("Non little-endian hardware is not supported"); - var fHt = Array.from({ length: 256 }, (t, e) => - e.toString(16).padStart(2, "0") - ); - function dHt(t) { - if (!(t instanceof Uint8Array)) throw new Error("Uint8Array expected"); - let e = ""; - for (let r = 0; r < t.length; r++) e += fHt[t[r]]; - return e; - } - Cn.bytesToHex = dHt; - function hHt(t) { - if (typeof t != "string") - throw new TypeError("hexToBytes: expected string, got " + typeof t); - if (t.length % 2) - throw new Error("hexToBytes: received invalid unpadded hex"); - let e = new Uint8Array(t.length / 2); - for (let r = 0; r < e.length; r++) { - let n = r * 2, - i = t.slice(n, n + 2), - o = Number.parseInt(i, 16); - if (Number.isNaN(o) || o < 0) throw new Error("Invalid byte sequence"); - e[r] = o; - } - return e; - } - Cn.hexToBytes = hHt; - var pHt = async () => {}; - Cn.nextTick = pHt; - async function yHt(t, e, r) { - let n = Date.now(); - for (let i = 0; i < t; i++) { - r(i); - let o = Date.now() - n; - (o >= 0 && o < e) || (await (0, Cn.nextTick)(), (n += o)); - } - } - Cn.asyncLoop = yHt; - function Cze(t) { - if (typeof t != "string") - throw new TypeError(`utf8ToBytes expected string, got ${typeof t}`); - return new TextEncoder().encode(t); - } - Cn.utf8ToBytes = Cze; - function Yme(t) { - if ((typeof t == "string" && (t = Cze(t)), !(t instanceof Uint8Array))) - throw new TypeError( - `Expected input type is Uint8Array (got ${typeof t})` - ); - return t; - } - Cn.toBytes = Yme; - function mHt(...t) { - if (!t.every((n) => n instanceof Uint8Array)) - throw new Error("Uint8Array list expected"); - if (t.length === 1) return t[0]; - let e = t.reduce((n, i) => n + i.length, 0), - r = new Uint8Array(e); - for (let n = 0, i = 0; n < t.length; n++) { - let o = t[n]; - r.set(o, i), (i += o.length); - } - return r; - } - Cn.concatBytes = mHt; - var Xme = class { - clone() { - return this._cloneInto(); - } - }; - Cn.Hash = Xme; - var gHt = (t) => - Object.prototype.toString.call(t) === "[object Object]" && - t.constructor === Object; - function vHt(t, e) { - if (e !== void 0 && (typeof e != "object" || !gHt(e))) - throw new TypeError("Options should be object or undefined"); - return Object.assign(t, e); - } - Cn.checkOpts = vHt; - function bHt(t) { - let e = (n) => t().update(Yme(n)).digest(), - r = t(); - return ( - (e.outputLen = r.outputLen), - (e.blockLen = r.blockLen), - (e.create = () => t()), - e - ); - } - Cn.wrapConstructor = bHt; - function wHt(t) { - let e = (n, i) => t(i).update(Yme(n)).digest(), - r = t({}); - return ( - (e.outputLen = r.outputLen), - (e.blockLen = r.blockLen), - (e.create = (n) => t(n)), - e - ); - } - Cn.wrapConstructorWithOpts = wHt; - function _Ht(t = 32) { - if (P$.crypto.web) - return P$.crypto.web.getRandomValues(new Uint8Array(t)); - if (P$.crypto.node) - return new Uint8Array(P$.crypto.node.randomBytes(t).buffer); - throw new Error("The environment doesn't have randomBytes function"); - } - Cn.randomBytes = _Ht; - }); - var tge = I((O$) => { - "use strict"; - m(); - g(); - Object.defineProperty(O$, "__esModule", { value: !0 }); - O$.SHA2 = void 0; - var Qme = T$(), - eq = r5(); - function xHt(t, e, r, n) { - if (typeof t.setBigUint64 == "function") return t.setBigUint64(e, r, n); - let i = BigInt(32), - o = BigInt(4294967295), - a = Number((r >> i) & o), - s = Number(r & o), - c = n ? 4 : 0, - u = n ? 0 : 4; - t.setUint32(e + c, a, n), t.setUint32(e + u, s, n); - } - var ege = class extends eq.Hash { - constructor(e, r, n, i) { - super(), - (this.blockLen = e), - (this.outputLen = r), - (this.padOffset = n), - (this.isLE = i), - (this.finished = !1), - (this.length = 0), - (this.pos = 0), - (this.destroyed = !1), - (this.buffer = new Uint8Array(e)), - (this.view = (0, eq.createView)(this.buffer)); - } - update(e) { - Qme.default.exists(this); - let { view: r, buffer: n, blockLen: i } = this; - e = (0, eq.toBytes)(e); - let o = e.length; - for (let a = 0; a < o; ) { - let s = Math.min(i - this.pos, o - a); - if (s === i) { - let c = (0, eq.createView)(e); - for (; i <= o - a; a += i) this.process(c, a); - continue; - } - n.set(e.subarray(a, a + s), this.pos), - (this.pos += s), - (a += s), - this.pos === i && (this.process(r, 0), (this.pos = 0)); - } - return (this.length += e.length), this.roundClean(), this; - } - digestInto(e) { - Qme.default.exists(this), - Qme.default.output(e, this), - (this.finished = !0); - let { buffer: r, view: n, blockLen: i, isLE: o } = this, - { pos: a } = this; - (r[a++] = 128), - this.buffer.subarray(a).fill(0), - this.padOffset > i - a && (this.process(n, 0), (a = 0)); - for (let c = a; c < i; c++) r[c] = 0; - xHt(n, i - 8, BigInt(this.length * 8), o), this.process(n, 0); - let s = (0, eq.createView)(e); - this.get().forEach((c, u) => s.setUint32(4 * u, c, o)); - } - digest() { - let { buffer: e, outputLen: r } = this; - this.digestInto(e); - let n = e.slice(0, r); - return this.destroy(), n; - } - _cloneInto(e) { - e || (e = new this.constructor()), e.set(...this.get()); - let { - blockLen: r, - buffer: n, - length: i, - finished: o, - destroyed: a, - pos: s, - } = this; - return ( - (e.length = i), - (e.pos = s), - (e.finished = o), - (e.destroyed = a), - i % r && e.buffer.set(n), - e - ); - } - }; - O$.SHA2 = ege; - }); - var ige = I((X0) => { - "use strict"; - m(); - g(); - Object.defineProperty(X0, "__esModule", { value: !0 }); - X0.add = X0.toBig = X0.split = X0.fromBig = void 0; - var B$ = BigInt(2 ** 32 - 1), - rge = BigInt(32); - function nge(t, e = !1) { - return e - ? { h: Number(t & B$), l: Number((t >> rge) & B$) } - : { h: Number((t >> rge) & B$) | 0, l: Number(t & B$) | 0 }; - } - X0.fromBig = nge; - function Rze(t, e = !1) { - let r = new Uint32Array(t.length), - n = new Uint32Array(t.length); - for (let i = 0; i < t.length; i++) { - let { h: o, l: a } = nge(t[i], e); - [r[i], n[i]] = [o, a]; - } - return [r, n]; - } - X0.split = Rze; - var SHt = (t, e) => (BigInt(t >>> 0) << rge) | BigInt(e >>> 0); - X0.toBig = SHt; - var AHt = (t, e, r) => t >>> r, - EHt = (t, e, r) => (t << (32 - r)) | (e >>> r), - MHt = (t, e, r) => (t >>> r) | (e << (32 - r)), - THt = (t, e, r) => (t << (32 - r)) | (e >>> r), - kHt = (t, e, r) => (t << (64 - r)) | (e >>> (r - 32)), - PHt = (t, e, r) => (t >>> (r - 32)) | (e << (64 - r)), - OHt = (t, e) => e, - BHt = (t, e) => t, - IHt = (t, e, r) => (t << r) | (e >>> (32 - r)), - CHt = (t, e, r) => (e << r) | (t >>> (32 - r)), - RHt = (t, e, r) => (e << (r - 32)) | (t >>> (64 - r)), - NHt = (t, e, r) => (t << (r - 32)) | (e >>> (64 - r)); - function Nze(t, e, r, n) { - let i = (e >>> 0) + (n >>> 0); - return { h: (t + r + ((i / 2 ** 32) | 0)) | 0, l: i | 0 }; - } - X0.add = Nze; - var DHt = (t, e, r) => (t >>> 0) + (e >>> 0) + (r >>> 0), - FHt = (t, e, r, n) => (e + r + n + ((t / 2 ** 32) | 0)) | 0, - LHt = (t, e, r, n) => (t >>> 0) + (e >>> 0) + (r >>> 0) + (n >>> 0), - qHt = (t, e, r, n, i) => (e + r + n + i + ((t / 2 ** 32) | 0)) | 0, - zHt = (t, e, r, n, i) => - (t >>> 0) + (e >>> 0) + (r >>> 0) + (n >>> 0) + (i >>> 0), - jHt = (t, e, r, n, i, o) => (e + r + n + i + o + ((t / 2 ** 32) | 0)) | 0, - UHt = { - fromBig: nge, - split: Rze, - toBig: X0.toBig, - shrSH: AHt, - shrSL: EHt, - rotrSH: MHt, - rotrSL: THt, - rotrBH: kHt, - rotrBL: PHt, - rotr32H: OHt, - rotr32L: BHt, - rotlSH: IHt, - rotlSL: CHt, - rotlBH: RHt, - rotlBL: NHt, - add: Nze, - add3L: DHt, - add3H: FHt, - add4L: LHt, - add4H: qHt, - add5H: jHt, - add5L: zHt, - }; - X0.default = UHt; - }); - var Dze = I((cv) => { - "use strict"; - m(); - g(); - Object.defineProperty(cv, "__esModule", { value: !0 }); - cv.sha384 = cv.sha512_256 = cv.sha512 = cv.SHA512 = void 0; - var KHt = tge(), - _n = ige(), - sge = r5(), - [HHt, VHt] = _n.default.split( - [ - "0x428a2f98d728ae22", - "0x7137449123ef65cd", - "0xb5c0fbcfec4d3b2f", - "0xe9b5dba58189dbbc", - "0x3956c25bf348b538", - "0x59f111f1b605d019", - "0x923f82a4af194f9b", - "0xab1c5ed5da6d8118", - "0xd807aa98a3030242", - "0x12835b0145706fbe", - "0x243185be4ee4b28c", - "0x550c7dc3d5ffb4e2", - "0x72be5d74f27b896f", - "0x80deb1fe3b1696b1", - "0x9bdc06a725c71235", - "0xc19bf174cf692694", - "0xe49b69c19ef14ad2", - "0xefbe4786384f25e3", - "0x0fc19dc68b8cd5b5", - "0x240ca1cc77ac9c65", - "0x2de92c6f592b0275", - "0x4a7484aa6ea6e483", - "0x5cb0a9dcbd41fbd4", - "0x76f988da831153b5", - "0x983e5152ee66dfab", - "0xa831c66d2db43210", - "0xb00327c898fb213f", - "0xbf597fc7beef0ee4", - "0xc6e00bf33da88fc2", - "0xd5a79147930aa725", - "0x06ca6351e003826f", - "0x142929670a0e6e70", - "0x27b70a8546d22ffc", - "0x2e1b21385c26c926", - "0x4d2c6dfc5ac42aed", - "0x53380d139d95b3df", - "0x650a73548baf63de", - "0x766a0abb3c77b2a8", - "0x81c2c92e47edaee6", - "0x92722c851482353b", - "0xa2bfe8a14cf10364", - "0xa81a664bbc423001", - "0xc24b8b70d0f89791", - "0xc76c51a30654be30", - "0xd192e819d6ef5218", - "0xd69906245565a910", - "0xf40e35855771202a", - "0x106aa07032bbd1b8", - "0x19a4c116b8d2d0c8", - "0x1e376c085141ab53", - "0x2748774cdf8eeb99", - "0x34b0bcb5e19b48a8", - "0x391c0cb3c5c95a63", - "0x4ed8aa4ae3418acb", - "0x5b9cca4f7763e373", - "0x682e6ff3d6b2b8a3", - "0x748f82ee5defb2fc", - "0x78a5636f43172f60", - "0x84c87814a1f0ab72", - "0x8cc702081a6439ec", - "0x90befffa23631e28", - "0xa4506cebde82bde9", - "0xbef9a3f7b2c67915", - "0xc67178f2e372532b", - "0xca273eceea26619c", - "0xd186b8c721c0c207", - "0xeada7dd6cde0eb1e", - "0xf57d4f7fee6ed178", - "0x06f067aa72176fba", - "0x0a637dc5a2c898a6", - "0x113f9804bef90dae", - "0x1b710b35131c471b", - "0x28db77f523047d84", - "0x32caab7b40c72493", - "0x3c9ebe0a15c9bebc", - "0x431d67c49c100d4c", - "0x4cc5d4becb3e42b6", - "0x597f299cfc657e2a", - "0x5fcb6fab3ad6faec", - "0x6c44198c4a475817", - ].map((t) => BigInt(t)) - ), - t2 = new Uint32Array(80), - r2 = new Uint32Array(80), - n5 = class extends KHt.SHA2 { - constructor() { - super(128, 64, 16, !1), - (this.Ah = 1779033703), - (this.Al = -205731576), - (this.Bh = -1150833019), - (this.Bl = -2067093701), - (this.Ch = 1013904242), - (this.Cl = -23791573), - (this.Dh = -1521486534), - (this.Dl = 1595750129), - (this.Eh = 1359893119), - (this.El = -1377402159), - (this.Fh = -1694144372), - (this.Fl = 725511199), - (this.Gh = 528734635), - (this.Gl = -79577749), - (this.Hh = 1541459225), - (this.Hl = 327033209); - } - get() { - let { - Ah: e, - Al: r, - Bh: n, - Bl: i, - Ch: o, - Cl: a, - Dh: s, - Dl: c, - Eh: u, - El: h, - Fh: w, - Fl: M, - Gh: k, - Gl: O, - Hh: D, - Hl: F, - } = this; - return [e, r, n, i, o, a, s, c, u, h, w, M, k, O, D, F]; - } - set(e, r, n, i, o, a, s, c, u, h, w, M, k, O, D, F) { - (this.Ah = e | 0), - (this.Al = r | 0), - (this.Bh = n | 0), - (this.Bl = i | 0), - (this.Ch = o | 0), - (this.Cl = a | 0), - (this.Dh = s | 0), - (this.Dl = c | 0), - (this.Eh = u | 0), - (this.El = h | 0), - (this.Fh = w | 0), - (this.Fl = M | 0), - (this.Gh = k | 0), - (this.Gl = O | 0), - (this.Hh = D | 0), - (this.Hl = F | 0); - } - process(e, r) { - for (let z = 0; z < 16; z++, r += 4) - (t2[z] = e.getUint32(r)), (r2[z] = e.getUint32((r += 4))); - for (let z = 16; z < 80; z++) { - let H = t2[z - 15] | 0, - Z = r2[z - 15] | 0, - $ = - _n.default.rotrSH(H, Z, 1) ^ - _n.default.rotrSH(H, Z, 8) ^ - _n.default.shrSH(H, Z, 7), - ue = - _n.default.rotrSL(H, Z, 1) ^ - _n.default.rotrSL(H, Z, 8) ^ - _n.default.shrSL(H, Z, 7), - te = t2[z - 2] | 0, - ne = r2[z - 2] | 0, - A = - _n.default.rotrSH(te, ne, 19) ^ - _n.default.rotrBH(te, ne, 61) ^ - _n.default.shrSH(te, ne, 6), - l = - _n.default.rotrSL(te, ne, 19) ^ - _n.default.rotrBL(te, ne, 61) ^ - _n.default.shrSL(te, ne, 6), - p = _n.default.add4L(ue, l, r2[z - 7], r2[z - 16]), - y = _n.default.add4H(p, $, A, t2[z - 7], t2[z - 16]); - (t2[z] = y | 0), (r2[z] = p | 0); - } - let { - Ah: n, - Al: i, - Bh: o, - Bl: a, - Ch: s, - Cl: c, - Dh: u, - Dl: h, - Eh: w, - El: M, - Fh: k, - Fl: O, - Gh: D, - Gl: F, - Hh: N, - Hl: q, - } = this; - for (let z = 0; z < 80; z++) { - let H = - _n.default.rotrSH(w, M, 14) ^ - _n.default.rotrSH(w, M, 18) ^ - _n.default.rotrBH(w, M, 41), - Z = - _n.default.rotrSL(w, M, 14) ^ - _n.default.rotrSL(w, M, 18) ^ - _n.default.rotrBL(w, M, 41), - $ = (w & k) ^ (~w & D), - ue = (M & O) ^ (~M & F), - te = _n.default.add5L(q, Z, ue, VHt[z], r2[z]), - ne = _n.default.add5H(te, N, H, $, HHt[z], t2[z]), - A = te | 0, - l = - _n.default.rotrSH(n, i, 28) ^ - _n.default.rotrBH(n, i, 34) ^ - _n.default.rotrBH(n, i, 39), - p = - _n.default.rotrSL(n, i, 28) ^ - _n.default.rotrBL(n, i, 34) ^ - _n.default.rotrBL(n, i, 39), - y = (n & o) ^ (n & s) ^ (o & s), - d = (i & a) ^ (i & c) ^ (a & c); - (N = D | 0), - (q = F | 0), - (D = k | 0), - (F = O | 0), - (k = w | 0), - (O = M | 0), - ({ h: w, l: M } = _n.default.add(u | 0, h | 0, ne | 0, A | 0)), - (u = s | 0), - (h = c | 0), - (s = o | 0), - (c = a | 0), - (o = n | 0), - (a = i | 0); - let v = _n.default.add3L(A, p, d); - (n = _n.default.add3H(v, ne, l, y)), (i = v | 0); - } - ({ h: n, l: i } = _n.default.add( - this.Ah | 0, - this.Al | 0, - n | 0, - i | 0 - )), - ({ h: o, l: a } = _n.default.add( - this.Bh | 0, - this.Bl | 0, - o | 0, - a | 0 - )), - ({ h: s, l: c } = _n.default.add( - this.Ch | 0, - this.Cl | 0, - s | 0, - c | 0 - )), - ({ h: u, l: h } = _n.default.add( - this.Dh | 0, - this.Dl | 0, - u | 0, - h | 0 - )), - ({ h: w, l: M } = _n.default.add( - this.Eh | 0, - this.El | 0, - w | 0, - M | 0 - )), - ({ h: k, l: O } = _n.default.add( - this.Fh | 0, - this.Fl | 0, - k | 0, - O | 0 - )), - ({ h: D, l: F } = _n.default.add( - this.Gh | 0, - this.Gl | 0, - D | 0, - F | 0 - )), - ({ h: N, l: q } = _n.default.add( - this.Hh | 0, - this.Hl | 0, - N | 0, - q | 0 - )), - this.set(n, i, o, a, s, c, u, h, w, M, k, O, D, F, N, q); - } - roundClean() { - t2.fill(0), r2.fill(0); - } - destroy() { - this.buffer.fill(0), - this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); - } - }; - cv.SHA512 = n5; - var oge = class extends n5 { - constructor() { - super(), - (this.Ah = 573645204), - (this.Al = -64227540), - (this.Bh = -1621794909), - (this.Bl = -934517566), - (this.Ch = 596883563), - (this.Cl = 1867755857), - (this.Dh = -1774684391), - (this.Dl = 1497426621), - (this.Eh = -1775747358), - (this.El = -1467023389), - (this.Fh = -1101128155), - (this.Fl = 1401305490), - (this.Gh = 721525244), - (this.Gl = 746961066), - (this.Hh = 246885852), - (this.Hl = -2117784414), - (this.outputLen = 32); - } - }, - age = class extends n5 { - constructor() { - super(), - (this.Ah = -876896931), - (this.Al = -1056596264), - (this.Bh = 1654270250), - (this.Bl = 914150663), - (this.Ch = -1856437926), - (this.Cl = 812702999), - (this.Dh = 355462360), - (this.Dl = -150054599), - (this.Eh = 1731405415), - (this.El = -4191439), - (this.Fh = -1900787065), - (this.Fl = 1750603025), - (this.Gh = -619958771), - (this.Gl = 1694076839), - (this.Hh = 1203062813), - (this.Hl = -1090891868), - (this.outputLen = 48); - } - }; - cv.sha512 = (0, sge.wrapConstructor)(() => new n5()); - cv.sha512_256 = (0, sge.wrapConstructor)(() => new oge()); - cv.sha384 = (0, sge.wrapConstructor)(() => new age()); - }); - var vn = I((uge, Lze) => { - m(); - g(); - var I$ = Qr(), - lv = I$.Buffer; - function Fze(t, e) { - for (var r in t) e[r] = t[r]; - } - lv.from && lv.alloc && lv.allocUnsafe && lv.allocUnsafeSlow - ? (Lze.exports = I$) - : (Fze(I$, uge), (uge.Buffer = aM)); - function aM(t, e, r) { - return lv(t, e, r); - } - aM.prototype = Object.create(lv.prototype); - Fze(lv, aM); - aM.from = function (t, e, r) { - if (typeof t == "number") - throw new TypeError("Argument must not be a number"); - return lv(t, e, r); - }; - aM.alloc = function (t, e, r) { - if (typeof t != "number") - throw new TypeError("Argument must be a number"); - var n = lv(t); - return ( - e !== void 0 - ? typeof r == "string" - ? n.fill(e, r) - : n.fill(e) - : n.fill(0), - n - ); - }; - aM.allocUnsafe = function (t) { - if (typeof t != "number") - throw new TypeError("Argument must be a number"); - return lv(t); - }; - aM.allocUnsafeSlow = function (t) { - if (typeof t != "number") - throw new TypeError("Argument must be a number"); - return I$.SlowBuffer(t); - }; - }); - var sM = I((rcn, lge) => { - "use strict"; - m(); - g(); - var cge = 65536, - WHt = 4294967295; - function GHt() { - throw new Error(`Secure random number generation is not supported by this browser. -Use Chrome, Firefox or Internet Explorer 11`); - } - var JHt = vn().Buffer, - C$ = window.crypto || window.msCrypto; - C$ && C$.getRandomValues ? (lge.exports = $Ht) : (lge.exports = GHt); - function $Ht(t, e) { - if (t > WHt) throw new RangeError("requested too many random bytes"); - var r = JHt.allocUnsafe(t); - if (t > 0) - if (t > cge) - for (var n = 0; n < t; n += cge) - C$.getRandomValues(r.slice(n, n + cge)); - else C$.getRandomValues(r); - return typeof e == "function" - ? process.nextTick(function () { - e(null, r); - }) - : r; - } - }); - var dn = I((ncn, fge) => { - m(); - g(); - typeof Object.create == "function" - ? (fge.exports = function (e, r) { - r && - ((e.super_ = r), - (e.prototype = Object.create(r.prototype, { - constructor: { - value: e, - enumerable: !1, - writable: !0, - configurable: !0, - }, - }))); - }) - : (fge.exports = function (e, r) { - if (r) { - e.super_ = r; - var n = function () {}; - (n.prototype = r.prototype), - (e.prototype = new n()), - (e.prototype.constructor = e); - } - }); - }); - var o5 = I((icn, dge) => { - "use strict"; - m(); - g(); - var i5 = typeof Reflect == "object" ? Reflect : null, - qze = - i5 && typeof i5.apply == "function" - ? i5.apply - : function (e, r, n) { - return Function.prototype.apply.call(e, r, n); - }, - R$; - i5 && typeof i5.ownKeys == "function" - ? (R$ = i5.ownKeys) - : Object.getOwnPropertySymbols - ? (R$ = function (e) { - return Object.getOwnPropertyNames(e).concat( - Object.getOwnPropertySymbols(e) - ); - }) - : (R$ = function (e) { - return Object.getOwnPropertyNames(e); - }); - function ZHt(t) { - console && console.warn && console.warn(t); - } - var jze = - Number.isNaN || - function (e) { - return e !== e; - }; - function oo() { - oo.init.call(this); - } - dge.exports = oo; - dge.exports.once = eVt; - oo.EventEmitter = oo; - oo.prototype._events = void 0; - oo.prototype._eventsCount = 0; - oo.prototype._maxListeners = void 0; - var zze = 10; - function N$(t) { - if (typeof t != "function") - throw new TypeError( - 'The "listener" argument must be of type Function. Received type ' + - typeof t - ); - } - Object.defineProperty(oo, "defaultMaxListeners", { - enumerable: !0, - get: function () { - return zze; - }, - set: function (t) { - if (typeof t != "number" || t < 0 || jze(t)) - throw new RangeError( - 'The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + - t + - "." - ); - zze = t; - }, - }); - oo.init = function () { - (this._events === void 0 || - this._events === Object.getPrototypeOf(this)._events) && - ((this._events = Object.create(null)), (this._eventsCount = 0)), - (this._maxListeners = this._maxListeners || void 0); - }; - oo.prototype.setMaxListeners = function (e) { - if (typeof e != "number" || e < 0 || jze(e)) - throw new RangeError( - 'The value of "n" is out of range. It must be a non-negative number. Received ' + - e + - "." - ); - return (this._maxListeners = e), this; - }; - function Uze(t) { - return t._maxListeners === void 0 - ? oo.defaultMaxListeners - : t._maxListeners; - } - oo.prototype.getMaxListeners = function () { - return Uze(this); - }; - oo.prototype.emit = function (e) { - for (var r = [], n = 1; n < arguments.length; n++) r.push(arguments[n]); - var i = e === "error", - o = this._events; - if (o !== void 0) i = i && o.error === void 0; - else if (!i) return !1; - if (i) { - var a; - if ((r.length > 0 && (a = r[0]), a instanceof Error)) throw a; - var s = new Error( - "Unhandled error." + (a ? " (" + a.message + ")" : "") - ); - throw ((s.context = a), s); - } - var c = o[e]; - if (c === void 0) return !1; - if (typeof c == "function") qze(c, this, r); - else - for (var u = c.length, h = Gze(c, u), n = 0; n < u; ++n) - qze(h[n], this, r); - return !0; - }; - function Kze(t, e, r, n) { - var i, o, a; - if ( - (N$(r), - (o = t._events), - o === void 0 - ? ((o = t._events = Object.create(null)), (t._eventsCount = 0)) - : (o.newListener !== void 0 && - (t.emit("newListener", e, r.listener ? r.listener : r), - (o = t._events)), - (a = o[e])), - a === void 0) - ) - (a = o[e] = r), ++t._eventsCount; - else if ( - (typeof a == "function" - ? (a = o[e] = n ? [r, a] : [a, r]) - : n - ? a.unshift(r) - : a.push(r), - (i = Uze(t)), - i > 0 && a.length > i && !a.warned) - ) { - a.warned = !0; - var s = new Error( - "Possible EventEmitter memory leak detected. " + - a.length + - " " + - String(e) + - " listeners added. Use emitter.setMaxListeners() to increase limit" - ); - (s.name = "MaxListenersExceededWarning"), - (s.emitter = t), - (s.type = e), - (s.count = a.length), - ZHt(s); - } - return t; - } - oo.prototype.addListener = function (e, r) { - return Kze(this, e, r, !1); - }; - oo.prototype.on = oo.prototype.addListener; - oo.prototype.prependListener = function (e, r) { - return Kze(this, e, r, !0); - }; - function XHt() { - if (!this.fired) - return ( - this.target.removeListener(this.type, this.wrapFn), - (this.fired = !0), - arguments.length === 0 - ? this.listener.call(this.target) - : this.listener.apply(this.target, arguments) - ); - } - function Hze(t, e, r) { - var n = { fired: !1, wrapFn: void 0, target: t, type: e, listener: r }, - i = XHt.bind(n); - return (i.listener = r), (n.wrapFn = i), i; - } - oo.prototype.once = function (e, r) { - return N$(r), this.on(e, Hze(this, e, r)), this; - }; - oo.prototype.prependOnceListener = function (e, r) { - return N$(r), this.prependListener(e, Hze(this, e, r)), this; - }; - oo.prototype.removeListener = function (e, r) { - var n, i, o, a, s; - if ((N$(r), (i = this._events), i === void 0)) return this; - if (((n = i[e]), n === void 0)) return this; - if (n === r || n.listener === r) - --this._eventsCount === 0 - ? (this._events = Object.create(null)) - : (delete i[e], - i.removeListener && - this.emit("removeListener", e, n.listener || r)); - else if (typeof n != "function") { - for (o = -1, a = n.length - 1; a >= 0; a--) - if (n[a] === r || n[a].listener === r) { - (s = n[a].listener), (o = a); - break; - } - if (o < 0) return this; - o === 0 ? n.shift() : YHt(n, o), - n.length === 1 && (i[e] = n[0]), - i.removeListener !== void 0 && this.emit("removeListener", e, s || r); - } - return this; - }; - oo.prototype.off = oo.prototype.removeListener; - oo.prototype.removeAllListeners = function (e) { - var r, n, i; - if (((n = this._events), n === void 0)) return this; - if (n.removeListener === void 0) - return ( - arguments.length === 0 - ? ((this._events = Object.create(null)), (this._eventsCount = 0)) - : n[e] !== void 0 && - (--this._eventsCount === 0 - ? (this._events = Object.create(null)) - : delete n[e]), - this - ); - if (arguments.length === 0) { - var o = Object.keys(n), - a; - for (i = 0; i < o.length; ++i) - (a = o[i]), a !== "removeListener" && this.removeAllListeners(a); - return ( - this.removeAllListeners("removeListener"), - (this._events = Object.create(null)), - (this._eventsCount = 0), - this - ); - } - if (((r = n[e]), typeof r == "function")) this.removeListener(e, r); - else if (r !== void 0) - for (i = r.length - 1; i >= 0; i--) this.removeListener(e, r[i]); - return this; - }; - function Vze(t, e, r) { - var n = t._events; - if (n === void 0) return []; - var i = n[e]; - return i === void 0 - ? [] - : typeof i == "function" - ? r - ? [i.listener || i] - : [i] - : r - ? QHt(i) - : Gze(i, i.length); - } - oo.prototype.listeners = function (e) { - return Vze(this, e, !0); - }; - oo.prototype.rawListeners = function (e) { - return Vze(this, e, !1); - }; - oo.listenerCount = function (t, e) { - return typeof t.listenerCount == "function" - ? t.listenerCount(e) - : Wze.call(t, e); - }; - oo.prototype.listenerCount = Wze; - function Wze(t) { - var e = this._events; - if (e !== void 0) { - var r = e[t]; - if (typeof r == "function") return 1; - if (r !== void 0) return r.length; - } - return 0; - } - oo.prototype.eventNames = function () { - return this._eventsCount > 0 ? R$(this._events) : []; - }; - function Gze(t, e) { - for (var r = new Array(e), n = 0; n < e; ++n) r[n] = t[n]; - return r; - } - function YHt(t, e) { - for (; e + 1 < t.length; e++) t[e] = t[e + 1]; - t.pop(); - } - function QHt(t) { - for (var e = new Array(t.length), r = 0; r < e.length; ++r) - e[r] = t[r].listener || t[r]; - return e; - } - function eVt(t, e) { - return new Promise(function (r, n) { - function i(a) { - t.removeListener(e, o), n(a); - } - function o() { - typeof t.removeListener == "function" && t.removeListener("error", i), - r([].slice.call(arguments)); - } - Jze(t, e, o, { once: !0 }), e !== "error" && tVt(t, i, { once: !0 }); - }); - } - function tVt(t, e, r) { - typeof t.on == "function" && Jze(t, "error", e, r); - } - function Jze(t, e, r, n) { - if (typeof t.on == "function") n.once ? t.once(e, r) : t.on(e, r); - else if (typeof t.addEventListener == "function") - t.addEventListener(e, function i(o) { - n.once && t.removeEventListener(e, i), r(o); - }); - else - throw new TypeError( - 'The "emitter" argument must be of type EventEmitter. Received type ' + - typeof t - ); - } - }); - var hge = I((ocn, $ze) => { - m(); - g(); - $ze.exports = o5().EventEmitter; - }); - var pge = I((acn, Zze) => { - "use strict"; - m(); - g(); - Zze.exports = function () { - if ( - typeof Symbol != "function" || - typeof Object.getOwnPropertySymbols != "function" - ) - return !1; - if (typeof Symbol.iterator == "symbol") return !0; - var e = {}, - r = Symbol("test"), - n = Object(r); - if ( - typeof r == "string" || - Object.prototype.toString.call(r) !== "[object Symbol]" || - Object.prototype.toString.call(n) !== "[object Symbol]" - ) - return !1; - var i = 42; - e[r] = i; - for (r in e) return !1; - if ( - (typeof Object.keys == "function" && Object.keys(e).length !== 0) || - (typeof Object.getOwnPropertyNames == "function" && - Object.getOwnPropertyNames(e).length !== 0) - ) - return !1; - var o = Object.getOwnPropertySymbols(e); - if ( - o.length !== 1 || - o[0] !== r || - !Object.prototype.propertyIsEnumerable.call(e, r) - ) - return !1; - if (typeof Object.getOwnPropertyDescriptor == "function") { - var a = Object.getOwnPropertyDescriptor(e, r); - if (a.value !== i || a.enumerable !== !0) return !1; - } - return !0; - }; - }); - var tq = I((scn, Xze) => { - "use strict"; - m(); - g(); - var rVt = pge(); - Xze.exports = function () { - return rVt() && !!Symbol.toStringTag; - }; - }); - var eje = I((ucn, Qze) => { - "use strict"; - m(); - g(); - var Yze = typeof Symbol < "u" && Symbol, - nVt = pge(); - Qze.exports = function () { - return typeof Yze != "function" || - typeof Symbol != "function" || - typeof Yze("foo") != "symbol" || - typeof Symbol("bar") != "symbol" - ? !1 - : nVt(); - }; - }); - var rje = I((ccn, tje) => { - "use strict"; - m(); - g(); - var iVt = "Function.prototype.bind called on incompatible ", - yge = Array.prototype.slice, - oVt = Object.prototype.toString, - aVt = "[object Function]"; - tje.exports = function (e) { - var r = this; - if (typeof r != "function" || oVt.call(r) !== aVt) - throw new TypeError(iVt + r); - for ( - var n = yge.call(arguments, 1), - i, - o = function () { - if (this instanceof i) { - var h = r.apply(this, n.concat(yge.call(arguments))); - return Object(h) === h ? h : this; - } else return r.apply(e, n.concat(yge.call(arguments))); - }, - a = Math.max(0, r.length - n.length), - s = [], - c = 0; - c < a; - c++ - ) - s.push("$" + c); - if ( - ((i = Function( - "binder", - "return function (" + - s.join(",") + - "){ return binder.apply(this,arguments); }" - )(o)), - r.prototype) - ) { - var u = function () {}; - (u.prototype = r.prototype), - (i.prototype = new u()), - (u.prototype = null); - } - return i; - }; - }); - var D$ = I((lcn, nje) => { - "use strict"; - m(); - g(); - var sVt = rje(); - nje.exports = Function.prototype.bind || sVt; - }); - var oje = I((fcn, ije) => { - "use strict"; - m(); - g(); - var uVt = D$(); - ije.exports = uVt.call(Function.call, Object.prototype.hasOwnProperty); - }); - var nq = I((dcn, cje) => { - "use strict"; - m(); - g(); - var gi, - rq = SyntaxError, - uje = Function, - u5 = TypeError, - mge = function (t) { - try { - return uje('"use strict"; return (' + t + ").constructor;")(); - } catch {} - }, - uM = Object.getOwnPropertyDescriptor; - if (uM) - try { - uM({}, ""); - } catch { - uM = null; - } - var gge = function () { - throw new u5(); - }, - cVt = uM - ? (function () { - try { - return arguments.callee, gge; - } catch { - try { - return uM(arguments, "callee").get; - } catch { - return gge; - } - } - })() - : gge, - a5 = eje()(), - n2 = - Object.getPrototypeOf || - function (t) { - return t.__proto__; - }, - s5 = {}, - lVt = typeof Uint8Array > "u" ? gi : n2(Uint8Array), - c5 = { - "%AggregateError%": typeof AggregateError > "u" ? gi : AggregateError, - "%Array%": Array, - "%ArrayBuffer%": typeof ArrayBuffer > "u" ? gi : ArrayBuffer, - "%ArrayIteratorPrototype%": a5 ? n2([][Symbol.iterator]()) : gi, - "%AsyncFromSyncIteratorPrototype%": gi, - "%AsyncFunction%": s5, - "%AsyncGenerator%": s5, - "%AsyncGeneratorFunction%": s5, - "%AsyncIteratorPrototype%": s5, - "%Atomics%": typeof Atomics > "u" ? gi : Atomics, - "%BigInt%": typeof BigInt > "u" ? gi : BigInt, - "%Boolean%": Boolean, - "%DataView%": typeof DataView > "u" ? gi : DataView, - "%Date%": Date, - "%decodeURI%": decodeURI, - "%decodeURIComponent%": decodeURIComponent, - "%encodeURI%": encodeURI, - "%encodeURIComponent%": encodeURIComponent, - "%Error%": Error, - "%eval%": eval, - "%EvalError%": EvalError, - "%Float32Array%": typeof Float32Array > "u" ? gi : Float32Array, - "%Float64Array%": typeof Float64Array > "u" ? gi : Float64Array, - "%FinalizationRegistry%": - typeof FinalizationRegistry > "u" ? gi : FinalizationRegistry, - "%Function%": uje, - "%GeneratorFunction%": s5, - "%Int8Array%": typeof Int8Array > "u" ? gi : Int8Array, - "%Int16Array%": typeof Int16Array > "u" ? gi : Int16Array, - "%Int32Array%": typeof Int32Array > "u" ? gi : Int32Array, - "%isFinite%": isFinite, - "%isNaN%": isNaN, - "%IteratorPrototype%": a5 ? n2(n2([][Symbol.iterator]())) : gi, - "%JSON%": typeof JSON == "object" ? JSON : gi, - "%Map%": typeof Map > "u" ? gi : Map, - "%MapIteratorPrototype%": - typeof Map > "u" || !a5 ? gi : n2(new Map()[Symbol.iterator]()), - "%Math%": Math, - "%Number%": Number, - "%Object%": Object, - "%parseFloat%": parseFloat, - "%parseInt%": parseInt, - "%Promise%": typeof Promise > "u" ? gi : Promise, - "%Proxy%": typeof Proxy > "u" ? gi : Proxy, - "%RangeError%": RangeError, - "%ReferenceError%": ReferenceError, - "%Reflect%": typeof Reflect > "u" ? gi : Reflect, - "%RegExp%": RegExp, - "%Set%": typeof Set > "u" ? gi : Set, - "%SetIteratorPrototype%": - typeof Set > "u" || !a5 ? gi : n2(new Set()[Symbol.iterator]()), - "%SharedArrayBuffer%": - typeof SharedArrayBuffer > "u" ? gi : SharedArrayBuffer, - "%String%": String, - "%StringIteratorPrototype%": a5 ? n2(""[Symbol.iterator]()) : gi, - "%Symbol%": a5 ? Symbol : gi, - "%SyntaxError%": rq, - "%ThrowTypeError%": cVt, - "%TypedArray%": lVt, - "%TypeError%": u5, - "%Uint8Array%": typeof Uint8Array > "u" ? gi : Uint8Array, - "%Uint8ClampedArray%": - typeof Uint8ClampedArray > "u" ? gi : Uint8ClampedArray, - "%Uint16Array%": typeof Uint16Array > "u" ? gi : Uint16Array, - "%Uint32Array%": typeof Uint32Array > "u" ? gi : Uint32Array, - "%URIError%": URIError, - "%WeakMap%": typeof WeakMap > "u" ? gi : WeakMap, - "%WeakRef%": typeof WeakRef > "u" ? gi : WeakRef, - "%WeakSet%": typeof WeakSet > "u" ? gi : WeakSet, - }, - fVt = function t(e) { - var r; - if (e === "%AsyncFunction%") r = mge("async function () {}"); - else if (e === "%GeneratorFunction%") r = mge("function* () {}"); - else if (e === "%AsyncGeneratorFunction%") - r = mge("async function* () {}"); - else if (e === "%AsyncGenerator%") { - var n = t("%AsyncGeneratorFunction%"); - n && (r = n.prototype); - } else if (e === "%AsyncIteratorPrototype%") { - var i = t("%AsyncGenerator%"); - i && (r = n2(i.prototype)); - } - return (c5[e] = r), r; - }, - aje = { - "%ArrayBufferPrototype%": ["ArrayBuffer", "prototype"], - "%ArrayPrototype%": ["Array", "prototype"], - "%ArrayProto_entries%": ["Array", "prototype", "entries"], - "%ArrayProto_forEach%": ["Array", "prototype", "forEach"], - "%ArrayProto_keys%": ["Array", "prototype", "keys"], - "%ArrayProto_values%": ["Array", "prototype", "values"], - "%AsyncFunctionPrototype%": ["AsyncFunction", "prototype"], - "%AsyncGenerator%": ["AsyncGeneratorFunction", "prototype"], - "%AsyncGeneratorPrototype%": [ - "AsyncGeneratorFunction", - "prototype", - "prototype", - ], - "%BooleanPrototype%": ["Boolean", "prototype"], - "%DataViewPrototype%": ["DataView", "prototype"], - "%DatePrototype%": ["Date", "prototype"], - "%ErrorPrototype%": ["Error", "prototype"], - "%EvalErrorPrototype%": ["EvalError", "prototype"], - "%Float32ArrayPrototype%": ["Float32Array", "prototype"], - "%Float64ArrayPrototype%": ["Float64Array", "prototype"], - "%FunctionPrototype%": ["Function", "prototype"], - "%Generator%": ["GeneratorFunction", "prototype"], - "%GeneratorPrototype%": ["GeneratorFunction", "prototype", "prototype"], - "%Int8ArrayPrototype%": ["Int8Array", "prototype"], - "%Int16ArrayPrototype%": ["Int16Array", "prototype"], - "%Int32ArrayPrototype%": ["Int32Array", "prototype"], - "%JSONParse%": ["JSON", "parse"], - "%JSONStringify%": ["JSON", "stringify"], - "%MapPrototype%": ["Map", "prototype"], - "%NumberPrototype%": ["Number", "prototype"], - "%ObjectPrototype%": ["Object", "prototype"], - "%ObjProto_toString%": ["Object", "prototype", "toString"], - "%ObjProto_valueOf%": ["Object", "prototype", "valueOf"], - "%PromisePrototype%": ["Promise", "prototype"], - "%PromiseProto_then%": ["Promise", "prototype", "then"], - "%Promise_all%": ["Promise", "all"], - "%Promise_reject%": ["Promise", "reject"], - "%Promise_resolve%": ["Promise", "resolve"], - "%RangeErrorPrototype%": ["RangeError", "prototype"], - "%ReferenceErrorPrototype%": ["ReferenceError", "prototype"], - "%RegExpPrototype%": ["RegExp", "prototype"], - "%SetPrototype%": ["Set", "prototype"], - "%SharedArrayBufferPrototype%": ["SharedArrayBuffer", "prototype"], - "%StringPrototype%": ["String", "prototype"], - "%SymbolPrototype%": ["Symbol", "prototype"], - "%SyntaxErrorPrototype%": ["SyntaxError", "prototype"], - "%TypedArrayPrototype%": ["TypedArray", "prototype"], - "%TypeErrorPrototype%": ["TypeError", "prototype"], - "%Uint8ArrayPrototype%": ["Uint8Array", "prototype"], - "%Uint8ClampedArrayPrototype%": ["Uint8ClampedArray", "prototype"], - "%Uint16ArrayPrototype%": ["Uint16Array", "prototype"], - "%Uint32ArrayPrototype%": ["Uint32Array", "prototype"], - "%URIErrorPrototype%": ["URIError", "prototype"], - "%WeakMapPrototype%": ["WeakMap", "prototype"], - "%WeakSetPrototype%": ["WeakSet", "prototype"], - }, - q$ = D$(), - F$ = oje(), - dVt = q$.call(Function.call, Array.prototype.concat), - hVt = q$.call(Function.apply, Array.prototype.splice), - sje = q$.call(Function.call, String.prototype.replace), - L$ = q$.call(Function.call, String.prototype.slice), - pVt = - /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g, - yVt = /\\(\\)?/g, - mVt = function (e) { - var r = L$(e, 0, 1), - n = L$(e, -1); - if (r === "%" && n !== "%") - throw new rq("invalid intrinsic syntax, expected closing `%`"); - if (n === "%" && r !== "%") - throw new rq("invalid intrinsic syntax, expected opening `%`"); - var i = []; - return ( - sje(e, pVt, function (o, a, s, c) { - i[i.length] = s ? sje(c, yVt, "$1") : a || o; - }), - i - ); - }, - gVt = function (e, r) { - var n = e, - i; - if ((F$(aje, n) && ((i = aje[n]), (n = "%" + i[0] + "%")), F$(c5, n))) { - var o = c5[n]; - if ((o === s5 && (o = fVt(n)), typeof o > "u" && !r)) - throw new u5( - "intrinsic " + - e + - " exists, but is not available. Please file an issue!" - ); - return { alias: i, name: n, value: o }; - } - throw new rq("intrinsic " + e + " does not exist!"); - }; - cje.exports = function (e, r) { - if (typeof e != "string" || e.length === 0) - throw new u5("intrinsic name must be a non-empty string"); - if (arguments.length > 1 && typeof r != "boolean") - throw new u5('"allowMissing" argument must be a boolean'); - var n = mVt(e), - i = n.length > 0 ? n[0] : "", - o = gVt("%" + i + "%", r), - a = o.name, - s = o.value, - c = !1, - u = o.alias; - u && ((i = u[0]), hVt(n, dVt([0, 1], u))); - for (var h = 1, w = !0; h < n.length; h += 1) { - var M = n[h], - k = L$(M, 0, 1), - O = L$(M, -1); - if ( - (k === '"' || - k === "'" || - k === "`" || - O === '"' || - O === "'" || - O === "`") && - k !== O - ) - throw new rq("property names with quotes must have matching quotes"); - if ( - ((M === "constructor" || !w) && (c = !0), - (i += "." + M), - (a = "%" + i + "%"), - F$(c5, a)) - ) - s = c5[a]; - else if (s != null) { - if (!(M in s)) { - if (!r) - throw new u5( - "base intrinsic for " + - e + - " exists, but the property is not available." - ); - return; - } - if (uM && h + 1 >= n.length) { - var D = uM(s, M); - (w = !!D), - w && "get" in D && !("originalValue" in D.get) - ? (s = D.get) - : (s = s[M]); - } else (w = F$(s, M)), (s = s[M]); - w && !c && (c5[a] = s); - } - } - return s; - }; - }); - var j$ = I((hcn, z$) => { - "use strict"; - m(); - g(); - var vge = D$(), - l5 = nq(), - dje = l5("%Function.prototype.apply%"), - hje = l5("%Function.prototype.call%"), - pje = l5("%Reflect.apply%", !0) || vge.call(hje, dje), - lje = l5("%Object.getOwnPropertyDescriptor%", !0), - cM = l5("%Object.defineProperty%", !0), - vVt = l5("%Math.max%"); - if (cM) - try { - cM({}, "a", { value: 1 }); - } catch { - cM = null; - } - z$.exports = function (e) { - var r = pje(vge, hje, arguments); - if (lje && cM) { - var n = lje(r, "length"); - n.configurable && - cM(r, "length", { - value: 1 + vVt(0, e.length - (arguments.length - 1)), - }); - } - return r; - }; - var fje = function () { - return pje(vge, dje, arguments); - }; - cM ? cM(z$.exports, "apply", { value: fje }) : (z$.exports.apply = fje); - }); - var U$ = I((pcn, gje) => { - "use strict"; - m(); - g(); - var yje = nq(), - mje = j$(), - bVt = mje(yje("String.prototype.indexOf")); - gje.exports = function (e, r) { - var n = yje(e, !!r); - return typeof n == "function" && bVt(e, ".prototype.") > -1 ? mje(n) : n; - }; - }); - var wje = I((ycn, bje) => { - "use strict"; - m(); - g(); - var wVt = tq()(), - _Vt = U$(), - bge = _Vt("Object.prototype.toString"), - K$ = function (e) { - return wVt && e && typeof e == "object" && Symbol.toStringTag in e - ? !1 - : bge(e) === "[object Arguments]"; - }, - vje = function (e) { - return K$(e) - ? !0 - : e !== null && - typeof e == "object" && - typeof e.length == "number" && - e.length >= 0 && - bge(e) !== "[object Array]" && - bge(e.callee) === "[object Function]"; - }, - xVt = (function () { - return K$(arguments); - })(); - K$.isLegacyArguments = vje; - bje.exports = xVt ? K$ : vje; - }); - var Sje = I((mcn, xje) => { - "use strict"; - m(); - g(); - var SVt = Object.prototype.toString, - AVt = Function.prototype.toString, - EVt = /^\s*(?:function)?\*/, - _je = tq()(), - wge = Object.getPrototypeOf, - MVt = function () { - if (!_je) return !1; - try { - return Function("return function*() {}")(); - } catch {} - }, - _ge; - xje.exports = function (e) { - if (typeof e != "function") return !1; - if (EVt.test(AVt.call(e))) return !0; - if (!_je) { - var r = SVt.call(e); - return r === "[object GeneratorFunction]"; - } - if (!wge) return !1; - if (typeof _ge > "u") { - var n = MVt(); - _ge = n ? wge(n) : !1; - } - return wge(e) === _ge; - }; - }); - var Tje = I((gcn, Mje) => { - "use strict"; - m(); - g(); - var Eje = Function.prototype.toString, - f5 = typeof Reflect == "object" && Reflect !== null && Reflect.apply, - xge, - H$; - if (typeof f5 == "function" && typeof Object.defineProperty == "function") - try { - (xge = Object.defineProperty({}, "length", { - get: function () { - throw H$; - }, - })), - (H$ = {}), - f5( - function () { - throw 42; - }, - null, - xge - ); - } catch (t) { - t !== H$ && (f5 = null); - } - else f5 = null; - var TVt = /^\s*class\b/, - Sge = function (e) { - try { - var r = Eje.call(e); - return TVt.test(r); - } catch { - return !1; - } - }, - kVt = function (e) { - try { - return Sge(e) ? !1 : (Eje.call(e), !0); - } catch { - return !1; - } - }, - PVt = Object.prototype.toString, - OVt = "[object Function]", - BVt = "[object GeneratorFunction]", - IVt = typeof Symbol == "function" && !!Symbol.toStringTag, - Aje = - typeof document == "object" && - typeof document.all > "u" && - document.all !== void 0 - ? document.all - : {}; - Mje.exports = f5 - ? function (e) { - if (e === Aje) return !0; - if (!e || (typeof e != "function" && typeof e != "object")) return !1; - if (typeof e == "function" && !e.prototype) return !0; - try { - f5(e, null, xge); - } catch (r) { - if (r !== H$) return !1; - } - return !Sge(e); - } - : function (e) { - if (e === Aje) return !0; - if (!e || (typeof e != "function" && typeof e != "object")) return !1; - if (typeof e == "function" && !e.prototype) return !0; - if (IVt) return kVt(e); - if (Sge(e)) return !1; - var r = PVt.call(e); - return r === OVt || r === BVt; - }; - }); - var Age = I((vcn, Pje) => { - "use strict"; - m(); - g(); - var CVt = Tje(), - RVt = Object.prototype.toString, - kje = Object.prototype.hasOwnProperty, - NVt = function (e, r, n) { - for (var i = 0, o = e.length; i < o; i++) - kje.call(e, i) && (n == null ? r(e[i], i, e) : r.call(n, e[i], i, e)); - }, - DVt = function (e, r, n) { - for (var i = 0, o = e.length; i < o; i++) - n == null ? r(e.charAt(i), i, e) : r.call(n, e.charAt(i), i, e); - }, - FVt = function (e, r, n) { - for (var i in e) - kje.call(e, i) && (n == null ? r(e[i], i, e) : r.call(n, e[i], i, e)); - }, - LVt = function (e, r, n) { - if (!CVt(r)) throw new TypeError("iterator must be a function"); - var i; - arguments.length >= 3 && (i = n), - RVt.call(e) === "[object Array]" - ? NVt(e, r, i) - : typeof e == "string" - ? DVt(e, r, i) - : FVt(e, r, i); - }; - Pje.exports = LVt; - }); - var Mge = I((bcn, Oje) => { - "use strict"; - m(); - g(); - var Ege = [ - "BigInt64Array", - "BigUint64Array", - "Float32Array", - "Float64Array", - "Int16Array", - "Int32Array", - "Int8Array", - "Uint16Array", - "Uint32Array", - "Uint8Array", - "Uint8ClampedArray", - ], - qVt = typeof globalThis > "u" ? window : globalThis; - Oje.exports = function () { - for (var e = [], r = 0; r < Ege.length; r++) - typeof qVt[Ege[r]] == "function" && (e[e.length] = Ege[r]); - return e; - }; - }); - var Tge = I((wcn, Bje) => { - "use strict"; - m(); - g(); - var zVt = nq(), - V$ = zVt("%Object.getOwnPropertyDescriptor%", !0); - if (V$) - try { - V$([], "length"); - } catch { - V$ = null; - } - Bje.exports = V$; - }); - var Oge = I((_cn, Dje) => { - "use strict"; - m(); - g(); - var Ije = Age(), - jVt = Mge(), - Pge = U$(), - UVt = Pge("Object.prototype.toString"), - Cje = tq()(), - KVt = typeof globalThis > "u" ? window : globalThis, - Rje = jVt(), - HVt = - Pge("Array.prototype.indexOf", !0) || - function (e, r) { - for (var n = 0; n < e.length; n += 1) if (e[n] === r) return n; - return -1; - }, - VVt = Pge("String.prototype.slice"), - Nje = {}, - W$ = Tge(), - kge = Object.getPrototypeOf; - Cje && - W$ && - kge && - Ije(Rje, function (t) { - var e = new KVt[t](); - if (Symbol.toStringTag in e) { - var r = kge(e), - n = W$(r, Symbol.toStringTag); - if (!n) { - var i = kge(r); - n = W$(i, Symbol.toStringTag); - } - Nje[t] = n.get; - } - }); - var WVt = function (e) { - var r = !1; - return ( - Ije(Nje, function (n, i) { - if (!r) - try { - r = n.call(e) === i; - } catch {} - }), - r - ); - }; - Dje.exports = function (e) { - if (!e || typeof e != "object") return !1; - if (!Cje || !(Symbol.toStringTag in e)) { - var r = VVt(UVt(e), 8, -1); - return HVt(Rje, r) > -1; - } - return W$ ? WVt(e) : !1; - }; - }); - var Kje = I((xcn, Uje) => { - "use strict"; - m(); - g(); - var Lje = Age(), - GVt = Mge(), - qje = U$(), - JVt = qje("Object.prototype.toString"), - zje = tq()(), - Fje = typeof globalThis > "u" ? window : globalThis, - $Vt = GVt(), - ZVt = qje("String.prototype.slice"), - jje = {}, - Bge = Tge(), - Ige = Object.getPrototypeOf; - zje && - Bge && - Ige && - Lje($Vt, function (t) { - if (typeof Fje[t] == "function") { - var e = new Fje[t](); - if (Symbol.toStringTag in e) { - var r = Ige(e), - n = Bge(r, Symbol.toStringTag); - if (!n) { - var i = Ige(r); - n = Bge(i, Symbol.toStringTag); - } - jje[t] = n.get; - } - } - }); - var XVt = function (e) { - var r = !1; - return ( - Lje(jje, function (n, i) { - if (!r) - try { - var o = n.call(e); - o === i && (r = o); - } catch {} - }), - r - ); - }, - YVt = Oge(); - Uje.exports = function (e) { - return YVt(e) - ? !zje || !(Symbol.toStringTag in e) - ? ZVt(JVt(e), 8, -1) - : XVt(e) - : !1; - }; - }); - var nUe = I((Jn) => { - "use strict"; - m(); - g(); - var QVt = wje(), - eWt = Sje(), - Im = Kje(), - Hje = Oge(); - function d5(t) { - return t.call.bind(t); - } - var Vje = typeof BigInt < "u", - Wje = typeof Symbol < "u", - Y0 = d5(Object.prototype.toString), - tWt = d5(Number.prototype.valueOf), - rWt = d5(String.prototype.valueOf), - nWt = d5(Boolean.prototype.valueOf); - Vje && (Gje = d5(BigInt.prototype.valueOf)); - var Gje; - Wje && (Jje = d5(Symbol.prototype.valueOf)); - var Jje; - function oq(t, e) { - if (typeof t != "object") return !1; - try { - return e(t), !0; - } catch { - return !1; - } - } - Jn.isArgumentsObject = QVt; - Jn.isGeneratorFunction = eWt; - Jn.isTypedArray = Hje; - function iWt(t) { - return ( - (typeof Promise < "u" && t instanceof Promise) || - (t !== null && - typeof t == "object" && - typeof t.then == "function" && - typeof t.catch == "function") - ); - } - Jn.isPromise = iWt; - function oWt(t) { - return typeof ArrayBuffer < "u" && ArrayBuffer.isView - ? ArrayBuffer.isView(t) - : Hje(t) || Zje(t); - } - Jn.isArrayBufferView = oWt; - function aWt(t) { - return Im(t) === "Uint8Array"; - } - Jn.isUint8Array = aWt; - function sWt(t) { - return Im(t) === "Uint8ClampedArray"; - } - Jn.isUint8ClampedArray = sWt; - function uWt(t) { - return Im(t) === "Uint16Array"; - } - Jn.isUint16Array = uWt; - function cWt(t) { - return Im(t) === "Uint32Array"; - } - Jn.isUint32Array = cWt; - function lWt(t) { - return Im(t) === "Int8Array"; - } - Jn.isInt8Array = lWt; - function fWt(t) { - return Im(t) === "Int16Array"; - } - Jn.isInt16Array = fWt; - function dWt(t) { - return Im(t) === "Int32Array"; - } - Jn.isInt32Array = dWt; - function hWt(t) { - return Im(t) === "Float32Array"; - } - Jn.isFloat32Array = hWt; - function pWt(t) { - return Im(t) === "Float64Array"; - } - Jn.isFloat64Array = pWt; - function yWt(t) { - return Im(t) === "BigInt64Array"; - } - Jn.isBigInt64Array = yWt; - function mWt(t) { - return Im(t) === "BigUint64Array"; - } - Jn.isBigUint64Array = mWt; - function G$(t) { - return Y0(t) === "[object Map]"; - } - G$.working = typeof Map < "u" && G$(new Map()); - function gWt(t) { - return typeof Map > "u" ? !1 : G$.working ? G$(t) : t instanceof Map; - } - Jn.isMap = gWt; - function J$(t) { - return Y0(t) === "[object Set]"; - } - J$.working = typeof Set < "u" && J$(new Set()); - function vWt(t) { - return typeof Set > "u" ? !1 : J$.working ? J$(t) : t instanceof Set; - } - Jn.isSet = vWt; - function $$(t) { - return Y0(t) === "[object WeakMap]"; - } - $$.working = typeof WeakMap < "u" && $$(new WeakMap()); - function bWt(t) { - return typeof WeakMap > "u" - ? !1 - : $$.working - ? $$(t) - : t instanceof WeakMap; - } - Jn.isWeakMap = bWt; - function Rge(t) { - return Y0(t) === "[object WeakSet]"; - } - Rge.working = typeof WeakSet < "u" && Rge(new WeakSet()); - function wWt(t) { - return Rge(t); - } - Jn.isWeakSet = wWt; - function Z$(t) { - return Y0(t) === "[object ArrayBuffer]"; - } - Z$.working = typeof ArrayBuffer < "u" && Z$(new ArrayBuffer()); - function $je(t) { - return typeof ArrayBuffer > "u" - ? !1 - : Z$.working - ? Z$(t) - : t instanceof ArrayBuffer; - } - Jn.isArrayBuffer = $je; - function X$(t) { - return Y0(t) === "[object DataView]"; - } - X$.working = - typeof ArrayBuffer < "u" && - typeof DataView < "u" && - X$(new DataView(new ArrayBuffer(1), 0, 1)); - function Zje(t) { - return typeof DataView > "u" - ? !1 - : X$.working - ? X$(t) - : t instanceof DataView; - } - Jn.isDataView = Zje; - var Cge = typeof SharedArrayBuffer < "u" ? SharedArrayBuffer : void 0; - function iq(t) { - return Y0(t) === "[object SharedArrayBuffer]"; - } - function Xje(t) { - return typeof Cge > "u" - ? !1 - : (typeof iq.working > "u" && (iq.working = iq(new Cge())), - iq.working ? iq(t) : t instanceof Cge); - } - Jn.isSharedArrayBuffer = Xje; - function _Wt(t) { - return Y0(t) === "[object AsyncFunction]"; - } - Jn.isAsyncFunction = _Wt; - function xWt(t) { - return Y0(t) === "[object Map Iterator]"; - } - Jn.isMapIterator = xWt; - function SWt(t) { - return Y0(t) === "[object Set Iterator]"; - } - Jn.isSetIterator = SWt; - function AWt(t) { - return Y0(t) === "[object Generator]"; - } - Jn.isGeneratorObject = AWt; - function EWt(t) { - return Y0(t) === "[object WebAssembly.Module]"; - } - Jn.isWebAssemblyCompiledModule = EWt; - function Yje(t) { - return oq(t, tWt); - } - Jn.isNumberObject = Yje; - function Qje(t) { - return oq(t, rWt); - } - Jn.isStringObject = Qje; - function eUe(t) { - return oq(t, nWt); - } - Jn.isBooleanObject = eUe; - function tUe(t) { - return Vje && oq(t, Gje); - } - Jn.isBigIntObject = tUe; - function rUe(t) { - return Wje && oq(t, Jje); - } - Jn.isSymbolObject = rUe; - function MWt(t) { - return Yje(t) || Qje(t) || eUe(t) || tUe(t) || rUe(t); - } - Jn.isBoxedPrimitive = MWt; - function TWt(t) { - return typeof Uint8Array < "u" && ($je(t) || Xje(t)); - } - Jn.isAnyArrayBuffer = TWt; - ["isProxy", "isExternal", "isModuleNamespaceObject"].forEach(function (t) { - Object.defineProperty(Jn, t, { - enumerable: !1, - value: function () { - throw new Error(t + " is not supported in userland"); - }, - }); - }); - }); - var oUe = I((Acn, iUe) => { - m(); - g(); - iUe.exports = function (e) { - return ( - e && - typeof e == "object" && - typeof e.copy == "function" && - typeof e.fill == "function" && - typeof e.readUInt8 == "function" - ); - }; - }); - var es = I(($n) => { - m(); - g(); - var aUe = - Object.getOwnPropertyDescriptors || - function (e) { - for (var r = Object.keys(e), n = {}, i = 0; i < r.length; i++) - n[r[i]] = Object.getOwnPropertyDescriptor(e, r[i]); - return n; - }, - kWt = /%[sdj%]/g; - $n.format = function (t) { - if (!iZ(t)) { - for (var e = [], r = 0; r < arguments.length; r++) - e.push(i2(arguments[r])); - return e.join(" "); - } - for ( - var r = 1, - n = arguments, - i = n.length, - o = String(t).replace(kWt, function (s) { - if (s === "%%") return "%"; - if (r >= i) return s; - switch (s) { - case "%s": - return String(n[r++]); - case "%d": - return Number(n[r++]); - case "%j": - try { - return JSON.stringify(n[r++]); - } catch { - return "[Circular]"; - } - default: - return s; - } - }), - a = n[r]; - r < i; - a = n[++r] - ) - nZ(a) || !h5(a) ? (o += " " + a) : (o += " " + i2(a)); - return o; - }; - $n.deprecate = function (t, e) { - if (typeof process < "u" && process.noDeprecation === !0) return t; - if (typeof process > "u") - return function () { - return $n.deprecate(t, e).apply(this, arguments); - }; - var r = !1; - function n() { - if (!r) { - if (process.throwDeprecation) throw new Error(e); - process.traceDeprecation ? console.trace(e) : console.error(e), - (r = !0); - } - return t.apply(this, arguments); - } - return n; - }; - var Y$ = {}, - sUe = /^$/; - process.env.NODE_DEBUG && - ((Q$ = process.env.NODE_DEBUG), - (Q$ = Q$.replace(/[|\\{}()[\]^$+?.]/g, "\\$&") - .replace(/\*/g, ".*") - .replace(/,/g, "$|^") - .toUpperCase()), - (sUe = new RegExp("^" + Q$ + "$", "i"))); - var Q$; - $n.debuglog = function (t) { - if (((t = t.toUpperCase()), !Y$[t])) - if (sUe.test(t)) { - var e = process.pid; - Y$[t] = function () { - var r = $n.format.apply($n, arguments); - console.error("%s %d: %s", t, e, r); - }; - } else Y$[t] = function () {}; - return Y$[t]; - }; - function i2(t, e) { - var r = { seen: [], stylize: OWt }; - return ( - arguments.length >= 3 && (r.depth = arguments[2]), - arguments.length >= 4 && (r.colors = arguments[3]), - Lge(e) ? (r.showHidden = e) : e && $n._extend(r, e), - fM(r.showHidden) && (r.showHidden = !1), - fM(r.depth) && (r.depth = 2), - fM(r.colors) && (r.colors = !1), - fM(r.customInspect) && (r.customInspect = !0), - r.colors && (r.stylize = PWt), - tZ(r, t, r.depth) - ); - } - $n.inspect = i2; - i2.colors = { - bold: [1, 22], - italic: [3, 23], - underline: [4, 24], - inverse: [7, 27], - white: [37, 39], - grey: [90, 39], - black: [30, 39], - blue: [34, 39], - cyan: [36, 39], - green: [32, 39], - magenta: [35, 39], - red: [31, 39], - yellow: [33, 39], - }; - i2.styles = { - special: "cyan", - number: "yellow", - boolean: "yellow", - undefined: "grey", - null: "bold", - string: "green", - date: "magenta", - regexp: "red", - }; - function PWt(t, e) { - var r = i2.styles[e]; - return r - ? "\x1B[" + i2.colors[r][0] + "m" + t + "\x1B[" + i2.colors[r][1] + "m" - : t; - } - function OWt(t, e) { - return t; - } - function BWt(t) { - var e = {}; - return ( - t.forEach(function (r, n) { - e[r] = !0; - }), - e - ); - } - function tZ(t, e, r) { - if ( - t.customInspect && - e && - eZ(e.inspect) && - e.inspect !== $n.inspect && - !(e.constructor && e.constructor.prototype === e) - ) { - var n = e.inspect(r, t); - return iZ(n) || (n = tZ(t, n, r)), n; - } - var i = IWt(t, e); - if (i) return i; - var o = Object.keys(e), - a = BWt(o); - if ( - (t.showHidden && (o = Object.getOwnPropertyNames(e)), - sq(e) && (o.indexOf("message") >= 0 || o.indexOf("description") >= 0)) - ) - return Nge(e); - if (o.length === 0) { - if (eZ(e)) { - var s = e.name ? ": " + e.name : ""; - return t.stylize("[Function" + s + "]", "special"); - } - if (aq(e)) - return t.stylize(RegExp.prototype.toString.call(e), "regexp"); - if (rZ(e)) return t.stylize(Date.prototype.toString.call(e), "date"); - if (sq(e)) return Nge(e); - } - var c = "", - u = !1, - h = ["{", "}"]; - if ((uUe(e) && ((u = !0), (h = ["[", "]"])), eZ(e))) { - var w = e.name ? ": " + e.name : ""; - c = " [Function" + w + "]"; - } - if ( - (aq(e) && (c = " " + RegExp.prototype.toString.call(e)), - rZ(e) && (c = " " + Date.prototype.toUTCString.call(e)), - sq(e) && (c = " " + Nge(e)), - o.length === 0 && (!u || e.length == 0)) - ) - return h[0] + c + h[1]; - if (r < 0) - return aq(e) - ? t.stylize(RegExp.prototype.toString.call(e), "regexp") - : t.stylize("[Object]", "special"); - t.seen.push(e); - var M; - return ( - u - ? (M = CWt(t, e, r, a, o)) - : (M = o.map(function (k) { - return Fge(t, e, r, a, k, u); - })), - t.seen.pop(), - RWt(M, c, h) - ); - } - function IWt(t, e) { - if (fM(e)) return t.stylize("undefined", "undefined"); - if (iZ(e)) { - var r = - "'" + - JSON.stringify(e) - .replace(/^"|"$/g, "") - .replace(/'/g, "\\'") - .replace(/\\"/g, '"') + - "'"; - return t.stylize(r, "string"); - } - if (cUe(e)) return t.stylize("" + e, "number"); - if (Lge(e)) return t.stylize("" + e, "boolean"); - if (nZ(e)) return t.stylize("null", "null"); - } - function Nge(t) { - return "[" + Error.prototype.toString.call(t) + "]"; - } - function CWt(t, e, r, n, i) { - for (var o = [], a = 0, s = e.length; a < s; ++a) - lUe(e, String(a)) ? o.push(Fge(t, e, r, n, String(a), !0)) : o.push(""); - return ( - i.forEach(function (c) { - c.match(/^\d+$/) || o.push(Fge(t, e, r, n, c, !0)); - }), - o - ); - } - function Fge(t, e, r, n, i, o) { - var a, s, c; - if ( - ((c = Object.getOwnPropertyDescriptor(e, i) || { value: e[i] }), - c.get - ? c.set - ? (s = t.stylize("[Getter/Setter]", "special")) - : (s = t.stylize("[Getter]", "special")) - : c.set && (s = t.stylize("[Setter]", "special")), - lUe(n, i) || (a = "[" + i + "]"), - s || - (t.seen.indexOf(c.value) < 0 - ? (nZ(r) ? (s = tZ(t, c.value, null)) : (s = tZ(t, c.value, r - 1)), - s.indexOf(` -`) > -1 && - (o - ? (s = s - .split( - ` -` - ) - .map(function (u) { - return " " + u; - }) - .join( - ` -` - ) - .substr(2)) - : (s = - ` -` + - s - .split( - ` -` - ) - .map(function (u) { - return " " + u; - }).join(` -`)))) - : (s = t.stylize("[Circular]", "special"))), - fM(a)) - ) { - if (o && i.match(/^\d+$/)) return s; - (a = JSON.stringify("" + i)), - a.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/) - ? ((a = a.substr(1, a.length - 2)), (a = t.stylize(a, "name"))) - : ((a = a - .replace(/'/g, "\\'") - .replace(/\\"/g, '"') - .replace(/(^"|"$)/g, "'")), - (a = t.stylize(a, "string"))); - } - return a + ": " + s; - } - function RWt(t, e, r) { - var n = 0, - i = t.reduce(function (o, a) { - return ( - n++, - a.indexOf(` -`) >= 0 && n++, - o + a.replace(/\u001b\[\d\d?m/g, "").length + 1 - ); - }, 0); - return i > 60 - ? r[0] + - (e === "" - ? "" - : e + - ` - `) + - " " + - t.join(`, - `) + - " " + - r[1] - : r[0] + e + " " + t.join(", ") + " " + r[1]; - } - $n.types = nUe(); - function uUe(t) { - return Array.isArray(t); - } - $n.isArray = uUe; - function Lge(t) { - return typeof t == "boolean"; - } - $n.isBoolean = Lge; - function nZ(t) { - return t === null; - } - $n.isNull = nZ; - function NWt(t) { - return t == null; - } - $n.isNullOrUndefined = NWt; - function cUe(t) { - return typeof t == "number"; - } - $n.isNumber = cUe; - function iZ(t) { - return typeof t == "string"; - } - $n.isString = iZ; - function DWt(t) { - return typeof t == "symbol"; - } - $n.isSymbol = DWt; - function fM(t) { - return t === void 0; - } - $n.isUndefined = fM; - function aq(t) { - return h5(t) && qge(t) === "[object RegExp]"; - } - $n.isRegExp = aq; - $n.types.isRegExp = aq; - function h5(t) { - return typeof t == "object" && t !== null; - } - $n.isObject = h5; - function rZ(t) { - return h5(t) && qge(t) === "[object Date]"; - } - $n.isDate = rZ; - $n.types.isDate = rZ; - function sq(t) { - return h5(t) && (qge(t) === "[object Error]" || t instanceof Error); - } - $n.isError = sq; - $n.types.isNativeError = sq; - function eZ(t) { - return typeof t == "function"; - } - $n.isFunction = eZ; - function FWt(t) { - return ( - t === null || - typeof t == "boolean" || - typeof t == "number" || - typeof t == "string" || - typeof t == "symbol" || - typeof t > "u" - ); - } - $n.isPrimitive = FWt; - $n.isBuffer = oUe(); - function qge(t) { - return Object.prototype.toString.call(t); - } - function Dge(t) { - return t < 10 ? "0" + t.toString(10) : t.toString(10); - } - var LWt = [ - "Jan", - "Feb", - "Mar", - "Apr", - "May", - "Jun", - "Jul", - "Aug", - "Sep", - "Oct", - "Nov", - "Dec", - ]; - function qWt() { - var t = new Date(), - e = [Dge(t.getHours()), Dge(t.getMinutes()), Dge(t.getSeconds())].join( - ":" - ); - return [t.getDate(), LWt[t.getMonth()], e].join(" "); - } - $n.log = function () { - console.log("%s - %s", qWt(), $n.format.apply($n, arguments)); - }; - $n.inherits = dn(); - $n._extend = function (t, e) { - if (!e || !h5(e)) return t; - for (var r = Object.keys(e), n = r.length; n--; ) t[r[n]] = e[r[n]]; - return t; - }; - function lUe(t, e) { - return Object.prototype.hasOwnProperty.call(t, e); - } - var lM = typeof Symbol < "u" ? Symbol("util.promisify.custom") : void 0; - $n.promisify = function (e) { - if (typeof e != "function") - throw new TypeError('The "original" argument must be of type Function'); - if (lM && e[lM]) { - var r = e[lM]; - if (typeof r != "function") - throw new TypeError( - 'The "util.promisify.custom" argument must be of type Function' - ); - return ( - Object.defineProperty(r, lM, { - value: r, - enumerable: !1, - writable: !1, - configurable: !0, - }), - r - ); - } - function r() { - for ( - var n, - i, - o = new Promise(function (c, u) { - (n = c), (i = u); - }), - a = [], - s = 0; - s < arguments.length; - s++ - ) - a.push(arguments[s]); - a.push(function (c, u) { - c ? i(c) : n(u); - }); - try { - e.apply(this, a); - } catch (c) { - i(c); - } - return o; - } - return ( - Object.setPrototypeOf(r, Object.getPrototypeOf(e)), - lM && - Object.defineProperty(r, lM, { - value: r, - enumerable: !1, - writable: !1, - configurable: !0, - }), - Object.defineProperties(r, aUe(e)) - ); - }; - $n.promisify.custom = lM; - function zWt(t, e) { - if (!t) { - var r = new Error("Promise was rejected with a falsy value"); - (r.reason = t), (t = r); - } - return e(t); - } - function jWt(t) { - if (typeof t != "function") - throw new TypeError('The "original" argument must be of type Function'); - function e() { - for (var r = [], n = 0; n < arguments.length; n++) r.push(arguments[n]); - var i = r.pop(); - if (typeof i != "function") - throw new TypeError("The last argument must be of type Function"); - var o = this, - a = function () { - return i.apply(o, arguments); - }; - t.apply(this, r).then( - function (s) { - process.nextTick(a.bind(null, null, s)); - }, - function (s) { - process.nextTick(zWt.bind(null, s, a)); - } - ); - } - return ( - Object.setPrototypeOf(e, Object.getPrototypeOf(t)), - Object.defineProperties(e, aUe(t)), - e - ); - } - $n.callbackify = jWt; - }); - var pUe = I((Mcn, hUe) => { - "use strict"; - m(); - g(); - function fUe(t, e) { - var r = Object.keys(t); - if (Object.getOwnPropertySymbols) { - var n = Object.getOwnPropertySymbols(t); - e && - (n = n.filter(function (i) { - return Object.getOwnPropertyDescriptor(t, i).enumerable; - })), - r.push.apply(r, n); - } - return r; - } - function UWt(t) { - for (var e = 1; e < arguments.length; e++) { - var r = arguments[e] != null ? arguments[e] : {}; - e % 2 - ? fUe(Object(r), !0).forEach(function (n) { - KWt(t, n, r[n]); - }) - : Object.getOwnPropertyDescriptors - ? Object.defineProperties(t, Object.getOwnPropertyDescriptors(r)) - : fUe(Object(r)).forEach(function (n) { - Object.defineProperty( - t, - n, - Object.getOwnPropertyDescriptor(r, n) - ); - }); - } - return t; - } - function KWt(t, e, r) { - return ( - e in t - ? Object.defineProperty(t, e, { - value: r, - enumerable: !0, - configurable: !0, - writable: !0, - }) - : (t[e] = r), - t - ); - } - function HWt(t, e) { - if (!(t instanceof e)) - throw new TypeError("Cannot call a class as a function"); - } - function dUe(t, e) { - for (var r = 0; r < e.length; r++) { - var n = e[r]; - (n.enumerable = n.enumerable || !1), - (n.configurable = !0), - "value" in n && (n.writable = !0), - Object.defineProperty(t, n.key, n); - } - } - function VWt(t, e, r) { - return e && dUe(t.prototype, e), r && dUe(t, r), t; - } - var WWt = Qr(), - oZ = WWt.Buffer, - GWt = es(), - zge = GWt.inspect, - JWt = (zge && zge.custom) || "inspect"; - function $Wt(t, e, r) { - oZ.prototype.copy.call(t, e, r); - } - hUe.exports = (function () { - function t() { - HWt(this, t), (this.head = null), (this.tail = null), (this.length = 0); - } - return ( - VWt(t, [ - { - key: "push", - value: function (r) { - var n = { data: r, next: null }; - this.length > 0 ? (this.tail.next = n) : (this.head = n), - (this.tail = n), - ++this.length; - }, - }, - { - key: "unshift", - value: function (r) { - var n = { data: r, next: this.head }; - this.length === 0 && (this.tail = n), - (this.head = n), - ++this.length; - }, - }, - { - key: "shift", - value: function () { - if (this.length !== 0) { - var r = this.head.data; - return ( - this.length === 1 - ? (this.head = this.tail = null) - : (this.head = this.head.next), - --this.length, - r - ); - } - }, - }, - { - key: "clear", - value: function () { - (this.head = this.tail = null), (this.length = 0); - }, - }, - { - key: "join", - value: function (r) { - if (this.length === 0) return ""; - for (var n = this.head, i = "" + n.data; (n = n.next); ) - i += r + n.data; - return i; - }, - }, - { - key: "concat", - value: function (r) { - if (this.length === 0) return oZ.alloc(0); - for (var n = oZ.allocUnsafe(r >>> 0), i = this.head, o = 0; i; ) - $Wt(i.data, n, o), (o += i.data.length), (i = i.next); - return n; - }, - }, - { - key: "consume", - value: function (r, n) { - var i; - return ( - r < this.head.data.length - ? ((i = this.head.data.slice(0, r)), - (this.head.data = this.head.data.slice(r))) - : r === this.head.data.length - ? (i = this.shift()) - : (i = n ? this._getString(r) : this._getBuffer(r)), - i - ); - }, - }, - { - key: "first", - value: function () { - return this.head.data; - }, - }, - { - key: "_getString", - value: function (r) { - var n = this.head, - i = 1, - o = n.data; - for (r -= o.length; (n = n.next); ) { - var a = n.data, - s = r > a.length ? a.length : r; - if ( - (s === a.length ? (o += a) : (o += a.slice(0, r)), - (r -= s), - r === 0) - ) { - s === a.length - ? (++i, - n.next - ? (this.head = n.next) - : (this.head = this.tail = null)) - : ((this.head = n), (n.data = a.slice(s))); - break; - } - ++i; - } - return (this.length -= i), o; - }, - }, - { - key: "_getBuffer", - value: function (r) { - var n = oZ.allocUnsafe(r), - i = this.head, - o = 1; - for (i.data.copy(n), r -= i.data.length; (i = i.next); ) { - var a = i.data, - s = r > a.length ? a.length : r; - if ((a.copy(n, n.length - r, 0, s), (r -= s), r === 0)) { - s === a.length - ? (++o, - i.next - ? (this.head = i.next) - : (this.head = this.tail = null)) - : ((this.head = i), (i.data = a.slice(s))); - break; - } - ++o; - } - return (this.length -= o), n; - }, - }, - { - key: JWt, - value: function (r, n) { - return zge(this, UWt({}, n, { depth: 0, customInspect: !1 })); - }, - }, - ]), - t - ); - })(); - }); - var Uge = I((Tcn, mUe) => { - "use strict"; - m(); - g(); - function ZWt(t, e) { - var r = this, - n = this._readableState && this._readableState.destroyed, - i = this._writableState && this._writableState.destroyed; - return n || i - ? (e - ? e(t) - : t && - (this._writableState - ? this._writableState.errorEmitted || - ((this._writableState.errorEmitted = !0), - process.nextTick(jge, this, t)) - : process.nextTick(jge, this, t)), - this) - : (this._readableState && (this._readableState.destroyed = !0), - this._writableState && (this._writableState.destroyed = !0), - this._destroy(t || null, function (o) { - !e && o - ? r._writableState - ? r._writableState.errorEmitted - ? process.nextTick(aZ, r) - : ((r._writableState.errorEmitted = !0), - process.nextTick(yUe, r, o)) - : process.nextTick(yUe, r, o) - : e - ? (process.nextTick(aZ, r), e(o)) - : process.nextTick(aZ, r); - }), - this); - } - function yUe(t, e) { - jge(t, e), aZ(t); - } - function aZ(t) { - (t._writableState && !t._writableState.emitClose) || - (t._readableState && !t._readableState.emitClose) || - t.emit("close"); - } - function XWt() { - this._readableState && - ((this._readableState.destroyed = !1), - (this._readableState.reading = !1), - (this._readableState.ended = !1), - (this._readableState.endEmitted = !1)), - this._writableState && - ((this._writableState.destroyed = !1), - (this._writableState.ended = !1), - (this._writableState.ending = !1), - (this._writableState.finalCalled = !1), - (this._writableState.prefinished = !1), - (this._writableState.finished = !1), - (this._writableState.errorEmitted = !1)); - } - function jge(t, e) { - t.emit("error", e); - } - function YWt(t, e) { - var r = t._readableState, - n = t._writableState; - (r && r.autoDestroy) || (n && n.autoDestroy) - ? t.destroy(e) - : t.emit("error", e); - } - mUe.exports = { destroy: ZWt, undestroy: XWt, errorOrDestroy: YWt }; - }); - var dM = I((kcn, bUe) => { - "use strict"; - m(); - g(); - function QWt(t, e) { - (t.prototype = Object.create(e.prototype)), - (t.prototype.constructor = t), - (t.__proto__ = e); - } - var vUe = {}; - function Q0(t, e, r) { - r || (r = Error); - function n(o, a, s) { - return typeof e == "string" ? e : e(o, a, s); - } - var i = (function (o) { - QWt(a, o); - function a(s, c, u) { - return o.call(this, n(s, c, u)) || this; - } - return a; - })(r); - (i.prototype.name = r.name), (i.prototype.code = t), (vUe[t] = i); - } - function gUe(t, e) { - if (Array.isArray(t)) { - var r = t.length; - return ( - (t = t.map(function (n) { - return String(n); - })), - r > 2 - ? "one of " - .concat(e, " ") - .concat(t.slice(0, r - 1).join(", "), ", or ") + t[r - 1] - : r === 2 - ? "one of ".concat(e, " ").concat(t[0], " or ").concat(t[1]) - : "of ".concat(e, " ").concat(t[0]) - ); - } else return "of ".concat(e, " ").concat(String(t)); - } - function eGt(t, e, r) { - return t.substr(!r || r < 0 ? 0 : +r, e.length) === e; - } - function tGt(t, e, r) { - return ( - (r === void 0 || r > t.length) && (r = t.length), - t.substring(r - e.length, r) === e - ); - } - function rGt(t, e, r) { - return ( - typeof r != "number" && (r = 0), - r + e.length > t.length ? !1 : t.indexOf(e, r) !== -1 - ); - } - Q0( - "ERR_INVALID_OPT_VALUE", - function (t, e) { - return 'The value "' + e + '" is invalid for option "' + t + '"'; - }, - TypeError - ); - Q0( - "ERR_INVALID_ARG_TYPE", - function (t, e, r) { - var n; - typeof e == "string" && eGt(e, "not ") - ? ((n = "must not be"), (e = e.replace(/^not /, ""))) - : (n = "must be"); - var i; - if (tGt(t, " argument")) - i = "The ".concat(t, " ").concat(n, " ").concat(gUe(e, "type")); - else { - var o = rGt(t, ".") ? "property" : "argument"; - i = 'The "' - .concat(t, '" ') - .concat(o, " ") - .concat(n, " ") - .concat(gUe(e, "type")); - } - return (i += ". Received type ".concat(typeof r)), i; - }, - TypeError - ); - Q0("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF"); - Q0("ERR_METHOD_NOT_IMPLEMENTED", function (t) { - return "The " + t + " method is not implemented"; - }); - Q0("ERR_STREAM_PREMATURE_CLOSE", "Premature close"); - Q0("ERR_STREAM_DESTROYED", function (t) { - return "Cannot call " + t + " after a stream was destroyed"; - }); - Q0("ERR_MULTIPLE_CALLBACK", "Callback called multiple times"); - Q0("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable"); - Q0("ERR_STREAM_WRITE_AFTER_END", "write after end"); - Q0( - "ERR_STREAM_NULL_VALUES", - "May not write null values to stream", - TypeError - ); - Q0( - "ERR_UNKNOWN_ENCODING", - function (t) { - return "Unknown encoding: " + t; - }, - TypeError - ); - Q0( - "ERR_STREAM_UNSHIFT_AFTER_END_EVENT", - "stream.unshift() after end event" - ); - bUe.exports.codes = vUe; - }); - var Kge = I((Pcn, wUe) => { - "use strict"; - m(); - g(); - var nGt = dM().codes.ERR_INVALID_OPT_VALUE; - function iGt(t, e, r) { - return t.highWaterMark != null ? t.highWaterMark : e ? t[r] : null; - } - function oGt(t, e, r, n) { - var i = iGt(e, n, r); - if (i != null) { - if (!(isFinite(i) && Math.floor(i) === i) || i < 0) { - var o = n ? r : "highWaterMark"; - throw new nGt(o, i); - } - return Math.floor(i); - } - return t.objectMode ? 16 : 16 * 1024; - } - wUe.exports = { getHighWaterMark: oGt }; - }); - var xUe = I((Ocn, _Ue) => { - m(); - g(); - _Ue.exports = aGt; - function aGt(t, e) { - if (Hge("noDeprecation")) return t; - var r = !1; - function n() { - if (!r) { - if (Hge("throwDeprecation")) throw new Error(e); - Hge("traceDeprecation") ? console.trace(e) : console.warn(e), - (r = !0); - } - return t.apply(this, arguments); - } - return n; - } - function Hge(t) { - try { - if (!window.localStorage) return !1; - } catch { - return !1; - } - var e = window.localStorage[t]; - return e == null ? !1 : String(e).toLowerCase() === "true"; - } - }); - var cZ = I((Bcn, kUe) => { - "use strict"; - m(); - g(); - kUe.exports = Ca; - function AUe(t) { - var e = this; - (this.next = null), - (this.entry = null), - (this.finish = function () { - CGt(e, t); - }); - } - var p5; - Ca.WritableState = cq; - var sGt = { deprecate: xUe() }, - EUe = hge(), - uZ = Qr().Buffer, - uGt = window.Uint8Array || function () {}; - function cGt(t) { - return uZ.from(t); - } - function lGt(t) { - return uZ.isBuffer(t) || t instanceof uGt; - } - var Wge = Uge(), - fGt = Kge(), - dGt = fGt.getHighWaterMark, - o2 = dM().codes, - hGt = o2.ERR_INVALID_ARG_TYPE, - pGt = o2.ERR_METHOD_NOT_IMPLEMENTED, - yGt = o2.ERR_MULTIPLE_CALLBACK, - mGt = o2.ERR_STREAM_CANNOT_PIPE, - gGt = o2.ERR_STREAM_DESTROYED, - vGt = o2.ERR_STREAM_NULL_VALUES, - bGt = o2.ERR_STREAM_WRITE_AFTER_END, - wGt = o2.ERR_UNKNOWN_ENCODING, - y5 = Wge.errorOrDestroy; - dn()(Ca, EUe); - function _Gt() {} - function cq(t, e, r) { - (p5 = p5 || a2()), - (t = t || {}), - typeof r != "boolean" && (r = e instanceof p5), - (this.objectMode = !!t.objectMode), - r && (this.objectMode = this.objectMode || !!t.writableObjectMode), - (this.highWaterMark = dGt(this, t, "writableHighWaterMark", r)), - (this.finalCalled = !1), - (this.needDrain = !1), - (this.ending = !1), - (this.ended = !1), - (this.finished = !1), - (this.destroyed = !1); - var n = t.decodeStrings === !1; - (this.decodeStrings = !n), - (this.defaultEncoding = t.defaultEncoding || "utf8"), - (this.length = 0), - (this.writing = !1), - (this.corked = 0), - (this.sync = !0), - (this.bufferProcessing = !1), - (this.onwrite = function (i) { - kGt(e, i); - }), - (this.writecb = null), - (this.writelen = 0), - (this.bufferedRequest = null), - (this.lastBufferedRequest = null), - (this.pendingcb = 0), - (this.prefinished = !1), - (this.errorEmitted = !1), - (this.emitClose = t.emitClose !== !1), - (this.autoDestroy = !!t.autoDestroy), - (this.bufferedRequestCount = 0), - (this.corkedRequestsFree = new AUe(this)); - } - cq.prototype.getBuffer = function () { - for (var e = this.bufferedRequest, r = []; e; ) r.push(e), (e = e.next); - return r; - }; - (function () { - try { - Object.defineProperty(cq.prototype, "buffer", { - get: sGt.deprecate( - function () { - return this.getBuffer(); - }, - "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", - "DEP0003" - ), - }); - } catch {} - })(); - var sZ; - typeof Symbol == "function" && - Symbol.hasInstance && - typeof Function.prototype[Symbol.hasInstance] == "function" - ? ((sZ = Function.prototype[Symbol.hasInstance]), - Object.defineProperty(Ca, Symbol.hasInstance, { - value: function (e) { - return sZ.call(this, e) - ? !0 - : this !== Ca - ? !1 - : e && e._writableState instanceof cq; - }, - })) - : (sZ = function (e) { - return e instanceof this; - }); - function Ca(t) { - p5 = p5 || a2(); - var e = this instanceof p5; - if (!e && !sZ.call(Ca, this)) return new Ca(t); - (this._writableState = new cq(t, this, e)), - (this.writable = !0), - t && - (typeof t.write == "function" && (this._write = t.write), - typeof t.writev == "function" && (this._writev = t.writev), - typeof t.destroy == "function" && (this._destroy = t.destroy), - typeof t.final == "function" && (this._final = t.final)), - EUe.call(this); - } - Ca.prototype.pipe = function () { - y5(this, new mGt()); - }; - function xGt(t, e) { - var r = new bGt(); - y5(t, r), process.nextTick(e, r); - } - function SGt(t, e, r, n) { - var i; - return ( - r === null - ? (i = new vGt()) - : typeof r != "string" && - !e.objectMode && - (i = new hGt("chunk", ["string", "Buffer"], r)), - i ? (y5(t, i), process.nextTick(n, i), !1) : !0 - ); - } - Ca.prototype.write = function (t, e, r) { - var n = this._writableState, - i = !1, - o = !n.objectMode && lGt(t); - return ( - o && !uZ.isBuffer(t) && (t = cGt(t)), - typeof e == "function" && ((r = e), (e = null)), - o ? (e = "buffer") : e || (e = n.defaultEncoding), - typeof r != "function" && (r = _Gt), - n.ending - ? xGt(this, r) - : (o || SGt(this, n, t, r)) && - (n.pendingcb++, (i = EGt(this, n, o, t, e, r))), - i - ); - }; - Ca.prototype.cork = function () { - this._writableState.corked++; - }; - Ca.prototype.uncork = function () { - var t = this._writableState; - t.corked && - (t.corked--, - !t.writing && - !t.corked && - !t.bufferProcessing && - t.bufferedRequest && - MUe(this, t)); - }; - Ca.prototype.setDefaultEncoding = function (e) { - if ( - (typeof e == "string" && (e = e.toLowerCase()), - !( - [ - "hex", - "utf8", - "utf-8", - "ascii", - "binary", - "base64", - "ucs2", - "ucs-2", - "utf16le", - "utf-16le", - "raw", - ].indexOf((e + "").toLowerCase()) > -1 - )) - ) - throw new wGt(e); - return (this._writableState.defaultEncoding = e), this; - }; - Object.defineProperty(Ca.prototype, "writableBuffer", { - enumerable: !1, - get: function () { - return this._writableState && this._writableState.getBuffer(); - }, - }); - function AGt(t, e, r) { - return ( - !t.objectMode && - t.decodeStrings !== !1 && - typeof e == "string" && - (e = uZ.from(e, r)), - e - ); - } - Object.defineProperty(Ca.prototype, "writableHighWaterMark", { - enumerable: !1, - get: function () { - return this._writableState.highWaterMark; - }, - }); - function EGt(t, e, r, n, i, o) { - if (!r) { - var a = AGt(e, n, i); - n !== a && ((r = !0), (i = "buffer"), (n = a)); - } - var s = e.objectMode ? 1 : n.length; - e.length += s; - var c = e.length < e.highWaterMark; - if ((c || (e.needDrain = !0), e.writing || e.corked)) { - var u = e.lastBufferedRequest; - (e.lastBufferedRequest = { - chunk: n, - encoding: i, - isBuf: r, - callback: o, - next: null, - }), - u - ? (u.next = e.lastBufferedRequest) - : (e.bufferedRequest = e.lastBufferedRequest), - (e.bufferedRequestCount += 1); - } else Vge(t, e, !1, s, n, i, o); - return c; - } - function Vge(t, e, r, n, i, o, a) { - (e.writelen = n), - (e.writecb = a), - (e.writing = !0), - (e.sync = !0), - e.destroyed - ? e.onwrite(new gGt("write")) - : r - ? t._writev(i, e.onwrite) - : t._write(i, o, e.onwrite), - (e.sync = !1); - } - function MGt(t, e, r, n, i) { - --e.pendingcb, - r - ? (process.nextTick(i, n), - process.nextTick(uq, t, e), - (t._writableState.errorEmitted = !0), - y5(t, n)) - : (i(n), (t._writableState.errorEmitted = !0), y5(t, n), uq(t, e)); - } - function TGt(t) { - (t.writing = !1), - (t.writecb = null), - (t.length -= t.writelen), - (t.writelen = 0); - } - function kGt(t, e) { - var r = t._writableState, - n = r.sync, - i = r.writecb; - if (typeof i != "function") throw new yGt(); - if ((TGt(r), e)) MGt(t, r, n, e, i); - else { - var o = TUe(r) || t.destroyed; - !o && - !r.corked && - !r.bufferProcessing && - r.bufferedRequest && - MUe(t, r), - n ? process.nextTick(SUe, t, r, o, i) : SUe(t, r, o, i); - } - } - function SUe(t, e, r, n) { - r || PGt(t, e), e.pendingcb--, n(), uq(t, e); - } - function PGt(t, e) { - e.length === 0 && e.needDrain && ((e.needDrain = !1), t.emit("drain")); - } - function MUe(t, e) { - e.bufferProcessing = !0; - var r = e.bufferedRequest; - if (t._writev && r && r.next) { - var n = e.bufferedRequestCount, - i = new Array(n), - o = e.corkedRequestsFree; - o.entry = r; - for (var a = 0, s = !0; r; ) - (i[a] = r), r.isBuf || (s = !1), (r = r.next), (a += 1); - (i.allBuffers = s), - Vge(t, e, !0, e.length, i, "", o.finish), - e.pendingcb++, - (e.lastBufferedRequest = null), - o.next - ? ((e.corkedRequestsFree = o.next), (o.next = null)) - : (e.corkedRequestsFree = new AUe(e)), - (e.bufferedRequestCount = 0); - } else { - for (; r; ) { - var c = r.chunk, - u = r.encoding, - h = r.callback, - w = e.objectMode ? 1 : c.length; - if ( - (Vge(t, e, !1, w, c, u, h), - (r = r.next), - e.bufferedRequestCount--, - e.writing) - ) - break; - } - r === null && (e.lastBufferedRequest = null); - } - (e.bufferedRequest = r), (e.bufferProcessing = !1); - } - Ca.prototype._write = function (t, e, r) { - r(new pGt("_write()")); - }; - Ca.prototype._writev = null; - Ca.prototype.end = function (t, e, r) { - var n = this._writableState; - return ( - typeof t == "function" - ? ((r = t), (t = null), (e = null)) - : typeof e == "function" && ((r = e), (e = null)), - t != null && this.write(t, e), - n.corked && ((n.corked = 1), this.uncork()), - n.ending || IGt(this, n, r), - this - ); - }; - Object.defineProperty(Ca.prototype, "writableLength", { - enumerable: !1, - get: function () { - return this._writableState.length; - }, - }); - function TUe(t) { - return ( - t.ending && - t.length === 0 && - t.bufferedRequest === null && - !t.finished && - !t.writing - ); - } - function OGt(t, e) { - t._final(function (r) { - e.pendingcb--, - r && y5(t, r), - (e.prefinished = !0), - t.emit("prefinish"), - uq(t, e); - }); - } - function BGt(t, e) { - !e.prefinished && - !e.finalCalled && - (typeof t._final == "function" && !e.destroyed - ? (e.pendingcb++, (e.finalCalled = !0), process.nextTick(OGt, t, e)) - : ((e.prefinished = !0), t.emit("prefinish"))); - } - function uq(t, e) { - var r = TUe(e); - if ( - r && - (BGt(t, e), - e.pendingcb === 0 && - ((e.finished = !0), t.emit("finish"), e.autoDestroy)) - ) { - var n = t._readableState; - (!n || (n.autoDestroy && n.endEmitted)) && t.destroy(); - } - return r; - } - function IGt(t, e, r) { - (e.ending = !0), - uq(t, e), - r && (e.finished ? process.nextTick(r) : t.once("finish", r)), - (e.ended = !0), - (t.writable = !1); - } - function CGt(t, e, r) { - var n = t.entry; - for (t.entry = null; n; ) { - var i = n.callback; - e.pendingcb--, i(r), (n = n.next); - } - e.corkedRequestsFree.next = t; - } - Object.defineProperty(Ca.prototype, "destroyed", { - enumerable: !1, - get: function () { - return this._writableState === void 0 - ? !1 - : this._writableState.destroyed; - }, - set: function (e) { - !this._writableState || (this._writableState.destroyed = e); - }, - }); - Ca.prototype.destroy = Wge.destroy; - Ca.prototype._undestroy = Wge.undestroy; - Ca.prototype._destroy = function (t, e) { - e(t); - }; - }); - var a2 = I((Icn, OUe) => { - "use strict"; - m(); - g(); - var RGt = - Object.keys || - function (t) { - var e = []; - for (var r in t) e.push(r); - return e; - }; - OUe.exports = fv; - var PUe = dZ(), - Jge = cZ(); - dn()(fv, PUe); - for (Gge = RGt(Jge.prototype), lZ = 0; lZ < Gge.length; lZ++) - (fZ = Gge[lZ]), - fv.prototype[fZ] || (fv.prototype[fZ] = Jge.prototype[fZ]); - var Gge, fZ, lZ; - function fv(t) { - if (!(this instanceof fv)) return new fv(t); - PUe.call(this, t), - Jge.call(this, t), - (this.allowHalfOpen = !0), - t && - (t.readable === !1 && (this.readable = !1), - t.writable === !1 && (this.writable = !1), - t.allowHalfOpen === !1 && - ((this.allowHalfOpen = !1), this.once("end", NGt))); - } - Object.defineProperty(fv.prototype, "writableHighWaterMark", { - enumerable: !1, - get: function () { - return this._writableState.highWaterMark; - }, - }); - Object.defineProperty(fv.prototype, "writableBuffer", { - enumerable: !1, - get: function () { - return this._writableState && this._writableState.getBuffer(); - }, - }); - Object.defineProperty(fv.prototype, "writableLength", { - enumerable: !1, - get: function () { - return this._writableState.length; - }, - }); - function NGt() { - this._writableState.ended || process.nextTick(DGt, this); - } - function DGt(t) { - t.end(); - } - Object.defineProperty(fv.prototype, "destroyed", { - enumerable: !1, - get: function () { - return this._readableState === void 0 || this._writableState === void 0 - ? !1 - : this._readableState.destroyed && this._writableState.destroyed; - }, - set: function (e) { - this._readableState === void 0 || - this._writableState === void 0 || - ((this._readableState.destroyed = e), - (this._writableState.destroyed = e)); - }, - }); - }); - var hZ = I((IUe) => { - "use strict"; - m(); - g(); - var Zge = vn().Buffer, - BUe = - Zge.isEncoding || - function (t) { - switch (((t = "" + t), t && t.toLowerCase())) { - case "hex": - case "utf8": - case "utf-8": - case "ascii": - case "binary": - case "base64": - case "ucs2": - case "ucs-2": - case "utf16le": - case "utf-16le": - case "raw": - return !0; - default: - return !1; - } - }; - function FGt(t) { - if (!t) return "utf8"; - for (var e; ; ) - switch (t) { - case "utf8": - case "utf-8": - return "utf8"; - case "ucs2": - case "ucs-2": - case "utf16le": - case "utf-16le": - return "utf16le"; - case "latin1": - case "binary": - return "latin1"; - case "base64": - case "ascii": - case "hex": - return t; - default: - if (e) return; - (t = ("" + t).toLowerCase()), (e = !0); - } - } - function LGt(t) { - var e = FGt(t); - if (typeof e != "string" && (Zge.isEncoding === BUe || !BUe(t))) - throw new Error("Unknown encoding: " + t); - return e || t; - } - IUe.StringDecoder = lq; - function lq(t) { - this.encoding = LGt(t); - var e; - switch (this.encoding) { - case "utf16le": - (this.text = HGt), (this.end = VGt), (e = 4); - break; - case "utf8": - (this.fillLast = jGt), (e = 4); - break; - case "base64": - (this.text = WGt), (this.end = GGt), (e = 3); - break; - default: - (this.write = JGt), (this.end = $Gt); - return; - } - (this.lastNeed = 0), - (this.lastTotal = 0), - (this.lastChar = Zge.allocUnsafe(e)); - } - lq.prototype.write = function (t) { - if (t.length === 0) return ""; - var e, r; - if (this.lastNeed) { - if (((e = this.fillLast(t)), e === void 0)) return ""; - (r = this.lastNeed), (this.lastNeed = 0); - } else r = 0; - return r < t.length - ? e - ? e + this.text(t, r) - : this.text(t, r) - : e || ""; - }; - lq.prototype.end = KGt; - lq.prototype.text = UGt; - lq.prototype.fillLast = function (t) { - if (this.lastNeed <= t.length) - return ( - t.copy( - this.lastChar, - this.lastTotal - this.lastNeed, - 0, - this.lastNeed - ), - this.lastChar.toString(this.encoding, 0, this.lastTotal) - ); - t.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, t.length), - (this.lastNeed -= t.length); - }; - function $ge(t) { - return t <= 127 - ? 0 - : t >> 5 === 6 - ? 2 - : t >> 4 === 14 - ? 3 - : t >> 3 === 30 - ? 4 - : t >> 6 === 2 - ? -1 - : -2; - } - function qGt(t, e, r) { - var n = e.length - 1; - if (n < r) return 0; - var i = $ge(e[n]); - return i >= 0 - ? (i > 0 && (t.lastNeed = i - 1), i) - : --n < r || i === -2 - ? 0 - : ((i = $ge(e[n])), - i >= 0 - ? (i > 0 && (t.lastNeed = i - 2), i) - : --n < r || i === -2 - ? 0 - : ((i = $ge(e[n])), - i >= 0 - ? (i > 0 && (i === 2 ? (i = 0) : (t.lastNeed = i - 3)), i) - : 0)); - } - function zGt(t, e, r) { - if ((e[0] & 192) !== 128) return (t.lastNeed = 0), "\uFFFD"; - if (t.lastNeed > 1 && e.length > 1) { - if ((e[1] & 192) !== 128) return (t.lastNeed = 1), "\uFFFD"; - if (t.lastNeed > 2 && e.length > 2 && (e[2] & 192) !== 128) - return (t.lastNeed = 2), "\uFFFD"; - } - } - function jGt(t) { - var e = this.lastTotal - this.lastNeed, - r = zGt(this, t, e); - if (r !== void 0) return r; - if (this.lastNeed <= t.length) - return ( - t.copy(this.lastChar, e, 0, this.lastNeed), - this.lastChar.toString(this.encoding, 0, this.lastTotal) - ); - t.copy(this.lastChar, e, 0, t.length), (this.lastNeed -= t.length); - } - function UGt(t, e) { - var r = qGt(this, t, e); - if (!this.lastNeed) return t.toString("utf8", e); - this.lastTotal = r; - var n = t.length - (r - this.lastNeed); - return t.copy(this.lastChar, 0, n), t.toString("utf8", e, n); - } - function KGt(t) { - var e = t && t.length ? this.write(t) : ""; - return this.lastNeed ? e + "\uFFFD" : e; - } - function HGt(t, e) { - if ((t.length - e) % 2 === 0) { - var r = t.toString("utf16le", e); - if (r) { - var n = r.charCodeAt(r.length - 1); - if (n >= 55296 && n <= 56319) - return ( - (this.lastNeed = 2), - (this.lastTotal = 4), - (this.lastChar[0] = t[t.length - 2]), - (this.lastChar[1] = t[t.length - 1]), - r.slice(0, -1) - ); - } - return r; - } - return ( - (this.lastNeed = 1), - (this.lastTotal = 2), - (this.lastChar[0] = t[t.length - 1]), - t.toString("utf16le", e, t.length - 1) - ); - } - function VGt(t) { - var e = t && t.length ? this.write(t) : ""; - if (this.lastNeed) { - var r = this.lastTotal - this.lastNeed; - return e + this.lastChar.toString("utf16le", 0, r); - } - return e; - } - function WGt(t, e) { - var r = (t.length - e) % 3; - return r === 0 - ? t.toString("base64", e) - : ((this.lastNeed = 3 - r), - (this.lastTotal = 3), - r === 1 - ? (this.lastChar[0] = t[t.length - 1]) - : ((this.lastChar[0] = t[t.length - 2]), - (this.lastChar[1] = t[t.length - 1])), - t.toString("base64", e, t.length - r)); - } - function GGt(t) { - var e = t && t.length ? this.write(t) : ""; - return this.lastNeed - ? e + this.lastChar.toString("base64", 0, 3 - this.lastNeed) - : e; - } - function JGt(t) { - return t.toString(this.encoding); - } - function $Gt(t) { - return t && t.length ? this.write(t) : ""; - } - }); - var fq = I((Rcn, NUe) => { - "use strict"; - m(); - g(); - var CUe = dM().codes.ERR_STREAM_PREMATURE_CLOSE; - function ZGt(t) { - var e = !1; - return function () { - if (!e) { - e = !0; - for (var r = arguments.length, n = new Array(r), i = 0; i < r; i++) - n[i] = arguments[i]; - t.apply(this, n); - } - }; - } - function XGt() {} - function YGt(t) { - return t.setHeader && typeof t.abort == "function"; - } - function RUe(t, e, r) { - if (typeof e == "function") return RUe(t, null, e); - e || (e = {}), (r = ZGt(r || XGt)); - var n = e.readable || (e.readable !== !1 && t.readable), - i = e.writable || (e.writable !== !1 && t.writable), - o = function () { - t.writable || s(); - }, - a = t._writableState && t._writableState.finished, - s = function () { - (i = !1), (a = !0), n || r.call(t); - }, - c = t._readableState && t._readableState.endEmitted, - u = function () { - (n = !1), (c = !0), i || r.call(t); - }, - h = function (O) { - r.call(t, O); - }, - w = function () { - var O; - if (n && !c) - return ( - (!t._readableState || !t._readableState.ended) && (O = new CUe()), - r.call(t, O) - ); - if (i && !a) - return ( - (!t._writableState || !t._writableState.ended) && (O = new CUe()), - r.call(t, O) - ); - }, - M = function () { - t.req.on("finish", s); - }; - return ( - YGt(t) - ? (t.on("complete", s), - t.on("abort", w), - t.req ? M() : t.on("request", M)) - : i && !t._writableState && (t.on("end", o), t.on("close", o)), - t.on("end", u), - t.on("finish", s), - e.error !== !1 && t.on("error", h), - t.on("close", w), - function () { - t.removeListener("complete", s), - t.removeListener("abort", w), - t.removeListener("request", M), - t.req && t.req.removeListener("finish", s), - t.removeListener("end", o), - t.removeListener("close", o), - t.removeListener("finish", s), - t.removeListener("end", u), - t.removeListener("error", h), - t.removeListener("close", w); - } - ); - } - NUe.exports = RUe; - }); - var FUe = I((Ncn, DUe) => { - "use strict"; - m(); - g(); - var pZ; - function s2(t, e, r) { - return ( - e in t - ? Object.defineProperty(t, e, { - value: r, - enumerable: !0, - configurable: !0, - writable: !0, - }) - : (t[e] = r), - t - ); - } - var QGt = fq(), - u2 = Symbol("lastResolve"), - hM = Symbol("lastReject"), - dq = Symbol("error"), - yZ = Symbol("ended"), - pM = Symbol("lastPromise"), - Xge = Symbol("handlePromise"), - yM = Symbol("stream"); - function c2(t, e) { - return { value: t, done: e }; - } - function eJt(t) { - var e = t[u2]; - if (e !== null) { - var r = t[yM].read(); - r !== null && - ((t[pM] = null), (t[u2] = null), (t[hM] = null), e(c2(r, !1))); - } - } - function tJt(t) { - process.nextTick(eJt, t); - } - function rJt(t, e) { - return function (r, n) { - t.then(function () { - if (e[yZ]) { - r(c2(void 0, !0)); - return; - } - e[Xge](r, n); - }, n); - }; - } - var nJt = Object.getPrototypeOf(function () {}), - iJt = Object.setPrototypeOf( - ((pZ = { - get stream() { - return this[yM]; - }, - next: function () { - var e = this, - r = this[dq]; - if (r !== null) return Promise.reject(r); - if (this[yZ]) return Promise.resolve(c2(void 0, !0)); - if (this[yM].destroyed) - return new Promise(function (a, s) { - process.nextTick(function () { - e[dq] ? s(e[dq]) : a(c2(void 0, !0)); - }); - }); - var n = this[pM], - i; - if (n) i = new Promise(rJt(n, this)); - else { - var o = this[yM].read(); - if (o !== null) return Promise.resolve(c2(o, !1)); - i = new Promise(this[Xge]); - } - return (this[pM] = i), i; - }, - }), - s2(pZ, Symbol.asyncIterator, function () { - return this; - }), - s2(pZ, "return", function () { - var e = this; - return new Promise(function (r, n) { - e[yM].destroy(null, function (i) { - if (i) { - n(i); - return; - } - r(c2(void 0, !0)); - }); - }); - }), - pZ), - nJt - ), - oJt = function (e) { - var r, - n = Object.create( - iJt, - ((r = {}), - s2(r, yM, { value: e, writable: !0 }), - s2(r, u2, { value: null, writable: !0 }), - s2(r, hM, { value: null, writable: !0 }), - s2(r, dq, { value: null, writable: !0 }), - s2(r, yZ, { value: e._readableState.endEmitted, writable: !0 }), - s2(r, Xge, { - value: function (o, a) { - var s = n[yM].read(); - s - ? ((n[pM] = null), - (n[u2] = null), - (n[hM] = null), - o(c2(s, !1))) - : ((n[u2] = o), (n[hM] = a)); - }, - writable: !0, - }), - r) - ); - return ( - (n[pM] = null), - QGt(e, function (i) { - if (i && i.code !== "ERR_STREAM_PREMATURE_CLOSE") { - var o = n[hM]; - o !== null && - ((n[pM] = null), (n[u2] = null), (n[hM] = null), o(i)), - (n[dq] = i); - return; - } - var a = n[u2]; - a !== null && - ((n[pM] = null), - (n[u2] = null), - (n[hM] = null), - a(c2(void 0, !0))), - (n[yZ] = !0); - }), - e.on("readable", tJt.bind(null, n)), - n - ); - }; - DUe.exports = oJt; - }); - var qUe = I((Dcn, LUe) => { - m(); - g(); - LUe.exports = function () { - throw new Error("Readable.from is not available in the browser"); - }; - }); - var dZ = I((Lcn, $Ue) => { - "use strict"; - m(); - g(); - $Ue.exports = Ai; - var m5; - Ai.ReadableState = KUe; - var Fcn = o5().EventEmitter, - UUe = function (e, r) { - return e.listeners(r).length; - }, - pq = hge(), - mZ = Qr().Buffer, - aJt = window.Uint8Array || function () {}; - function sJt(t) { - return mZ.from(t); - } - function uJt(t) { - return mZ.isBuffer(t) || t instanceof aJt; - } - var Yge = es(), - Rn; - Yge && Yge.debuglog ? (Rn = Yge.debuglog("stream")) : (Rn = function () {}); - var cJt = pUe(), - ove = Uge(), - lJt = Kge(), - fJt = lJt.getHighWaterMark, - gZ = dM().codes, - dJt = gZ.ERR_INVALID_ARG_TYPE, - hJt = gZ.ERR_STREAM_PUSH_AFTER_EOF, - pJt = gZ.ERR_METHOD_NOT_IMPLEMENTED, - yJt = gZ.ERR_STREAM_UNSHIFT_AFTER_END_EVENT, - g5, - Qge, - eve; - dn()(Ai, pq); - var hq = ove.errorOrDestroy, - tve = ["error", "close", "destroy", "pause", "resume"]; - function mJt(t, e, r) { - if (typeof t.prependListener == "function") - return t.prependListener(e, r); - !t._events || !t._events[e] - ? t.on(e, r) - : Array.isArray(t._events[e]) - ? t._events[e].unshift(r) - : (t._events[e] = [r, t._events[e]]); - } - function KUe(t, e, r) { - (m5 = m5 || a2()), - (t = t || {}), - typeof r != "boolean" && (r = e instanceof m5), - (this.objectMode = !!t.objectMode), - r && (this.objectMode = this.objectMode || !!t.readableObjectMode), - (this.highWaterMark = fJt(this, t, "readableHighWaterMark", r)), - (this.buffer = new cJt()), - (this.length = 0), - (this.pipes = null), - (this.pipesCount = 0), - (this.flowing = null), - (this.ended = !1), - (this.endEmitted = !1), - (this.reading = !1), - (this.sync = !0), - (this.needReadable = !1), - (this.emittedReadable = !1), - (this.readableListening = !1), - (this.resumeScheduled = !1), - (this.paused = !0), - (this.emitClose = t.emitClose !== !1), - (this.autoDestroy = !!t.autoDestroy), - (this.destroyed = !1), - (this.defaultEncoding = t.defaultEncoding || "utf8"), - (this.awaitDrain = 0), - (this.readingMore = !1), - (this.decoder = null), - (this.encoding = null), - t.encoding && - (g5 || (g5 = hZ().StringDecoder), - (this.decoder = new g5(t.encoding)), - (this.encoding = t.encoding)); - } - function Ai(t) { - if (((m5 = m5 || a2()), !(this instanceof Ai))) return new Ai(t); - var e = this instanceof m5; - (this._readableState = new KUe(t, this, e)), - (this.readable = !0), - t && - (typeof t.read == "function" && (this._read = t.read), - typeof t.destroy == "function" && (this._destroy = t.destroy)), - pq.call(this); - } - Object.defineProperty(Ai.prototype, "destroyed", { - enumerable: !1, - get: function () { - return this._readableState === void 0 - ? !1 - : this._readableState.destroyed; - }, - set: function (e) { - !this._readableState || (this._readableState.destroyed = e); - }, - }); - Ai.prototype.destroy = ove.destroy; - Ai.prototype._undestroy = ove.undestroy; - Ai.prototype._destroy = function (t, e) { - e(t); - }; - Ai.prototype.push = function (t, e) { - var r = this._readableState, - n; - return ( - r.objectMode - ? (n = !0) - : typeof t == "string" && - ((e = e || r.defaultEncoding), - e !== r.encoding && ((t = mZ.from(t, e)), (e = "")), - (n = !0)), - HUe(this, t, e, !1, n) - ); - }; - Ai.prototype.unshift = function (t) { - return HUe(this, t, null, !0, !1); - }; - function HUe(t, e, r, n, i) { - Rn("readableAddChunk", e); - var o = t._readableState; - if (e === null) (o.reading = !1), bJt(t, o); - else { - var a; - if ((i || (a = gJt(o, e)), a)) hq(t, a); - else if (o.objectMode || (e && e.length > 0)) - if ( - (typeof e != "string" && - !o.objectMode && - Object.getPrototypeOf(e) !== mZ.prototype && - (e = sJt(e)), - n) - ) - o.endEmitted ? hq(t, new yJt()) : rve(t, o, e, !0); - else if (o.ended) hq(t, new hJt()); - else { - if (o.destroyed) return !1; - (o.reading = !1), - o.decoder && !r - ? ((e = o.decoder.write(e)), - o.objectMode || e.length !== 0 ? rve(t, o, e, !1) : ive(t, o)) - : rve(t, o, e, !1); - } - else n || ((o.reading = !1), ive(t, o)); - } - return !o.ended && (o.length < o.highWaterMark || o.length === 0); - } - function rve(t, e, r, n) { - e.flowing && e.length === 0 && !e.sync - ? ((e.awaitDrain = 0), t.emit("data", r)) - : ((e.length += e.objectMode ? 1 : r.length), - n ? e.buffer.unshift(r) : e.buffer.push(r), - e.needReadable && vZ(t)), - ive(t, e); - } - function gJt(t, e) { - var r; - return ( - !uJt(e) && - typeof e != "string" && - e !== void 0 && - !t.objectMode && - (r = new dJt("chunk", ["string", "Buffer", "Uint8Array"], e)), - r - ); - } - Ai.prototype.isPaused = function () { - return this._readableState.flowing === !1; - }; - Ai.prototype.setEncoding = function (t) { - g5 || (g5 = hZ().StringDecoder); - var e = new g5(t); - (this._readableState.decoder = e), - (this._readableState.encoding = this._readableState.decoder.encoding); - for (var r = this._readableState.buffer.head, n = ""; r !== null; ) - (n += e.write(r.data)), (r = r.next); - return ( - this._readableState.buffer.clear(), - n !== "" && this._readableState.buffer.push(n), - (this._readableState.length = n.length), - this - ); - }; - var zUe = 1073741824; - function vJt(t) { - return ( - t >= zUe - ? (t = zUe) - : (t--, - (t |= t >>> 1), - (t |= t >>> 2), - (t |= t >>> 4), - (t |= t >>> 8), - (t |= t >>> 16), - t++), - t - ); - } - function jUe(t, e) { - return t <= 0 || (e.length === 0 && e.ended) - ? 0 - : e.objectMode - ? 1 - : t !== t - ? e.flowing && e.length - ? e.buffer.head.data.length - : e.length - : (t > e.highWaterMark && (e.highWaterMark = vJt(t)), - t <= e.length ? t : e.ended ? e.length : ((e.needReadable = !0), 0)); - } - Ai.prototype.read = function (t) { - Rn("read", t), (t = parseInt(t, 10)); - var e = this._readableState, - r = t; - if ( - (t !== 0 && (e.emittedReadable = !1), - t === 0 && - e.needReadable && - ((e.highWaterMark !== 0 - ? e.length >= e.highWaterMark - : e.length > 0) || - e.ended)) - ) - return ( - Rn("read: emitReadable", e.length, e.ended), - e.length === 0 && e.ended ? nve(this) : vZ(this), - null - ); - if (((t = jUe(t, e)), t === 0 && e.ended)) - return e.length === 0 && nve(this), null; - var n = e.needReadable; - Rn("need readable", n), - (e.length === 0 || e.length - t < e.highWaterMark) && - ((n = !0), Rn("length less than watermark", n)), - e.ended || e.reading - ? ((n = !1), Rn("reading or ended", n)) - : n && - (Rn("do read"), - (e.reading = !0), - (e.sync = !0), - e.length === 0 && (e.needReadable = !0), - this._read(e.highWaterMark), - (e.sync = !1), - e.reading || (t = jUe(r, e))); - var i; - return ( - t > 0 ? (i = GUe(t, e)) : (i = null), - i === null - ? ((e.needReadable = e.length <= e.highWaterMark), (t = 0)) - : ((e.length -= t), (e.awaitDrain = 0)), - e.length === 0 && - (e.ended || (e.needReadable = !0), r !== t && e.ended && nve(this)), - i !== null && this.emit("data", i), - i - ); - }; - function bJt(t, e) { - if ((Rn("onEofChunk"), !e.ended)) { - if (e.decoder) { - var r = e.decoder.end(); - r && - r.length && - (e.buffer.push(r), (e.length += e.objectMode ? 1 : r.length)); - } - (e.ended = !0), - e.sync - ? vZ(t) - : ((e.needReadable = !1), - e.emittedReadable || ((e.emittedReadable = !0), VUe(t))); - } - } - function vZ(t) { - var e = t._readableState; - Rn("emitReadable", e.needReadable, e.emittedReadable), - (e.needReadable = !1), - e.emittedReadable || - (Rn("emitReadable", e.flowing), - (e.emittedReadable = !0), - process.nextTick(VUe, t)); - } - function VUe(t) { - var e = t._readableState; - Rn("emitReadable_", e.destroyed, e.length, e.ended), - !e.destroyed && - (e.length || e.ended) && - (t.emit("readable"), (e.emittedReadable = !1)), - (e.needReadable = - !e.flowing && !e.ended && e.length <= e.highWaterMark), - ave(t); - } - function ive(t, e) { - e.readingMore || ((e.readingMore = !0), process.nextTick(wJt, t, e)); - } - function wJt(t, e) { - for ( - ; - !e.reading && - !e.ended && - (e.length < e.highWaterMark || (e.flowing && e.length === 0)); - - ) { - var r = e.length; - if ((Rn("maybeReadMore read 0"), t.read(0), r === e.length)) break; - } - e.readingMore = !1; - } - Ai.prototype._read = function (t) { - hq(this, new pJt("_read()")); - }; - Ai.prototype.pipe = function (t, e) { - var r = this, - n = this._readableState; - switch (n.pipesCount) { - case 0: - n.pipes = t; - break; - case 1: - n.pipes = [n.pipes, t]; - break; - default: - n.pipes.push(t); - break; - } - (n.pipesCount += 1), Rn("pipe count=%d opts=%j", n.pipesCount, e); - var i = - (!e || e.end !== !1) && t !== process.stdout && t !== process.stderr, - o = i ? s : D; - n.endEmitted ? process.nextTick(o) : r.once("end", o), t.on("unpipe", a); - function a(F, N) { - Rn("onunpipe"), - F === r && N && N.hasUnpiped === !1 && ((N.hasUnpiped = !0), h()); - } - function s() { - Rn("onend"), t.end(); - } - var c = _Jt(r); - t.on("drain", c); - var u = !1; - function h() { - Rn("cleanup"), - t.removeListener("close", k), - t.removeListener("finish", O), - t.removeListener("drain", c), - t.removeListener("error", M), - t.removeListener("unpipe", a), - r.removeListener("end", s), - r.removeListener("end", D), - r.removeListener("data", w), - (u = !0), - n.awaitDrain && - (!t._writableState || t._writableState.needDrain) && - c(); - } - r.on("data", w); - function w(F) { - Rn("ondata"); - var N = t.write(F); - Rn("dest.write", N), - N === !1 && - (((n.pipesCount === 1 && n.pipes === t) || - (n.pipesCount > 1 && JUe(n.pipes, t) !== -1)) && - !u && - (Rn("false write response, pause", n.awaitDrain), n.awaitDrain++), - r.pause()); - } - function M(F) { - Rn("onerror", F), - D(), - t.removeListener("error", M), - UUe(t, "error") === 0 && hq(t, F); - } - mJt(t, "error", M); - function k() { - t.removeListener("finish", O), D(); - } - t.once("close", k); - function O() { - Rn("onfinish"), t.removeListener("close", k), D(); - } - t.once("finish", O); - function D() { - Rn("unpipe"), r.unpipe(t); - } - return t.emit("pipe", r), n.flowing || (Rn("pipe resume"), r.resume()), t; - }; - function _Jt(t) { - return function () { - var r = t._readableState; - Rn("pipeOnDrain", r.awaitDrain), - r.awaitDrain && r.awaitDrain--, - r.awaitDrain === 0 && UUe(t, "data") && ((r.flowing = !0), ave(t)); - }; - } - Ai.prototype.unpipe = function (t) { - var e = this._readableState, - r = { hasUnpiped: !1 }; - if (e.pipesCount === 0) return this; - if (e.pipesCount === 1) - return t && t !== e.pipes - ? this - : (t || (t = e.pipes), - (e.pipes = null), - (e.pipesCount = 0), - (e.flowing = !1), - t && t.emit("unpipe", this, r), - this); - if (!t) { - var n = e.pipes, - i = e.pipesCount; - (e.pipes = null), (e.pipesCount = 0), (e.flowing = !1); - for (var o = 0; o < i; o++) - n[o].emit("unpipe", this, { hasUnpiped: !1 }); - return this; - } - var a = JUe(e.pipes, t); - return a === -1 - ? this - : (e.pipes.splice(a, 1), - (e.pipesCount -= 1), - e.pipesCount === 1 && (e.pipes = e.pipes[0]), - t.emit("unpipe", this, r), - this); - }; - Ai.prototype.on = function (t, e) { - var r = pq.prototype.on.call(this, t, e), - n = this._readableState; - return ( - t === "data" - ? ((n.readableListening = this.listenerCount("readable") > 0), - n.flowing !== !1 && this.resume()) - : t === "readable" && - !n.endEmitted && - !n.readableListening && - ((n.readableListening = n.needReadable = !0), - (n.flowing = !1), - (n.emittedReadable = !1), - Rn("on readable", n.length, n.reading), - n.length ? vZ(this) : n.reading || process.nextTick(xJt, this)), - r - ); - }; - Ai.prototype.addListener = Ai.prototype.on; - Ai.prototype.removeListener = function (t, e) { - var r = pq.prototype.removeListener.call(this, t, e); - return t === "readable" && process.nextTick(WUe, this), r; - }; - Ai.prototype.removeAllListeners = function (t) { - var e = pq.prototype.removeAllListeners.apply(this, arguments); - return ( - (t === "readable" || t === void 0) && process.nextTick(WUe, this), e - ); - }; - function WUe(t) { - var e = t._readableState; - (e.readableListening = t.listenerCount("readable") > 0), - e.resumeScheduled && !e.paused - ? (e.flowing = !0) - : t.listenerCount("data") > 0 && t.resume(); - } - function xJt(t) { - Rn("readable nexttick read 0"), t.read(0); - } - Ai.prototype.resume = function () { - var t = this._readableState; - return ( - t.flowing || - (Rn("resume"), (t.flowing = !t.readableListening), SJt(this, t)), - (t.paused = !1), - this - ); - }; - function SJt(t, e) { - e.resumeScheduled || - ((e.resumeScheduled = !0), process.nextTick(AJt, t, e)); - } - function AJt(t, e) { - Rn("resume", e.reading), - e.reading || t.read(0), - (e.resumeScheduled = !1), - t.emit("resume"), - ave(t), - e.flowing && !e.reading && t.read(0); - } - Ai.prototype.pause = function () { - return ( - Rn("call pause flowing=%j", this._readableState.flowing), - this._readableState.flowing !== !1 && - (Rn("pause"), (this._readableState.flowing = !1), this.emit("pause")), - (this._readableState.paused = !0), - this - ); - }; - function ave(t) { - var e = t._readableState; - for (Rn("flow", e.flowing); e.flowing && t.read() !== null; ); - } - Ai.prototype.wrap = function (t) { - var e = this, - r = this._readableState, - n = !1; - t.on("end", function () { - if ((Rn("wrapped end"), r.decoder && !r.ended)) { - var a = r.decoder.end(); - a && a.length && e.push(a); - } - e.push(null); - }), - t.on("data", function (a) { - if ( - (Rn("wrapped data"), - r.decoder && (a = r.decoder.write(a)), - !(r.objectMode && a == null) && - !(!r.objectMode && (!a || !a.length))) - ) { - var s = e.push(a); - s || ((n = !0), t.pause()); - } - }); - for (var i in t) - this[i] === void 0 && - typeof t[i] == "function" && - (this[i] = (function (s) { - return function () { - return t[s].apply(t, arguments); - }; - })(i)); - for (var o = 0; o < tve.length; o++) - t.on(tve[o], this.emit.bind(this, tve[o])); - return ( - (this._read = function (a) { - Rn("wrapped _read", a), n && ((n = !1), t.resume()); - }), - this - ); - }; - typeof Symbol == "function" && - (Ai.prototype[Symbol.asyncIterator] = function () { - return Qge === void 0 && (Qge = FUe()), Qge(this); - }); - Object.defineProperty(Ai.prototype, "readableHighWaterMark", { - enumerable: !1, - get: function () { - return this._readableState.highWaterMark; - }, - }); - Object.defineProperty(Ai.prototype, "readableBuffer", { - enumerable: !1, - get: function () { - return this._readableState && this._readableState.buffer; - }, - }); - Object.defineProperty(Ai.prototype, "readableFlowing", { - enumerable: !1, - get: function () { - return this._readableState.flowing; - }, - set: function (e) { - this._readableState && (this._readableState.flowing = e); - }, - }); - Ai._fromList = GUe; - Object.defineProperty(Ai.prototype, "readableLength", { - enumerable: !1, - get: function () { - return this._readableState.length; - }, - }); - function GUe(t, e) { - if (e.length === 0) return null; - var r; - return ( - e.objectMode - ? (r = e.buffer.shift()) - : !t || t >= e.length - ? (e.decoder - ? (r = e.buffer.join("")) - : e.buffer.length === 1 - ? (r = e.buffer.first()) - : (r = e.buffer.concat(e.length)), - e.buffer.clear()) - : (r = e.buffer.consume(t, e.decoder)), - r - ); - } - function nve(t) { - var e = t._readableState; - Rn("endReadable", e.endEmitted), - e.endEmitted || ((e.ended = !0), process.nextTick(EJt, e, t)); - } - function EJt(t, e) { - if ( - (Rn("endReadableNT", t.endEmitted, t.length), - !t.endEmitted && - t.length === 0 && - ((t.endEmitted = !0), - (e.readable = !1), - e.emit("end"), - t.autoDestroy)) - ) { - var r = e._writableState; - (!r || (r.autoDestroy && r.finished)) && e.destroy(); - } - } - typeof Symbol == "function" && - (Ai.from = function (t, e) { - return eve === void 0 && (eve = qUe()), eve(Ai, t, e); - }); - function JUe(t, e) { - for (var r = 0, n = t.length; r < n; r++) if (t[r] === e) return r; - return -1; - } - }); - var _Z = I((qcn, XUe) => { - "use strict"; - m(); - g(); - XUe.exports = E_; - var bZ = dM().codes, - MJt = bZ.ERR_METHOD_NOT_IMPLEMENTED, - TJt = bZ.ERR_MULTIPLE_CALLBACK, - kJt = bZ.ERR_TRANSFORM_ALREADY_TRANSFORMING, - PJt = bZ.ERR_TRANSFORM_WITH_LENGTH_0, - wZ = a2(); - dn()(E_, wZ); - function OJt(t, e) { - var r = this._transformState; - r.transforming = !1; - var n = r.writecb; - if (n === null) return this.emit("error", new TJt()); - (r.writechunk = null), - (r.writecb = null), - e != null && this.push(e), - n(t); - var i = this._readableState; - (i.reading = !1), - (i.needReadable || i.length < i.highWaterMark) && - this._read(i.highWaterMark); - } - function E_(t) { - if (!(this instanceof E_)) return new E_(t); - wZ.call(this, t), - (this._transformState = { - afterTransform: OJt.bind(this), - needTransform: !1, - transforming: !1, - writecb: null, - writechunk: null, - writeencoding: null, - }), - (this._readableState.needReadable = !0), - (this._readableState.sync = !1), - t && - (typeof t.transform == "function" && (this._transform = t.transform), - typeof t.flush == "function" && (this._flush = t.flush)), - this.on("prefinish", BJt); - } - function BJt() { - var t = this; - typeof this._flush == "function" && !this._readableState.destroyed - ? this._flush(function (e, r) { - ZUe(t, e, r); - }) - : ZUe(this, null, null); - } - E_.prototype.push = function (t, e) { - return ( - (this._transformState.needTransform = !1), - wZ.prototype.push.call(this, t, e) - ); - }; - E_.prototype._transform = function (t, e, r) { - r(new MJt("_transform()")); - }; - E_.prototype._write = function (t, e, r) { - var n = this._transformState; - if ( - ((n.writecb = r), - (n.writechunk = t), - (n.writeencoding = e), - !n.transforming) - ) { - var i = this._readableState; - (n.needTransform || i.needReadable || i.length < i.highWaterMark) && - this._read(i.highWaterMark); - } - }; - E_.prototype._read = function (t) { - var e = this._transformState; - e.writechunk !== null && !e.transforming - ? ((e.transforming = !0), - this._transform(e.writechunk, e.writeencoding, e.afterTransform)) - : (e.needTransform = !0); - }; - E_.prototype._destroy = function (t, e) { - wZ.prototype._destroy.call(this, t, function (r) { - e(r); - }); - }; - function ZUe(t, e, r) { - if (e) return t.emit("error", e); - if ((r != null && t.push(r), t._writableState.length)) throw new PJt(); - if (t._transformState.transforming) throw new kJt(); - return t.push(null); - } - }); - var sve = I((zcn, QUe) => { - "use strict"; - m(); - g(); - QUe.exports = yq; - var YUe = _Z(); - dn()(yq, YUe); - function yq(t) { - if (!(this instanceof yq)) return new yq(t); - YUe.call(this, t); - } - yq.prototype._transform = function (t, e, r) { - r(null, t); - }; - }); - var cve = I((jcn, nKe) => { - "use strict"; - m(); - g(); - var uve; - function IJt(t) { - var e = !1; - return function () { - e || ((e = !0), t.apply(void 0, arguments)); - }; - } - var rKe = dM().codes, - CJt = rKe.ERR_MISSING_ARGS, - RJt = rKe.ERR_STREAM_DESTROYED; - function eKe(t) { - if (t) throw t; - } - function NJt(t) { - return t.setHeader && typeof t.abort == "function"; - } - function DJt(t, e, r, n) { - n = IJt(n); - var i = !1; - t.on("close", function () { - i = !0; - }), - uve === void 0 && (uve = fq()), - uve(t, { readable: e, writable: r }, function (a) { - if (a) return n(a); - (i = !0), n(); - }); - var o = !1; - return function (a) { - if (!i && !o) { - if (((o = !0), NJt(t))) return t.abort(); - if (typeof t.destroy == "function") return t.destroy(); - n(a || new RJt("pipe")); - } - }; - } - function tKe(t) { - t(); - } - function FJt(t, e) { - return t.pipe(e); - } - function LJt(t) { - return !t.length || typeof t[t.length - 1] != "function" ? eKe : t.pop(); - } - function qJt() { - for (var t = arguments.length, e = new Array(t), r = 0; r < t; r++) - e[r] = arguments[r]; - var n = LJt(e); - if ((Array.isArray(e[0]) && (e = e[0]), e.length < 2)) - throw new CJt("streams"); - var i, - o = e.map(function (a, s) { - var c = s < e.length - 1, - u = s > 0; - return DJt(a, c, u, function (h) { - i || (i = h), h && o.forEach(tKe), !c && (o.forEach(tKe), n(i)); - }); - }); - return e.reduce(FJt); - } - nKe.exports = qJt; - }); - var mq = I((ey, iKe) => { - m(); - g(); - ey = iKe.exports = dZ(); - ey.Stream = ey; - ey.Readable = ey; - ey.Writable = cZ(); - ey.Duplex = a2(); - ey.Transform = _Z(); - ey.PassThrough = sve(); - ey.finished = fq(); - ey.pipeline = cve(); - }); - var lve = I((Ucn, aKe) => { - "use strict"; - m(); - g(); - var xZ = vn().Buffer, - oKe = mq().Transform, - zJt = dn(); - function jJt(t, e) { - if (!xZ.isBuffer(t) && typeof t != "string") - throw new TypeError(e + " must be a string or a buffer"); - } - function l2(t) { - oKe.call(this), - (this._block = xZ.allocUnsafe(t)), - (this._blockSize = t), - (this._blockOffset = 0), - (this._length = [0, 0, 0, 0]), - (this._finalized = !1); - } - zJt(l2, oKe); - l2.prototype._transform = function (t, e, r) { - var n = null; - try { - this.update(t, e); - } catch (i) { - n = i; - } - r(n); - }; - l2.prototype._flush = function (t) { - var e = null; - try { - this.push(this.digest()); - } catch (r) { - e = r; - } - t(e); - }; - l2.prototype.update = function (t, e) { - if ((jJt(t, "Data"), this._finalized)) - throw new Error("Digest already called"); - xZ.isBuffer(t) || (t = xZ.from(t, e)); - for ( - var r = this._block, n = 0; - this._blockOffset + t.length - n >= this._blockSize; - - ) { - for (var i = this._blockOffset; i < this._blockSize; ) r[i++] = t[n++]; - this._update(), (this._blockOffset = 0); - } - for (; n < t.length; ) r[this._blockOffset++] = t[n++]; - for (var o = 0, a = t.length * 8; a > 0; ++o) - (this._length[o] += a), - (a = (this._length[o] / 4294967296) | 0), - a > 0 && (this._length[o] -= 4294967296 * a); - return this; - }; - l2.prototype._update = function () { - throw new Error("_update is not implemented"); - }; - l2.prototype.digest = function (t) { - if (this._finalized) throw new Error("Digest already called"); - this._finalized = !0; - var e = this._digest(); - t !== void 0 && (e = e.toString(t)), - this._block.fill(0), - (this._blockOffset = 0); - for (var r = 0; r < 4; ++r) this._length[r] = 0; - return e; - }; - l2.prototype._digest = function () { - throw new Error("_digest is not implemented"); - }; - aKe.exports = l2; - }); - var EZ = I((Kcn, uKe) => { - "use strict"; - m(); - g(); - var UJt = dn(), - sKe = lve(), - KJt = vn().Buffer, - HJt = new Array(16); - function SZ() { - sKe.call(this, 64), - (this._a = 1732584193), - (this._b = 4023233417), - (this._c = 2562383102), - (this._d = 271733878); - } - UJt(SZ, sKe); - SZ.prototype._update = function () { - for (var t = HJt, e = 0; e < 16; ++e) - t[e] = this._block.readInt32LE(e * 4); - var r = this._a, - n = this._b, - i = this._c, - o = this._d; - (r = Nc(r, n, i, o, t[0], 3614090360, 7)), - (o = Nc(o, r, n, i, t[1], 3905402710, 12)), - (i = Nc(i, o, r, n, t[2], 606105819, 17)), - (n = Nc(n, i, o, r, t[3], 3250441966, 22)), - (r = Nc(r, n, i, o, t[4], 4118548399, 7)), - (o = Nc(o, r, n, i, t[5], 1200080426, 12)), - (i = Nc(i, o, r, n, t[6], 2821735955, 17)), - (n = Nc(n, i, o, r, t[7], 4249261313, 22)), - (r = Nc(r, n, i, o, t[8], 1770035416, 7)), - (o = Nc(o, r, n, i, t[9], 2336552879, 12)), - (i = Nc(i, o, r, n, t[10], 4294925233, 17)), - (n = Nc(n, i, o, r, t[11], 2304563134, 22)), - (r = Nc(r, n, i, o, t[12], 1804603682, 7)), - (o = Nc(o, r, n, i, t[13], 4254626195, 12)), - (i = Nc(i, o, r, n, t[14], 2792965006, 17)), - (n = Nc(n, i, o, r, t[15], 1236535329, 22)), - (r = Dc(r, n, i, o, t[1], 4129170786, 5)), - (o = Dc(o, r, n, i, t[6], 3225465664, 9)), - (i = Dc(i, o, r, n, t[11], 643717713, 14)), - (n = Dc(n, i, o, r, t[0], 3921069994, 20)), - (r = Dc(r, n, i, o, t[5], 3593408605, 5)), - (o = Dc(o, r, n, i, t[10], 38016083, 9)), - (i = Dc(i, o, r, n, t[15], 3634488961, 14)), - (n = Dc(n, i, o, r, t[4], 3889429448, 20)), - (r = Dc(r, n, i, o, t[9], 568446438, 5)), - (o = Dc(o, r, n, i, t[14], 3275163606, 9)), - (i = Dc(i, o, r, n, t[3], 4107603335, 14)), - (n = Dc(n, i, o, r, t[8], 1163531501, 20)), - (r = Dc(r, n, i, o, t[13], 2850285829, 5)), - (o = Dc(o, r, n, i, t[2], 4243563512, 9)), - (i = Dc(i, o, r, n, t[7], 1735328473, 14)), - (n = Dc(n, i, o, r, t[12], 2368359562, 20)), - (r = Fc(r, n, i, o, t[5], 4294588738, 4)), - (o = Fc(o, r, n, i, t[8], 2272392833, 11)), - (i = Fc(i, o, r, n, t[11], 1839030562, 16)), - (n = Fc(n, i, o, r, t[14], 4259657740, 23)), - (r = Fc(r, n, i, o, t[1], 2763975236, 4)), - (o = Fc(o, r, n, i, t[4], 1272893353, 11)), - (i = Fc(i, o, r, n, t[7], 4139469664, 16)), - (n = Fc(n, i, o, r, t[10], 3200236656, 23)), - (r = Fc(r, n, i, o, t[13], 681279174, 4)), - (o = Fc(o, r, n, i, t[0], 3936430074, 11)), - (i = Fc(i, o, r, n, t[3], 3572445317, 16)), - (n = Fc(n, i, o, r, t[6], 76029189, 23)), - (r = Fc(r, n, i, o, t[9], 3654602809, 4)), - (o = Fc(o, r, n, i, t[12], 3873151461, 11)), - (i = Fc(i, o, r, n, t[15], 530742520, 16)), - (n = Fc(n, i, o, r, t[2], 3299628645, 23)), - (r = Lc(r, n, i, o, t[0], 4096336452, 6)), - (o = Lc(o, r, n, i, t[7], 1126891415, 10)), - (i = Lc(i, o, r, n, t[14], 2878612391, 15)), - (n = Lc(n, i, o, r, t[5], 4237533241, 21)), - (r = Lc(r, n, i, o, t[12], 1700485571, 6)), - (o = Lc(o, r, n, i, t[3], 2399980690, 10)), - (i = Lc(i, o, r, n, t[10], 4293915773, 15)), - (n = Lc(n, i, o, r, t[1], 2240044497, 21)), - (r = Lc(r, n, i, o, t[8], 1873313359, 6)), - (o = Lc(o, r, n, i, t[15], 4264355552, 10)), - (i = Lc(i, o, r, n, t[6], 2734768916, 15)), - (n = Lc(n, i, o, r, t[13], 1309151649, 21)), - (r = Lc(r, n, i, o, t[4], 4149444226, 6)), - (o = Lc(o, r, n, i, t[11], 3174756917, 10)), - (i = Lc(i, o, r, n, t[2], 718787259, 15)), - (n = Lc(n, i, o, r, t[9], 3951481745, 21)), - (this._a = (this._a + r) | 0), - (this._b = (this._b + n) | 0), - (this._c = (this._c + i) | 0), - (this._d = (this._d + o) | 0); - }; - SZ.prototype._digest = function () { - (this._block[this._blockOffset++] = 128), - this._blockOffset > 56 && - (this._block.fill(0, this._blockOffset, 64), - this._update(), - (this._blockOffset = 0)), - this._block.fill(0, this._blockOffset, 56), - this._block.writeUInt32LE(this._length[0], 56), - this._block.writeUInt32LE(this._length[1], 60), - this._update(); - var t = KJt.allocUnsafe(16); - return ( - t.writeInt32LE(this._a, 0), - t.writeInt32LE(this._b, 4), - t.writeInt32LE(this._c, 8), - t.writeInt32LE(this._d, 12), - t - ); - }; - function AZ(t, e) { - return (t << e) | (t >>> (32 - e)); - } - function Nc(t, e, r, n, i, o, a) { - return (AZ((t + ((e & r) | (~e & n)) + i + o) | 0, a) + e) | 0; - } - function Dc(t, e, r, n, i, o, a) { - return (AZ((t + ((e & n) | (r & ~n)) + i + o) | 0, a) + e) | 0; - } - function Fc(t, e, r, n, i, o, a) { - return (AZ((t + (e ^ r ^ n) + i + o) | 0, a) + e) | 0; - } - function Lc(t, e, r, n, i, o, a) { - return (AZ((t + (r ^ (e | ~n)) + i + o) | 0, a) + e) | 0; - } - uKe.exports = SZ; - }); - var TZ = I((Hcn, yKe) => { - "use strict"; - m(); - g(); - var fve = Qr().Buffer, - VJt = dn(), - pKe = lve(), - WJt = new Array(16), - gq = [ - 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 7, 4, 13, 1, 10, - 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, - 6, 13, 11, 5, 12, 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, - 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13, - ], - vq = [ - 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, 6, 11, 3, 7, 0, - 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, - 12, 2, 10, 0, 4, 13, 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, - 14, 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11, - ], - bq = [ - 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, 7, 6, 8, 13, 11, - 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, 11, 13, 6, 7, 14, 9, 13, 15, 14, - 8, 13, 6, 5, 12, 7, 5, 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, - 5, 12, 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6, - ], - wq = [ - 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, 9, 13, 15, 7, - 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, 9, 7, 15, 11, 8, 6, 6, 14, 12, - 13, 5, 14, 13, 13, 7, 5, 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, - 5, 15, 8, 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11, - ], - _q = [0, 1518500249, 1859775393, 2400959708, 2840853838], - xq = [1352829926, 1548603684, 1836072691, 2053994217, 0]; - function MZ() { - pKe.call(this, 64), - (this._a = 1732584193), - (this._b = 4023233417), - (this._c = 2562383102), - (this._d = 271733878), - (this._e = 3285377520); - } - VJt(MZ, pKe); - MZ.prototype._update = function () { - for (var t = WJt, e = 0; e < 16; ++e) - t[e] = this._block.readInt32LE(e * 4); - for ( - var r = this._a | 0, - n = this._b | 0, - i = this._c | 0, - o = this._d | 0, - a = this._e | 0, - s = this._a | 0, - c = this._b | 0, - u = this._c | 0, - h = this._d | 0, - w = this._e | 0, - M = 0; - M < 80; - M += 1 - ) { - var k, O; - M < 16 - ? ((k = cKe(r, n, i, o, a, t[gq[M]], _q[0], bq[M])), - (O = hKe(s, c, u, h, w, t[vq[M]], xq[0], wq[M]))) - : M < 32 - ? ((k = lKe(r, n, i, o, a, t[gq[M]], _q[1], bq[M])), - (O = dKe(s, c, u, h, w, t[vq[M]], xq[1], wq[M]))) - : M < 48 - ? ((k = fKe(r, n, i, o, a, t[gq[M]], _q[2], bq[M])), - (O = fKe(s, c, u, h, w, t[vq[M]], xq[2], wq[M]))) - : M < 64 - ? ((k = dKe(r, n, i, o, a, t[gq[M]], _q[3], bq[M])), - (O = lKe(s, c, u, h, w, t[vq[M]], xq[3], wq[M]))) - : ((k = hKe(r, n, i, o, a, t[gq[M]], _q[4], bq[M])), - (O = cKe(s, c, u, h, w, t[vq[M]], xq[4], wq[M]))), - (r = a), - (a = o), - (o = mM(i, 10)), - (i = n), - (n = k), - (s = w), - (w = h), - (h = mM(u, 10)), - (u = c), - (c = O); - } - var D = (this._b + i + h) | 0; - (this._b = (this._c + o + w) | 0), - (this._c = (this._d + a + s) | 0), - (this._d = (this._e + r + c) | 0), - (this._e = (this._a + n + u) | 0), - (this._a = D); - }; - MZ.prototype._digest = function () { - (this._block[this._blockOffset++] = 128), - this._blockOffset > 56 && - (this._block.fill(0, this._blockOffset, 64), - this._update(), - (this._blockOffset = 0)), - this._block.fill(0, this._blockOffset, 56), - this._block.writeUInt32LE(this._length[0], 56), - this._block.writeUInt32LE(this._length[1], 60), - this._update(); - var t = fve.alloc ? fve.alloc(20) : new fve(20); - return ( - t.writeInt32LE(this._a, 0), - t.writeInt32LE(this._b, 4), - t.writeInt32LE(this._c, 8), - t.writeInt32LE(this._d, 12), - t.writeInt32LE(this._e, 16), - t - ); - }; - function mM(t, e) { - return (t << e) | (t >>> (32 - e)); - } - function cKe(t, e, r, n, i, o, a, s) { - return (mM((t + (e ^ r ^ n) + o + a) | 0, s) + i) | 0; - } - function lKe(t, e, r, n, i, o, a, s) { - return (mM((t + ((e & r) | (~e & n)) + o + a) | 0, s) + i) | 0; - } - function fKe(t, e, r, n, i, o, a, s) { - return (mM((t + ((e | ~r) ^ n) + o + a) | 0, s) + i) | 0; - } - function dKe(t, e, r, n, i, o, a, s) { - return (mM((t + ((e & n) | (r & ~n)) + o + a) | 0, s) + i) | 0; - } - function hKe(t, e, r, n, i, o, a, s) { - return (mM((t + (e ^ (r | ~n)) + o + a) | 0, s) + i) | 0; - } - yKe.exports = MZ; - }); - var gM = I((Vcn, gKe) => { - m(); - g(); - var mKe = vn().Buffer; - function kZ(t, e) { - (this._block = mKe.alloc(t)), - (this._finalSize = e), - (this._blockSize = t), - (this._len = 0); - } - kZ.prototype.update = function (t, e) { - typeof t == "string" && ((e = e || "utf8"), (t = mKe.from(t, e))); - for ( - var r = this._block, - n = this._blockSize, - i = t.length, - o = this._len, - a = 0; - a < i; - - ) { - for (var s = o % n, c = Math.min(i - a, n - s), u = 0; u < c; u++) - r[s + u] = t[a + u]; - (o += c), (a += c), o % n === 0 && this._update(r); - } - return (this._len += i), this; - }; - kZ.prototype.digest = function (t) { - var e = this._len % this._blockSize; - (this._block[e] = 128), - this._block.fill(0, e + 1), - e >= this._finalSize && - (this._update(this._block), this._block.fill(0)); - var r = this._len * 8; - if (r <= 4294967295) this._block.writeUInt32BE(r, this._blockSize - 4); - else { - var n = (r & 4294967295) >>> 0, - i = (r - n) / 4294967296; - this._block.writeUInt32BE(i, this._blockSize - 8), - this._block.writeUInt32BE(n, this._blockSize - 4); - } - this._update(this._block); - var o = this._hash(); - return t ? o.toString(t) : o; - }; - kZ.prototype._update = function () { - throw new Error("_update must be implemented by subclass"); - }; - gKe.exports = kZ; - }); - var wKe = I((Wcn, bKe) => { - m(); - g(); - var GJt = dn(), - vKe = gM(), - JJt = vn().Buffer, - $Jt = [1518500249, 1859775393, -1894007588, -899497514], - ZJt = new Array(80); - function Sq() { - this.init(), (this._w = ZJt), vKe.call(this, 64, 56); - } - GJt(Sq, vKe); - Sq.prototype.init = function () { - return ( - (this._a = 1732584193), - (this._b = 4023233417), - (this._c = 2562383102), - (this._d = 271733878), - (this._e = 3285377520), - this - ); - }; - function XJt(t) { - return (t << 5) | (t >>> 27); - } - function YJt(t) { - return (t << 30) | (t >>> 2); - } - function QJt(t, e, r, n) { - return t === 0 - ? (e & r) | (~e & n) - : t === 2 - ? (e & r) | (e & n) | (r & n) - : e ^ r ^ n; - } - Sq.prototype._update = function (t) { - for ( - var e = this._w, - r = this._a | 0, - n = this._b | 0, - i = this._c | 0, - o = this._d | 0, - a = this._e | 0, - s = 0; - s < 16; - ++s - ) - e[s] = t.readInt32BE(s * 4); - for (; s < 80; ++s) e[s] = e[s - 3] ^ e[s - 8] ^ e[s - 14] ^ e[s - 16]; - for (var c = 0; c < 80; ++c) { - var u = ~~(c / 20), - h = (XJt(r) + QJt(u, n, i, o) + a + e[c] + $Jt[u]) | 0; - (a = o), (o = i), (i = YJt(n)), (n = r), (r = h); - } - (this._a = (r + this._a) | 0), - (this._b = (n + this._b) | 0), - (this._c = (i + this._c) | 0), - (this._d = (o + this._d) | 0), - (this._e = (a + this._e) | 0); - }; - Sq.prototype._hash = function () { - var t = JJt.allocUnsafe(20); - return ( - t.writeInt32BE(this._a | 0, 0), - t.writeInt32BE(this._b | 0, 4), - t.writeInt32BE(this._c | 0, 8), - t.writeInt32BE(this._d | 0, 12), - t.writeInt32BE(this._e | 0, 16), - t - ); - }; - bKe.exports = Sq; - }); - var SKe = I((Gcn, xKe) => { - m(); - g(); - var e$t = dn(), - _Ke = gM(), - t$t = vn().Buffer, - r$t = [1518500249, 1859775393, -1894007588, -899497514], - n$t = new Array(80); - function Aq() { - this.init(), (this._w = n$t), _Ke.call(this, 64, 56); - } - e$t(Aq, _Ke); - Aq.prototype.init = function () { - return ( - (this._a = 1732584193), - (this._b = 4023233417), - (this._c = 2562383102), - (this._d = 271733878), - (this._e = 3285377520), - this - ); - }; - function i$t(t) { - return (t << 1) | (t >>> 31); - } - function o$t(t) { - return (t << 5) | (t >>> 27); - } - function a$t(t) { - return (t << 30) | (t >>> 2); - } - function s$t(t, e, r, n) { - return t === 0 - ? (e & r) | (~e & n) - : t === 2 - ? (e & r) | (e & n) | (r & n) - : e ^ r ^ n; - } - Aq.prototype._update = function (t) { - for ( - var e = this._w, - r = this._a | 0, - n = this._b | 0, - i = this._c | 0, - o = this._d | 0, - a = this._e | 0, - s = 0; - s < 16; - ++s - ) - e[s] = t.readInt32BE(s * 4); - for (; s < 80; ++s) - e[s] = i$t(e[s - 3] ^ e[s - 8] ^ e[s - 14] ^ e[s - 16]); - for (var c = 0; c < 80; ++c) { - var u = ~~(c / 20), - h = (o$t(r) + s$t(u, n, i, o) + a + e[c] + r$t[u]) | 0; - (a = o), (o = i), (i = a$t(n)), (n = r), (r = h); - } - (this._a = (r + this._a) | 0), - (this._b = (n + this._b) | 0), - (this._c = (i + this._c) | 0), - (this._d = (o + this._d) | 0), - (this._e = (a + this._e) | 0); - }; - Aq.prototype._hash = function () { - var t = t$t.allocUnsafe(20); - return ( - t.writeInt32BE(this._a | 0, 0), - t.writeInt32BE(this._b | 0, 4), - t.writeInt32BE(this._c | 0, 8), - t.writeInt32BE(this._d | 0, 12), - t.writeInt32BE(this._e | 0, 16), - t - ); - }; - xKe.exports = Aq; - }); - var dve = I((Jcn, EKe) => { - m(); - g(); - var u$t = dn(), - AKe = gM(), - c$t = vn().Buffer, - l$t = [ - 1116352408, 1899447441, 3049323471, 3921009573, 961987163, 1508970993, - 2453635748, 2870763221, 3624381080, 310598401, 607225278, 1426881987, - 1925078388, 2162078206, 2614888103, 3248222580, 3835390401, 4022224774, - 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986, - 2554220882, 2821834349, 2952996808, 3210313671, 3336571891, 3584528711, - 113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291, - 1695183700, 1986661051, 2177026350, 2456956037, 2730485921, 2820302411, - 3259730800, 3345764771, 3516065817, 3600352804, 4094571909, 275423344, - 430227734, 506948616, 659060556, 883997877, 958139571, 1322822218, - 1537002063, 1747873779, 1955562222, 2024104815, 2227730452, 2361852424, - 2428436474, 2756734187, 3204031479, 3329325298, - ], - f$t = new Array(64); - function Eq() { - this.init(), (this._w = f$t), AKe.call(this, 64, 56); - } - u$t(Eq, AKe); - Eq.prototype.init = function () { - return ( - (this._a = 1779033703), - (this._b = 3144134277), - (this._c = 1013904242), - (this._d = 2773480762), - (this._e = 1359893119), - (this._f = 2600822924), - (this._g = 528734635), - (this._h = 1541459225), - this - ); - }; - function d$t(t, e, r) { - return r ^ (t & (e ^ r)); - } - function h$t(t, e, r) { - return (t & e) | (r & (t | e)); - } - function p$t(t) { - return ( - ((t >>> 2) | (t << 30)) ^ - ((t >>> 13) | (t << 19)) ^ - ((t >>> 22) | (t << 10)) - ); - } - function y$t(t) { - return ( - ((t >>> 6) | (t << 26)) ^ - ((t >>> 11) | (t << 21)) ^ - ((t >>> 25) | (t << 7)) - ); - } - function m$t(t) { - return ((t >>> 7) | (t << 25)) ^ ((t >>> 18) | (t << 14)) ^ (t >>> 3); - } - function g$t(t) { - return ((t >>> 17) | (t << 15)) ^ ((t >>> 19) | (t << 13)) ^ (t >>> 10); - } - Eq.prototype._update = function (t) { - for ( - var e = this._w, - r = this._a | 0, - n = this._b | 0, - i = this._c | 0, - o = this._d | 0, - a = this._e | 0, - s = this._f | 0, - c = this._g | 0, - u = this._h | 0, - h = 0; - h < 16; - ++h - ) - e[h] = t.readInt32BE(h * 4); - for (; h < 64; ++h) - e[h] = (g$t(e[h - 2]) + e[h - 7] + m$t(e[h - 15]) + e[h - 16]) | 0; - for (var w = 0; w < 64; ++w) { - var M = (u + y$t(a) + d$t(a, s, c) + l$t[w] + e[w]) | 0, - k = (p$t(r) + h$t(r, n, i)) | 0; - (u = c), - (c = s), - (s = a), - (a = (o + M) | 0), - (o = i), - (i = n), - (n = r), - (r = (M + k) | 0); - } - (this._a = (r + this._a) | 0), - (this._b = (n + this._b) | 0), - (this._c = (i + this._c) | 0), - (this._d = (o + this._d) | 0), - (this._e = (a + this._e) | 0), - (this._f = (s + this._f) | 0), - (this._g = (c + this._g) | 0), - (this._h = (u + this._h) | 0); - }; - Eq.prototype._hash = function () { - var t = c$t.allocUnsafe(32); - return ( - t.writeInt32BE(this._a, 0), - t.writeInt32BE(this._b, 4), - t.writeInt32BE(this._c, 8), - t.writeInt32BE(this._d, 12), - t.writeInt32BE(this._e, 16), - t.writeInt32BE(this._f, 20), - t.writeInt32BE(this._g, 24), - t.writeInt32BE(this._h, 28), - t - ); - }; - EKe.exports = Eq; - }); - var TKe = I(($cn, MKe) => { - m(); - g(); - var v$t = dn(), - b$t = dve(), - w$t = gM(), - _$t = vn().Buffer, - x$t = new Array(64); - function PZ() { - this.init(), (this._w = x$t), w$t.call(this, 64, 56); - } - v$t(PZ, b$t); - PZ.prototype.init = function () { - return ( - (this._a = 3238371032), - (this._b = 914150663), - (this._c = 812702999), - (this._d = 4144912697), - (this._e = 4290775857), - (this._f = 1750603025), - (this._g = 1694076839), - (this._h = 3204075428), - this - ); - }; - PZ.prototype._hash = function () { - var t = _$t.allocUnsafe(28); - return ( - t.writeInt32BE(this._a, 0), - t.writeInt32BE(this._b, 4), - t.writeInt32BE(this._c, 8), - t.writeInt32BE(this._d, 12), - t.writeInt32BE(this._e, 16), - t.writeInt32BE(this._f, 20), - t.writeInt32BE(this._g, 24), - t - ); - }; - MKe.exports = PZ; - }); - var hve = I((Zcn, RKe) => { - m(); - g(); - var S$t = dn(), - CKe = gM(), - A$t = vn().Buffer, - kKe = [ - 1116352408, 3609767458, 1899447441, 602891725, 3049323471, 3964484399, - 3921009573, 2173295548, 961987163, 4081628472, 1508970993, 3053834265, - 2453635748, 2937671579, 2870763221, 3664609560, 3624381080, 2734883394, - 310598401, 1164996542, 607225278, 1323610764, 1426881987, 3590304994, - 1925078388, 4068182383, 2162078206, 991336113, 2614888103, 633803317, - 3248222580, 3479774868, 3835390401, 2666613458, 4022224774, 944711139, - 264347078, 2341262773, 604807628, 2007800933, 770255983, 1495990901, - 1249150122, 1856431235, 1555081692, 3175218132, 1996064986, 2198950837, - 2554220882, 3999719339, 2821834349, 766784016, 2952996808, 2566594879, - 3210313671, 3203337956, 3336571891, 1034457026, 3584528711, 2466948901, - 113926993, 3758326383, 338241895, 168717936, 666307205, 1188179964, - 773529912, 1546045734, 1294757372, 1522805485, 1396182291, 2643833823, - 1695183700, 2343527390, 1986661051, 1014477480, 2177026350, 1206759142, - 2456956037, 344077627, 2730485921, 1290863460, 2820302411, 3158454273, - 3259730800, 3505952657, 3345764771, 106217008, 3516065817, 3606008344, - 3600352804, 1432725776, 4094571909, 1467031594, 275423344, 851169720, - 430227734, 3100823752, 506948616, 1363258195, 659060556, 3750685593, - 883997877, 3785050280, 958139571, 3318307427, 1322822218, 3812723403, - 1537002063, 2003034995, 1747873779, 3602036899, 1955562222, 1575990012, - 2024104815, 1125592928, 2227730452, 2716904306, 2361852424, 442776044, - 2428436474, 593698344, 2756734187, 3733110249, 3204031479, 2999351573, - 3329325298, 3815920427, 3391569614, 3928383900, 3515267271, 566280711, - 3940187606, 3454069534, 4118630271, 4000239992, 116418474, 1914138554, - 174292421, 2731055270, 289380356, 3203993006, 460393269, 320620315, - 685471733, 587496836, 852142971, 1086792851, 1017036298, 365543100, - 1126000580, 2618297676, 1288033470, 3409855158, 1501505948, 4234509866, - 1607167915, 987167468, 1816402316, 1246189591, - ], - E$t = new Array(160); - function Mq() { - this.init(), (this._w = E$t), CKe.call(this, 128, 112); - } - S$t(Mq, CKe); - Mq.prototype.init = function () { - return ( - (this._ah = 1779033703), - (this._bh = 3144134277), - (this._ch = 1013904242), - (this._dh = 2773480762), - (this._eh = 1359893119), - (this._fh = 2600822924), - (this._gh = 528734635), - (this._hh = 1541459225), - (this._al = 4089235720), - (this._bl = 2227873595), - (this._cl = 4271175723), - (this._dl = 1595750129), - (this._el = 2917565137), - (this._fl = 725511199), - (this._gl = 4215389547), - (this._hl = 327033209), - this - ); - }; - function PKe(t, e, r) { - return r ^ (t & (e ^ r)); - } - function OKe(t, e, r) { - return (t & e) | (r & (t | e)); - } - function BKe(t, e) { - return ( - ((t >>> 28) | (e << 4)) ^ - ((e >>> 2) | (t << 30)) ^ - ((e >>> 7) | (t << 25)) - ); - } - function IKe(t, e) { - return ( - ((t >>> 14) | (e << 18)) ^ - ((t >>> 18) | (e << 14)) ^ - ((e >>> 9) | (t << 23)) - ); - } - function M$t(t, e) { - return ((t >>> 1) | (e << 31)) ^ ((t >>> 8) | (e << 24)) ^ (t >>> 7); - } - function T$t(t, e) { - return ( - ((t >>> 1) | (e << 31)) ^ - ((t >>> 8) | (e << 24)) ^ - ((t >>> 7) | (e << 25)) - ); - } - function k$t(t, e) { - return ((t >>> 19) | (e << 13)) ^ ((e >>> 29) | (t << 3)) ^ (t >>> 6); - } - function P$t(t, e) { - return ( - ((t >>> 19) | (e << 13)) ^ - ((e >>> 29) | (t << 3)) ^ - ((t >>> 6) | (e << 26)) - ); - } - function bu(t, e) { - return t >>> 0 < e >>> 0 ? 1 : 0; - } - Mq.prototype._update = function (t) { - for ( - var e = this._w, - r = this._ah | 0, - n = this._bh | 0, - i = this._ch | 0, - o = this._dh | 0, - a = this._eh | 0, - s = this._fh | 0, - c = this._gh | 0, - u = this._hh | 0, - h = this._al | 0, - w = this._bl | 0, - M = this._cl | 0, - k = this._dl | 0, - O = this._el | 0, - D = this._fl | 0, - F = this._gl | 0, - N = this._hl | 0, - q = 0; - q < 32; - q += 2 - ) - (e[q] = t.readInt32BE(q * 4)), (e[q + 1] = t.readInt32BE(q * 4 + 4)); - for (; q < 160; q += 2) { - var z = e[q - 30], - H = e[q - 15 * 2 + 1], - Z = M$t(z, H), - $ = T$t(H, z); - (z = e[q - 2 * 2]), (H = e[q - 2 * 2 + 1]); - var ue = k$t(z, H), - te = P$t(H, z), - ne = e[q - 7 * 2], - A = e[q - 7 * 2 + 1], - l = e[q - 16 * 2], - p = e[q - 16 * 2 + 1], - y = ($ + A) | 0, - d = (Z + ne + bu(y, $)) | 0; - (y = (y + te) | 0), - (d = (d + ue + bu(y, te)) | 0), - (y = (y + p) | 0), - (d = (d + l + bu(y, p)) | 0), - (e[q] = d), - (e[q + 1] = y); - } - for (var v = 0; v < 160; v += 2) { - (d = e[v]), (y = e[v + 1]); - var _ = OKe(r, n, i), - S = OKe(h, w, M), - b = BKe(r, h), - f = BKe(h, r), - x = IKe(a, O), - C = IKe(O, a), - E = kKe[v], - B = kKe[v + 1], - G = PKe(a, s, c), - L = PKe(O, D, F), - ee = (N + C) | 0, - ge = (u + x + bu(ee, N)) | 0; - (ee = (ee + L) | 0), - (ge = (ge + G + bu(ee, L)) | 0), - (ee = (ee + B) | 0), - (ge = (ge + E + bu(ee, B)) | 0), - (ee = (ee + y) | 0), - (ge = (ge + d + bu(ee, y)) | 0); - var fe = (f + S) | 0, - V = (b + _ + bu(fe, f)) | 0; - (u = c), - (N = F), - (c = s), - (F = D), - (s = a), - (D = O), - (O = (k + ee) | 0), - (a = (o + ge + bu(O, k)) | 0), - (o = i), - (k = M), - (i = n), - (M = w), - (n = r), - (w = h), - (h = (ee + fe) | 0), - (r = (ge + V + bu(h, ee)) | 0); - } - (this._al = (this._al + h) | 0), - (this._bl = (this._bl + w) | 0), - (this._cl = (this._cl + M) | 0), - (this._dl = (this._dl + k) | 0), - (this._el = (this._el + O) | 0), - (this._fl = (this._fl + D) | 0), - (this._gl = (this._gl + F) | 0), - (this._hl = (this._hl + N) | 0), - (this._ah = (this._ah + r + bu(this._al, h)) | 0), - (this._bh = (this._bh + n + bu(this._bl, w)) | 0), - (this._ch = (this._ch + i + bu(this._cl, M)) | 0), - (this._dh = (this._dh + o + bu(this._dl, k)) | 0), - (this._eh = (this._eh + a + bu(this._el, O)) | 0), - (this._fh = (this._fh + s + bu(this._fl, D)) | 0), - (this._gh = (this._gh + c + bu(this._gl, F)) | 0), - (this._hh = (this._hh + u + bu(this._hl, N)) | 0); - }; - Mq.prototype._hash = function () { - var t = A$t.allocUnsafe(64); - function e(r, n, i) { - t.writeInt32BE(r, i), t.writeInt32BE(n, i + 4); - } - return ( - e(this._ah, this._al, 0), - e(this._bh, this._bl, 8), - e(this._ch, this._cl, 16), - e(this._dh, this._dl, 24), - e(this._eh, this._el, 32), - e(this._fh, this._fl, 40), - e(this._gh, this._gl, 48), - e(this._hh, this._hl, 56), - t - ); - }; - RKe.exports = Mq; - }); - var DKe = I((Xcn, NKe) => { - m(); - g(); - var O$t = dn(), - B$t = hve(), - I$t = gM(), - C$t = vn().Buffer, - R$t = new Array(160); - function OZ() { - this.init(), (this._w = R$t), I$t.call(this, 128, 112); - } - O$t(OZ, B$t); - OZ.prototype.init = function () { - return ( - (this._ah = 3418070365), - (this._bh = 1654270250), - (this._ch = 2438529370), - (this._dh = 355462360), - (this._eh = 1731405415), - (this._fh = 2394180231), - (this._gh = 3675008525), - (this._hh = 1203062813), - (this._al = 3238371032), - (this._bl = 914150663), - (this._cl = 812702999), - (this._dl = 4144912697), - (this._el = 4290775857), - (this._fl = 1750603025), - (this._gl = 1694076839), - (this._hl = 3204075428), - this - ); - }; - OZ.prototype._hash = function () { - var t = C$t.allocUnsafe(48); - function e(r, n, i) { - t.writeInt32BE(r, i), t.writeInt32BE(n, i + 4); - } - return ( - e(this._ah, this._al, 0), - e(this._bh, this._bl, 8), - e(this._ch, this._cl, 16), - e(this._dh, this._dl, 24), - e(this._eh, this._el, 32), - e(this._fh, this._fl, 40), - t - ); - }; - NKe.exports = OZ; - }); - var BZ = I((M_, FKe) => { - m(); - g(); - var M_ = (FKe.exports = function (e) { - e = e.toLowerCase(); - var r = M_[e]; - if (!r) - throw new Error(e + " is not supported (we accept pull requests)"); - return new r(); - }); - M_.sha = wKe(); - M_.sha1 = SKe(); - M_.sha224 = TKe(); - M_.sha256 = dve(); - M_.sha384 = DKe(); - M_.sha512 = hve(); - }); - var vM = I((Ycn, LKe) => { - m(); - g(); - LKe.exports = ty; - var pve = o5().EventEmitter, - N$t = dn(); - N$t(ty, pve); - ty.Readable = dZ(); - ty.Writable = cZ(); - ty.Duplex = a2(); - ty.Transform = _Z(); - ty.PassThrough = sve(); - ty.finished = fq(); - ty.pipeline = cve(); - ty.Stream = ty; - function ty() { - pve.call(this); - } - ty.prototype.pipe = function (t, e) { - var r = this; - function n(h) { - t.writable && t.write(h) === !1 && r.pause && r.pause(); - } - r.on("data", n); - function i() { - r.readable && r.resume && r.resume(); - } - t.on("drain", i), - !t._isStdio && - (!e || e.end !== !1) && - (r.on("end", a), r.on("close", s)); - var o = !1; - function a() { - o || ((o = !0), t.end()); - } - function s() { - o || ((o = !0), typeof t.destroy == "function" && t.destroy()); - } - function c(h) { - if ((u(), pve.listenerCount(this, "error") === 0)) throw h; - } - r.on("error", c), t.on("error", c); - function u() { - r.removeListener("data", n), - t.removeListener("drain", i), - r.removeListener("end", a), - r.removeListener("close", s), - r.removeListener("error", c), - t.removeListener("error", c), - r.removeListener("end", u), - r.removeListener("close", u), - t.removeListener("close", u); - } - return ( - r.on("end", u), r.on("close", u), t.on("close", u), t.emit("pipe", r), t - ); - }; - }); - var T_ = I((Qcn, jKe) => { - m(); - g(); - var qKe = vn().Buffer, - zKe = vM().Transform, - D$t = hZ().StringDecoder, - F$t = dn(); - function Cm(t) { - zKe.call(this), - (this.hashMode = typeof t == "string"), - this.hashMode - ? (this[t] = this._finalOrDigest) - : (this.final = this._finalOrDigest), - this._final && ((this.__final = this._final), (this._final = null)), - (this._decoder = null), - (this._encoding = null); - } - F$t(Cm, zKe); - Cm.prototype.update = function (t, e, r) { - typeof t == "string" && (t = qKe.from(t, e)); - var n = this._update(t); - return this.hashMode ? this : (r && (n = this._toString(n, r)), n); - }; - Cm.prototype.setAutoPadding = function () {}; - Cm.prototype.getAuthTag = function () { - throw new Error("trying to get auth tag in unsupported state"); - }; - Cm.prototype.setAuthTag = function () { - throw new Error("trying to set auth tag in unsupported state"); - }; - Cm.prototype.setAAD = function () { - throw new Error("trying to set aad in unsupported state"); - }; - Cm.prototype._transform = function (t, e, r) { - var n; - try { - this.hashMode ? this._update(t) : this.push(this._update(t)); - } catch (i) { - n = i; - } finally { - r(n); - } - }; - Cm.prototype._flush = function (t) { - var e; - try { - this.push(this.__final()); - } catch (r) { - e = r; - } - t(e); - }; - Cm.prototype._finalOrDigest = function (t) { - var e = this.__final() || qKe.alloc(0); - return t && (e = this._toString(e, t, !0)), e; - }; - Cm.prototype._toString = function (t, e, r) { - if ( - (this._decoder || ((this._decoder = new D$t(e)), (this._encoding = e)), - this._encoding !== e) - ) - throw new Error("can't switch encodings"); - var n = this._decoder.write(t); - return r && (n += this._decoder.end()), n; - }; - jKe.exports = Cm; - }); - var v5 = I((eln, KKe) => { - "use strict"; - m(); - g(); - var L$t = dn(), - q$t = EZ(), - z$t = TZ(), - j$t = BZ(), - UKe = T_(); - function IZ(t) { - UKe.call(this, "digest"), (this._hash = t); - } - L$t(IZ, UKe); - IZ.prototype._update = function (t) { - this._hash.update(t); - }; - IZ.prototype._final = function () { - return this._hash.digest(); - }; - KKe.exports = function (e) { - return ( - (e = e.toLowerCase()), - e === "md5" - ? new q$t() - : e === "rmd160" || e === "ripemd160" - ? new z$t() - : new IZ(j$t(e)) - ); - }; - }); - var WKe = I((tln, VKe) => { - "use strict"; - m(); - g(); - var U$t = dn(), - bM = vn().Buffer, - HKe = T_(), - K$t = bM.alloc(128), - b5 = 64; - function CZ(t, e) { - HKe.call(this, "digest"), - typeof e == "string" && (e = bM.from(e)), - (this._alg = t), - (this._key = e), - e.length > b5 - ? (e = t(e)) - : e.length < b5 && (e = bM.concat([e, K$t], b5)); - for ( - var r = (this._ipad = bM.allocUnsafe(b5)), - n = (this._opad = bM.allocUnsafe(b5)), - i = 0; - i < b5; - i++ - ) - (r[i] = e[i] ^ 54), (n[i] = e[i] ^ 92); - this._hash = [r]; - } - U$t(CZ, HKe); - CZ.prototype._update = function (t) { - this._hash.push(t); - }; - CZ.prototype._final = function () { - var t = this._alg(bM.concat(this._hash)); - return this._alg(bM.concat([this._opad, t])); - }; - VKe.exports = CZ; - }); - var yve = I((rln, GKe) => { - m(); - g(); - var H$t = EZ(); - GKe.exports = function (t) { - return new H$t().update(t).digest(); - }; - }); - var vve = I((nln, $Ke) => { - "use strict"; - m(); - g(); - var V$t = dn(), - W$t = WKe(), - JKe = T_(), - Tq = vn().Buffer, - G$t = yve(), - mve = TZ(), - gve = BZ(), - J$t = Tq.alloc(128); - function kq(t, e) { - JKe.call(this, "digest"), typeof e == "string" && (e = Tq.from(e)); - var r = t === "sha512" || t === "sha384" ? 128 : 64; - if (((this._alg = t), (this._key = e), e.length > r)) { - var n = t === "rmd160" ? new mve() : gve(t); - e = n.update(e).digest(); - } else e.length < r && (e = Tq.concat([e, J$t], r)); - for ( - var i = (this._ipad = Tq.allocUnsafe(r)), - o = (this._opad = Tq.allocUnsafe(r)), - a = 0; - a < r; - a++ - ) - (i[a] = e[a] ^ 54), (o[a] = e[a] ^ 92); - (this._hash = t === "rmd160" ? new mve() : gve(t)), this._hash.update(i); - } - V$t(kq, JKe); - kq.prototype._update = function (t) { - this._hash.update(t); - }; - kq.prototype._final = function () { - var t = this._hash.digest(), - e = this._alg === "rmd160" ? new mve() : gve(this._alg); - return e.update(this._opad).update(t).digest(); - }; - $Ke.exports = function (e, r) { - return ( - (e = e.toLowerCase()), - e === "rmd160" || e === "ripemd160" - ? new kq("rmd160", r) - : e === "md5" - ? new W$t(G$t, r) - : new kq(e, r) - ); - }; - }); - var bve = I((iln, $$t) => { - $$t.exports = { - sha224WithRSAEncryption: { - sign: "rsa", - hash: "sha224", - id: "302d300d06096086480165030402040500041c", - }, - "RSA-SHA224": { - sign: "ecdsa/rsa", - hash: "sha224", - id: "302d300d06096086480165030402040500041c", - }, - sha256WithRSAEncryption: { - sign: "rsa", - hash: "sha256", - id: "3031300d060960864801650304020105000420", - }, - "RSA-SHA256": { - sign: "ecdsa/rsa", - hash: "sha256", - id: "3031300d060960864801650304020105000420", - }, - sha384WithRSAEncryption: { - sign: "rsa", - hash: "sha384", - id: "3041300d060960864801650304020205000430", - }, - "RSA-SHA384": { - sign: "ecdsa/rsa", - hash: "sha384", - id: "3041300d060960864801650304020205000430", - }, - sha512WithRSAEncryption: { - sign: "rsa", - hash: "sha512", - id: "3051300d060960864801650304020305000440", - }, - "RSA-SHA512": { - sign: "ecdsa/rsa", - hash: "sha512", - id: "3051300d060960864801650304020305000440", - }, - "RSA-SHA1": { - sign: "rsa", - hash: "sha1", - id: "3021300906052b0e03021a05000414", - }, - "ecdsa-with-SHA1": { sign: "ecdsa", hash: "sha1", id: "" }, - sha256: { sign: "ecdsa", hash: "sha256", id: "" }, - sha224: { sign: "ecdsa", hash: "sha224", id: "" }, - sha384: { sign: "ecdsa", hash: "sha384", id: "" }, - sha512: { sign: "ecdsa", hash: "sha512", id: "" }, - "DSA-SHA": { sign: "dsa", hash: "sha1", id: "" }, - "DSA-SHA1": { sign: "dsa", hash: "sha1", id: "" }, - DSA: { sign: "dsa", hash: "sha1", id: "" }, - "DSA-WITH-SHA224": { sign: "dsa", hash: "sha224", id: "" }, - "DSA-SHA224": { sign: "dsa", hash: "sha224", id: "" }, - "DSA-WITH-SHA256": { sign: "dsa", hash: "sha256", id: "" }, - "DSA-SHA256": { sign: "dsa", hash: "sha256", id: "" }, - "DSA-WITH-SHA384": { sign: "dsa", hash: "sha384", id: "" }, - "DSA-SHA384": { sign: "dsa", hash: "sha384", id: "" }, - "DSA-WITH-SHA512": { sign: "dsa", hash: "sha512", id: "" }, - "DSA-SHA512": { sign: "dsa", hash: "sha512", id: "" }, - "DSA-RIPEMD160": { sign: "dsa", hash: "rmd160", id: "" }, - ripemd160WithRSA: { - sign: "rsa", - hash: "rmd160", - id: "3021300906052b2403020105000414", - }, - "RSA-RIPEMD160": { - sign: "rsa", - hash: "rmd160", - id: "3021300906052b2403020105000414", - }, - md5WithRSAEncryption: { - sign: "rsa", - hash: "md5", - id: "3020300c06082a864886f70d020505000410", - }, - "RSA-MD5": { - sign: "rsa", - hash: "md5", - id: "3020300c06082a864886f70d020505000410", - }, - }; - }); - var XKe = I((oln, ZKe) => { - m(); - g(); - ZKe.exports = bve(); - }); - var wve = I((aln, YKe) => { - m(); - g(); - var Z$t = Math.pow(2, 30) - 1; - YKe.exports = function (t, e) { - if (typeof t != "number") throw new TypeError("Iterations not a number"); - if (t < 0) throw new TypeError("Bad iterations"); - if (typeof e != "number") throw new TypeError("Key length not a number"); - if (e < 0 || e > Z$t || e !== e) throw new TypeError("Bad key length"); - }; - }); - var _ve = I((sln, eHe) => { - m(); - g(); - var RZ; - window.process && window.process.browser - ? (RZ = "utf-8") - : window.process && window.process.version - ? ((QKe = parseInt(process.version.split(".")[0].slice(1), 10)), - (RZ = QKe >= 6 ? "utf-8" : "binary")) - : (RZ = "utf-8"); - var QKe; - eHe.exports = RZ; - }); - var Sve = I((uln, tHe) => { - m(); - g(); - var xve = vn().Buffer; - tHe.exports = function (t, e, r) { - if (xve.isBuffer(t)) return t; - if (typeof t == "string") return xve.from(t, e); - if (ArrayBuffer.isView(t)) return xve.from(t.buffer); - throw new TypeError( - r + " must be a string, a Buffer, a typed array or a DataView" - ); - }; - }); - var Ave = I((cln, oHe) => { - m(); - g(); - var X$t = yve(), - Y$t = TZ(), - Q$t = BZ(), - wM = vn().Buffer, - eZt = wve(), - rHe = _ve(), - nHe = Sve(), - tZt = wM.alloc(128), - NZ = { - md5: 16, - sha1: 20, - sha224: 28, - sha256: 32, - sha384: 48, - sha512: 64, - rmd160: 20, - ripemd160: 20, - }; - function iHe(t, e, r) { - var n = rZt(t), - i = t === "sha512" || t === "sha384" ? 128 : 64; - e.length > i ? (e = n(e)) : e.length < i && (e = wM.concat([e, tZt], i)); - for ( - var o = wM.allocUnsafe(i + NZ[t]), a = wM.allocUnsafe(i + NZ[t]), s = 0; - s < i; - s++ - ) - (o[s] = e[s] ^ 54), (a[s] = e[s] ^ 92); - var c = wM.allocUnsafe(i + r + 4); - o.copy(c, 0, 0, i), - (this.ipad1 = c), - (this.ipad2 = o), - (this.opad = a), - (this.alg = t), - (this.blocksize = i), - (this.hash = n), - (this.size = NZ[t]); - } - iHe.prototype.run = function (t, e) { - t.copy(e, this.blocksize); - var r = this.hash(e); - return r.copy(this.opad, this.blocksize), this.hash(this.opad); - }; - function rZt(t) { - function e(n) { - return Q$t(t).update(n).digest(); - } - function r(n) { - return new Y$t().update(n).digest(); - } - return t === "rmd160" || t === "ripemd160" ? r : t === "md5" ? X$t : e; - } - function nZt(t, e, r, n, i) { - eZt(r, n), - (t = nHe(t, rHe, "Password")), - (e = nHe(e, rHe, "Salt")), - (i = i || "sha1"); - var o = new iHe(i, t, e.length), - a = wM.allocUnsafe(n), - s = wM.allocUnsafe(e.length + 4); - e.copy(s, 0, 0, e.length); - for (var c = 0, u = NZ[i], h = Math.ceil(n / u), w = 1; w <= h; w++) { - s.writeUInt32BE(w, e.length); - for (var M = o.run(s, o.ipad1), k = M, O = 1; O < r; O++) { - k = o.run(k, o.ipad2); - for (var D = 0; D < u; D++) M[D] ^= k[D]; - } - M.copy(a, c), (c += u); - } - return a; - } - oHe.exports = nZt; - }); - var dHe = I((lln, fHe) => { - m(); - g(); - var cHe = vn().Buffer, - iZt = wve(), - aHe = _ve(), - sHe = Ave(), - uHe = Sve(), - DZ, - Pq = window.crypto && window.crypto.subtle, - oZt = { - sha: "SHA-1", - "sha-1": "SHA-1", - sha1: "SHA-1", - sha256: "SHA-256", - "sha-256": "SHA-256", - sha384: "SHA-384", - "sha-384": "SHA-384", - "sha-512": "SHA-512", - sha512: "SHA-512", - }, - Eve = []; - function aZt(t) { - if ( - (window.process && !window.process.browser) || - !Pq || - !Pq.importKey || - !Pq.deriveBits - ) - return Promise.resolve(!1); - if (Eve[t] !== void 0) return Eve[t]; - DZ = DZ || cHe.alloc(8); - var e = lHe(DZ, DZ, 10, 128, t) - .then(function () { - return !0; - }) - .catch(function () { - return !1; - }); - return (Eve[t] = e), e; - } - var _M; - function Mve() { - return ( - _M || - (window.process && window.process.nextTick - ? (_M = window.process.nextTick) - : window.queueMicrotask - ? (_M = window.queueMicrotask) - : window.setImmediate - ? (_M = window.setImmediate) - : (_M = window.setTimeout), - _M) - ); - } - function lHe(t, e, r, n, i) { - return Pq.importKey("raw", t, { name: "PBKDF2" }, !1, ["deriveBits"]) - .then(function (o) { - return Pq.deriveBits( - { name: "PBKDF2", salt: e, iterations: r, hash: { name: i } }, - o, - n << 3 - ); - }) - .then(function (o) { - return cHe.from(o); - }); - } - function sZt(t, e) { - t.then( - function (r) { - Mve()(function () { - e(null, r); - }); - }, - function (r) { - Mve()(function () { - e(r); - }); - } - ); - } - fHe.exports = function (t, e, r, n, i, o) { - typeof i == "function" && ((o = i), (i = void 0)), (i = i || "sha1"); - var a = oZt[i.toLowerCase()]; - if (!a || typeof window.Promise != "function") { - Mve()(function () { - var s; - try { - s = sHe(t, e, r, n, i); - } catch (c) { - return o(c); - } - o(null, s); - }); - return; - } - if ( - (iZt(r, n), - (t = uHe(t, aHe, "Password")), - (e = uHe(e, aHe, "Salt")), - typeof o != "function") - ) - throw new Error("No callback provided to pbkdf2"); - sZt( - aZt(a).then(function (s) { - return s ? lHe(t, e, r, n, a) : sHe(t, e, r, n, i); - }), - o - ); - }; - }); - var kve = I((Tve) => { - m(); - g(); - Tve.pbkdf2 = dHe(); - Tve.pbkdf2Sync = Ave(); - }); - var Pve = I((ry) => { - "use strict"; - m(); - g(); - ry.readUInt32BE = function (e, r) { - var n = (e[0 + r] << 24) | (e[1 + r] << 16) | (e[2 + r] << 8) | e[3 + r]; - return n >>> 0; - }; - ry.writeUInt32BE = function (e, r, n) { - (e[0 + n] = r >>> 24), - (e[1 + n] = (r >>> 16) & 255), - (e[2 + n] = (r >>> 8) & 255), - (e[3 + n] = r & 255); - }; - ry.ip = function (e, r, n, i) { - for (var o = 0, a = 0, s = 6; s >= 0; s -= 2) { - for (var c = 0; c <= 24; c += 8) (o <<= 1), (o |= (r >>> (c + s)) & 1); - for (var c = 0; c <= 24; c += 8) (o <<= 1), (o |= (e >>> (c + s)) & 1); - } - for (var s = 6; s >= 0; s -= 2) { - for (var c = 1; c <= 25; c += 8) (a <<= 1), (a |= (r >>> (c + s)) & 1); - for (var c = 1; c <= 25; c += 8) (a <<= 1), (a |= (e >>> (c + s)) & 1); - } - (n[i + 0] = o >>> 0), (n[i + 1] = a >>> 0); - }; - ry.rip = function (e, r, n, i) { - for (var o = 0, a = 0, s = 0; s < 4; s++) - for (var c = 24; c >= 0; c -= 8) - (o <<= 1), - (o |= (r >>> (c + s)) & 1), - (o <<= 1), - (o |= (e >>> (c + s)) & 1); - for (var s = 4; s < 8; s++) - for (var c = 24; c >= 0; c -= 8) - (a <<= 1), - (a |= (r >>> (c + s)) & 1), - (a <<= 1), - (a |= (e >>> (c + s)) & 1); - (n[i + 0] = o >>> 0), (n[i + 1] = a >>> 0); - }; - ry.pc1 = function (e, r, n, i) { - for (var o = 0, a = 0, s = 7; s >= 5; s--) { - for (var c = 0; c <= 24; c += 8) (o <<= 1), (o |= (r >> (c + s)) & 1); - for (var c = 0; c <= 24; c += 8) (o <<= 1), (o |= (e >> (c + s)) & 1); - } - for (var c = 0; c <= 24; c += 8) (o <<= 1), (o |= (r >> (c + s)) & 1); - for (var s = 1; s <= 3; s++) { - for (var c = 0; c <= 24; c += 8) (a <<= 1), (a |= (r >> (c + s)) & 1); - for (var c = 0; c <= 24; c += 8) (a <<= 1), (a |= (e >> (c + s)) & 1); - } - for (var c = 0; c <= 24; c += 8) (a <<= 1), (a |= (e >> (c + s)) & 1); - (n[i + 0] = o >>> 0), (n[i + 1] = a >>> 0); - }; - ry.r28shl = function (e, r) { - return ((e << r) & 268435455) | (e >>> (28 - r)); - }; - var FZ = [ - 14, 11, 17, 4, 27, 23, 25, 0, 13, 22, 7, 18, 5, 9, 16, 24, 2, 20, 12, 21, - 1, 8, 15, 26, 15, 4, 25, 19, 9, 1, 26, 16, 5, 11, 23, 8, 12, 7, 17, 0, 22, - 3, 10, 14, 6, 20, 27, 24, - ]; - ry.pc2 = function (e, r, n, i) { - for (var o = 0, a = 0, s = FZ.length >>> 1, c = 0; c < s; c++) - (o <<= 1), (o |= (e >>> FZ[c]) & 1); - for (var c = s; c < FZ.length; c++) (a <<= 1), (a |= (r >>> FZ[c]) & 1); - (n[i + 0] = o >>> 0), (n[i + 1] = a >>> 0); - }; - ry.expand = function (e, r, n) { - var i = 0, - o = 0; - i = ((e & 1) << 5) | (e >>> 27); - for (var a = 23; a >= 15; a -= 4) (i <<= 6), (i |= (e >>> a) & 63); - for (var a = 11; a >= 3; a -= 4) (o |= (e >>> a) & 63), (o <<= 6); - (o |= ((e & 31) << 1) | (e >>> 31)), - (r[n + 0] = i >>> 0), - (r[n + 1] = o >>> 0); - }; - var hHe = [ - 14, 0, 4, 15, 13, 7, 1, 4, 2, 14, 15, 2, 11, 13, 8, 1, 3, 10, 10, 6, 6, - 12, 12, 11, 5, 9, 9, 5, 0, 3, 7, 8, 4, 15, 1, 12, 14, 8, 8, 2, 13, 4, 6, - 9, 2, 1, 11, 7, 15, 5, 12, 11, 9, 3, 7, 14, 3, 10, 10, 0, 5, 6, 0, 13, 15, - 3, 1, 13, 8, 4, 14, 7, 6, 15, 11, 2, 3, 8, 4, 14, 9, 12, 7, 0, 2, 1, 13, - 10, 12, 6, 0, 9, 5, 11, 10, 5, 0, 13, 14, 8, 7, 10, 11, 1, 10, 3, 4, 15, - 13, 4, 1, 2, 5, 11, 8, 6, 12, 7, 6, 12, 9, 0, 3, 5, 2, 14, 15, 9, 10, 13, - 0, 7, 9, 0, 14, 9, 6, 3, 3, 4, 15, 6, 5, 10, 1, 2, 13, 8, 12, 5, 7, 14, - 11, 12, 4, 11, 2, 15, 8, 1, 13, 1, 6, 10, 4, 13, 9, 0, 8, 6, 15, 9, 3, 8, - 0, 7, 11, 4, 1, 15, 2, 14, 12, 3, 5, 11, 10, 5, 14, 2, 7, 12, 7, 13, 13, - 8, 14, 11, 3, 5, 0, 6, 6, 15, 9, 0, 10, 3, 1, 4, 2, 7, 8, 2, 5, 12, 11, 1, - 12, 10, 4, 14, 15, 9, 10, 3, 6, 15, 9, 0, 0, 6, 12, 10, 11, 1, 7, 13, 13, - 8, 15, 9, 1, 4, 3, 5, 14, 11, 5, 12, 2, 7, 8, 2, 4, 14, 2, 14, 12, 11, 4, - 2, 1, 12, 7, 4, 10, 7, 11, 13, 6, 1, 8, 5, 5, 0, 3, 15, 15, 10, 13, 3, 0, - 9, 14, 8, 9, 6, 4, 11, 2, 8, 1, 12, 11, 7, 10, 1, 13, 14, 7, 2, 8, 13, 15, - 6, 9, 15, 12, 0, 5, 9, 6, 10, 3, 4, 0, 5, 14, 3, 12, 10, 1, 15, 10, 4, 15, - 2, 9, 7, 2, 12, 6, 9, 8, 5, 0, 6, 13, 1, 3, 13, 4, 14, 14, 0, 7, 11, 5, 3, - 11, 8, 9, 4, 14, 3, 15, 2, 5, 12, 2, 9, 8, 5, 12, 15, 3, 10, 7, 11, 0, 14, - 4, 1, 10, 7, 1, 6, 13, 0, 11, 8, 6, 13, 4, 13, 11, 0, 2, 11, 14, 7, 15, 4, - 0, 9, 8, 1, 13, 10, 3, 14, 12, 3, 9, 5, 7, 12, 5, 2, 10, 15, 6, 8, 1, 6, - 1, 6, 4, 11, 11, 13, 13, 8, 12, 1, 3, 4, 7, 10, 14, 7, 10, 9, 15, 5, 6, 0, - 8, 15, 0, 14, 5, 2, 9, 3, 2, 12, 13, 1, 2, 15, 8, 13, 4, 8, 6, 10, 15, 3, - 11, 7, 1, 4, 10, 12, 9, 5, 3, 6, 14, 11, 5, 0, 0, 14, 12, 9, 7, 2, 7, 2, - 11, 1, 4, 14, 1, 7, 9, 4, 12, 10, 14, 8, 2, 13, 0, 15, 6, 12, 10, 9, 13, - 0, 15, 3, 3, 5, 5, 6, 8, 11, - ]; - ry.substitute = function (e, r) { - for (var n = 0, i = 0; i < 4; i++) { - var o = (e >>> (18 - i * 6)) & 63, - a = hHe[i * 64 + o]; - (n <<= 4), (n |= a); - } - for (var i = 0; i < 4; i++) { - var o = (r >>> (18 - i * 6)) & 63, - a = hHe[4 * 64 + i * 64 + o]; - (n <<= 4), (n |= a); - } - return n >>> 0; - }; - var pHe = [ - 16, 25, 12, 11, 3, 20, 4, 15, 31, 17, 9, 6, 27, 14, 1, 22, 30, 24, 8, 18, - 0, 5, 29, 23, 13, 19, 2, 26, 10, 21, 28, 7, - ]; - ry.permute = function (e) { - for (var r = 0, n = 0; n < pHe.length; n++) - (r <<= 1), (r |= (e >>> pHe[n]) & 1); - return r >>> 0; - }; - ry.padSplit = function (e, r, n) { - for (var i = e.toString(2); i.length < r; ) i = "0" + i; - for (var o = [], a = 0; a < r; a += n) o.push(i.slice(a, a + n)); - return o.join(" "); - }; - }); - var Cp = I((hln, mHe) => { - m(); - g(); - mHe.exports = yHe; - function yHe(t, e) { - if (!t) throw new Error(e || "Assertion failed"); - } - yHe.equal = function (e, r, n) { - if (e != r) throw new Error(n || "Assertion failed: " + e + " != " + r); - }; - }); - var LZ = I((pln, gHe) => { - "use strict"; - m(); - g(); - var uZt = Cp(); - function ny(t) { - (this.options = t), - (this.type = this.options.type), - (this.blockSize = 8), - this._init(), - (this.buffer = new Array(this.blockSize)), - (this.bufferOff = 0); - } - gHe.exports = ny; - ny.prototype._init = function () {}; - ny.prototype.update = function (e) { - return e.length === 0 - ? [] - : this.type === "decrypt" - ? this._updateDecrypt(e) - : this._updateEncrypt(e); - }; - ny.prototype._buffer = function (e, r) { - for ( - var n = Math.min(this.buffer.length - this.bufferOff, e.length - r), - i = 0; - i < n; - i++ - ) - this.buffer[this.bufferOff + i] = e[r + i]; - return (this.bufferOff += n), n; - }; - ny.prototype._flushBuffer = function (e, r) { - return ( - this._update(this.buffer, 0, e, r), (this.bufferOff = 0), this.blockSize - ); - }; - ny.prototype._updateEncrypt = function (e) { - var r = 0, - n = 0, - i = ((this.bufferOff + e.length) / this.blockSize) | 0, - o = new Array(i * this.blockSize); - this.bufferOff !== 0 && - ((r += this._buffer(e, r)), - this.bufferOff === this.buffer.length && - (n += this._flushBuffer(o, n))); - for ( - var a = e.length - ((e.length - r) % this.blockSize); - r < a; - r += this.blockSize - ) - this._update(e, r, o, n), (n += this.blockSize); - for (; r < e.length; r++, this.bufferOff++) - this.buffer[this.bufferOff] = e[r]; - return o; - }; - ny.prototype._updateDecrypt = function (e) { - for ( - var r = 0, - n = 0, - i = Math.ceil((this.bufferOff + e.length) / this.blockSize) - 1, - o = new Array(i * this.blockSize); - i > 0; - i-- - ) - (r += this._buffer(e, r)), (n += this._flushBuffer(o, n)); - return (r += this._buffer(e, r)), o; - }; - ny.prototype.final = function (e) { - var r; - e && (r = this.update(e)); - var n; - return ( - this.type === "encrypt" - ? (n = this._finalEncrypt()) - : (n = this._finalDecrypt()), - r ? r.concat(n) : n - ); - }; - ny.prototype._pad = function (e, r) { - if (r === 0) return !1; - for (; r < e.length; ) e[r++] = 0; - return !0; - }; - ny.prototype._finalEncrypt = function () { - if (!this._pad(this.buffer, this.bufferOff)) return []; - var e = new Array(this.blockSize); - return this._update(this.buffer, 0, e, 0), e; - }; - ny.prototype._unpad = function (e) { - return e; - }; - ny.prototype._finalDecrypt = function () { - uZt.equal(this.bufferOff, this.blockSize, "Not enough data to decrypt"); - var e = new Array(this.blockSize); - return this._flushBuffer(e, 0), this._unpad(e); - }; - }); - var Ove = I((yln, wHe) => { - "use strict"; - m(); - g(); - var vHe = Cp(), - cZt = dn(), - Vs = Pve(), - bHe = LZ(); - function lZt() { - (this.tmp = new Array(2)), (this.keys = null); - } - function dv(t) { - bHe.call(this, t); - var e = new lZt(); - (this._desState = e), this.deriveKeys(e, t.key); - } - cZt(dv, bHe); - wHe.exports = dv; - dv.create = function (e) { - return new dv(e); - }; - var fZt = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1]; - dv.prototype.deriveKeys = function (e, r) { - (e.keys = new Array(16 * 2)), - vHe.equal(r.length, this.blockSize, "Invalid key length"); - var n = Vs.readUInt32BE(r, 0), - i = Vs.readUInt32BE(r, 4); - Vs.pc1(n, i, e.tmp, 0), (n = e.tmp[0]), (i = e.tmp[1]); - for (var o = 0; o < e.keys.length; o += 2) { - var a = fZt[o >>> 1]; - (n = Vs.r28shl(n, a)), (i = Vs.r28shl(i, a)), Vs.pc2(n, i, e.keys, o); - } - }; - dv.prototype._update = function (e, r, n, i) { - var o = this._desState, - a = Vs.readUInt32BE(e, r), - s = Vs.readUInt32BE(e, r + 4); - Vs.ip(a, s, o.tmp, 0), - (a = o.tmp[0]), - (s = o.tmp[1]), - this.type === "encrypt" - ? this._encrypt(o, a, s, o.tmp, 0) - : this._decrypt(o, a, s, o.tmp, 0), - (a = o.tmp[0]), - (s = o.tmp[1]), - Vs.writeUInt32BE(n, a, i), - Vs.writeUInt32BE(n, s, i + 4); - }; - dv.prototype._pad = function (e, r) { - for (var n = e.length - r, i = r; i < e.length; i++) e[i] = n; - return !0; - }; - dv.prototype._unpad = function (e) { - for (var r = e[e.length - 1], n = e.length - r; n < e.length; n++) - vHe.equal(e[n], r); - return e.slice(0, e.length - r); - }; - dv.prototype._encrypt = function (e, r, n, i, o) { - for (var a = r, s = n, c = 0; c < e.keys.length; c += 2) { - var u = e.keys[c], - h = e.keys[c + 1]; - Vs.expand(s, e.tmp, 0), (u ^= e.tmp[0]), (h ^= e.tmp[1]); - var w = Vs.substitute(u, h), - M = Vs.permute(w), - k = s; - (s = (a ^ M) >>> 0), (a = k); - } - Vs.rip(s, a, i, o); - }; - dv.prototype._decrypt = function (e, r, n, i, o) { - for (var a = n, s = r, c = e.keys.length - 2; c >= 0; c -= 2) { - var u = e.keys[c], - h = e.keys[c + 1]; - Vs.expand(a, e.tmp, 0), (u ^= e.tmp[0]), (h ^= e.tmp[1]); - var w = Vs.substitute(u, h), - M = Vs.permute(w), - k = a; - (a = (s ^ M) >>> 0), (s = k); - } - Vs.rip(a, s, i, o); - }; - }); - var xHe = I((_He) => { - "use strict"; - m(); - g(); - var dZt = Cp(), - hZt = dn(), - qZ = {}; - function pZt(t) { - dZt.equal(t.length, 8, "Invalid IV length"), (this.iv = new Array(8)); - for (var e = 0; e < this.iv.length; e++) this.iv[e] = t[e]; - } - function yZt(t) { - function e(o) { - t.call(this, o), this._cbcInit(); - } - hZt(e, t); - for (var r = Object.keys(qZ), n = 0; n < r.length; n++) { - var i = r[n]; - e.prototype[i] = qZ[i]; - } - return ( - (e.create = function (a) { - return new e(a); - }), - e - ); - } - _He.instantiate = yZt; - qZ._cbcInit = function () { - var e = new pZt(this.options.iv); - this._cbcState = e; - }; - qZ._update = function (e, r, n, i) { - var o = this._cbcState, - a = this.constructor.super_.prototype, - s = o.iv; - if (this.type === "encrypt") { - for (var c = 0; c < this.blockSize; c++) s[c] ^= e[r + c]; - a._update.call(this, s, 0, n, i); - for (var c = 0; c < this.blockSize; c++) s[c] = n[i + c]; - } else { - a._update.call(this, e, r, n, i); - for (var c = 0; c < this.blockSize; c++) n[i + c] ^= s[c]; - for (var c = 0; c < this.blockSize; c++) s[c] = e[r + c]; - } - }; - }); - var EHe = I((gln, AHe) => { - "use strict"; - m(); - g(); - var mZt = Cp(), - gZt = dn(), - SHe = LZ(), - f2 = Ove(); - function vZt(t, e) { - mZt.equal(e.length, 24, "Invalid key length"); - var r = e.slice(0, 8), - n = e.slice(8, 16), - i = e.slice(16, 24); - t === "encrypt" - ? (this.ciphers = [ - f2.create({ type: "encrypt", key: r }), - f2.create({ type: "decrypt", key: n }), - f2.create({ type: "encrypt", key: i }), - ]) - : (this.ciphers = [ - f2.create({ type: "decrypt", key: i }), - f2.create({ type: "encrypt", key: n }), - f2.create({ type: "decrypt", key: r }), - ]); - } - function xM(t) { - SHe.call(this, t); - var e = new vZt(this.type, this.options.key); - this._edeState = e; - } - gZt(xM, SHe); - AHe.exports = xM; - xM.create = function (e) { - return new xM(e); - }; - xM.prototype._update = function (e, r, n, i) { - var o = this._edeState; - o.ciphers[0]._update(e, r, n, i), - o.ciphers[1]._update(n, i, n, i), - o.ciphers[2]._update(n, i, n, i); - }; - xM.prototype._pad = f2.prototype._pad; - xM.prototype._unpad = f2.prototype._unpad; - }); - var MHe = I((w5) => { - "use strict"; - m(); - g(); - w5.utils = Pve(); - w5.Cipher = LZ(); - w5.DES = Ove(); - w5.CBC = xHe(); - w5.EDE = EHe(); - }); - var PHe = I((bln, kHe) => { - m(); - g(); - var THe = T_(), - k_ = MHe(), - bZt = dn(), - SM = vn().Buffer, - Oq = { - "des-ede3-cbc": k_.CBC.instantiate(k_.EDE), - "des-ede3": k_.EDE, - "des-ede-cbc": k_.CBC.instantiate(k_.EDE), - "des-ede": k_.EDE, - "des-cbc": k_.CBC.instantiate(k_.DES), - "des-ecb": k_.DES, - }; - Oq.des = Oq["des-cbc"]; - Oq.des3 = Oq["des-ede3-cbc"]; - kHe.exports = zZ; - bZt(zZ, THe); - function zZ(t) { - THe.call(this); - var e = t.mode.toLowerCase(), - r = Oq[e], - n; - t.decrypt ? (n = "decrypt") : (n = "encrypt"); - var i = t.key; - SM.isBuffer(i) || (i = SM.from(i)), - (e === "des-ede" || e === "des-ede-cbc") && - (i = SM.concat([i, i.slice(0, 8)])); - var o = t.iv; - SM.isBuffer(o) || (o = SM.from(o)), - (this._des = r.create({ key: i, iv: o, type: n })); - } - zZ.prototype._update = function (t) { - return SM.from(this._des.update(t)); - }; - zZ.prototype._final = function () { - return SM.from(this._des.final()); - }; - }); - var OHe = I((Bve) => { - m(); - g(); - Bve.encrypt = function (t, e) { - return t._cipher.encryptBlock(e); - }; - Bve.decrypt = function (t, e) { - return t._cipher.decryptBlock(e); - }; - }); - var _5 = I((_ln, BHe) => { - m(); - g(); - BHe.exports = function (e, r) { - for ( - var n = Math.min(e.length, r.length), i = new Buffer(n), o = 0; - o < n; - ++o - ) - i[o] = e[o] ^ r[o]; - return i; - }; - }); - var CHe = I((Ive) => { - m(); - g(); - var IHe = _5(); - Ive.encrypt = function (t, e) { - var r = IHe(e, t._prev); - return (t._prev = t._cipher.encryptBlock(r)), t._prev; - }; - Ive.decrypt = function (t, e) { - var r = t._prev; - t._prev = e; - var n = t._cipher.decryptBlock(e); - return IHe(n, r); - }; - }); - var DHe = I((NHe) => { - m(); - g(); - var Bq = vn().Buffer, - wZt = _5(); - function RHe(t, e, r) { - var n = e.length, - i = wZt(e, t._cache); - return ( - (t._cache = t._cache.slice(n)), - (t._prev = Bq.concat([t._prev, r ? e : i])), - i - ); - } - NHe.encrypt = function (t, e, r) { - for (var n = Bq.allocUnsafe(0), i; e.length; ) - if ( - (t._cache.length === 0 && - ((t._cache = t._cipher.encryptBlock(t._prev)), - (t._prev = Bq.allocUnsafe(0))), - t._cache.length <= e.length) - ) - (i = t._cache.length), - (n = Bq.concat([n, RHe(t, e.slice(0, i), r)])), - (e = e.slice(i)); - else { - n = Bq.concat([n, RHe(t, e, r)]); - break; - } - return n; - }; - }); - var LHe = I((FHe) => { - m(); - g(); - var Cve = vn().Buffer; - function _Zt(t, e, r) { - var n = t._cipher.encryptBlock(t._prev), - i = n[0] ^ e; - return ( - (t._prev = Cve.concat([t._prev.slice(1), Cve.from([r ? e : i])])), i - ); - } - FHe.encrypt = function (t, e, r) { - for (var n = e.length, i = Cve.allocUnsafe(n), o = -1; ++o < n; ) - i[o] = _Zt(t, e[o], r); - return i; - }; - }); - var zHe = I((qHe) => { - m(); - g(); - var jZ = vn().Buffer; - function xZt(t, e, r) { - for (var n, i = -1, o = 8, a = 0, s, c; ++i < o; ) - (n = t._cipher.encryptBlock(t._prev)), - (s = e & (1 << (7 - i)) ? 128 : 0), - (c = n[0] ^ s), - (a += (c & 128) >> i % 8), - (t._prev = SZt(t._prev, r ? s : c)); - return a; - } - function SZt(t, e) { - var r = t.length, - n = -1, - i = jZ.allocUnsafe(t.length); - for (t = jZ.concat([t, jZ.from([e])]); ++n < r; ) - i[n] = (t[n] << 1) | (t[n + 1] >> 7); - return i; - } - qHe.encrypt = function (t, e, r) { - for (var n = e.length, i = jZ.allocUnsafe(n), o = -1; ++o < n; ) - i[o] = xZt(t, e[o], r); - return i; - }; - }); - var UHe = I((jHe) => { - m(); - g(); - var AZt = _5(); - function EZt(t) { - return (t._prev = t._cipher.encryptBlock(t._prev)), t._prev; - } - jHe.encrypt = function (t, e) { - for (; t._cache.length < e.length; ) - t._cache = Buffer.concat([t._cache, EZt(t)]); - var r = t._cache.slice(0, e.length); - return (t._cache = t._cache.slice(e.length)), AZt(e, r); - }; - }); - var Rve = I((Tln, KHe) => { - m(); - g(); - function MZt(t) { - for (var e = t.length, r; e--; ) - if (((r = t.readUInt8(e)), r === 255)) t.writeUInt8(0, e); - else { - r++, t.writeUInt8(r, e); - break; - } - } - KHe.exports = MZt; - }); - var Dve = I((VHe) => { - m(); - g(); - var TZt = _5(), - HHe = vn().Buffer, - kZt = Rve(); - function PZt(t) { - var e = t._cipher.encryptBlockRaw(t._prev); - return kZt(t._prev), e; - } - var Nve = 16; - VHe.encrypt = function (t, e) { - var r = Math.ceil(e.length / Nve), - n = t._cache.length; - t._cache = HHe.concat([t._cache, HHe.allocUnsafe(r * Nve)]); - for (var i = 0; i < r; i++) { - var o = PZt(t), - a = n + i * Nve; - t._cache.writeUInt32BE(o[0], a + 0), - t._cache.writeUInt32BE(o[1], a + 4), - t._cache.writeUInt32BE(o[2], a + 8), - t._cache.writeUInt32BE(o[3], a + 12); - } - var s = t._cache.slice(0, e.length); - return (t._cache = t._cache.slice(e.length)), TZt(e, s); - }; - }); - var Fve = I((Pln, OZt) => { - OZt.exports = { - "aes-128-ecb": { - cipher: "AES", - key: 128, - iv: 0, - mode: "ECB", - type: "block", - }, - "aes-192-ecb": { - cipher: "AES", - key: 192, - iv: 0, - mode: "ECB", - type: "block", - }, - "aes-256-ecb": { - cipher: "AES", - key: 256, - iv: 0, - mode: "ECB", - type: "block", - }, - "aes-128-cbc": { - cipher: "AES", - key: 128, - iv: 16, - mode: "CBC", - type: "block", - }, - "aes-192-cbc": { - cipher: "AES", - key: 192, - iv: 16, - mode: "CBC", - type: "block", - }, - "aes-256-cbc": { - cipher: "AES", - key: 256, - iv: 16, - mode: "CBC", - type: "block", - }, - aes128: { cipher: "AES", key: 128, iv: 16, mode: "CBC", type: "block" }, - aes192: { cipher: "AES", key: 192, iv: 16, mode: "CBC", type: "block" }, - aes256: { cipher: "AES", key: 256, iv: 16, mode: "CBC", type: "block" }, - "aes-128-cfb": { - cipher: "AES", - key: 128, - iv: 16, - mode: "CFB", - type: "stream", - }, - "aes-192-cfb": { - cipher: "AES", - key: 192, - iv: 16, - mode: "CFB", - type: "stream", - }, - "aes-256-cfb": { - cipher: "AES", - key: 256, - iv: 16, - mode: "CFB", - type: "stream", - }, - "aes-128-cfb8": { - cipher: "AES", - key: 128, - iv: 16, - mode: "CFB8", - type: "stream", - }, - "aes-192-cfb8": { - cipher: "AES", - key: 192, - iv: 16, - mode: "CFB8", - type: "stream", - }, - "aes-256-cfb8": { - cipher: "AES", - key: 256, - iv: 16, - mode: "CFB8", - type: "stream", - }, - "aes-128-cfb1": { - cipher: "AES", - key: 128, - iv: 16, - mode: "CFB1", - type: "stream", - }, - "aes-192-cfb1": { - cipher: "AES", - key: 192, - iv: 16, - mode: "CFB1", - type: "stream", - }, - "aes-256-cfb1": { - cipher: "AES", - key: 256, - iv: 16, - mode: "CFB1", - type: "stream", - }, - "aes-128-ofb": { - cipher: "AES", - key: 128, - iv: 16, - mode: "OFB", - type: "stream", - }, - "aes-192-ofb": { - cipher: "AES", - key: 192, - iv: 16, - mode: "OFB", - type: "stream", - }, - "aes-256-ofb": { - cipher: "AES", - key: 256, - iv: 16, - mode: "OFB", - type: "stream", - }, - "aes-128-ctr": { - cipher: "AES", - key: 128, - iv: 16, - mode: "CTR", - type: "stream", - }, - "aes-192-ctr": { - cipher: "AES", - key: 192, - iv: 16, - mode: "CTR", - type: "stream", - }, - "aes-256-ctr": { - cipher: "AES", - key: 256, - iv: 16, - mode: "CTR", - type: "stream", - }, - "aes-128-gcm": { - cipher: "AES", - key: 128, - iv: 12, - mode: "GCM", - type: "auth", - }, - "aes-192-gcm": { - cipher: "AES", - key: 192, - iv: 12, - mode: "GCM", - type: "auth", - }, - "aes-256-gcm": { - cipher: "AES", - key: 256, - iv: 12, - mode: "GCM", - type: "auth", - }, - }; - }); - var KZ = I((Oln, WHe) => { - m(); - g(); - var BZt = { - ECB: OHe(), - CBC: CHe(), - CFB: DHe(), - CFB8: LHe(), - CFB1: zHe(), - OFB: UHe(), - CTR: Dve(), - GCM: Dve(), - }, - UZ = Fve(); - for (Lve in UZ) UZ[Lve].module = BZt[UZ[Lve].mode]; - var Lve; - WHe.exports = UZ; - }); - var Iq = I((Bln, JHe) => { - m(); - g(); - var HZ = vn().Buffer; - function zve(t) { - HZ.isBuffer(t) || (t = HZ.from(t)); - for (var e = (t.length / 4) | 0, r = new Array(e), n = 0; n < e; n++) - r[n] = t.readUInt32BE(n * 4); - return r; - } - function qve(t) { - for (var e = 0; e < t.length; t++) t[e] = 0; - } - function GHe(t, e, r, n, i) { - for ( - var o = r[0], - a = r[1], - s = r[2], - c = r[3], - u = t[0] ^ e[0], - h = t[1] ^ e[1], - w = t[2] ^ e[2], - M = t[3] ^ e[3], - k, - O, - D, - F, - N = 4, - q = 1; - q < i; - q++ - ) - (k = - o[u >>> 24] ^ - a[(h >>> 16) & 255] ^ - s[(w >>> 8) & 255] ^ - c[M & 255] ^ - e[N++]), - (O = - o[h >>> 24] ^ - a[(w >>> 16) & 255] ^ - s[(M >>> 8) & 255] ^ - c[u & 255] ^ - e[N++]), - (D = - o[w >>> 24] ^ - a[(M >>> 16) & 255] ^ - s[(u >>> 8) & 255] ^ - c[h & 255] ^ - e[N++]), - (F = - o[M >>> 24] ^ - a[(u >>> 16) & 255] ^ - s[(h >>> 8) & 255] ^ - c[w & 255] ^ - e[N++]), - (u = k), - (h = O), - (w = D), - (M = F); - return ( - (k = - ((n[u >>> 24] << 24) | - (n[(h >>> 16) & 255] << 16) | - (n[(w >>> 8) & 255] << 8) | - n[M & 255]) ^ - e[N++]), - (O = - ((n[h >>> 24] << 24) | - (n[(w >>> 16) & 255] << 16) | - (n[(M >>> 8) & 255] << 8) | - n[u & 255]) ^ - e[N++]), - (D = - ((n[w >>> 24] << 24) | - (n[(M >>> 16) & 255] << 16) | - (n[(u >>> 8) & 255] << 8) | - n[h & 255]) ^ - e[N++]), - (F = - ((n[M >>> 24] << 24) | - (n[(u >>> 16) & 255] << 16) | - (n[(h >>> 8) & 255] << 8) | - n[w & 255]) ^ - e[N++]), - (k = k >>> 0), - (O = O >>> 0), - (D = D >>> 0), - (F = F >>> 0), - [k, O, D, F] - ); - } - var IZt = [0, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54], - bs = (function () { - for (var t = new Array(256), e = 0; e < 256; e++) - e < 128 ? (t[e] = e << 1) : (t[e] = (e << 1) ^ 283); - for ( - var r = [], - n = [], - i = [[], [], [], []], - o = [[], [], [], []], - a = 0, - s = 0, - c = 0; - c < 256; - ++c - ) { - var u = s ^ (s << 1) ^ (s << 2) ^ (s << 3) ^ (s << 4); - (u = (u >>> 8) ^ (u & 255) ^ 99), (r[a] = u), (n[u] = a); - var h = t[a], - w = t[h], - M = t[w], - k = (t[u] * 257) ^ (u * 16843008); - (i[0][a] = (k << 24) | (k >>> 8)), - (i[1][a] = (k << 16) | (k >>> 16)), - (i[2][a] = (k << 8) | (k >>> 24)), - (i[3][a] = k), - (k = (M * 16843009) ^ (w * 65537) ^ (h * 257) ^ (a * 16843008)), - (o[0][u] = (k << 24) | (k >>> 8)), - (o[1][u] = (k << 16) | (k >>> 16)), - (o[2][u] = (k << 8) | (k >>> 24)), - (o[3][u] = k), - a === 0 ? (a = s = 1) : ((a = h ^ t[t[t[M ^ h]]]), (s ^= t[t[s]])); - } - return { SBOX: r, INV_SBOX: n, SUB_MIX: i, INV_SUB_MIX: o }; - })(); - function iy(t) { - (this._key = zve(t)), this._reset(); - } - iy.blockSize = 4 * 4; - iy.keySize = 256 / 8; - iy.prototype.blockSize = iy.blockSize; - iy.prototype.keySize = iy.keySize; - iy.prototype._reset = function () { - for ( - var t = this._key, - e = t.length, - r = e + 6, - n = (r + 1) * 4, - i = [], - o = 0; - o < e; - o++ - ) - i[o] = t[o]; - for (o = e; o < n; o++) { - var a = i[o - 1]; - o % e === 0 - ? ((a = (a << 8) | (a >>> 24)), - (a = - (bs.SBOX[a >>> 24] << 24) | - (bs.SBOX[(a >>> 16) & 255] << 16) | - (bs.SBOX[(a >>> 8) & 255] << 8) | - bs.SBOX[a & 255]), - (a ^= IZt[(o / e) | 0] << 24)) - : e > 6 && - o % e === 4 && - (a = - (bs.SBOX[a >>> 24] << 24) | - (bs.SBOX[(a >>> 16) & 255] << 16) | - (bs.SBOX[(a >>> 8) & 255] << 8) | - bs.SBOX[a & 255]), - (i[o] = i[o - e] ^ a); - } - for (var s = [], c = 0; c < n; c++) { - var u = n - c, - h = i[u - (c % 4 ? 0 : 4)]; - c < 4 || u <= 4 - ? (s[c] = h) - : (s[c] = - bs.INV_SUB_MIX[0][bs.SBOX[h >>> 24]] ^ - bs.INV_SUB_MIX[1][bs.SBOX[(h >>> 16) & 255]] ^ - bs.INV_SUB_MIX[2][bs.SBOX[(h >>> 8) & 255]] ^ - bs.INV_SUB_MIX[3][bs.SBOX[h & 255]]); - } - (this._nRounds = r), (this._keySchedule = i), (this._invKeySchedule = s); - }; - iy.prototype.encryptBlockRaw = function (t) { - return ( - (t = zve(t)), - GHe(t, this._keySchedule, bs.SUB_MIX, bs.SBOX, this._nRounds) - ); - }; - iy.prototype.encryptBlock = function (t) { - var e = this.encryptBlockRaw(t), - r = HZ.allocUnsafe(16); - return ( - r.writeUInt32BE(e[0], 0), - r.writeUInt32BE(e[1], 4), - r.writeUInt32BE(e[2], 8), - r.writeUInt32BE(e[3], 12), - r - ); - }; - iy.prototype.decryptBlock = function (t) { - t = zve(t); - var e = t[1]; - (t[1] = t[3]), (t[3] = e); - var r = GHe( - t, - this._invKeySchedule, - bs.INV_SUB_MIX, - bs.INV_SBOX, - this._nRounds - ), - n = HZ.allocUnsafe(16); - return ( - n.writeUInt32BE(r[0], 0), - n.writeUInt32BE(r[3], 4), - n.writeUInt32BE(r[2], 8), - n.writeUInt32BE(r[1], 12), - n - ); - }; - iy.prototype.scrub = function () { - qve(this._keySchedule), qve(this._invKeySchedule), qve(this._key); - }; - JHe.exports.AES = iy; - }); - var XHe = I((Iln, ZHe) => { - m(); - g(); - var x5 = vn().Buffer, - CZt = x5.alloc(16, 0); - function RZt(t) { - return [ - t.readUInt32BE(0), - t.readUInt32BE(4), - t.readUInt32BE(8), - t.readUInt32BE(12), - ]; - } - function $He(t) { - var e = x5.allocUnsafe(16); - return ( - e.writeUInt32BE(t[0] >>> 0, 0), - e.writeUInt32BE(t[1] >>> 0, 4), - e.writeUInt32BE(t[2] >>> 0, 8), - e.writeUInt32BE(t[3] >>> 0, 12), - e - ); - } - function Cq(t) { - (this.h = t), - (this.state = x5.alloc(16, 0)), - (this.cache = x5.allocUnsafe(0)); - } - Cq.prototype.ghash = function (t) { - for (var e = -1; ++e < t.length; ) this.state[e] ^= t[e]; - this._multiply(); - }; - Cq.prototype._multiply = function () { - for ( - var t = RZt(this.h), e = [0, 0, 0, 0], r, n, i, o = -1; - ++o < 128; - - ) { - for ( - n = (this.state[~~(o / 8)] & (1 << (7 - (o % 8)))) !== 0, - n && - ((e[0] ^= t[0]), (e[1] ^= t[1]), (e[2] ^= t[2]), (e[3] ^= t[3])), - i = (t[3] & 1) !== 0, - r = 3; - r > 0; - r-- - ) - t[r] = (t[r] >>> 1) | ((t[r - 1] & 1) << 31); - (t[0] = t[0] >>> 1), i && (t[0] = t[0] ^ (225 << 24)); - } - this.state = $He(e); - }; - Cq.prototype.update = function (t) { - this.cache = x5.concat([this.cache, t]); - for (var e; this.cache.length >= 16; ) - (e = this.cache.slice(0, 16)), - (this.cache = this.cache.slice(16)), - this.ghash(e); - }; - Cq.prototype.final = function (t, e) { - return ( - this.cache.length && this.ghash(x5.concat([this.cache, CZt], 16)), - this.ghash($He([0, t, 0, e])), - this.state - ); - }; - ZHe.exports = Cq; - }); - var jve = I((Cln, eVe) => { - m(); - g(); - var NZt = Iq(), - kh = vn().Buffer, - YHe = T_(), - DZt = dn(), - QHe = XHe(), - FZt = _5(), - LZt = Rve(); - function qZt(t, e) { - var r = 0; - t.length !== e.length && r++; - for (var n = Math.min(t.length, e.length), i = 0; i < n; ++i) - r += t[i] ^ e[i]; - return r; - } - function zZt(t, e, r) { - if (e.length === 12) - return ( - (t._finID = kh.concat([e, kh.from([0, 0, 0, 1])])), - kh.concat([e, kh.from([0, 0, 0, 2])]) - ); - var n = new QHe(r), - i = e.length, - o = i % 16; - n.update(e), - o && ((o = 16 - o), n.update(kh.alloc(o, 0))), - n.update(kh.alloc(8, 0)); - var a = i * 8, - s = kh.alloc(8); - s.writeUIntBE(a, 0, 8), n.update(s), (t._finID = n.state); - var c = kh.from(t._finID); - return LZt(c), c; - } - function AM(t, e, r, n) { - YHe.call(this); - var i = kh.alloc(4, 0); - this._cipher = new NZt.AES(e); - var o = this._cipher.encryptBlock(i); - (this._ghash = new QHe(o)), - (r = zZt(this, r, o)), - (this._prev = kh.from(r)), - (this._cache = kh.allocUnsafe(0)), - (this._secCache = kh.allocUnsafe(0)), - (this._decrypt = n), - (this._alen = 0), - (this._len = 0), - (this._mode = t), - (this._authTag = null), - (this._called = !1); - } - DZt(AM, YHe); - AM.prototype._update = function (t) { - if (!this._called && this._alen) { - var e = 16 - (this._alen % 16); - e < 16 && ((e = kh.alloc(e, 0)), this._ghash.update(e)); - } - this._called = !0; - var r = this._mode.encrypt(this, t); - return ( - this._decrypt ? this._ghash.update(t) : this._ghash.update(r), - (this._len += t.length), - r - ); - }; - AM.prototype._final = function () { - if (this._decrypt && !this._authTag) - throw new Error("Unsupported state or unable to authenticate data"); - var t = FZt( - this._ghash.final(this._alen * 8, this._len * 8), - this._cipher.encryptBlock(this._finID) - ); - if (this._decrypt && qZt(t, this._authTag)) - throw new Error("Unsupported state or unable to authenticate data"); - (this._authTag = t), this._cipher.scrub(); - }; - AM.prototype.getAuthTag = function () { - if (this._decrypt || !kh.isBuffer(this._authTag)) - throw new Error("Attempting to get auth tag in unsupported state"); - return this._authTag; - }; - AM.prototype.setAuthTag = function (e) { - if (!this._decrypt) - throw new Error("Attempting to set auth tag in unsupported state"); - this._authTag = e; - }; - AM.prototype.setAAD = function (e) { - if (this._called) - throw new Error("Attempting to set AAD in unsupported state"); - this._ghash.update(e), (this._alen += e.length); - }; - eVe.exports = AM; - }); - var Kve = I((Rln, rVe) => { - m(); - g(); - var jZt = Iq(), - Uve = vn().Buffer, - tVe = T_(), - UZt = dn(); - function VZ(t, e, r, n) { - tVe.call(this), - (this._cipher = new jZt.AES(e)), - (this._prev = Uve.from(r)), - (this._cache = Uve.allocUnsafe(0)), - (this._secCache = Uve.allocUnsafe(0)), - (this._decrypt = n), - (this._mode = t); - } - UZt(VZ, tVe); - VZ.prototype._update = function (t) { - return this._mode.encrypt(this, t, this._decrypt); - }; - VZ.prototype._final = function () { - this._cipher.scrub(); - }; - rVe.exports = VZ; - }); - var Rq = I((Nln, nVe) => { - m(); - g(); - var EM = vn().Buffer, - KZt = EZ(); - function HZt(t, e, r, n) { - if ( - (EM.isBuffer(t) || (t = EM.from(t, "binary")), - e && (EM.isBuffer(e) || (e = EM.from(e, "binary")), e.length !== 8)) - ) - throw new RangeError("salt should be Buffer with 8 byte length"); - for ( - var i = r / 8, o = EM.alloc(i), a = EM.alloc(n || 0), s = EM.alloc(0); - i > 0 || n > 0; - - ) { - var c = new KZt(); - c.update(s), c.update(t), e && c.update(e), (s = c.digest()); - var u = 0; - if (i > 0) { - var h = o.length - i; - (u = Math.min(i, s.length)), s.copy(o, h, 0, u), (i -= u); - } - if (u < s.length && n > 0) { - var w = a.length - n, - M = Math.min(n, s.length - u); - s.copy(a, w, u, u + M), (n -= M); - } - } - return s.fill(0), { key: o, iv: a }; - } - nVe.exports = HZt; - }); - var sVe = I((Hve) => { - m(); - g(); - var iVe = KZ(), - VZt = jve(), - P_ = vn().Buffer, - WZt = Kve(), - oVe = T_(), - GZt = Iq(), - JZt = Rq(), - $Zt = dn(); - function Nq(t, e, r) { - oVe.call(this), - (this._cache = new WZ()), - (this._cipher = new GZt.AES(e)), - (this._prev = P_.from(r)), - (this._mode = t), - (this._autopadding = !0); - } - $Zt(Nq, oVe); - Nq.prototype._update = function (t) { - this._cache.add(t); - for (var e, r, n = []; (e = this._cache.get()); ) - (r = this._mode.encrypt(this, e)), n.push(r); - return P_.concat(n); - }; - var ZZt = P_.alloc(16, 16); - Nq.prototype._final = function () { - var t = this._cache.flush(); - if (this._autopadding) - return (t = this._mode.encrypt(this, t)), this._cipher.scrub(), t; - if (!t.equals(ZZt)) - throw ( - (this._cipher.scrub(), new Error("data not multiple of block length")) - ); - }; - Nq.prototype.setAutoPadding = function (t) { - return (this._autopadding = !!t), this; - }; - function WZ() { - this.cache = P_.allocUnsafe(0); - } - WZ.prototype.add = function (t) { - this.cache = P_.concat([this.cache, t]); - }; - WZ.prototype.get = function () { - if (this.cache.length > 15) { - var t = this.cache.slice(0, 16); - return (this.cache = this.cache.slice(16)), t; - } - return null; - }; - WZ.prototype.flush = function () { - for ( - var t = 16 - this.cache.length, e = P_.allocUnsafe(t), r = -1; - ++r < t; - - ) - e.writeUInt8(t, r); - return P_.concat([this.cache, e]); - }; - function aVe(t, e, r) { - var n = iVe[t.toLowerCase()]; - if (!n) throw new TypeError("invalid suite type"); - if ((typeof e == "string" && (e = P_.from(e)), e.length !== n.key / 8)) - throw new TypeError("invalid key length " + e.length); - if ( - (typeof r == "string" && (r = P_.from(r)), - n.mode !== "GCM" && r.length !== n.iv) - ) - throw new TypeError("invalid iv length " + r.length); - return n.type === "stream" - ? new WZt(n.module, e, r) - : n.type === "auth" - ? new VZt(n.module, e, r) - : new Nq(n.module, e, r); - } - function XZt(t, e) { - var r = iVe[t.toLowerCase()]; - if (!r) throw new TypeError("invalid suite type"); - var n = JZt(e, !1, r.key, r.iv); - return aVe(t, n.key, n.iv); - } - Hve.createCipheriv = aVe; - Hve.createCipher = XZt; - }); - var fVe = I((Vve) => { - m(); - g(); - var YZt = jve(), - S5 = vn().Buffer, - uVe = KZ(), - QZt = Kve(), - cVe = T_(), - eXt = Iq(), - tXt = Rq(), - rXt = dn(); - function Dq(t, e, r) { - cVe.call(this), - (this._cache = new GZ()), - (this._last = void 0), - (this._cipher = new eXt.AES(e)), - (this._prev = S5.from(r)), - (this._mode = t), - (this._autopadding = !0); - } - rXt(Dq, cVe); - Dq.prototype._update = function (t) { - this._cache.add(t); - for (var e, r, n = []; (e = this._cache.get(this._autopadding)); ) - (r = this._mode.decrypt(this, e)), n.push(r); - return S5.concat(n); - }; - Dq.prototype._final = function () { - var t = this._cache.flush(); - if (this._autopadding) return nXt(this._mode.decrypt(this, t)); - if (t) throw new Error("data not multiple of block length"); - }; - Dq.prototype.setAutoPadding = function (t) { - return (this._autopadding = !!t), this; - }; - function GZ() { - this.cache = S5.allocUnsafe(0); - } - GZ.prototype.add = function (t) { - this.cache = S5.concat([this.cache, t]); - }; - GZ.prototype.get = function (t) { - var e; - if (t) { - if (this.cache.length > 16) - return ( - (e = this.cache.slice(0, 16)), - (this.cache = this.cache.slice(16)), - e - ); - } else if (this.cache.length >= 16) - return ( - (e = this.cache.slice(0, 16)), (this.cache = this.cache.slice(16)), e - ); - return null; - }; - GZ.prototype.flush = function () { - if (this.cache.length) return this.cache; - }; - function nXt(t) { - var e = t[15]; - if (e < 1 || e > 16) throw new Error("unable to decrypt data"); - for (var r = -1; ++r < e; ) - if (t[r + (16 - e)] !== e) throw new Error("unable to decrypt data"); - if (e !== 16) return t.slice(0, 16 - e); - } - function lVe(t, e, r) { - var n = uVe[t.toLowerCase()]; - if (!n) throw new TypeError("invalid suite type"); - if ( - (typeof r == "string" && (r = S5.from(r)), - n.mode !== "GCM" && r.length !== n.iv) - ) - throw new TypeError("invalid iv length " + r.length); - if ((typeof e == "string" && (e = S5.from(e)), e.length !== n.key / 8)) - throw new TypeError("invalid key length " + e.length); - return n.type === "stream" - ? new QZt(n.module, e, r, !0) - : n.type === "auth" - ? new YZt(n.module, e, r, !0) - : new Dq(n.module, e, r); - } - function iXt(t, e) { - var r = uVe[t.toLowerCase()]; - if (!r) throw new TypeError("invalid suite type"); - var n = tXt(e, !1, r.key, r.iv); - return lVe(t, n.key, n.iv); - } - Vve.createDecipher = iXt; - Vve.createDecipheriv = lVe; - }); - var JZ = I((Rm) => { - m(); - g(); - var dVe = sVe(), - hVe = fVe(), - oXt = Fve(); - function aXt() { - return Object.keys(oXt); - } - Rm.createCipher = Rm.Cipher = dVe.createCipher; - Rm.createCipheriv = Rm.Cipheriv = dVe.createCipheriv; - Rm.createDecipher = Rm.Decipher = hVe.createDecipher; - Rm.createDecipheriv = Rm.Decipheriv = hVe.createDecipheriv; - Rm.listCiphers = Rm.getCiphers = aXt; - }); - var pVe = I((O_) => { - m(); - g(); - O_["des-ecb"] = { key: 8, iv: 0 }; - O_["des-cbc"] = O_.des = { key: 8, iv: 8 }; - O_["des-ede3-cbc"] = O_.des3 = { key: 24, iv: 8 }; - O_["des-ede3"] = { key: 24, iv: 0 }; - O_["des-ede-cbc"] = { key: 16, iv: 8 }; - O_["des-ede"] = { key: 16, iv: 0 }; - }); - var bVe = I((Nm) => { - m(); - g(); - var yVe = PHe(), - Wve = JZ(), - d2 = KZ(), - B_ = pVe(), - mVe = Rq(); - function sXt(t, e) { - t = t.toLowerCase(); - var r, n; - if (d2[t]) (r = d2[t].key), (n = d2[t].iv); - else if (B_[t]) (r = B_[t].key * 8), (n = B_[t].iv); - else throw new TypeError("invalid suite type"); - var i = mVe(e, !1, r, n); - return gVe(t, i.key, i.iv); - } - function uXt(t, e) { - t = t.toLowerCase(); - var r, n; - if (d2[t]) (r = d2[t].key), (n = d2[t].iv); - else if (B_[t]) (r = B_[t].key * 8), (n = B_[t].iv); - else throw new TypeError("invalid suite type"); - var i = mVe(e, !1, r, n); - return vVe(t, i.key, i.iv); - } - function gVe(t, e, r) { - if (((t = t.toLowerCase()), d2[t])) return Wve.createCipheriv(t, e, r); - if (B_[t]) return new yVe({ key: e, iv: r, mode: t }); - throw new TypeError("invalid suite type"); - } - function vVe(t, e, r) { - if (((t = t.toLowerCase()), d2[t])) return Wve.createDecipheriv(t, e, r); - if (B_[t]) return new yVe({ key: e, iv: r, mode: t, decrypt: !0 }); - throw new TypeError("invalid suite type"); - } - function cXt() { - return Object.keys(B_).concat(Wve.getCiphers()); - } - Nm.createCipher = Nm.Cipher = sXt; - Nm.createCipheriv = Nm.Cipheriv = gVe; - Nm.createDecipher = Nm.Decipher = uXt; - Nm.createDecipheriv = Nm.Decipheriv = vVe; - Nm.listCiphers = Nm.getCiphers = cXt; - }); - var Jve = I((wVe, Gve) => { - m(); - g(); - (function (t, e) { - "use strict"; - function r(A, l) { - if (!A) throw new Error(l || "Assertion failed"); - } - function n(A, l) { - A.super_ = l; - var p = function () {}; - (p.prototype = l.prototype), - (A.prototype = new p()), - (A.prototype.constructor = A); - } - function i(A, l, p) { - if (i.isBN(A)) return A; - (this.negative = 0), - (this.words = null), - (this.length = 0), - (this.red = null), - A !== null && - ((l === "le" || l === "be") && ((p = l), (l = 10)), - this._init(A || 0, l || 10, p || "be")); - } - typeof t == "object" ? (t.exports = i) : (e.BN = i), - (i.BN = i), - (i.wordSize = 26); - var o; - try { - typeof window < "u" && typeof window.Buffer < "u" - ? (o = window.Buffer) - : (o = Qr().Buffer); - } catch {} - (i.isBN = function (l) { - return l instanceof i - ? !0 - : l !== null && - typeof l == "object" && - l.constructor.wordSize === i.wordSize && - Array.isArray(l.words); - }), - (i.max = function (l, p) { - return l.cmp(p) > 0 ? l : p; - }), - (i.min = function (l, p) { - return l.cmp(p) < 0 ? l : p; - }), - (i.prototype._init = function (l, p, y) { - if (typeof l == "number") return this._initNumber(l, p, y); - if (typeof l == "object") return this._initArray(l, p, y); - p === "hex" && (p = 16), - r(p === (p | 0) && p >= 2 && p <= 36), - (l = l.toString().replace(/\s+/g, "")); - var d = 0; - l[0] === "-" && (d++, (this.negative = 1)), - d < l.length && - (p === 16 - ? this._parseHex(l, d, y) - : (this._parseBase(l, p, d), - y === "le" && this._initArray(this.toArray(), p, y))); - }), - (i.prototype._initNumber = function (l, p, y) { - l < 0 && ((this.negative = 1), (l = -l)), - l < 67108864 - ? ((this.words = [l & 67108863]), (this.length = 1)) - : l < 4503599627370496 - ? ((this.words = [l & 67108863, (l / 67108864) & 67108863]), - (this.length = 2)) - : (r(l < 9007199254740992), - (this.words = [l & 67108863, (l / 67108864) & 67108863, 1]), - (this.length = 3)), - y === "le" && this._initArray(this.toArray(), p, y); - }), - (i.prototype._initArray = function (l, p, y) { - if ((r(typeof l.length == "number"), l.length <= 0)) - return (this.words = [0]), (this.length = 1), this; - (this.length = Math.ceil(l.length / 3)), - (this.words = new Array(this.length)); - for (var d = 0; d < this.length; d++) this.words[d] = 0; - var v, - _, - S = 0; - if (y === "be") - for (d = l.length - 1, v = 0; d >= 0; d -= 3) - (_ = l[d] | (l[d - 1] << 8) | (l[d - 2] << 16)), - (this.words[v] |= (_ << S) & 67108863), - (this.words[v + 1] = (_ >>> (26 - S)) & 67108863), - (S += 24), - S >= 26 && ((S -= 26), v++); - else if (y === "le") - for (d = 0, v = 0; d < l.length; d += 3) - (_ = l[d] | (l[d + 1] << 8) | (l[d + 2] << 16)), - (this.words[v] |= (_ << S) & 67108863), - (this.words[v + 1] = (_ >>> (26 - S)) & 67108863), - (S += 24), - S >= 26 && ((S -= 26), v++); - return this.strip(); - }); - function a(A, l) { - var p = A.charCodeAt(l); - return p >= 65 && p <= 70 - ? p - 55 - : p >= 97 && p <= 102 - ? p - 87 - : (p - 48) & 15; - } - function s(A, l, p) { - var y = a(A, p); - return p - 1 >= l && (y |= a(A, p - 1) << 4), y; - } - i.prototype._parseHex = function (l, p, y) { - (this.length = Math.ceil((l.length - p) / 6)), - (this.words = new Array(this.length)); - for (var d = 0; d < this.length; d++) this.words[d] = 0; - var v = 0, - _ = 0, - S; - if (y === "be") - for (d = l.length - 1; d >= p; d -= 2) - (S = s(l, p, d) << v), - (this.words[_] |= S & 67108863), - v >= 18 - ? ((v -= 18), (_ += 1), (this.words[_] |= S >>> 26)) - : (v += 8); - else { - var b = l.length - p; - for (d = b % 2 === 0 ? p + 1 : p; d < l.length; d += 2) - (S = s(l, p, d) << v), - (this.words[_] |= S & 67108863), - v >= 18 - ? ((v -= 18), (_ += 1), (this.words[_] |= S >>> 26)) - : (v += 8); - } - this.strip(); - }; - function c(A, l, p, y) { - for (var d = 0, v = Math.min(A.length, p), _ = l; _ < v; _++) { - var S = A.charCodeAt(_) - 48; - (d *= y), - S >= 49 - ? (d += S - 49 + 10) - : S >= 17 - ? (d += S - 17 + 10) - : (d += S); - } - return d; - } - (i.prototype._parseBase = function (l, p, y) { - (this.words = [0]), (this.length = 1); - for (var d = 0, v = 1; v <= 67108863; v *= p) d++; - d--, (v = (v / p) | 0); - for ( - var _ = l.length - y, - S = _ % d, - b = Math.min(_, _ - S) + y, - f = 0, - x = y; - x < b; - x += d - ) - (f = c(l, x, x + d, p)), - this.imuln(v), - this.words[0] + f < 67108864 - ? (this.words[0] += f) - : this._iaddn(f); - if (S !== 0) { - var C = 1; - for (f = c(l, x, l.length, p), x = 0; x < S; x++) C *= p; - this.imuln(C), - this.words[0] + f < 67108864 - ? (this.words[0] += f) - : this._iaddn(f); - } - this.strip(); - }), - (i.prototype.copy = function (l) { - l.words = new Array(this.length); - for (var p = 0; p < this.length; p++) l.words[p] = this.words[p]; - (l.length = this.length), - (l.negative = this.negative), - (l.red = this.red); - }), - (i.prototype.clone = function () { - var l = new i(null); - return this.copy(l), l; - }), - (i.prototype._expand = function (l) { - for (; this.length < l; ) this.words[this.length++] = 0; - return this; - }), - (i.prototype.strip = function () { - for (; this.length > 1 && this.words[this.length - 1] === 0; ) - this.length--; - return this._normSign(); - }), - (i.prototype._normSign = function () { - return ( - this.length === 1 && this.words[0] === 0 && (this.negative = 0), - this - ); - }), - (i.prototype.inspect = function () { - return (this.red ? ""; - }); - var u = [ - "", - "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", - ], - h = [ - 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, - ], - w = [ - 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, - ]; - (i.prototype.toString = function (l, p) { - (l = l || 10), (p = p | 0 || 1); - var y; - if (l === 16 || l === "hex") { - y = ""; - for (var d = 0, v = 0, _ = 0; _ < this.length; _++) { - var S = this.words[_], - b = (((S << d) | v) & 16777215).toString(16); - (v = (S >>> (24 - d)) & 16777215), - v !== 0 || _ !== this.length - 1 - ? (y = u[6 - b.length] + b + y) - : (y = b + y), - (d += 2), - d >= 26 && ((d -= 26), _--); - } - for (v !== 0 && (y = v.toString(16) + y); y.length % p !== 0; ) - y = "0" + y; - return this.negative !== 0 && (y = "-" + y), y; - } - if (l === (l | 0) && l >= 2 && l <= 36) { - var f = h[l], - x = w[l]; - y = ""; - var C = this.clone(); - for (C.negative = 0; !C.isZero(); ) { - var E = C.modn(x).toString(l); - (C = C.idivn(x)), - C.isZero() ? (y = E + y) : (y = u[f - E.length] + E + y); - } - for (this.isZero() && (y = "0" + y); y.length % p !== 0; ) - y = "0" + y; - return this.negative !== 0 && (y = "-" + y), y; - } - r(!1, "Base should be between 2 and 36"); - }), - (i.prototype.toNumber = function () { - var l = this.words[0]; - return ( - this.length === 2 - ? (l += this.words[1] * 67108864) - : this.length === 3 && this.words[2] === 1 - ? (l += 4503599627370496 + this.words[1] * 67108864) - : this.length > 2 && - r(!1, "Number can only safely store up to 53 bits"), - this.negative !== 0 ? -l : l - ); - }), - (i.prototype.toJSON = function () { - return this.toString(16); - }), - (i.prototype.toBuffer = function (l, p) { - return r(typeof o < "u"), this.toArrayLike(o, l, p); - }), - (i.prototype.toArray = function (l, p) { - return this.toArrayLike(Array, l, p); - }), - (i.prototype.toArrayLike = function (l, p, y) { - var d = this.byteLength(), - v = y || Math.max(1, d); - r(d <= v, "byte array longer than desired length"), - r(v > 0, "Requested array length <= 0"), - this.strip(); - var _ = p === "le", - S = new l(v), - b, - f, - x = this.clone(); - if (_) { - for (f = 0; !x.isZero(); f++) - (b = x.andln(255)), x.iushrn(8), (S[f] = b); - for (; f < v; f++) S[f] = 0; - } else { - for (f = 0; f < v - d; f++) S[f] = 0; - for (f = 0; !x.isZero(); f++) - (b = x.andln(255)), x.iushrn(8), (S[v - f - 1] = b); - } - return S; - }), - Math.clz32 - ? (i.prototype._countBits = function (l) { - return 32 - Math.clz32(l); - }) - : (i.prototype._countBits = function (l) { - var p = l, - y = 0; - return ( - p >= 4096 && ((y += 13), (p >>>= 13)), - p >= 64 && ((y += 7), (p >>>= 7)), - p >= 8 && ((y += 4), (p >>>= 4)), - p >= 2 && ((y += 2), (p >>>= 2)), - y + p - ); - }), - (i.prototype._zeroBits = function (l) { - if (l === 0) return 26; - var p = l, - y = 0; - return ( - (p & 8191) === 0 && ((y += 13), (p >>>= 13)), - (p & 127) === 0 && ((y += 7), (p >>>= 7)), - (p & 15) === 0 && ((y += 4), (p >>>= 4)), - (p & 3) === 0 && ((y += 2), (p >>>= 2)), - (p & 1) === 0 && y++, - y - ); - }), - (i.prototype.bitLength = function () { - var l = this.words[this.length - 1], - p = this._countBits(l); - return (this.length - 1) * 26 + p; - }); - function M(A) { - for (var l = new Array(A.bitLength()), p = 0; p < l.length; p++) { - var y = (p / 26) | 0, - d = p % 26; - l[p] = (A.words[y] & (1 << d)) >>> d; - } - return l; - } - (i.prototype.zeroBits = function () { - if (this.isZero()) return 0; - for (var l = 0, p = 0; p < this.length; p++) { - var y = this._zeroBits(this.words[p]); - if (((l += y), y !== 26)) break; - } - return l; - }), - (i.prototype.byteLength = function () { - return Math.ceil(this.bitLength() / 8); - }), - (i.prototype.toTwos = function (l) { - return this.negative !== 0 - ? this.abs().inotn(l).iaddn(1) - : this.clone(); - }), - (i.prototype.fromTwos = function (l) { - return this.testn(l - 1) - ? this.notn(l).iaddn(1).ineg() - : this.clone(); - }), - (i.prototype.isNeg = function () { - return this.negative !== 0; - }), - (i.prototype.neg = function () { - return this.clone().ineg(); - }), - (i.prototype.ineg = function () { - return this.isZero() || (this.negative ^= 1), this; - }), - (i.prototype.iuor = function (l) { - for (; this.length < l.length; ) this.words[this.length++] = 0; - for (var p = 0; p < l.length; p++) - this.words[p] = this.words[p] | l.words[p]; - return this.strip(); - }), - (i.prototype.ior = function (l) { - return r((this.negative | l.negative) === 0), this.iuor(l); - }), - (i.prototype.or = function (l) { - return this.length > l.length - ? this.clone().ior(l) - : l.clone().ior(this); - }), - (i.prototype.uor = function (l) { - return this.length > l.length - ? this.clone().iuor(l) - : l.clone().iuor(this); - }), - (i.prototype.iuand = function (l) { - var p; - this.length > l.length ? (p = l) : (p = this); - for (var y = 0; y < p.length; y++) - this.words[y] = this.words[y] & l.words[y]; - return (this.length = p.length), this.strip(); - }), - (i.prototype.iand = function (l) { - return r((this.negative | l.negative) === 0), this.iuand(l); - }), - (i.prototype.and = function (l) { - return this.length > l.length - ? this.clone().iand(l) - : l.clone().iand(this); - }), - (i.prototype.uand = function (l) { - return this.length > l.length - ? this.clone().iuand(l) - : l.clone().iuand(this); - }), - (i.prototype.iuxor = function (l) { - var p, y; - this.length > l.length - ? ((p = this), (y = l)) - : ((p = l), (y = this)); - for (var d = 0; d < y.length; d++) - this.words[d] = p.words[d] ^ y.words[d]; - if (this !== p) for (; d < p.length; d++) this.words[d] = p.words[d]; - return (this.length = p.length), this.strip(); - }), - (i.prototype.ixor = function (l) { - return r((this.negative | l.negative) === 0), this.iuxor(l); - }), - (i.prototype.xor = function (l) { - return this.length > l.length - ? this.clone().ixor(l) - : l.clone().ixor(this); - }), - (i.prototype.uxor = function (l) { - return this.length > l.length - ? this.clone().iuxor(l) - : l.clone().iuxor(this); - }), - (i.prototype.inotn = function (l) { - r(typeof l == "number" && l >= 0); - var p = Math.ceil(l / 26) | 0, - y = l % 26; - this._expand(p), y > 0 && p--; - for (var d = 0; d < p; d++) this.words[d] = ~this.words[d] & 67108863; - return ( - y > 0 && (this.words[d] = ~this.words[d] & (67108863 >> (26 - y))), - this.strip() - ); - }), - (i.prototype.notn = function (l) { - return this.clone().inotn(l); - }), - (i.prototype.setn = function (l, p) { - r(typeof l == "number" && l >= 0); - var y = (l / 26) | 0, - d = l % 26; - return ( - this._expand(y + 1), - p - ? (this.words[y] = this.words[y] | (1 << d)) - : (this.words[y] = this.words[y] & ~(1 << d)), - this.strip() - ); - }), - (i.prototype.iadd = function (l) { - var p; - if (this.negative !== 0 && l.negative === 0) - return ( - (this.negative = 0), - (p = this.isub(l)), - (this.negative ^= 1), - this._normSign() - ); - if (this.negative === 0 && l.negative !== 0) - return ( - (l.negative = 0), - (p = this.isub(l)), - (l.negative = 1), - p._normSign() - ); - var y, d; - this.length > l.length - ? ((y = this), (d = l)) - : ((y = l), (d = this)); - for (var v = 0, _ = 0; _ < d.length; _++) - (p = (y.words[_] | 0) + (d.words[_] | 0) + v), - (this.words[_] = p & 67108863), - (v = p >>> 26); - for (; v !== 0 && _ < y.length; _++) - (p = (y.words[_] | 0) + v), - (this.words[_] = p & 67108863), - (v = p >>> 26); - if (((this.length = y.length), v !== 0)) - (this.words[this.length] = v), this.length++; - else if (y !== this) - for (; _ < y.length; _++) this.words[_] = y.words[_]; - return this; - }), - (i.prototype.add = function (l) { - var p; - return l.negative !== 0 && this.negative === 0 - ? ((l.negative = 0), (p = this.sub(l)), (l.negative ^= 1), p) - : l.negative === 0 && this.negative !== 0 - ? ((this.negative = 0), (p = l.sub(this)), (this.negative = 1), p) - : this.length > l.length - ? this.clone().iadd(l) - : l.clone().iadd(this); - }), - (i.prototype.isub = function (l) { - if (l.negative !== 0) { - l.negative = 0; - var p = this.iadd(l); - return (l.negative = 1), p._normSign(); - } else if (this.negative !== 0) - return ( - (this.negative = 0), - this.iadd(l), - (this.negative = 1), - this._normSign() - ); - var y = this.cmp(l); - if (y === 0) - return ( - (this.negative = 0), (this.length = 1), (this.words[0] = 0), this - ); - var d, v; - y > 0 ? ((d = this), (v = l)) : ((d = l), (v = this)); - for (var _ = 0, S = 0; S < v.length; S++) - (p = (d.words[S] | 0) - (v.words[S] | 0) + _), - (_ = p >> 26), - (this.words[S] = p & 67108863); - for (; _ !== 0 && S < d.length; S++) - (p = (d.words[S] | 0) + _), - (_ = p >> 26), - (this.words[S] = p & 67108863); - if (_ === 0 && S < d.length && d !== this) - for (; S < d.length; S++) this.words[S] = d.words[S]; - return ( - (this.length = Math.max(this.length, S)), - d !== this && (this.negative = 1), - this.strip() - ); - }), - (i.prototype.sub = function (l) { - return this.clone().isub(l); - }); - function k(A, l, p) { - p.negative = l.negative ^ A.negative; - var y = (A.length + l.length) | 0; - (p.length = y), (y = (y - 1) | 0); - var d = A.words[0] | 0, - v = l.words[0] | 0, - _ = d * v, - S = _ & 67108863, - b = (_ / 67108864) | 0; - p.words[0] = S; - for (var f = 1; f < y; f++) { - for ( - var x = b >>> 26, - C = b & 67108863, - E = Math.min(f, l.length - 1), - B = Math.max(0, f - A.length + 1); - B <= E; - B++ - ) { - var G = (f - B) | 0; - (d = A.words[G] | 0), - (v = l.words[B] | 0), - (_ = d * v + C), - (x += (_ / 67108864) | 0), - (C = _ & 67108863); - } - (p.words[f] = C | 0), (b = x | 0); - } - return b !== 0 ? (p.words[f] = b | 0) : p.length--, p.strip(); - } - var O = function (l, p, y) { - var d = l.words, - v = p.words, - _ = y.words, - S = 0, - b, - f, - x, - C = d[0] | 0, - E = C & 8191, - B = C >>> 13, - G = d[1] | 0, - L = G & 8191, - ee = G >>> 13, - ge = d[2] | 0, - fe = ge & 8191, - V = ge >>> 13, - ye = d[3] | 0, - ae = ye & 8191, - le = ye >>> 13, - Me = d[4] | 0, - de = Me & 8191, - ve = Me >>> 13, - De = d[5] | 0, - me = De & 8191, - _e = De >>> 13, - Ye = d[6] | 0, - Ee = Ye & 8191, - Be = Ye >>> 13, - kt = d[7] | 0, - Ve = kt & 8191, - We = kt >>> 13, - er = d[8] | 0, - Ue = er & 8191, - Y = er >>> 13, - W = d[9] | 0, - j = W & 8191, - ce = W >>> 13, - ze = v[0] | 0, - we = ze & 8191, - xe = ze >>> 13, - Ft = v[1] | 0, - Ke = Ft & 8191, - pe = Ft >>> 13, - Re = v[2] | 0, - Se = Re & 8191, - Pe = Re >>> 13, - At = v[3] | 0, - Ie = At & 8191, - je = At >>> 13, - qt = v[4] | 0, - Fe = qt & 8191, - He = qt >>> 13, - lr = v[5] | 0, - Xe = lr & 8191, - Ze = lr >>> 13, - Ir = v[6] | 0, - $e = Ir & 8191, - tt = Ir >>> 13, - oe = v[7] | 0, - ie = oe & 8191, - re = oe >>> 13, - U = v[8] | 0, - se = U & 8191, - be = U >>> 13, - Qe = v[9] | 0, - Ae = Qe & 8191, - ke = Qe >>> 13; - (y.negative = l.negative ^ p.negative), - (y.length = 19), - (b = Math.imul(E, we)), - (f = Math.imul(E, xe)), - (f = (f + Math.imul(B, we)) | 0), - (x = Math.imul(B, xe)); - var Ct = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ct >>> 26)) | 0), - (Ct &= 67108863), - (b = Math.imul(L, we)), - (f = Math.imul(L, xe)), - (f = (f + Math.imul(ee, we)) | 0), - (x = Math.imul(ee, xe)), - (b = (b + Math.imul(E, Ke)) | 0), - (f = (f + Math.imul(E, pe)) | 0), - (f = (f + Math.imul(B, Ke)) | 0), - (x = (x + Math.imul(B, pe)) | 0); - var ut = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (ut >>> 26)) | 0), - (ut &= 67108863), - (b = Math.imul(fe, we)), - (f = Math.imul(fe, xe)), - (f = (f + Math.imul(V, we)) | 0), - (x = Math.imul(V, xe)), - (b = (b + Math.imul(L, Ke)) | 0), - (f = (f + Math.imul(L, pe)) | 0), - (f = (f + Math.imul(ee, Ke)) | 0), - (x = (x + Math.imul(ee, pe)) | 0), - (b = (b + Math.imul(E, Se)) | 0), - (f = (f + Math.imul(E, Pe)) | 0), - (f = (f + Math.imul(B, Se)) | 0), - (x = (x + Math.imul(B, Pe)) | 0); - var St = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (St >>> 26)) | 0), - (St &= 67108863), - (b = Math.imul(ae, we)), - (f = Math.imul(ae, xe)), - (f = (f + Math.imul(le, we)) | 0), - (x = Math.imul(le, xe)), - (b = (b + Math.imul(fe, Ke)) | 0), - (f = (f + Math.imul(fe, pe)) | 0), - (f = (f + Math.imul(V, Ke)) | 0), - (x = (x + Math.imul(V, pe)) | 0), - (b = (b + Math.imul(L, Se)) | 0), - (f = (f + Math.imul(L, Pe)) | 0), - (f = (f + Math.imul(ee, Se)) | 0), - (x = (x + Math.imul(ee, Pe)) | 0), - (b = (b + Math.imul(E, Ie)) | 0), - (f = (f + Math.imul(E, je)) | 0), - (f = (f + Math.imul(B, Ie)) | 0), - (x = (x + Math.imul(B, je)) | 0); - var wt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (wt >>> 26)) | 0), - (wt &= 67108863), - (b = Math.imul(de, we)), - (f = Math.imul(de, xe)), - (f = (f + Math.imul(ve, we)) | 0), - (x = Math.imul(ve, xe)), - (b = (b + Math.imul(ae, Ke)) | 0), - (f = (f + Math.imul(ae, pe)) | 0), - (f = (f + Math.imul(le, Ke)) | 0), - (x = (x + Math.imul(le, pe)) | 0), - (b = (b + Math.imul(fe, Se)) | 0), - (f = (f + Math.imul(fe, Pe)) | 0), - (f = (f + Math.imul(V, Se)) | 0), - (x = (x + Math.imul(V, Pe)) | 0), - (b = (b + Math.imul(L, Ie)) | 0), - (f = (f + Math.imul(L, je)) | 0), - (f = (f + Math.imul(ee, Ie)) | 0), - (x = (x + Math.imul(ee, je)) | 0), - (b = (b + Math.imul(E, Fe)) | 0), - (f = (f + Math.imul(E, He)) | 0), - (f = (f + Math.imul(B, Fe)) | 0), - (x = (x + Math.imul(B, He)) | 0); - var zt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (zt >>> 26)) | 0), - (zt &= 67108863), - (b = Math.imul(me, we)), - (f = Math.imul(me, xe)), - (f = (f + Math.imul(_e, we)) | 0), - (x = Math.imul(_e, xe)), - (b = (b + Math.imul(de, Ke)) | 0), - (f = (f + Math.imul(de, pe)) | 0), - (f = (f + Math.imul(ve, Ke)) | 0), - (x = (x + Math.imul(ve, pe)) | 0), - (b = (b + Math.imul(ae, Se)) | 0), - (f = (f + Math.imul(ae, Pe)) | 0), - (f = (f + Math.imul(le, Se)) | 0), - (x = (x + Math.imul(le, Pe)) | 0), - (b = (b + Math.imul(fe, Ie)) | 0), - (f = (f + Math.imul(fe, je)) | 0), - (f = (f + Math.imul(V, Ie)) | 0), - (x = (x + Math.imul(V, je)) | 0), - (b = (b + Math.imul(L, Fe)) | 0), - (f = (f + Math.imul(L, He)) | 0), - (f = (f + Math.imul(ee, Fe)) | 0), - (x = (x + Math.imul(ee, He)) | 0), - (b = (b + Math.imul(E, Xe)) | 0), - (f = (f + Math.imul(E, Ze)) | 0), - (f = (f + Math.imul(B, Xe)) | 0), - (x = (x + Math.imul(B, Ze)) | 0); - var jt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (jt >>> 26)) | 0), - (jt &= 67108863), - (b = Math.imul(Ee, we)), - (f = Math.imul(Ee, xe)), - (f = (f + Math.imul(Be, we)) | 0), - (x = Math.imul(Be, xe)), - (b = (b + Math.imul(me, Ke)) | 0), - (f = (f + Math.imul(me, pe)) | 0), - (f = (f + Math.imul(_e, Ke)) | 0), - (x = (x + Math.imul(_e, pe)) | 0), - (b = (b + Math.imul(de, Se)) | 0), - (f = (f + Math.imul(de, Pe)) | 0), - (f = (f + Math.imul(ve, Se)) | 0), - (x = (x + Math.imul(ve, Pe)) | 0), - (b = (b + Math.imul(ae, Ie)) | 0), - (f = (f + Math.imul(ae, je)) | 0), - (f = (f + Math.imul(le, Ie)) | 0), - (x = (x + Math.imul(le, je)) | 0), - (b = (b + Math.imul(fe, Fe)) | 0), - (f = (f + Math.imul(fe, He)) | 0), - (f = (f + Math.imul(V, Fe)) | 0), - (x = (x + Math.imul(V, He)) | 0), - (b = (b + Math.imul(L, Xe)) | 0), - (f = (f + Math.imul(L, Ze)) | 0), - (f = (f + Math.imul(ee, Xe)) | 0), - (x = (x + Math.imul(ee, Ze)) | 0), - (b = (b + Math.imul(E, $e)) | 0), - (f = (f + Math.imul(E, tt)) | 0), - (f = (f + Math.imul(B, $e)) | 0), - (x = (x + Math.imul(B, tt)) | 0); - var Ht = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ht >>> 26)) | 0), - (Ht &= 67108863), - (b = Math.imul(Ve, we)), - (f = Math.imul(Ve, xe)), - (f = (f + Math.imul(We, we)) | 0), - (x = Math.imul(We, xe)), - (b = (b + Math.imul(Ee, Ke)) | 0), - (f = (f + Math.imul(Ee, pe)) | 0), - (f = (f + Math.imul(Be, Ke)) | 0), - (x = (x + Math.imul(Be, pe)) | 0), - (b = (b + Math.imul(me, Se)) | 0), - (f = (f + Math.imul(me, Pe)) | 0), - (f = (f + Math.imul(_e, Se)) | 0), - (x = (x + Math.imul(_e, Pe)) | 0), - (b = (b + Math.imul(de, Ie)) | 0), - (f = (f + Math.imul(de, je)) | 0), - (f = (f + Math.imul(ve, Ie)) | 0), - (x = (x + Math.imul(ve, je)) | 0), - (b = (b + Math.imul(ae, Fe)) | 0), - (f = (f + Math.imul(ae, He)) | 0), - (f = (f + Math.imul(le, Fe)) | 0), - (x = (x + Math.imul(le, He)) | 0), - (b = (b + Math.imul(fe, Xe)) | 0), - (f = (f + Math.imul(fe, Ze)) | 0), - (f = (f + Math.imul(V, Xe)) | 0), - (x = (x + Math.imul(V, Ze)) | 0), - (b = (b + Math.imul(L, $e)) | 0), - (f = (f + Math.imul(L, tt)) | 0), - (f = (f + Math.imul(ee, $e)) | 0), - (x = (x + Math.imul(ee, tt)) | 0), - (b = (b + Math.imul(E, ie)) | 0), - (f = (f + Math.imul(E, re)) | 0), - (f = (f + Math.imul(B, ie)) | 0), - (x = (x + Math.imul(B, re)) | 0); - var Ut = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ut >>> 26)) | 0), - (Ut &= 67108863), - (b = Math.imul(Ue, we)), - (f = Math.imul(Ue, xe)), - (f = (f + Math.imul(Y, we)) | 0), - (x = Math.imul(Y, xe)), - (b = (b + Math.imul(Ve, Ke)) | 0), - (f = (f + Math.imul(Ve, pe)) | 0), - (f = (f + Math.imul(We, Ke)) | 0), - (x = (x + Math.imul(We, pe)) | 0), - (b = (b + Math.imul(Ee, Se)) | 0), - (f = (f + Math.imul(Ee, Pe)) | 0), - (f = (f + Math.imul(Be, Se)) | 0), - (x = (x + Math.imul(Be, Pe)) | 0), - (b = (b + Math.imul(me, Ie)) | 0), - (f = (f + Math.imul(me, je)) | 0), - (f = (f + Math.imul(_e, Ie)) | 0), - (x = (x + Math.imul(_e, je)) | 0), - (b = (b + Math.imul(de, Fe)) | 0), - (f = (f + Math.imul(de, He)) | 0), - (f = (f + Math.imul(ve, Fe)) | 0), - (x = (x + Math.imul(ve, He)) | 0), - (b = (b + Math.imul(ae, Xe)) | 0), - (f = (f + Math.imul(ae, Ze)) | 0), - (f = (f + Math.imul(le, Xe)) | 0), - (x = (x + Math.imul(le, Ze)) | 0), - (b = (b + Math.imul(fe, $e)) | 0), - (f = (f + Math.imul(fe, tt)) | 0), - (f = (f + Math.imul(V, $e)) | 0), - (x = (x + Math.imul(V, tt)) | 0), - (b = (b + Math.imul(L, ie)) | 0), - (f = (f + Math.imul(L, re)) | 0), - (f = (f + Math.imul(ee, ie)) | 0), - (x = (x + Math.imul(ee, re)) | 0), - (b = (b + Math.imul(E, se)) | 0), - (f = (f + Math.imul(E, be)) | 0), - (f = (f + Math.imul(B, se)) | 0), - (x = (x + Math.imul(B, be)) | 0); - var Kt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Kt >>> 26)) | 0), - (Kt &= 67108863), - (b = Math.imul(j, we)), - (f = Math.imul(j, xe)), - (f = (f + Math.imul(ce, we)) | 0), - (x = Math.imul(ce, xe)), - (b = (b + Math.imul(Ue, Ke)) | 0), - (f = (f + Math.imul(Ue, pe)) | 0), - (f = (f + Math.imul(Y, Ke)) | 0), - (x = (x + Math.imul(Y, pe)) | 0), - (b = (b + Math.imul(Ve, Se)) | 0), - (f = (f + Math.imul(Ve, Pe)) | 0), - (f = (f + Math.imul(We, Se)) | 0), - (x = (x + Math.imul(We, Pe)) | 0), - (b = (b + Math.imul(Ee, Ie)) | 0), - (f = (f + Math.imul(Ee, je)) | 0), - (f = (f + Math.imul(Be, Ie)) | 0), - (x = (x + Math.imul(Be, je)) | 0), - (b = (b + Math.imul(me, Fe)) | 0), - (f = (f + Math.imul(me, He)) | 0), - (f = (f + Math.imul(_e, Fe)) | 0), - (x = (x + Math.imul(_e, He)) | 0), - (b = (b + Math.imul(de, Xe)) | 0), - (f = (f + Math.imul(de, Ze)) | 0), - (f = (f + Math.imul(ve, Xe)) | 0), - (x = (x + Math.imul(ve, Ze)) | 0), - (b = (b + Math.imul(ae, $e)) | 0), - (f = (f + Math.imul(ae, tt)) | 0), - (f = (f + Math.imul(le, $e)) | 0), - (x = (x + Math.imul(le, tt)) | 0), - (b = (b + Math.imul(fe, ie)) | 0), - (f = (f + Math.imul(fe, re)) | 0), - (f = (f + Math.imul(V, ie)) | 0), - (x = (x + Math.imul(V, re)) | 0), - (b = (b + Math.imul(L, se)) | 0), - (f = (f + Math.imul(L, be)) | 0), - (f = (f + Math.imul(ee, se)) | 0), - (x = (x + Math.imul(ee, be)) | 0), - (b = (b + Math.imul(E, Ae)) | 0), - (f = (f + Math.imul(E, ke)) | 0), - (f = (f + Math.imul(B, Ae)) | 0), - (x = (x + Math.imul(B, ke)) | 0); - var Ot = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ot >>> 26)) | 0), - (Ot &= 67108863), - (b = Math.imul(j, Ke)), - (f = Math.imul(j, pe)), - (f = (f + Math.imul(ce, Ke)) | 0), - (x = Math.imul(ce, pe)), - (b = (b + Math.imul(Ue, Se)) | 0), - (f = (f + Math.imul(Ue, Pe)) | 0), - (f = (f + Math.imul(Y, Se)) | 0), - (x = (x + Math.imul(Y, Pe)) | 0), - (b = (b + Math.imul(Ve, Ie)) | 0), - (f = (f + Math.imul(Ve, je)) | 0), - (f = (f + Math.imul(We, Ie)) | 0), - (x = (x + Math.imul(We, je)) | 0), - (b = (b + Math.imul(Ee, Fe)) | 0), - (f = (f + Math.imul(Ee, He)) | 0), - (f = (f + Math.imul(Be, Fe)) | 0), - (x = (x + Math.imul(Be, He)) | 0), - (b = (b + Math.imul(me, Xe)) | 0), - (f = (f + Math.imul(me, Ze)) | 0), - (f = (f + Math.imul(_e, Xe)) | 0), - (x = (x + Math.imul(_e, Ze)) | 0), - (b = (b + Math.imul(de, $e)) | 0), - (f = (f + Math.imul(de, tt)) | 0), - (f = (f + Math.imul(ve, $e)) | 0), - (x = (x + Math.imul(ve, tt)) | 0), - (b = (b + Math.imul(ae, ie)) | 0), - (f = (f + Math.imul(ae, re)) | 0), - (f = (f + Math.imul(le, ie)) | 0), - (x = (x + Math.imul(le, re)) | 0), - (b = (b + Math.imul(fe, se)) | 0), - (f = (f + Math.imul(fe, be)) | 0), - (f = (f + Math.imul(V, se)) | 0), - (x = (x + Math.imul(V, be)) | 0), - (b = (b + Math.imul(L, Ae)) | 0), - (f = (f + Math.imul(L, ke)) | 0), - (f = (f + Math.imul(ee, Ae)) | 0), - (x = (x + Math.imul(ee, ke)) | 0); - var Bt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Bt >>> 26)) | 0), - (Bt &= 67108863), - (b = Math.imul(j, Se)), - (f = Math.imul(j, Pe)), - (f = (f + Math.imul(ce, Se)) | 0), - (x = Math.imul(ce, Pe)), - (b = (b + Math.imul(Ue, Ie)) | 0), - (f = (f + Math.imul(Ue, je)) | 0), - (f = (f + Math.imul(Y, Ie)) | 0), - (x = (x + Math.imul(Y, je)) | 0), - (b = (b + Math.imul(Ve, Fe)) | 0), - (f = (f + Math.imul(Ve, He)) | 0), - (f = (f + Math.imul(We, Fe)) | 0), - (x = (x + Math.imul(We, He)) | 0), - (b = (b + Math.imul(Ee, Xe)) | 0), - (f = (f + Math.imul(Ee, Ze)) | 0), - (f = (f + Math.imul(Be, Xe)) | 0), - (x = (x + Math.imul(Be, Ze)) | 0), - (b = (b + Math.imul(me, $e)) | 0), - (f = (f + Math.imul(me, tt)) | 0), - (f = (f + Math.imul(_e, $e)) | 0), - (x = (x + Math.imul(_e, tt)) | 0), - (b = (b + Math.imul(de, ie)) | 0), - (f = (f + Math.imul(de, re)) | 0), - (f = (f + Math.imul(ve, ie)) | 0), - (x = (x + Math.imul(ve, re)) | 0), - (b = (b + Math.imul(ae, se)) | 0), - (f = (f + Math.imul(ae, be)) | 0), - (f = (f + Math.imul(le, se)) | 0), - (x = (x + Math.imul(le, be)) | 0), - (b = (b + Math.imul(fe, Ae)) | 0), - (f = (f + Math.imul(fe, ke)) | 0), - (f = (f + Math.imul(V, Ae)) | 0), - (x = (x + Math.imul(V, ke)) | 0); - var Et = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Et >>> 26)) | 0), - (Et &= 67108863), - (b = Math.imul(j, Ie)), - (f = Math.imul(j, je)), - (f = (f + Math.imul(ce, Ie)) | 0), - (x = Math.imul(ce, je)), - (b = (b + Math.imul(Ue, Fe)) | 0), - (f = (f + Math.imul(Ue, He)) | 0), - (f = (f + Math.imul(Y, Fe)) | 0), - (x = (x + Math.imul(Y, He)) | 0), - (b = (b + Math.imul(Ve, Xe)) | 0), - (f = (f + Math.imul(Ve, Ze)) | 0), - (f = (f + Math.imul(We, Xe)) | 0), - (x = (x + Math.imul(We, Ze)) | 0), - (b = (b + Math.imul(Ee, $e)) | 0), - (f = (f + Math.imul(Ee, tt)) | 0), - (f = (f + Math.imul(Be, $e)) | 0), - (x = (x + Math.imul(Be, tt)) | 0), - (b = (b + Math.imul(me, ie)) | 0), - (f = (f + Math.imul(me, re)) | 0), - (f = (f + Math.imul(_e, ie)) | 0), - (x = (x + Math.imul(_e, re)) | 0), - (b = (b + Math.imul(de, se)) | 0), - (f = (f + Math.imul(de, be)) | 0), - (f = (f + Math.imul(ve, se)) | 0), - (x = (x + Math.imul(ve, be)) | 0), - (b = (b + Math.imul(ae, Ae)) | 0), - (f = (f + Math.imul(ae, ke)) | 0), - (f = (f + Math.imul(le, Ae)) | 0), - (x = (x + Math.imul(le, ke)) | 0); - var Mt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Mt >>> 26)) | 0), - (Mt &= 67108863), - (b = Math.imul(j, Fe)), - (f = Math.imul(j, He)), - (f = (f + Math.imul(ce, Fe)) | 0), - (x = Math.imul(ce, He)), - (b = (b + Math.imul(Ue, Xe)) | 0), - (f = (f + Math.imul(Ue, Ze)) | 0), - (f = (f + Math.imul(Y, Xe)) | 0), - (x = (x + Math.imul(Y, Ze)) | 0), - (b = (b + Math.imul(Ve, $e)) | 0), - (f = (f + Math.imul(Ve, tt)) | 0), - (f = (f + Math.imul(We, $e)) | 0), - (x = (x + Math.imul(We, tt)) | 0), - (b = (b + Math.imul(Ee, ie)) | 0), - (f = (f + Math.imul(Ee, re)) | 0), - (f = (f + Math.imul(Be, ie)) | 0), - (x = (x + Math.imul(Be, re)) | 0), - (b = (b + Math.imul(me, se)) | 0), - (f = (f + Math.imul(me, be)) | 0), - (f = (f + Math.imul(_e, se)) | 0), - (x = (x + Math.imul(_e, be)) | 0), - (b = (b + Math.imul(de, Ae)) | 0), - (f = (f + Math.imul(de, ke)) | 0), - (f = (f + Math.imul(ve, Ae)) | 0), - (x = (x + Math.imul(ve, ke)) | 0); - var gt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (gt >>> 26)) | 0), - (gt &= 67108863), - (b = Math.imul(j, Xe)), - (f = Math.imul(j, Ze)), - (f = (f + Math.imul(ce, Xe)) | 0), - (x = Math.imul(ce, Ze)), - (b = (b + Math.imul(Ue, $e)) | 0), - (f = (f + Math.imul(Ue, tt)) | 0), - (f = (f + Math.imul(Y, $e)) | 0), - (x = (x + Math.imul(Y, tt)) | 0), - (b = (b + Math.imul(Ve, ie)) | 0), - (f = (f + Math.imul(Ve, re)) | 0), - (f = (f + Math.imul(We, ie)) | 0), - (x = (x + Math.imul(We, re)) | 0), - (b = (b + Math.imul(Ee, se)) | 0), - (f = (f + Math.imul(Ee, be)) | 0), - (f = (f + Math.imul(Be, se)) | 0), - (x = (x + Math.imul(Be, be)) | 0), - (b = (b + Math.imul(me, Ae)) | 0), - (f = (f + Math.imul(me, ke)) | 0), - (f = (f + Math.imul(_e, Ae)) | 0), - (x = (x + Math.imul(_e, ke)) | 0); - var Pt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Pt >>> 26)) | 0), - (Pt &= 67108863), - (b = Math.imul(j, $e)), - (f = Math.imul(j, tt)), - (f = (f + Math.imul(ce, $e)) | 0), - (x = Math.imul(ce, tt)), - (b = (b + Math.imul(Ue, ie)) | 0), - (f = (f + Math.imul(Ue, re)) | 0), - (f = (f + Math.imul(Y, ie)) | 0), - (x = (x + Math.imul(Y, re)) | 0), - (b = (b + Math.imul(Ve, se)) | 0), - (f = (f + Math.imul(Ve, be)) | 0), - (f = (f + Math.imul(We, se)) | 0), - (x = (x + Math.imul(We, be)) | 0), - (b = (b + Math.imul(Ee, Ae)) | 0), - (f = (f + Math.imul(Ee, ke)) | 0), - (f = (f + Math.imul(Be, Ae)) | 0), - (x = (x + Math.imul(Be, ke)) | 0); - var It = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (It >>> 26)) | 0), - (It &= 67108863), - (b = Math.imul(j, ie)), - (f = Math.imul(j, re)), - (f = (f + Math.imul(ce, ie)) | 0), - (x = Math.imul(ce, re)), - (b = (b + Math.imul(Ue, se)) | 0), - (f = (f + Math.imul(Ue, be)) | 0), - (f = (f + Math.imul(Y, se)) | 0), - (x = (x + Math.imul(Y, be)) | 0), - (b = (b + Math.imul(Ve, Ae)) | 0), - (f = (f + Math.imul(Ve, ke)) | 0), - (f = (f + Math.imul(We, Ae)) | 0), - (x = (x + Math.imul(We, ke)) | 0); - var yt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (yt >>> 26)) | 0), - (yt &= 67108863), - (b = Math.imul(j, se)), - (f = Math.imul(j, be)), - (f = (f + Math.imul(ce, se)) | 0), - (x = Math.imul(ce, be)), - (b = (b + Math.imul(Ue, Ae)) | 0), - (f = (f + Math.imul(Ue, ke)) | 0), - (f = (f + Math.imul(Y, Ae)) | 0), - (x = (x + Math.imul(Y, ke)) | 0); - var nt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (nt >>> 26)) | 0), - (nt &= 67108863), - (b = Math.imul(j, Ae)), - (f = Math.imul(j, ke)), - (f = (f + Math.imul(ce, Ae)) | 0), - (x = Math.imul(ce, ke)); - var it = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - return ( - (S = (((x + (f >>> 13)) | 0) + (it >>> 26)) | 0), - (it &= 67108863), - (_[0] = Ct), - (_[1] = ut), - (_[2] = St), - (_[3] = wt), - (_[4] = zt), - (_[5] = jt), - (_[6] = Ht), - (_[7] = Ut), - (_[8] = Kt), - (_[9] = Ot), - (_[10] = Bt), - (_[11] = Et), - (_[12] = Mt), - (_[13] = gt), - (_[14] = Pt), - (_[15] = It), - (_[16] = yt), - (_[17] = nt), - (_[18] = it), - S !== 0 && ((_[19] = S), y.length++), - y - ); - }; - Math.imul || (O = k); - function D(A, l, p) { - (p.negative = l.negative ^ A.negative), - (p.length = A.length + l.length); - for (var y = 0, d = 0, v = 0; v < p.length - 1; v++) { - var _ = d; - d = 0; - for ( - var S = y & 67108863, - b = Math.min(v, l.length - 1), - f = Math.max(0, v - A.length + 1); - f <= b; - f++ - ) { - var x = v - f, - C = A.words[x] | 0, - E = l.words[f] | 0, - B = C * E, - G = B & 67108863; - (_ = (_ + ((B / 67108864) | 0)) | 0), - (G = (G + S) | 0), - (S = G & 67108863), - (_ = (_ + (G >>> 26)) | 0), - (d += _ >>> 26), - (_ &= 67108863); - } - (p.words[v] = S), (y = _), (_ = d); - } - return y !== 0 ? (p.words[v] = y) : p.length--, p.strip(); - } - function F(A, l, p) { - var y = new N(); - return y.mulp(A, l, p); - } - i.prototype.mulTo = function (l, p) { - var y, - d = this.length + l.length; - return ( - this.length === 10 && l.length === 10 - ? (y = O(this, l, p)) - : d < 63 - ? (y = k(this, l, p)) - : d < 1024 - ? (y = D(this, l, p)) - : (y = F(this, l, p)), - y - ); - }; - function N(A, l) { - (this.x = A), (this.y = l); - } - (N.prototype.makeRBT = function (l) { - for ( - var p = new Array(l), y = i.prototype._countBits(l) - 1, d = 0; - d < l; - d++ - ) - p[d] = this.revBin(d, y, l); - return p; - }), - (N.prototype.revBin = function (l, p, y) { - if (l === 0 || l === y - 1) return l; - for (var d = 0, v = 0; v < p; v++) - (d |= (l & 1) << (p - v - 1)), (l >>= 1); - return d; - }), - (N.prototype.permute = function (l, p, y, d, v, _) { - for (var S = 0; S < _; S++) (d[S] = p[l[S]]), (v[S] = y[l[S]]); - }), - (N.prototype.transform = function (l, p, y, d, v, _) { - this.permute(_, l, p, y, d, v); - for (var S = 1; S < v; S <<= 1) - for ( - var b = S << 1, - f = Math.cos((2 * Math.PI) / b), - x = Math.sin((2 * Math.PI) / b), - C = 0; - C < v; - C += b - ) - for (var E = f, B = x, G = 0; G < S; G++) { - var L = y[C + G], - ee = d[C + G], - ge = y[C + G + S], - fe = d[C + G + S], - V = E * ge - B * fe; - (fe = E * fe + B * ge), - (ge = V), - (y[C + G] = L + ge), - (d[C + G] = ee + fe), - (y[C + G + S] = L - ge), - (d[C + G + S] = ee - fe), - G !== b && - ((V = f * E - x * B), (B = f * B + x * E), (E = V)); - } - }), - (N.prototype.guessLen13b = function (l, p) { - var y = Math.max(p, l) | 1, - d = y & 1, - v = 0; - for (y = (y / 2) | 0; y; y = y >>> 1) v++; - return 1 << (v + 1 + d); - }), - (N.prototype.conjugate = function (l, p, y) { - if (!(y <= 1)) - for (var d = 0; d < y / 2; d++) { - var v = l[d]; - (l[d] = l[y - d - 1]), - (l[y - d - 1] = v), - (v = p[d]), - (p[d] = -p[y - d - 1]), - (p[y - d - 1] = -v); - } - }), - (N.prototype.normalize13b = function (l, p) { - for (var y = 0, d = 0; d < p / 2; d++) { - var v = - Math.round(l[2 * d + 1] / p) * 8192 + - Math.round(l[2 * d] / p) + - y; - (l[d] = v & 67108863), - v < 67108864 ? (y = 0) : (y = (v / 67108864) | 0); - } - return l; - }), - (N.prototype.convert13b = function (l, p, y, d) { - for (var v = 0, _ = 0; _ < p; _++) - (v = v + (l[_] | 0)), - (y[2 * _] = v & 8191), - (v = v >>> 13), - (y[2 * _ + 1] = v & 8191), - (v = v >>> 13); - for (_ = 2 * p; _ < d; ++_) y[_] = 0; - r(v === 0), r((v & -8192) === 0); - }), - (N.prototype.stub = function (l) { - for (var p = new Array(l), y = 0; y < l; y++) p[y] = 0; - return p; - }), - (N.prototype.mulp = function (l, p, y) { - var d = 2 * this.guessLen13b(l.length, p.length), - v = this.makeRBT(d), - _ = this.stub(d), - S = new Array(d), - b = new Array(d), - f = new Array(d), - x = new Array(d), - C = new Array(d), - E = new Array(d), - B = y.words; - (B.length = d), - this.convert13b(l.words, l.length, S, d), - this.convert13b(p.words, p.length, x, d), - this.transform(S, _, b, f, d, v), - this.transform(x, _, C, E, d, v); - for (var G = 0; G < d; G++) { - var L = b[G] * C[G] - f[G] * E[G]; - (f[G] = b[G] * E[G] + f[G] * C[G]), (b[G] = L); - } - return ( - this.conjugate(b, f, d), - this.transform(b, f, B, _, d, v), - this.conjugate(B, _, d), - this.normalize13b(B, d), - (y.negative = l.negative ^ p.negative), - (y.length = l.length + p.length), - y.strip() - ); - }), - (i.prototype.mul = function (l) { - var p = new i(null); - return ( - (p.words = new Array(this.length + l.length)), this.mulTo(l, p) - ); - }), - (i.prototype.mulf = function (l) { - var p = new i(null); - return (p.words = new Array(this.length + l.length)), F(this, l, p); - }), - (i.prototype.imul = function (l) { - return this.clone().mulTo(l, this); - }), - (i.prototype.imuln = function (l) { - r(typeof l == "number"), r(l < 67108864); - for (var p = 0, y = 0; y < this.length; y++) { - var d = (this.words[y] | 0) * l, - v = (d & 67108863) + (p & 67108863); - (p >>= 26), - (p += (d / 67108864) | 0), - (p += v >>> 26), - (this.words[y] = v & 67108863); - } - return p !== 0 && ((this.words[y] = p), this.length++), this; - }), - (i.prototype.muln = function (l) { - return this.clone().imuln(l); - }), - (i.prototype.sqr = function () { - return this.mul(this); - }), - (i.prototype.isqr = function () { - return this.imul(this.clone()); - }), - (i.prototype.pow = function (l) { - var p = M(l); - if (p.length === 0) return new i(1); - for ( - var y = this, d = 0; - d < p.length && p[d] === 0; - d++, y = y.sqr() - ); - if (++d < p.length) - for (var v = y.sqr(); d < p.length; d++, v = v.sqr()) - p[d] !== 0 && (y = y.mul(v)); - return y; - }), - (i.prototype.iushln = function (l) { - r(typeof l == "number" && l >= 0); - var p = l % 26, - y = (l - p) / 26, - d = (67108863 >>> (26 - p)) << (26 - p), - v; - if (p !== 0) { - var _ = 0; - for (v = 0; v < this.length; v++) { - var S = this.words[v] & d, - b = ((this.words[v] | 0) - S) << p; - (this.words[v] = b | _), (_ = S >>> (26 - p)); - } - _ && ((this.words[v] = _), this.length++); - } - if (y !== 0) { - for (v = this.length - 1; v >= 0; v--) - this.words[v + y] = this.words[v]; - for (v = 0; v < y; v++) this.words[v] = 0; - this.length += y; - } - return this.strip(); - }), - (i.prototype.ishln = function (l) { - return r(this.negative === 0), this.iushln(l); - }), - (i.prototype.iushrn = function (l, p, y) { - r(typeof l == "number" && l >= 0); - var d; - p ? (d = (p - (p % 26)) / 26) : (d = 0); - var v = l % 26, - _ = Math.min((l - v) / 26, this.length), - S = 67108863 ^ ((67108863 >>> v) << v), - b = y; - if (((d -= _), (d = Math.max(0, d)), b)) { - for (var f = 0; f < _; f++) b.words[f] = this.words[f]; - b.length = _; - } - if (_ !== 0) - if (this.length > _) - for (this.length -= _, f = 0; f < this.length; f++) - this.words[f] = this.words[f + _]; - else (this.words[0] = 0), (this.length = 1); - var x = 0; - for (f = this.length - 1; f >= 0 && (x !== 0 || f >= d); f--) { - var C = this.words[f] | 0; - (this.words[f] = (x << (26 - v)) | (C >>> v)), (x = C & S); - } - return ( - b && x !== 0 && (b.words[b.length++] = x), - this.length === 0 && ((this.words[0] = 0), (this.length = 1)), - this.strip() - ); - }), - (i.prototype.ishrn = function (l, p, y) { - return r(this.negative === 0), this.iushrn(l, p, y); - }), - (i.prototype.shln = function (l) { - return this.clone().ishln(l); - }), - (i.prototype.ushln = function (l) { - return this.clone().iushln(l); - }), - (i.prototype.shrn = function (l) { - return this.clone().ishrn(l); - }), - (i.prototype.ushrn = function (l) { - return this.clone().iushrn(l); - }), - (i.prototype.testn = function (l) { - r(typeof l == "number" && l >= 0); - var p = l % 26, - y = (l - p) / 26, - d = 1 << p; - if (this.length <= y) return !1; - var v = this.words[y]; - return !!(v & d); - }), - (i.prototype.imaskn = function (l) { - r(typeof l == "number" && l >= 0); - var p = l % 26, - y = (l - p) / 26; - if ( - (r(this.negative === 0, "imaskn works only with positive numbers"), - this.length <= y) - ) - return this; - if ( - (p !== 0 && y++, (this.length = Math.min(y, this.length)), p !== 0) - ) { - var d = 67108863 ^ ((67108863 >>> p) << p); - this.words[this.length - 1] &= d; - } - return this.strip(); - }), - (i.prototype.maskn = function (l) { - return this.clone().imaskn(l); - }), - (i.prototype.iaddn = function (l) { - return ( - r(typeof l == "number"), - r(l < 67108864), - l < 0 - ? this.isubn(-l) - : this.negative !== 0 - ? this.length === 1 && (this.words[0] | 0) < l - ? ((this.words[0] = l - (this.words[0] | 0)), - (this.negative = 0), - this) - : ((this.negative = 0), - this.isubn(l), - (this.negative = 1), - this) - : this._iaddn(l) - ); - }), - (i.prototype._iaddn = function (l) { - this.words[0] += l; - for (var p = 0; p < this.length && this.words[p] >= 67108864; p++) - (this.words[p] -= 67108864), - p === this.length - 1 - ? (this.words[p + 1] = 1) - : this.words[p + 1]++; - return (this.length = Math.max(this.length, p + 1)), this; - }), - (i.prototype.isubn = function (l) { - if ((r(typeof l == "number"), r(l < 67108864), l < 0)) - return this.iaddn(-l); - if (this.negative !== 0) - return ( - (this.negative = 0), this.iaddn(l), (this.negative = 1), this - ); - if (((this.words[0] -= l), this.length === 1 && this.words[0] < 0)) - (this.words[0] = -this.words[0]), (this.negative = 1); - else - for (var p = 0; p < this.length && this.words[p] < 0; p++) - (this.words[p] += 67108864), (this.words[p + 1] -= 1); - return this.strip(); - }), - (i.prototype.addn = function (l) { - return this.clone().iaddn(l); - }), - (i.prototype.subn = function (l) { - return this.clone().isubn(l); - }), - (i.prototype.iabs = function () { - return (this.negative = 0), this; - }), - (i.prototype.abs = function () { - return this.clone().iabs(); - }), - (i.prototype._ishlnsubmul = function (l, p, y) { - var d = l.length + y, - v; - this._expand(d); - var _, - S = 0; - for (v = 0; v < l.length; v++) { - _ = (this.words[v + y] | 0) + S; - var b = (l.words[v] | 0) * p; - (_ -= b & 67108863), - (S = (_ >> 26) - ((b / 67108864) | 0)), - (this.words[v + y] = _ & 67108863); - } - for (; v < this.length - y; v++) - (_ = (this.words[v + y] | 0) + S), - (S = _ >> 26), - (this.words[v + y] = _ & 67108863); - if (S === 0) return this.strip(); - for (r(S === -1), S = 0, v = 0; v < this.length; v++) - (_ = -(this.words[v] | 0) + S), - (S = _ >> 26), - (this.words[v] = _ & 67108863); - return (this.negative = 1), this.strip(); - }), - (i.prototype._wordDiv = function (l, p) { - var y = this.length - l.length, - d = this.clone(), - v = l, - _ = v.words[v.length - 1] | 0, - S = this._countBits(_); - (y = 26 - S), - y !== 0 && - ((v = v.ushln(y)), d.iushln(y), (_ = v.words[v.length - 1] | 0)); - var b = d.length - v.length, - f; - if (p !== "mod") { - (f = new i(null)), - (f.length = b + 1), - (f.words = new Array(f.length)); - for (var x = 0; x < f.length; x++) f.words[x] = 0; - } - var C = d.clone()._ishlnsubmul(v, 1, b); - C.negative === 0 && ((d = C), f && (f.words[b] = 1)); - for (var E = b - 1; E >= 0; E--) { - var B = - (d.words[v.length + E] | 0) * 67108864 + - (d.words[v.length + E - 1] | 0); - for ( - B = Math.min((B / _) | 0, 67108863), d._ishlnsubmul(v, B, E); - d.negative !== 0; - - ) - B--, - (d.negative = 0), - d._ishlnsubmul(v, 1, E), - d.isZero() || (d.negative ^= 1); - f && (f.words[E] = B); - } - return ( - f && f.strip(), - d.strip(), - p !== "div" && y !== 0 && d.iushrn(y), - { div: f || null, mod: d } - ); - }), - (i.prototype.divmod = function (l, p, y) { - if ((r(!l.isZero()), this.isZero())) - return { div: new i(0), mod: new i(0) }; - var d, v, _; - return this.negative !== 0 && l.negative === 0 - ? ((_ = this.neg().divmod(l, p)), - p !== "mod" && (d = _.div.neg()), - p !== "div" && - ((v = _.mod.neg()), y && v.negative !== 0 && v.iadd(l)), - { div: d, mod: v }) - : this.negative === 0 && l.negative !== 0 - ? ((_ = this.divmod(l.neg(), p)), - p !== "mod" && (d = _.div.neg()), - { div: d, mod: _.mod }) - : (this.negative & l.negative) !== 0 - ? ((_ = this.neg().divmod(l.neg(), p)), - p !== "div" && - ((v = _.mod.neg()), y && v.negative !== 0 && v.isub(l)), - { div: _.div, mod: v }) - : l.length > this.length || this.cmp(l) < 0 - ? { div: new i(0), mod: this } - : l.length === 1 - ? p === "div" - ? { div: this.divn(l.words[0]), mod: null } - : p === "mod" - ? { div: null, mod: new i(this.modn(l.words[0])) } - : { - div: this.divn(l.words[0]), - mod: new i(this.modn(l.words[0])), - } - : this._wordDiv(l, p); - }), - (i.prototype.div = function (l) { - return this.divmod(l, "div", !1).div; - }), - (i.prototype.mod = function (l) { - return this.divmod(l, "mod", !1).mod; - }), - (i.prototype.umod = function (l) { - return this.divmod(l, "mod", !0).mod; - }), - (i.prototype.divRound = function (l) { - var p = this.divmod(l); - if (p.mod.isZero()) return p.div; - var y = p.div.negative !== 0 ? p.mod.isub(l) : p.mod, - d = l.ushrn(1), - v = l.andln(1), - _ = y.cmp(d); - return _ < 0 || (v === 1 && _ === 0) - ? p.div - : p.div.negative !== 0 - ? p.div.isubn(1) - : p.div.iaddn(1); - }), - (i.prototype.modn = function (l) { - r(l <= 67108863); - for (var p = (1 << 26) % l, y = 0, d = this.length - 1; d >= 0; d--) - y = (p * y + (this.words[d] | 0)) % l; - return y; - }), - (i.prototype.idivn = function (l) { - r(l <= 67108863); - for (var p = 0, y = this.length - 1; y >= 0; y--) { - var d = (this.words[y] | 0) + p * 67108864; - (this.words[y] = (d / l) | 0), (p = d % l); - } - return this.strip(); - }), - (i.prototype.divn = function (l) { - return this.clone().idivn(l); - }), - (i.prototype.egcd = function (l) { - r(l.negative === 0), r(!l.isZero()); - var p = this, - y = l.clone(); - p.negative !== 0 ? (p = p.umod(l)) : (p = p.clone()); - for ( - var d = new i(1), v = new i(0), _ = new i(0), S = new i(1), b = 0; - p.isEven() && y.isEven(); - - ) - p.iushrn(1), y.iushrn(1), ++b; - for (var f = y.clone(), x = p.clone(); !p.isZero(); ) { - for ( - var C = 0, E = 1; - (p.words[0] & E) === 0 && C < 26; - ++C, E <<= 1 - ); - if (C > 0) - for (p.iushrn(C); C-- > 0; ) - (d.isOdd() || v.isOdd()) && (d.iadd(f), v.isub(x)), - d.iushrn(1), - v.iushrn(1); - for ( - var B = 0, G = 1; - (y.words[0] & G) === 0 && B < 26; - ++B, G <<= 1 - ); - if (B > 0) - for (y.iushrn(B); B-- > 0; ) - (_.isOdd() || S.isOdd()) && (_.iadd(f), S.isub(x)), - _.iushrn(1), - S.iushrn(1); - p.cmp(y) >= 0 - ? (p.isub(y), d.isub(_), v.isub(S)) - : (y.isub(p), _.isub(d), S.isub(v)); - } - return { a: _, b: S, gcd: y.iushln(b) }; - }), - (i.prototype._invmp = function (l) { - r(l.negative === 0), r(!l.isZero()); - var p = this, - y = l.clone(); - p.negative !== 0 ? (p = p.umod(l)) : (p = p.clone()); - for ( - var d = new i(1), v = new i(0), _ = y.clone(); - p.cmpn(1) > 0 && y.cmpn(1) > 0; - - ) { - for ( - var S = 0, b = 1; - (p.words[0] & b) === 0 && S < 26; - ++S, b <<= 1 - ); - if (S > 0) - for (p.iushrn(S); S-- > 0; ) d.isOdd() && d.iadd(_), d.iushrn(1); - for ( - var f = 0, x = 1; - (y.words[0] & x) === 0 && f < 26; - ++f, x <<= 1 - ); - if (f > 0) - for (y.iushrn(f); f-- > 0; ) v.isOdd() && v.iadd(_), v.iushrn(1); - p.cmp(y) >= 0 ? (p.isub(y), d.isub(v)) : (y.isub(p), v.isub(d)); - } - var C; - return ( - p.cmpn(1) === 0 ? (C = d) : (C = v), C.cmpn(0) < 0 && C.iadd(l), C - ); - }), - (i.prototype.gcd = function (l) { - if (this.isZero()) return l.abs(); - if (l.isZero()) return this.abs(); - var p = this.clone(), - y = l.clone(); - (p.negative = 0), (y.negative = 0); - for (var d = 0; p.isEven() && y.isEven(); d++) - p.iushrn(1), y.iushrn(1); - do { - for (; p.isEven(); ) p.iushrn(1); - for (; y.isEven(); ) y.iushrn(1); - var v = p.cmp(y); - if (v < 0) { - var _ = p; - (p = y), (y = _); - } else if (v === 0 || y.cmpn(1) === 0) break; - p.isub(y); - } while (!0); - return y.iushln(d); - }), - (i.prototype.invm = function (l) { - return this.egcd(l).a.umod(l); - }), - (i.prototype.isEven = function () { - return (this.words[0] & 1) === 0; - }), - (i.prototype.isOdd = function () { - return (this.words[0] & 1) === 1; - }), - (i.prototype.andln = function (l) { - return this.words[0] & l; - }), - (i.prototype.bincn = function (l) { - r(typeof l == "number"); - var p = l % 26, - y = (l - p) / 26, - d = 1 << p; - if (this.length <= y) - return this._expand(y + 1), (this.words[y] |= d), this; - for (var v = d, _ = y; v !== 0 && _ < this.length; _++) { - var S = this.words[_] | 0; - (S += v), (v = S >>> 26), (S &= 67108863), (this.words[_] = S); - } - return v !== 0 && ((this.words[_] = v), this.length++), this; - }), - (i.prototype.isZero = function () { - return this.length === 1 && this.words[0] === 0; - }), - (i.prototype.cmpn = function (l) { - var p = l < 0; - if (this.negative !== 0 && !p) return -1; - if (this.negative === 0 && p) return 1; - this.strip(); - var y; - if (this.length > 1) y = 1; - else { - p && (l = -l), r(l <= 67108863, "Number is too big"); - var d = this.words[0] | 0; - y = d === l ? 0 : d < l ? -1 : 1; - } - return this.negative !== 0 ? -y | 0 : y; - }), - (i.prototype.cmp = function (l) { - if (this.negative !== 0 && l.negative === 0) return -1; - if (this.negative === 0 && l.negative !== 0) return 1; - var p = this.ucmp(l); - return this.negative !== 0 ? -p | 0 : p; - }), - (i.prototype.ucmp = function (l) { - if (this.length > l.length) return 1; - if (this.length < l.length) return -1; - for (var p = 0, y = this.length - 1; y >= 0; y--) { - var d = this.words[y] | 0, - v = l.words[y] | 0; - if (d !== v) { - d < v ? (p = -1) : d > v && (p = 1); - break; - } - } - return p; - }), - (i.prototype.gtn = function (l) { - return this.cmpn(l) === 1; - }), - (i.prototype.gt = function (l) { - return this.cmp(l) === 1; - }), - (i.prototype.gten = function (l) { - return this.cmpn(l) >= 0; - }), - (i.prototype.gte = function (l) { - return this.cmp(l) >= 0; - }), - (i.prototype.ltn = function (l) { - return this.cmpn(l) === -1; - }), - (i.prototype.lt = function (l) { - return this.cmp(l) === -1; - }), - (i.prototype.lten = function (l) { - return this.cmpn(l) <= 0; - }), - (i.prototype.lte = function (l) { - return this.cmp(l) <= 0; - }), - (i.prototype.eqn = function (l) { - return this.cmpn(l) === 0; - }), - (i.prototype.eq = function (l) { - return this.cmp(l) === 0; - }), - (i.red = function (l) { - return new te(l); - }), - (i.prototype.toRed = function (l) { - return ( - r(!this.red, "Already a number in reduction context"), - r(this.negative === 0, "red works only with positives"), - l.convertTo(this)._forceRed(l) - ); - }), - (i.prototype.fromRed = function () { - return ( - r(this.red, "fromRed works only with numbers in reduction context"), - this.red.convertFrom(this) - ); - }), - (i.prototype._forceRed = function (l) { - return (this.red = l), this; - }), - (i.prototype.forceRed = function (l) { - return ( - r(!this.red, "Already a number in reduction context"), - this._forceRed(l) - ); - }), - (i.prototype.redAdd = function (l) { - return ( - r(this.red, "redAdd works only with red numbers"), - this.red.add(this, l) - ); - }), - (i.prototype.redIAdd = function (l) { - return ( - r(this.red, "redIAdd works only with red numbers"), - this.red.iadd(this, l) - ); - }), - (i.prototype.redSub = function (l) { - return ( - r(this.red, "redSub works only with red numbers"), - this.red.sub(this, l) - ); - }), - (i.prototype.redISub = function (l) { - return ( - r(this.red, "redISub works only with red numbers"), - this.red.isub(this, l) - ); - }), - (i.prototype.redShl = function (l) { - return ( - r(this.red, "redShl works only with red numbers"), - this.red.shl(this, l) - ); - }), - (i.prototype.redMul = function (l) { - return ( - r(this.red, "redMul works only with red numbers"), - this.red._verify2(this, l), - this.red.mul(this, l) - ); - }), - (i.prototype.redIMul = function (l) { - return ( - r(this.red, "redMul works only with red numbers"), - this.red._verify2(this, l), - this.red.imul(this, l) - ); - }), - (i.prototype.redSqr = function () { - return ( - r(this.red, "redSqr works only with red numbers"), - this.red._verify1(this), - this.red.sqr(this) - ); - }), - (i.prototype.redISqr = function () { - return ( - r(this.red, "redISqr works only with red numbers"), - this.red._verify1(this), - this.red.isqr(this) - ); - }), - (i.prototype.redSqrt = function () { - return ( - r(this.red, "redSqrt works only with red numbers"), - this.red._verify1(this), - this.red.sqrt(this) - ); - }), - (i.prototype.redInvm = function () { - return ( - r(this.red, "redInvm works only with red numbers"), - this.red._verify1(this), - this.red.invm(this) - ); - }), - (i.prototype.redNeg = function () { - return ( - r(this.red, "redNeg works only with red numbers"), - this.red._verify1(this), - this.red.neg(this) - ); - }), - (i.prototype.redPow = function (l) { - return ( - r(this.red && !l.red, "redPow(normalNum)"), - this.red._verify1(this), - this.red.pow(this, l) - ); - }); - var q = { k256: null, p224: null, p192: null, p25519: null }; - function z(A, l) { - (this.name = A), - (this.p = new i(l, 16)), - (this.n = this.p.bitLength()), - (this.k = new i(1).iushln(this.n).isub(this.p)), - (this.tmp = this._tmp()); - } - (z.prototype._tmp = function () { - var l = new i(null); - return (l.words = new Array(Math.ceil(this.n / 13))), l; - }), - (z.prototype.ireduce = function (l) { - var p = l, - y; - do - this.split(p, this.tmp), - (p = this.imulK(p)), - (p = p.iadd(this.tmp)), - (y = p.bitLength()); - while (y > this.n); - var d = y < this.n ? -1 : p.ucmp(this.p); - return ( - d === 0 - ? ((p.words[0] = 0), (p.length = 1)) - : d > 0 - ? p.isub(this.p) - : p.strip !== void 0 - ? p.strip() - : p._strip(), - p - ); - }), - (z.prototype.split = function (l, p) { - l.iushrn(this.n, 0, p); - }), - (z.prototype.imulK = function (l) { - return l.imul(this.k); - }); - function H() { - z.call( - this, - "k256", - "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f" - ); - } - n(H, z), - (H.prototype.split = function (l, p) { - for (var y = 4194303, d = Math.min(l.length, 9), v = 0; v < d; v++) - p.words[v] = l.words[v]; - if (((p.length = d), l.length <= 9)) { - (l.words[0] = 0), (l.length = 1); - return; - } - var _ = l.words[9]; - for (p.words[p.length++] = _ & y, v = 10; v < l.length; v++) { - var S = l.words[v] | 0; - (l.words[v - 10] = ((S & y) << 4) | (_ >>> 22)), (_ = S); - } - (_ >>>= 22), - (l.words[v - 10] = _), - _ === 0 && l.length > 10 ? (l.length -= 10) : (l.length -= 9); - }), - (H.prototype.imulK = function (l) { - (l.words[l.length] = 0), (l.words[l.length + 1] = 0), (l.length += 2); - for (var p = 0, y = 0; y < l.length; y++) { - var d = l.words[y] | 0; - (p += d * 977), - (l.words[y] = p & 67108863), - (p = d * 64 + ((p / 67108864) | 0)); - } - return ( - l.words[l.length - 1] === 0 && - (l.length--, l.words[l.length - 1] === 0 && l.length--), - l - ); - }); - function Z() { - z.call( - this, - "p224", - "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001" - ); - } - n(Z, z); - function $() { - z.call( - this, - "p192", - "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff" - ); - } - n($, z); - function ue() { - z.call( - this, - "25519", - "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed" - ); - } - n(ue, z), - (ue.prototype.imulK = function (l) { - for (var p = 0, y = 0; y < l.length; y++) { - var d = (l.words[y] | 0) * 19 + p, - v = d & 67108863; - (d >>>= 26), (l.words[y] = v), (p = d); - } - return p !== 0 && (l.words[l.length++] = p), l; - }), - (i._prime = function (l) { - if (q[l]) return q[l]; - var p; - if (l === "k256") p = new H(); - else if (l === "p224") p = new Z(); - else if (l === "p192") p = new $(); - else if (l === "p25519") p = new ue(); - else throw new Error("Unknown prime " + l); - return (q[l] = p), p; - }); - function te(A) { - if (typeof A == "string") { - var l = i._prime(A); - (this.m = l.p), (this.prime = l); - } else - r(A.gtn(1), "modulus must be greater than 1"), - (this.m = A), - (this.prime = null); - } - (te.prototype._verify1 = function (l) { - r(l.negative === 0, "red works only with positives"), - r(l.red, "red works only with red numbers"); - }), - (te.prototype._verify2 = function (l, p) { - r((l.negative | p.negative) === 0, "red works only with positives"), - r(l.red && l.red === p.red, "red works only with red numbers"); - }), - (te.prototype.imod = function (l) { - return this.prime - ? this.prime.ireduce(l)._forceRed(this) - : l.umod(this.m)._forceRed(this); - }), - (te.prototype.neg = function (l) { - return l.isZero() ? l.clone() : this.m.sub(l)._forceRed(this); - }), - (te.prototype.add = function (l, p) { - this._verify2(l, p); - var y = l.add(p); - return y.cmp(this.m) >= 0 && y.isub(this.m), y._forceRed(this); - }), - (te.prototype.iadd = function (l, p) { - this._verify2(l, p); - var y = l.iadd(p); - return y.cmp(this.m) >= 0 && y.isub(this.m), y; - }), - (te.prototype.sub = function (l, p) { - this._verify2(l, p); - var y = l.sub(p); - return y.cmpn(0) < 0 && y.iadd(this.m), y._forceRed(this); - }), - (te.prototype.isub = function (l, p) { - this._verify2(l, p); - var y = l.isub(p); - return y.cmpn(0) < 0 && y.iadd(this.m), y; - }), - (te.prototype.shl = function (l, p) { - return this._verify1(l), this.imod(l.ushln(p)); - }), - (te.prototype.imul = function (l, p) { - return this._verify2(l, p), this.imod(l.imul(p)); - }), - (te.prototype.mul = function (l, p) { - return this._verify2(l, p), this.imod(l.mul(p)); - }), - (te.prototype.isqr = function (l) { - return this.imul(l, l.clone()); - }), - (te.prototype.sqr = function (l) { - return this.mul(l, l); - }), - (te.prototype.sqrt = function (l) { - if (l.isZero()) return l.clone(); - var p = this.m.andln(3); - if ((r(p % 2 === 1), p === 3)) { - var y = this.m.add(new i(1)).iushrn(2); - return this.pow(l, y); - } - for (var d = this.m.subn(1), v = 0; !d.isZero() && d.andln(1) === 0; ) - v++, d.iushrn(1); - r(!d.isZero()); - var _ = new i(1).toRed(this), - S = _.redNeg(), - b = this.m.subn(1).iushrn(1), - f = this.m.bitLength(); - for (f = new i(2 * f * f).toRed(this); this.pow(f, b).cmp(S) !== 0; ) - f.redIAdd(S); - for ( - var x = this.pow(f, d), - C = this.pow(l, d.addn(1).iushrn(1)), - E = this.pow(l, d), - B = v; - E.cmp(_) !== 0; - - ) { - for (var G = E, L = 0; G.cmp(_) !== 0; L++) G = G.redSqr(); - r(L < B); - var ee = this.pow(x, new i(1).iushln(B - L - 1)); - (C = C.redMul(ee)), (x = ee.redSqr()), (E = E.redMul(x)), (B = L); - } - return C; - }), - (te.prototype.invm = function (l) { - var p = l._invmp(this.m); - return p.negative !== 0 - ? ((p.negative = 0), this.imod(p).redNeg()) - : this.imod(p); - }), - (te.prototype.pow = function (l, p) { - if (p.isZero()) return new i(1).toRed(this); - if (p.cmpn(1) === 0) return l.clone(); - var y = 4, - d = new Array(1 << y); - (d[0] = new i(1).toRed(this)), (d[1] = l); - for (var v = 2; v < d.length; v++) d[v] = this.mul(d[v - 1], l); - var _ = d[0], - S = 0, - b = 0, - f = p.bitLength() % 26; - for (f === 0 && (f = 26), v = p.length - 1; v >= 0; v--) { - for (var x = p.words[v], C = f - 1; C >= 0; C--) { - var E = (x >> C) & 1; - if ((_ !== d[0] && (_ = this.sqr(_)), E === 0 && S === 0)) { - b = 0; - continue; - } - (S <<= 1), - (S |= E), - b++, - !(b !== y && (v !== 0 || C !== 0)) && - ((_ = this.mul(_, d[S])), (b = 0), (S = 0)); - } - f = 26; - } - return _; - }), - (te.prototype.convertTo = function (l) { - var p = l.umod(this.m); - return p === l ? p.clone() : p; - }), - (te.prototype.convertFrom = function (l) { - var p = l.clone(); - return (p.red = null), p; - }), - (i.mont = function (l) { - return new ne(l); - }); - function ne(A) { - te.call(this, A), - (this.shift = this.m.bitLength()), - this.shift % 26 !== 0 && (this.shift += 26 - (this.shift % 26)), - (this.r = new i(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)); - } - n(ne, te), - (ne.prototype.convertTo = function (l) { - return this.imod(l.ushln(this.shift)); - }), - (ne.prototype.convertFrom = function (l) { - var p = this.imod(l.mul(this.rinv)); - return (p.red = null), p; - }), - (ne.prototype.imul = function (l, p) { - if (l.isZero() || p.isZero()) - return (l.words[0] = 0), (l.length = 1), l; - var y = l.imul(p), - d = y - .maskn(this.shift) - .mul(this.minv) - .imaskn(this.shift) - .mul(this.m), - v = y.isub(d).iushrn(this.shift), - _ = v; - return ( - v.cmp(this.m) >= 0 - ? (_ = v.isub(this.m)) - : v.cmpn(0) < 0 && (_ = v.iadd(this.m)), - _._forceRed(this) - ); - }), - (ne.prototype.mul = function (l, p) { - if (l.isZero() || p.isZero()) return new i(0)._forceRed(this); - var y = l.mul(p), - d = y - .maskn(this.shift) - .mul(this.minv) - .imaskn(this.shift) - .mul(this.m), - v = y.isub(d).iushrn(this.shift), - _ = v; - return ( - v.cmp(this.m) >= 0 - ? (_ = v.isub(this.m)) - : v.cmpn(0) < 0 && (_ = v.iadd(this.m)), - _._forceRed(this) - ); - }), - (ne.prototype.invm = function (l) { - var p = this.imod(l._invmp(this.m).mul(this.r2)); - return p._forceRed(this); - }); - })(typeof Gve > "u" || Gve, wVe); - }); - var xVe = I((_Ve, $ve) => { - m(); - g(); - (function (t, e) { - "use strict"; - function r(A, l) { - if (!A) throw new Error(l || "Assertion failed"); - } - function n(A, l) { - A.super_ = l; - var p = function () {}; - (p.prototype = l.prototype), - (A.prototype = new p()), - (A.prototype.constructor = A); - } - function i(A, l, p) { - if (i.isBN(A)) return A; - (this.negative = 0), - (this.words = null), - (this.length = 0), - (this.red = null), - A !== null && - ((l === "le" || l === "be") && ((p = l), (l = 10)), - this._init(A || 0, l || 10, p || "be")); - } - typeof t == "object" ? (t.exports = i) : (e.BN = i), - (i.BN = i), - (i.wordSize = 26); - var o; - try { - typeof window < "u" && typeof window.Buffer < "u" - ? (o = window.Buffer) - : (o = Qr().Buffer); - } catch {} - (i.isBN = function (l) { - return l instanceof i - ? !0 - : l !== null && - typeof l == "object" && - l.constructor.wordSize === i.wordSize && - Array.isArray(l.words); - }), - (i.max = function (l, p) { - return l.cmp(p) > 0 ? l : p; - }), - (i.min = function (l, p) { - return l.cmp(p) < 0 ? l : p; - }), - (i.prototype._init = function (l, p, y) { - if (typeof l == "number") return this._initNumber(l, p, y); - if (typeof l == "object") return this._initArray(l, p, y); - p === "hex" && (p = 16), - r(p === (p | 0) && p >= 2 && p <= 36), - (l = l.toString().replace(/\s+/g, "")); - var d = 0; - l[0] === "-" && (d++, (this.negative = 1)), - d < l.length && - (p === 16 - ? this._parseHex(l, d, y) - : (this._parseBase(l, p, d), - y === "le" && this._initArray(this.toArray(), p, y))); - }), - (i.prototype._initNumber = function (l, p, y) { - l < 0 && ((this.negative = 1), (l = -l)), - l < 67108864 - ? ((this.words = [l & 67108863]), (this.length = 1)) - : l < 4503599627370496 - ? ((this.words = [l & 67108863, (l / 67108864) & 67108863]), - (this.length = 2)) - : (r(l < 9007199254740992), - (this.words = [l & 67108863, (l / 67108864) & 67108863, 1]), - (this.length = 3)), - y === "le" && this._initArray(this.toArray(), p, y); - }), - (i.prototype._initArray = function (l, p, y) { - if ((r(typeof l.length == "number"), l.length <= 0)) - return (this.words = [0]), (this.length = 1), this; - (this.length = Math.ceil(l.length / 3)), - (this.words = new Array(this.length)); - for (var d = 0; d < this.length; d++) this.words[d] = 0; - var v, - _, - S = 0; - if (y === "be") - for (d = l.length - 1, v = 0; d >= 0; d -= 3) - (_ = l[d] | (l[d - 1] << 8) | (l[d - 2] << 16)), - (this.words[v] |= (_ << S) & 67108863), - (this.words[v + 1] = (_ >>> (26 - S)) & 67108863), - (S += 24), - S >= 26 && ((S -= 26), v++); - else if (y === "le") - for (d = 0, v = 0; d < l.length; d += 3) - (_ = l[d] | (l[d + 1] << 8) | (l[d + 2] << 16)), - (this.words[v] |= (_ << S) & 67108863), - (this.words[v + 1] = (_ >>> (26 - S)) & 67108863), - (S += 24), - S >= 26 && ((S -= 26), v++); - return this.strip(); - }); - function a(A, l) { - var p = A.charCodeAt(l); - return p >= 65 && p <= 70 - ? p - 55 - : p >= 97 && p <= 102 - ? p - 87 - : (p - 48) & 15; - } - function s(A, l, p) { - var y = a(A, p); - return p - 1 >= l && (y |= a(A, p - 1) << 4), y; - } - i.prototype._parseHex = function (l, p, y) { - (this.length = Math.ceil((l.length - p) / 6)), - (this.words = new Array(this.length)); - for (var d = 0; d < this.length; d++) this.words[d] = 0; - var v = 0, - _ = 0, - S; - if (y === "be") - for (d = l.length - 1; d >= p; d -= 2) - (S = s(l, p, d) << v), - (this.words[_] |= S & 67108863), - v >= 18 - ? ((v -= 18), (_ += 1), (this.words[_] |= S >>> 26)) - : (v += 8); - else { - var b = l.length - p; - for (d = b % 2 === 0 ? p + 1 : p; d < l.length; d += 2) - (S = s(l, p, d) << v), - (this.words[_] |= S & 67108863), - v >= 18 - ? ((v -= 18), (_ += 1), (this.words[_] |= S >>> 26)) - : (v += 8); - } - this.strip(); - }; - function c(A, l, p, y) { - for (var d = 0, v = Math.min(A.length, p), _ = l; _ < v; _++) { - var S = A.charCodeAt(_) - 48; - (d *= y), - S >= 49 - ? (d += S - 49 + 10) - : S >= 17 - ? (d += S - 17 + 10) - : (d += S); - } - return d; - } - (i.prototype._parseBase = function (l, p, y) { - (this.words = [0]), (this.length = 1); - for (var d = 0, v = 1; v <= 67108863; v *= p) d++; - d--, (v = (v / p) | 0); - for ( - var _ = l.length - y, - S = _ % d, - b = Math.min(_, _ - S) + y, - f = 0, - x = y; - x < b; - x += d - ) - (f = c(l, x, x + d, p)), - this.imuln(v), - this.words[0] + f < 67108864 - ? (this.words[0] += f) - : this._iaddn(f); - if (S !== 0) { - var C = 1; - for (f = c(l, x, l.length, p), x = 0; x < S; x++) C *= p; - this.imuln(C), - this.words[0] + f < 67108864 - ? (this.words[0] += f) - : this._iaddn(f); - } - this.strip(); - }), - (i.prototype.copy = function (l) { - l.words = new Array(this.length); - for (var p = 0; p < this.length; p++) l.words[p] = this.words[p]; - (l.length = this.length), - (l.negative = this.negative), - (l.red = this.red); - }), - (i.prototype.clone = function () { - var l = new i(null); - return this.copy(l), l; - }), - (i.prototype._expand = function (l) { - for (; this.length < l; ) this.words[this.length++] = 0; - return this; - }), - (i.prototype.strip = function () { - for (; this.length > 1 && this.words[this.length - 1] === 0; ) - this.length--; - return this._normSign(); - }), - (i.prototype._normSign = function () { - return ( - this.length === 1 && this.words[0] === 0 && (this.negative = 0), - this - ); - }), - (i.prototype.inspect = function () { - return (this.red ? ""; - }); - var u = [ - "", - "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", - ], - h = [ - 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, - ], - w = [ - 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, - ]; - (i.prototype.toString = function (l, p) { - (l = l || 10), (p = p | 0 || 1); - var y; - if (l === 16 || l === "hex") { - y = ""; - for (var d = 0, v = 0, _ = 0; _ < this.length; _++) { - var S = this.words[_], - b = (((S << d) | v) & 16777215).toString(16); - (v = (S >>> (24 - d)) & 16777215), - v !== 0 || _ !== this.length - 1 - ? (y = u[6 - b.length] + b + y) - : (y = b + y), - (d += 2), - d >= 26 && ((d -= 26), _--); - } - for (v !== 0 && (y = v.toString(16) + y); y.length % p !== 0; ) - y = "0" + y; - return this.negative !== 0 && (y = "-" + y), y; - } - if (l === (l | 0) && l >= 2 && l <= 36) { - var f = h[l], - x = w[l]; - y = ""; - var C = this.clone(); - for (C.negative = 0; !C.isZero(); ) { - var E = C.modn(x).toString(l); - (C = C.idivn(x)), - C.isZero() ? (y = E + y) : (y = u[f - E.length] + E + y); - } - for (this.isZero() && (y = "0" + y); y.length % p !== 0; ) - y = "0" + y; - return this.negative !== 0 && (y = "-" + y), y; - } - r(!1, "Base should be between 2 and 36"); - }), - (i.prototype.toNumber = function () { - var l = this.words[0]; - return ( - this.length === 2 - ? (l += this.words[1] * 67108864) - : this.length === 3 && this.words[2] === 1 - ? (l += 4503599627370496 + this.words[1] * 67108864) - : this.length > 2 && - r(!1, "Number can only safely store up to 53 bits"), - this.negative !== 0 ? -l : l - ); - }), - (i.prototype.toJSON = function () { - return this.toString(16); - }), - (i.prototype.toBuffer = function (l, p) { - return r(typeof o < "u"), this.toArrayLike(o, l, p); - }), - (i.prototype.toArray = function (l, p) { - return this.toArrayLike(Array, l, p); - }), - (i.prototype.toArrayLike = function (l, p, y) { - var d = this.byteLength(), - v = y || Math.max(1, d); - r(d <= v, "byte array longer than desired length"), - r(v > 0, "Requested array length <= 0"), - this.strip(); - var _ = p === "le", - S = new l(v), - b, - f, - x = this.clone(); - if (_) { - for (f = 0; !x.isZero(); f++) - (b = x.andln(255)), x.iushrn(8), (S[f] = b); - for (; f < v; f++) S[f] = 0; - } else { - for (f = 0; f < v - d; f++) S[f] = 0; - for (f = 0; !x.isZero(); f++) - (b = x.andln(255)), x.iushrn(8), (S[v - f - 1] = b); - } - return S; - }), - Math.clz32 - ? (i.prototype._countBits = function (l) { - return 32 - Math.clz32(l); - }) - : (i.prototype._countBits = function (l) { - var p = l, - y = 0; - return ( - p >= 4096 && ((y += 13), (p >>>= 13)), - p >= 64 && ((y += 7), (p >>>= 7)), - p >= 8 && ((y += 4), (p >>>= 4)), - p >= 2 && ((y += 2), (p >>>= 2)), - y + p - ); - }), - (i.prototype._zeroBits = function (l) { - if (l === 0) return 26; - var p = l, - y = 0; - return ( - (p & 8191) === 0 && ((y += 13), (p >>>= 13)), - (p & 127) === 0 && ((y += 7), (p >>>= 7)), - (p & 15) === 0 && ((y += 4), (p >>>= 4)), - (p & 3) === 0 && ((y += 2), (p >>>= 2)), - (p & 1) === 0 && y++, - y - ); - }), - (i.prototype.bitLength = function () { - var l = this.words[this.length - 1], - p = this._countBits(l); - return (this.length - 1) * 26 + p; - }); - function M(A) { - for (var l = new Array(A.bitLength()), p = 0; p < l.length; p++) { - var y = (p / 26) | 0, - d = p % 26; - l[p] = (A.words[y] & (1 << d)) >>> d; - } - return l; - } - (i.prototype.zeroBits = function () { - if (this.isZero()) return 0; - for (var l = 0, p = 0; p < this.length; p++) { - var y = this._zeroBits(this.words[p]); - if (((l += y), y !== 26)) break; - } - return l; - }), - (i.prototype.byteLength = function () { - return Math.ceil(this.bitLength() / 8); - }), - (i.prototype.toTwos = function (l) { - return this.negative !== 0 - ? this.abs().inotn(l).iaddn(1) - : this.clone(); - }), - (i.prototype.fromTwos = function (l) { - return this.testn(l - 1) - ? this.notn(l).iaddn(1).ineg() - : this.clone(); - }), - (i.prototype.isNeg = function () { - return this.negative !== 0; - }), - (i.prototype.neg = function () { - return this.clone().ineg(); - }), - (i.prototype.ineg = function () { - return this.isZero() || (this.negative ^= 1), this; - }), - (i.prototype.iuor = function (l) { - for (; this.length < l.length; ) this.words[this.length++] = 0; - for (var p = 0; p < l.length; p++) - this.words[p] = this.words[p] | l.words[p]; - return this.strip(); - }), - (i.prototype.ior = function (l) { - return r((this.negative | l.negative) === 0), this.iuor(l); - }), - (i.prototype.or = function (l) { - return this.length > l.length - ? this.clone().ior(l) - : l.clone().ior(this); - }), - (i.prototype.uor = function (l) { - return this.length > l.length - ? this.clone().iuor(l) - : l.clone().iuor(this); - }), - (i.prototype.iuand = function (l) { - var p; - this.length > l.length ? (p = l) : (p = this); - for (var y = 0; y < p.length; y++) - this.words[y] = this.words[y] & l.words[y]; - return (this.length = p.length), this.strip(); - }), - (i.prototype.iand = function (l) { - return r((this.negative | l.negative) === 0), this.iuand(l); - }), - (i.prototype.and = function (l) { - return this.length > l.length - ? this.clone().iand(l) - : l.clone().iand(this); - }), - (i.prototype.uand = function (l) { - return this.length > l.length - ? this.clone().iuand(l) - : l.clone().iuand(this); - }), - (i.prototype.iuxor = function (l) { - var p, y; - this.length > l.length - ? ((p = this), (y = l)) - : ((p = l), (y = this)); - for (var d = 0; d < y.length; d++) - this.words[d] = p.words[d] ^ y.words[d]; - if (this !== p) for (; d < p.length; d++) this.words[d] = p.words[d]; - return (this.length = p.length), this.strip(); - }), - (i.prototype.ixor = function (l) { - return r((this.negative | l.negative) === 0), this.iuxor(l); - }), - (i.prototype.xor = function (l) { - return this.length > l.length - ? this.clone().ixor(l) - : l.clone().ixor(this); - }), - (i.prototype.uxor = function (l) { - return this.length > l.length - ? this.clone().iuxor(l) - : l.clone().iuxor(this); - }), - (i.prototype.inotn = function (l) { - r(typeof l == "number" && l >= 0); - var p = Math.ceil(l / 26) | 0, - y = l % 26; - this._expand(p), y > 0 && p--; - for (var d = 0; d < p; d++) this.words[d] = ~this.words[d] & 67108863; - return ( - y > 0 && (this.words[d] = ~this.words[d] & (67108863 >> (26 - y))), - this.strip() - ); - }), - (i.prototype.notn = function (l) { - return this.clone().inotn(l); - }), - (i.prototype.setn = function (l, p) { - r(typeof l == "number" && l >= 0); - var y = (l / 26) | 0, - d = l % 26; - return ( - this._expand(y + 1), - p - ? (this.words[y] = this.words[y] | (1 << d)) - : (this.words[y] = this.words[y] & ~(1 << d)), - this.strip() - ); - }), - (i.prototype.iadd = function (l) { - var p; - if (this.negative !== 0 && l.negative === 0) - return ( - (this.negative = 0), - (p = this.isub(l)), - (this.negative ^= 1), - this._normSign() - ); - if (this.negative === 0 && l.negative !== 0) - return ( - (l.negative = 0), - (p = this.isub(l)), - (l.negative = 1), - p._normSign() - ); - var y, d; - this.length > l.length - ? ((y = this), (d = l)) - : ((y = l), (d = this)); - for (var v = 0, _ = 0; _ < d.length; _++) - (p = (y.words[_] | 0) + (d.words[_] | 0) + v), - (this.words[_] = p & 67108863), - (v = p >>> 26); - for (; v !== 0 && _ < y.length; _++) - (p = (y.words[_] | 0) + v), - (this.words[_] = p & 67108863), - (v = p >>> 26); - if (((this.length = y.length), v !== 0)) - (this.words[this.length] = v), this.length++; - else if (y !== this) - for (; _ < y.length; _++) this.words[_] = y.words[_]; - return this; - }), - (i.prototype.add = function (l) { - var p; - return l.negative !== 0 && this.negative === 0 - ? ((l.negative = 0), (p = this.sub(l)), (l.negative ^= 1), p) - : l.negative === 0 && this.negative !== 0 - ? ((this.negative = 0), (p = l.sub(this)), (this.negative = 1), p) - : this.length > l.length - ? this.clone().iadd(l) - : l.clone().iadd(this); - }), - (i.prototype.isub = function (l) { - if (l.negative !== 0) { - l.negative = 0; - var p = this.iadd(l); - return (l.negative = 1), p._normSign(); - } else if (this.negative !== 0) - return ( - (this.negative = 0), - this.iadd(l), - (this.negative = 1), - this._normSign() - ); - var y = this.cmp(l); - if (y === 0) - return ( - (this.negative = 0), (this.length = 1), (this.words[0] = 0), this - ); - var d, v; - y > 0 ? ((d = this), (v = l)) : ((d = l), (v = this)); - for (var _ = 0, S = 0; S < v.length; S++) - (p = (d.words[S] | 0) - (v.words[S] | 0) + _), - (_ = p >> 26), - (this.words[S] = p & 67108863); - for (; _ !== 0 && S < d.length; S++) - (p = (d.words[S] | 0) + _), - (_ = p >> 26), - (this.words[S] = p & 67108863); - if (_ === 0 && S < d.length && d !== this) - for (; S < d.length; S++) this.words[S] = d.words[S]; - return ( - (this.length = Math.max(this.length, S)), - d !== this && (this.negative = 1), - this.strip() - ); - }), - (i.prototype.sub = function (l) { - return this.clone().isub(l); - }); - function k(A, l, p) { - p.negative = l.negative ^ A.negative; - var y = (A.length + l.length) | 0; - (p.length = y), (y = (y - 1) | 0); - var d = A.words[0] | 0, - v = l.words[0] | 0, - _ = d * v, - S = _ & 67108863, - b = (_ / 67108864) | 0; - p.words[0] = S; - for (var f = 1; f < y; f++) { - for ( - var x = b >>> 26, - C = b & 67108863, - E = Math.min(f, l.length - 1), - B = Math.max(0, f - A.length + 1); - B <= E; - B++ - ) { - var G = (f - B) | 0; - (d = A.words[G] | 0), - (v = l.words[B] | 0), - (_ = d * v + C), - (x += (_ / 67108864) | 0), - (C = _ & 67108863); - } - (p.words[f] = C | 0), (b = x | 0); - } - return b !== 0 ? (p.words[f] = b | 0) : p.length--, p.strip(); - } - var O = function (l, p, y) { - var d = l.words, - v = p.words, - _ = y.words, - S = 0, - b, - f, - x, - C = d[0] | 0, - E = C & 8191, - B = C >>> 13, - G = d[1] | 0, - L = G & 8191, - ee = G >>> 13, - ge = d[2] | 0, - fe = ge & 8191, - V = ge >>> 13, - ye = d[3] | 0, - ae = ye & 8191, - le = ye >>> 13, - Me = d[4] | 0, - de = Me & 8191, - ve = Me >>> 13, - De = d[5] | 0, - me = De & 8191, - _e = De >>> 13, - Ye = d[6] | 0, - Ee = Ye & 8191, - Be = Ye >>> 13, - kt = d[7] | 0, - Ve = kt & 8191, - We = kt >>> 13, - er = d[8] | 0, - Ue = er & 8191, - Y = er >>> 13, - W = d[9] | 0, - j = W & 8191, - ce = W >>> 13, - ze = v[0] | 0, - we = ze & 8191, - xe = ze >>> 13, - Ft = v[1] | 0, - Ke = Ft & 8191, - pe = Ft >>> 13, - Re = v[2] | 0, - Se = Re & 8191, - Pe = Re >>> 13, - At = v[3] | 0, - Ie = At & 8191, - je = At >>> 13, - qt = v[4] | 0, - Fe = qt & 8191, - He = qt >>> 13, - lr = v[5] | 0, - Xe = lr & 8191, - Ze = lr >>> 13, - Ir = v[6] | 0, - $e = Ir & 8191, - tt = Ir >>> 13, - oe = v[7] | 0, - ie = oe & 8191, - re = oe >>> 13, - U = v[8] | 0, - se = U & 8191, - be = U >>> 13, - Qe = v[9] | 0, - Ae = Qe & 8191, - ke = Qe >>> 13; - (y.negative = l.negative ^ p.negative), - (y.length = 19), - (b = Math.imul(E, we)), - (f = Math.imul(E, xe)), - (f = (f + Math.imul(B, we)) | 0), - (x = Math.imul(B, xe)); - var Ct = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ct >>> 26)) | 0), - (Ct &= 67108863), - (b = Math.imul(L, we)), - (f = Math.imul(L, xe)), - (f = (f + Math.imul(ee, we)) | 0), - (x = Math.imul(ee, xe)), - (b = (b + Math.imul(E, Ke)) | 0), - (f = (f + Math.imul(E, pe)) | 0), - (f = (f + Math.imul(B, Ke)) | 0), - (x = (x + Math.imul(B, pe)) | 0); - var ut = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (ut >>> 26)) | 0), - (ut &= 67108863), - (b = Math.imul(fe, we)), - (f = Math.imul(fe, xe)), - (f = (f + Math.imul(V, we)) | 0), - (x = Math.imul(V, xe)), - (b = (b + Math.imul(L, Ke)) | 0), - (f = (f + Math.imul(L, pe)) | 0), - (f = (f + Math.imul(ee, Ke)) | 0), - (x = (x + Math.imul(ee, pe)) | 0), - (b = (b + Math.imul(E, Se)) | 0), - (f = (f + Math.imul(E, Pe)) | 0), - (f = (f + Math.imul(B, Se)) | 0), - (x = (x + Math.imul(B, Pe)) | 0); - var St = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (St >>> 26)) | 0), - (St &= 67108863), - (b = Math.imul(ae, we)), - (f = Math.imul(ae, xe)), - (f = (f + Math.imul(le, we)) | 0), - (x = Math.imul(le, xe)), - (b = (b + Math.imul(fe, Ke)) | 0), - (f = (f + Math.imul(fe, pe)) | 0), - (f = (f + Math.imul(V, Ke)) | 0), - (x = (x + Math.imul(V, pe)) | 0), - (b = (b + Math.imul(L, Se)) | 0), - (f = (f + Math.imul(L, Pe)) | 0), - (f = (f + Math.imul(ee, Se)) | 0), - (x = (x + Math.imul(ee, Pe)) | 0), - (b = (b + Math.imul(E, Ie)) | 0), - (f = (f + Math.imul(E, je)) | 0), - (f = (f + Math.imul(B, Ie)) | 0), - (x = (x + Math.imul(B, je)) | 0); - var wt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (wt >>> 26)) | 0), - (wt &= 67108863), - (b = Math.imul(de, we)), - (f = Math.imul(de, xe)), - (f = (f + Math.imul(ve, we)) | 0), - (x = Math.imul(ve, xe)), - (b = (b + Math.imul(ae, Ke)) | 0), - (f = (f + Math.imul(ae, pe)) | 0), - (f = (f + Math.imul(le, Ke)) | 0), - (x = (x + Math.imul(le, pe)) | 0), - (b = (b + Math.imul(fe, Se)) | 0), - (f = (f + Math.imul(fe, Pe)) | 0), - (f = (f + Math.imul(V, Se)) | 0), - (x = (x + Math.imul(V, Pe)) | 0), - (b = (b + Math.imul(L, Ie)) | 0), - (f = (f + Math.imul(L, je)) | 0), - (f = (f + Math.imul(ee, Ie)) | 0), - (x = (x + Math.imul(ee, je)) | 0), - (b = (b + Math.imul(E, Fe)) | 0), - (f = (f + Math.imul(E, He)) | 0), - (f = (f + Math.imul(B, Fe)) | 0), - (x = (x + Math.imul(B, He)) | 0); - var zt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (zt >>> 26)) | 0), - (zt &= 67108863), - (b = Math.imul(me, we)), - (f = Math.imul(me, xe)), - (f = (f + Math.imul(_e, we)) | 0), - (x = Math.imul(_e, xe)), - (b = (b + Math.imul(de, Ke)) | 0), - (f = (f + Math.imul(de, pe)) | 0), - (f = (f + Math.imul(ve, Ke)) | 0), - (x = (x + Math.imul(ve, pe)) | 0), - (b = (b + Math.imul(ae, Se)) | 0), - (f = (f + Math.imul(ae, Pe)) | 0), - (f = (f + Math.imul(le, Se)) | 0), - (x = (x + Math.imul(le, Pe)) | 0), - (b = (b + Math.imul(fe, Ie)) | 0), - (f = (f + Math.imul(fe, je)) | 0), - (f = (f + Math.imul(V, Ie)) | 0), - (x = (x + Math.imul(V, je)) | 0), - (b = (b + Math.imul(L, Fe)) | 0), - (f = (f + Math.imul(L, He)) | 0), - (f = (f + Math.imul(ee, Fe)) | 0), - (x = (x + Math.imul(ee, He)) | 0), - (b = (b + Math.imul(E, Xe)) | 0), - (f = (f + Math.imul(E, Ze)) | 0), - (f = (f + Math.imul(B, Xe)) | 0), - (x = (x + Math.imul(B, Ze)) | 0); - var jt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (jt >>> 26)) | 0), - (jt &= 67108863), - (b = Math.imul(Ee, we)), - (f = Math.imul(Ee, xe)), - (f = (f + Math.imul(Be, we)) | 0), - (x = Math.imul(Be, xe)), - (b = (b + Math.imul(me, Ke)) | 0), - (f = (f + Math.imul(me, pe)) | 0), - (f = (f + Math.imul(_e, Ke)) | 0), - (x = (x + Math.imul(_e, pe)) | 0), - (b = (b + Math.imul(de, Se)) | 0), - (f = (f + Math.imul(de, Pe)) | 0), - (f = (f + Math.imul(ve, Se)) | 0), - (x = (x + Math.imul(ve, Pe)) | 0), - (b = (b + Math.imul(ae, Ie)) | 0), - (f = (f + Math.imul(ae, je)) | 0), - (f = (f + Math.imul(le, Ie)) | 0), - (x = (x + Math.imul(le, je)) | 0), - (b = (b + Math.imul(fe, Fe)) | 0), - (f = (f + Math.imul(fe, He)) | 0), - (f = (f + Math.imul(V, Fe)) | 0), - (x = (x + Math.imul(V, He)) | 0), - (b = (b + Math.imul(L, Xe)) | 0), - (f = (f + Math.imul(L, Ze)) | 0), - (f = (f + Math.imul(ee, Xe)) | 0), - (x = (x + Math.imul(ee, Ze)) | 0), - (b = (b + Math.imul(E, $e)) | 0), - (f = (f + Math.imul(E, tt)) | 0), - (f = (f + Math.imul(B, $e)) | 0), - (x = (x + Math.imul(B, tt)) | 0); - var Ht = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ht >>> 26)) | 0), - (Ht &= 67108863), - (b = Math.imul(Ve, we)), - (f = Math.imul(Ve, xe)), - (f = (f + Math.imul(We, we)) | 0), - (x = Math.imul(We, xe)), - (b = (b + Math.imul(Ee, Ke)) | 0), - (f = (f + Math.imul(Ee, pe)) | 0), - (f = (f + Math.imul(Be, Ke)) | 0), - (x = (x + Math.imul(Be, pe)) | 0), - (b = (b + Math.imul(me, Se)) | 0), - (f = (f + Math.imul(me, Pe)) | 0), - (f = (f + Math.imul(_e, Se)) | 0), - (x = (x + Math.imul(_e, Pe)) | 0), - (b = (b + Math.imul(de, Ie)) | 0), - (f = (f + Math.imul(de, je)) | 0), - (f = (f + Math.imul(ve, Ie)) | 0), - (x = (x + Math.imul(ve, je)) | 0), - (b = (b + Math.imul(ae, Fe)) | 0), - (f = (f + Math.imul(ae, He)) | 0), - (f = (f + Math.imul(le, Fe)) | 0), - (x = (x + Math.imul(le, He)) | 0), - (b = (b + Math.imul(fe, Xe)) | 0), - (f = (f + Math.imul(fe, Ze)) | 0), - (f = (f + Math.imul(V, Xe)) | 0), - (x = (x + Math.imul(V, Ze)) | 0), - (b = (b + Math.imul(L, $e)) | 0), - (f = (f + Math.imul(L, tt)) | 0), - (f = (f + Math.imul(ee, $e)) | 0), - (x = (x + Math.imul(ee, tt)) | 0), - (b = (b + Math.imul(E, ie)) | 0), - (f = (f + Math.imul(E, re)) | 0), - (f = (f + Math.imul(B, ie)) | 0), - (x = (x + Math.imul(B, re)) | 0); - var Ut = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ut >>> 26)) | 0), - (Ut &= 67108863), - (b = Math.imul(Ue, we)), - (f = Math.imul(Ue, xe)), - (f = (f + Math.imul(Y, we)) | 0), - (x = Math.imul(Y, xe)), - (b = (b + Math.imul(Ve, Ke)) | 0), - (f = (f + Math.imul(Ve, pe)) | 0), - (f = (f + Math.imul(We, Ke)) | 0), - (x = (x + Math.imul(We, pe)) | 0), - (b = (b + Math.imul(Ee, Se)) | 0), - (f = (f + Math.imul(Ee, Pe)) | 0), - (f = (f + Math.imul(Be, Se)) | 0), - (x = (x + Math.imul(Be, Pe)) | 0), - (b = (b + Math.imul(me, Ie)) | 0), - (f = (f + Math.imul(me, je)) | 0), - (f = (f + Math.imul(_e, Ie)) | 0), - (x = (x + Math.imul(_e, je)) | 0), - (b = (b + Math.imul(de, Fe)) | 0), - (f = (f + Math.imul(de, He)) | 0), - (f = (f + Math.imul(ve, Fe)) | 0), - (x = (x + Math.imul(ve, He)) | 0), - (b = (b + Math.imul(ae, Xe)) | 0), - (f = (f + Math.imul(ae, Ze)) | 0), - (f = (f + Math.imul(le, Xe)) | 0), - (x = (x + Math.imul(le, Ze)) | 0), - (b = (b + Math.imul(fe, $e)) | 0), - (f = (f + Math.imul(fe, tt)) | 0), - (f = (f + Math.imul(V, $e)) | 0), - (x = (x + Math.imul(V, tt)) | 0), - (b = (b + Math.imul(L, ie)) | 0), - (f = (f + Math.imul(L, re)) | 0), - (f = (f + Math.imul(ee, ie)) | 0), - (x = (x + Math.imul(ee, re)) | 0), - (b = (b + Math.imul(E, se)) | 0), - (f = (f + Math.imul(E, be)) | 0), - (f = (f + Math.imul(B, se)) | 0), - (x = (x + Math.imul(B, be)) | 0); - var Kt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Kt >>> 26)) | 0), - (Kt &= 67108863), - (b = Math.imul(j, we)), - (f = Math.imul(j, xe)), - (f = (f + Math.imul(ce, we)) | 0), - (x = Math.imul(ce, xe)), - (b = (b + Math.imul(Ue, Ke)) | 0), - (f = (f + Math.imul(Ue, pe)) | 0), - (f = (f + Math.imul(Y, Ke)) | 0), - (x = (x + Math.imul(Y, pe)) | 0), - (b = (b + Math.imul(Ve, Se)) | 0), - (f = (f + Math.imul(Ve, Pe)) | 0), - (f = (f + Math.imul(We, Se)) | 0), - (x = (x + Math.imul(We, Pe)) | 0), - (b = (b + Math.imul(Ee, Ie)) | 0), - (f = (f + Math.imul(Ee, je)) | 0), - (f = (f + Math.imul(Be, Ie)) | 0), - (x = (x + Math.imul(Be, je)) | 0), - (b = (b + Math.imul(me, Fe)) | 0), - (f = (f + Math.imul(me, He)) | 0), - (f = (f + Math.imul(_e, Fe)) | 0), - (x = (x + Math.imul(_e, He)) | 0), - (b = (b + Math.imul(de, Xe)) | 0), - (f = (f + Math.imul(de, Ze)) | 0), - (f = (f + Math.imul(ve, Xe)) | 0), - (x = (x + Math.imul(ve, Ze)) | 0), - (b = (b + Math.imul(ae, $e)) | 0), - (f = (f + Math.imul(ae, tt)) | 0), - (f = (f + Math.imul(le, $e)) | 0), - (x = (x + Math.imul(le, tt)) | 0), - (b = (b + Math.imul(fe, ie)) | 0), - (f = (f + Math.imul(fe, re)) | 0), - (f = (f + Math.imul(V, ie)) | 0), - (x = (x + Math.imul(V, re)) | 0), - (b = (b + Math.imul(L, se)) | 0), - (f = (f + Math.imul(L, be)) | 0), - (f = (f + Math.imul(ee, se)) | 0), - (x = (x + Math.imul(ee, be)) | 0), - (b = (b + Math.imul(E, Ae)) | 0), - (f = (f + Math.imul(E, ke)) | 0), - (f = (f + Math.imul(B, Ae)) | 0), - (x = (x + Math.imul(B, ke)) | 0); - var Ot = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ot >>> 26)) | 0), - (Ot &= 67108863), - (b = Math.imul(j, Ke)), - (f = Math.imul(j, pe)), - (f = (f + Math.imul(ce, Ke)) | 0), - (x = Math.imul(ce, pe)), - (b = (b + Math.imul(Ue, Se)) | 0), - (f = (f + Math.imul(Ue, Pe)) | 0), - (f = (f + Math.imul(Y, Se)) | 0), - (x = (x + Math.imul(Y, Pe)) | 0), - (b = (b + Math.imul(Ve, Ie)) | 0), - (f = (f + Math.imul(Ve, je)) | 0), - (f = (f + Math.imul(We, Ie)) | 0), - (x = (x + Math.imul(We, je)) | 0), - (b = (b + Math.imul(Ee, Fe)) | 0), - (f = (f + Math.imul(Ee, He)) | 0), - (f = (f + Math.imul(Be, Fe)) | 0), - (x = (x + Math.imul(Be, He)) | 0), - (b = (b + Math.imul(me, Xe)) | 0), - (f = (f + Math.imul(me, Ze)) | 0), - (f = (f + Math.imul(_e, Xe)) | 0), - (x = (x + Math.imul(_e, Ze)) | 0), - (b = (b + Math.imul(de, $e)) | 0), - (f = (f + Math.imul(de, tt)) | 0), - (f = (f + Math.imul(ve, $e)) | 0), - (x = (x + Math.imul(ve, tt)) | 0), - (b = (b + Math.imul(ae, ie)) | 0), - (f = (f + Math.imul(ae, re)) | 0), - (f = (f + Math.imul(le, ie)) | 0), - (x = (x + Math.imul(le, re)) | 0), - (b = (b + Math.imul(fe, se)) | 0), - (f = (f + Math.imul(fe, be)) | 0), - (f = (f + Math.imul(V, se)) | 0), - (x = (x + Math.imul(V, be)) | 0), - (b = (b + Math.imul(L, Ae)) | 0), - (f = (f + Math.imul(L, ke)) | 0), - (f = (f + Math.imul(ee, Ae)) | 0), - (x = (x + Math.imul(ee, ke)) | 0); - var Bt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Bt >>> 26)) | 0), - (Bt &= 67108863), - (b = Math.imul(j, Se)), - (f = Math.imul(j, Pe)), - (f = (f + Math.imul(ce, Se)) | 0), - (x = Math.imul(ce, Pe)), - (b = (b + Math.imul(Ue, Ie)) | 0), - (f = (f + Math.imul(Ue, je)) | 0), - (f = (f + Math.imul(Y, Ie)) | 0), - (x = (x + Math.imul(Y, je)) | 0), - (b = (b + Math.imul(Ve, Fe)) | 0), - (f = (f + Math.imul(Ve, He)) | 0), - (f = (f + Math.imul(We, Fe)) | 0), - (x = (x + Math.imul(We, He)) | 0), - (b = (b + Math.imul(Ee, Xe)) | 0), - (f = (f + Math.imul(Ee, Ze)) | 0), - (f = (f + Math.imul(Be, Xe)) | 0), - (x = (x + Math.imul(Be, Ze)) | 0), - (b = (b + Math.imul(me, $e)) | 0), - (f = (f + Math.imul(me, tt)) | 0), - (f = (f + Math.imul(_e, $e)) | 0), - (x = (x + Math.imul(_e, tt)) | 0), - (b = (b + Math.imul(de, ie)) | 0), - (f = (f + Math.imul(de, re)) | 0), - (f = (f + Math.imul(ve, ie)) | 0), - (x = (x + Math.imul(ve, re)) | 0), - (b = (b + Math.imul(ae, se)) | 0), - (f = (f + Math.imul(ae, be)) | 0), - (f = (f + Math.imul(le, se)) | 0), - (x = (x + Math.imul(le, be)) | 0), - (b = (b + Math.imul(fe, Ae)) | 0), - (f = (f + Math.imul(fe, ke)) | 0), - (f = (f + Math.imul(V, Ae)) | 0), - (x = (x + Math.imul(V, ke)) | 0); - var Et = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Et >>> 26)) | 0), - (Et &= 67108863), - (b = Math.imul(j, Ie)), - (f = Math.imul(j, je)), - (f = (f + Math.imul(ce, Ie)) | 0), - (x = Math.imul(ce, je)), - (b = (b + Math.imul(Ue, Fe)) | 0), - (f = (f + Math.imul(Ue, He)) | 0), - (f = (f + Math.imul(Y, Fe)) | 0), - (x = (x + Math.imul(Y, He)) | 0), - (b = (b + Math.imul(Ve, Xe)) | 0), - (f = (f + Math.imul(Ve, Ze)) | 0), - (f = (f + Math.imul(We, Xe)) | 0), - (x = (x + Math.imul(We, Ze)) | 0), - (b = (b + Math.imul(Ee, $e)) | 0), - (f = (f + Math.imul(Ee, tt)) | 0), - (f = (f + Math.imul(Be, $e)) | 0), - (x = (x + Math.imul(Be, tt)) | 0), - (b = (b + Math.imul(me, ie)) | 0), - (f = (f + Math.imul(me, re)) | 0), - (f = (f + Math.imul(_e, ie)) | 0), - (x = (x + Math.imul(_e, re)) | 0), - (b = (b + Math.imul(de, se)) | 0), - (f = (f + Math.imul(de, be)) | 0), - (f = (f + Math.imul(ve, se)) | 0), - (x = (x + Math.imul(ve, be)) | 0), - (b = (b + Math.imul(ae, Ae)) | 0), - (f = (f + Math.imul(ae, ke)) | 0), - (f = (f + Math.imul(le, Ae)) | 0), - (x = (x + Math.imul(le, ke)) | 0); - var Mt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Mt >>> 26)) | 0), - (Mt &= 67108863), - (b = Math.imul(j, Fe)), - (f = Math.imul(j, He)), - (f = (f + Math.imul(ce, Fe)) | 0), - (x = Math.imul(ce, He)), - (b = (b + Math.imul(Ue, Xe)) | 0), - (f = (f + Math.imul(Ue, Ze)) | 0), - (f = (f + Math.imul(Y, Xe)) | 0), - (x = (x + Math.imul(Y, Ze)) | 0), - (b = (b + Math.imul(Ve, $e)) | 0), - (f = (f + Math.imul(Ve, tt)) | 0), - (f = (f + Math.imul(We, $e)) | 0), - (x = (x + Math.imul(We, tt)) | 0), - (b = (b + Math.imul(Ee, ie)) | 0), - (f = (f + Math.imul(Ee, re)) | 0), - (f = (f + Math.imul(Be, ie)) | 0), - (x = (x + Math.imul(Be, re)) | 0), - (b = (b + Math.imul(me, se)) | 0), - (f = (f + Math.imul(me, be)) | 0), - (f = (f + Math.imul(_e, se)) | 0), - (x = (x + Math.imul(_e, be)) | 0), - (b = (b + Math.imul(de, Ae)) | 0), - (f = (f + Math.imul(de, ke)) | 0), - (f = (f + Math.imul(ve, Ae)) | 0), - (x = (x + Math.imul(ve, ke)) | 0); - var gt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (gt >>> 26)) | 0), - (gt &= 67108863), - (b = Math.imul(j, Xe)), - (f = Math.imul(j, Ze)), - (f = (f + Math.imul(ce, Xe)) | 0), - (x = Math.imul(ce, Ze)), - (b = (b + Math.imul(Ue, $e)) | 0), - (f = (f + Math.imul(Ue, tt)) | 0), - (f = (f + Math.imul(Y, $e)) | 0), - (x = (x + Math.imul(Y, tt)) | 0), - (b = (b + Math.imul(Ve, ie)) | 0), - (f = (f + Math.imul(Ve, re)) | 0), - (f = (f + Math.imul(We, ie)) | 0), - (x = (x + Math.imul(We, re)) | 0), - (b = (b + Math.imul(Ee, se)) | 0), - (f = (f + Math.imul(Ee, be)) | 0), - (f = (f + Math.imul(Be, se)) | 0), - (x = (x + Math.imul(Be, be)) | 0), - (b = (b + Math.imul(me, Ae)) | 0), - (f = (f + Math.imul(me, ke)) | 0), - (f = (f + Math.imul(_e, Ae)) | 0), - (x = (x + Math.imul(_e, ke)) | 0); - var Pt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Pt >>> 26)) | 0), - (Pt &= 67108863), - (b = Math.imul(j, $e)), - (f = Math.imul(j, tt)), - (f = (f + Math.imul(ce, $e)) | 0), - (x = Math.imul(ce, tt)), - (b = (b + Math.imul(Ue, ie)) | 0), - (f = (f + Math.imul(Ue, re)) | 0), - (f = (f + Math.imul(Y, ie)) | 0), - (x = (x + Math.imul(Y, re)) | 0), - (b = (b + Math.imul(Ve, se)) | 0), - (f = (f + Math.imul(Ve, be)) | 0), - (f = (f + Math.imul(We, se)) | 0), - (x = (x + Math.imul(We, be)) | 0), - (b = (b + Math.imul(Ee, Ae)) | 0), - (f = (f + Math.imul(Ee, ke)) | 0), - (f = (f + Math.imul(Be, Ae)) | 0), - (x = (x + Math.imul(Be, ke)) | 0); - var It = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (It >>> 26)) | 0), - (It &= 67108863), - (b = Math.imul(j, ie)), - (f = Math.imul(j, re)), - (f = (f + Math.imul(ce, ie)) | 0), - (x = Math.imul(ce, re)), - (b = (b + Math.imul(Ue, se)) | 0), - (f = (f + Math.imul(Ue, be)) | 0), - (f = (f + Math.imul(Y, se)) | 0), - (x = (x + Math.imul(Y, be)) | 0), - (b = (b + Math.imul(Ve, Ae)) | 0), - (f = (f + Math.imul(Ve, ke)) | 0), - (f = (f + Math.imul(We, Ae)) | 0), - (x = (x + Math.imul(We, ke)) | 0); - var yt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (yt >>> 26)) | 0), - (yt &= 67108863), - (b = Math.imul(j, se)), - (f = Math.imul(j, be)), - (f = (f + Math.imul(ce, se)) | 0), - (x = Math.imul(ce, be)), - (b = (b + Math.imul(Ue, Ae)) | 0), - (f = (f + Math.imul(Ue, ke)) | 0), - (f = (f + Math.imul(Y, Ae)) | 0), - (x = (x + Math.imul(Y, ke)) | 0); - var nt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (nt >>> 26)) | 0), - (nt &= 67108863), - (b = Math.imul(j, Ae)), - (f = Math.imul(j, ke)), - (f = (f + Math.imul(ce, Ae)) | 0), - (x = Math.imul(ce, ke)); - var it = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - return ( - (S = (((x + (f >>> 13)) | 0) + (it >>> 26)) | 0), - (it &= 67108863), - (_[0] = Ct), - (_[1] = ut), - (_[2] = St), - (_[3] = wt), - (_[4] = zt), - (_[5] = jt), - (_[6] = Ht), - (_[7] = Ut), - (_[8] = Kt), - (_[9] = Ot), - (_[10] = Bt), - (_[11] = Et), - (_[12] = Mt), - (_[13] = gt), - (_[14] = Pt), - (_[15] = It), - (_[16] = yt), - (_[17] = nt), - (_[18] = it), - S !== 0 && ((_[19] = S), y.length++), - y - ); - }; - Math.imul || (O = k); - function D(A, l, p) { - (p.negative = l.negative ^ A.negative), - (p.length = A.length + l.length); - for (var y = 0, d = 0, v = 0; v < p.length - 1; v++) { - var _ = d; - d = 0; - for ( - var S = y & 67108863, - b = Math.min(v, l.length - 1), - f = Math.max(0, v - A.length + 1); - f <= b; - f++ - ) { - var x = v - f, - C = A.words[x] | 0, - E = l.words[f] | 0, - B = C * E, - G = B & 67108863; - (_ = (_ + ((B / 67108864) | 0)) | 0), - (G = (G + S) | 0), - (S = G & 67108863), - (_ = (_ + (G >>> 26)) | 0), - (d += _ >>> 26), - (_ &= 67108863); - } - (p.words[v] = S), (y = _), (_ = d); - } - return y !== 0 ? (p.words[v] = y) : p.length--, p.strip(); - } - function F(A, l, p) { - var y = new N(); - return y.mulp(A, l, p); - } - i.prototype.mulTo = function (l, p) { - var y, - d = this.length + l.length; - return ( - this.length === 10 && l.length === 10 - ? (y = O(this, l, p)) - : d < 63 - ? (y = k(this, l, p)) - : d < 1024 - ? (y = D(this, l, p)) - : (y = F(this, l, p)), - y - ); - }; - function N(A, l) { - (this.x = A), (this.y = l); - } - (N.prototype.makeRBT = function (l) { - for ( - var p = new Array(l), y = i.prototype._countBits(l) - 1, d = 0; - d < l; - d++ - ) - p[d] = this.revBin(d, y, l); - return p; - }), - (N.prototype.revBin = function (l, p, y) { - if (l === 0 || l === y - 1) return l; - for (var d = 0, v = 0; v < p; v++) - (d |= (l & 1) << (p - v - 1)), (l >>= 1); - return d; - }), - (N.prototype.permute = function (l, p, y, d, v, _) { - for (var S = 0; S < _; S++) (d[S] = p[l[S]]), (v[S] = y[l[S]]); - }), - (N.prototype.transform = function (l, p, y, d, v, _) { - this.permute(_, l, p, y, d, v); - for (var S = 1; S < v; S <<= 1) - for ( - var b = S << 1, - f = Math.cos((2 * Math.PI) / b), - x = Math.sin((2 * Math.PI) / b), - C = 0; - C < v; - C += b - ) - for (var E = f, B = x, G = 0; G < S; G++) { - var L = y[C + G], - ee = d[C + G], - ge = y[C + G + S], - fe = d[C + G + S], - V = E * ge - B * fe; - (fe = E * fe + B * ge), - (ge = V), - (y[C + G] = L + ge), - (d[C + G] = ee + fe), - (y[C + G + S] = L - ge), - (d[C + G + S] = ee - fe), - G !== b && - ((V = f * E - x * B), (B = f * B + x * E), (E = V)); - } - }), - (N.prototype.guessLen13b = function (l, p) { - var y = Math.max(p, l) | 1, - d = y & 1, - v = 0; - for (y = (y / 2) | 0; y; y = y >>> 1) v++; - return 1 << (v + 1 + d); - }), - (N.prototype.conjugate = function (l, p, y) { - if (!(y <= 1)) - for (var d = 0; d < y / 2; d++) { - var v = l[d]; - (l[d] = l[y - d - 1]), - (l[y - d - 1] = v), - (v = p[d]), - (p[d] = -p[y - d - 1]), - (p[y - d - 1] = -v); - } - }), - (N.prototype.normalize13b = function (l, p) { - for (var y = 0, d = 0; d < p / 2; d++) { - var v = - Math.round(l[2 * d + 1] / p) * 8192 + - Math.round(l[2 * d] / p) + - y; - (l[d] = v & 67108863), - v < 67108864 ? (y = 0) : (y = (v / 67108864) | 0); - } - return l; - }), - (N.prototype.convert13b = function (l, p, y, d) { - for (var v = 0, _ = 0; _ < p; _++) - (v = v + (l[_] | 0)), - (y[2 * _] = v & 8191), - (v = v >>> 13), - (y[2 * _ + 1] = v & 8191), - (v = v >>> 13); - for (_ = 2 * p; _ < d; ++_) y[_] = 0; - r(v === 0), r((v & -8192) === 0); - }), - (N.prototype.stub = function (l) { - for (var p = new Array(l), y = 0; y < l; y++) p[y] = 0; - return p; - }), - (N.prototype.mulp = function (l, p, y) { - var d = 2 * this.guessLen13b(l.length, p.length), - v = this.makeRBT(d), - _ = this.stub(d), - S = new Array(d), - b = new Array(d), - f = new Array(d), - x = new Array(d), - C = new Array(d), - E = new Array(d), - B = y.words; - (B.length = d), - this.convert13b(l.words, l.length, S, d), - this.convert13b(p.words, p.length, x, d), - this.transform(S, _, b, f, d, v), - this.transform(x, _, C, E, d, v); - for (var G = 0; G < d; G++) { - var L = b[G] * C[G] - f[G] * E[G]; - (f[G] = b[G] * E[G] + f[G] * C[G]), (b[G] = L); - } - return ( - this.conjugate(b, f, d), - this.transform(b, f, B, _, d, v), - this.conjugate(B, _, d), - this.normalize13b(B, d), - (y.negative = l.negative ^ p.negative), - (y.length = l.length + p.length), - y.strip() - ); - }), - (i.prototype.mul = function (l) { - var p = new i(null); - return ( - (p.words = new Array(this.length + l.length)), this.mulTo(l, p) - ); - }), - (i.prototype.mulf = function (l) { - var p = new i(null); - return (p.words = new Array(this.length + l.length)), F(this, l, p); - }), - (i.prototype.imul = function (l) { - return this.clone().mulTo(l, this); - }), - (i.prototype.imuln = function (l) { - r(typeof l == "number"), r(l < 67108864); - for (var p = 0, y = 0; y < this.length; y++) { - var d = (this.words[y] | 0) * l, - v = (d & 67108863) + (p & 67108863); - (p >>= 26), - (p += (d / 67108864) | 0), - (p += v >>> 26), - (this.words[y] = v & 67108863); - } - return p !== 0 && ((this.words[y] = p), this.length++), this; - }), - (i.prototype.muln = function (l) { - return this.clone().imuln(l); - }), - (i.prototype.sqr = function () { - return this.mul(this); - }), - (i.prototype.isqr = function () { - return this.imul(this.clone()); - }), - (i.prototype.pow = function (l) { - var p = M(l); - if (p.length === 0) return new i(1); - for ( - var y = this, d = 0; - d < p.length && p[d] === 0; - d++, y = y.sqr() - ); - if (++d < p.length) - for (var v = y.sqr(); d < p.length; d++, v = v.sqr()) - p[d] !== 0 && (y = y.mul(v)); - return y; - }), - (i.prototype.iushln = function (l) { - r(typeof l == "number" && l >= 0); - var p = l % 26, - y = (l - p) / 26, - d = (67108863 >>> (26 - p)) << (26 - p), - v; - if (p !== 0) { - var _ = 0; - for (v = 0; v < this.length; v++) { - var S = this.words[v] & d, - b = ((this.words[v] | 0) - S) << p; - (this.words[v] = b | _), (_ = S >>> (26 - p)); - } - _ && ((this.words[v] = _), this.length++); - } - if (y !== 0) { - for (v = this.length - 1; v >= 0; v--) - this.words[v + y] = this.words[v]; - for (v = 0; v < y; v++) this.words[v] = 0; - this.length += y; - } - return this.strip(); - }), - (i.prototype.ishln = function (l) { - return r(this.negative === 0), this.iushln(l); - }), - (i.prototype.iushrn = function (l, p, y) { - r(typeof l == "number" && l >= 0); - var d; - p ? (d = (p - (p % 26)) / 26) : (d = 0); - var v = l % 26, - _ = Math.min((l - v) / 26, this.length), - S = 67108863 ^ ((67108863 >>> v) << v), - b = y; - if (((d -= _), (d = Math.max(0, d)), b)) { - for (var f = 0; f < _; f++) b.words[f] = this.words[f]; - b.length = _; - } - if (_ !== 0) - if (this.length > _) - for (this.length -= _, f = 0; f < this.length; f++) - this.words[f] = this.words[f + _]; - else (this.words[0] = 0), (this.length = 1); - var x = 0; - for (f = this.length - 1; f >= 0 && (x !== 0 || f >= d); f--) { - var C = this.words[f] | 0; - (this.words[f] = (x << (26 - v)) | (C >>> v)), (x = C & S); - } - return ( - b && x !== 0 && (b.words[b.length++] = x), - this.length === 0 && ((this.words[0] = 0), (this.length = 1)), - this.strip() - ); - }), - (i.prototype.ishrn = function (l, p, y) { - return r(this.negative === 0), this.iushrn(l, p, y); - }), - (i.prototype.shln = function (l) { - return this.clone().ishln(l); - }), - (i.prototype.ushln = function (l) { - return this.clone().iushln(l); - }), - (i.prototype.shrn = function (l) { - return this.clone().ishrn(l); - }), - (i.prototype.ushrn = function (l) { - return this.clone().iushrn(l); - }), - (i.prototype.testn = function (l) { - r(typeof l == "number" && l >= 0); - var p = l % 26, - y = (l - p) / 26, - d = 1 << p; - if (this.length <= y) return !1; - var v = this.words[y]; - return !!(v & d); - }), - (i.prototype.imaskn = function (l) { - r(typeof l == "number" && l >= 0); - var p = l % 26, - y = (l - p) / 26; - if ( - (r(this.negative === 0, "imaskn works only with positive numbers"), - this.length <= y) - ) - return this; - if ( - (p !== 0 && y++, (this.length = Math.min(y, this.length)), p !== 0) - ) { - var d = 67108863 ^ ((67108863 >>> p) << p); - this.words[this.length - 1] &= d; - } - return this.strip(); - }), - (i.prototype.maskn = function (l) { - return this.clone().imaskn(l); - }), - (i.prototype.iaddn = function (l) { - return ( - r(typeof l == "number"), - r(l < 67108864), - l < 0 - ? this.isubn(-l) - : this.negative !== 0 - ? this.length === 1 && (this.words[0] | 0) < l - ? ((this.words[0] = l - (this.words[0] | 0)), - (this.negative = 0), - this) - : ((this.negative = 0), - this.isubn(l), - (this.negative = 1), - this) - : this._iaddn(l) - ); - }), - (i.prototype._iaddn = function (l) { - this.words[0] += l; - for (var p = 0; p < this.length && this.words[p] >= 67108864; p++) - (this.words[p] -= 67108864), - p === this.length - 1 - ? (this.words[p + 1] = 1) - : this.words[p + 1]++; - return (this.length = Math.max(this.length, p + 1)), this; - }), - (i.prototype.isubn = function (l) { - if ((r(typeof l == "number"), r(l < 67108864), l < 0)) - return this.iaddn(-l); - if (this.negative !== 0) - return ( - (this.negative = 0), this.iaddn(l), (this.negative = 1), this - ); - if (((this.words[0] -= l), this.length === 1 && this.words[0] < 0)) - (this.words[0] = -this.words[0]), (this.negative = 1); - else - for (var p = 0; p < this.length && this.words[p] < 0; p++) - (this.words[p] += 67108864), (this.words[p + 1] -= 1); - return this.strip(); - }), - (i.prototype.addn = function (l) { - return this.clone().iaddn(l); - }), - (i.prototype.subn = function (l) { - return this.clone().isubn(l); - }), - (i.prototype.iabs = function () { - return (this.negative = 0), this; - }), - (i.prototype.abs = function () { - return this.clone().iabs(); - }), - (i.prototype._ishlnsubmul = function (l, p, y) { - var d = l.length + y, - v; - this._expand(d); - var _, - S = 0; - for (v = 0; v < l.length; v++) { - _ = (this.words[v + y] | 0) + S; - var b = (l.words[v] | 0) * p; - (_ -= b & 67108863), - (S = (_ >> 26) - ((b / 67108864) | 0)), - (this.words[v + y] = _ & 67108863); - } - for (; v < this.length - y; v++) - (_ = (this.words[v + y] | 0) + S), - (S = _ >> 26), - (this.words[v + y] = _ & 67108863); - if (S === 0) return this.strip(); - for (r(S === -1), S = 0, v = 0; v < this.length; v++) - (_ = -(this.words[v] | 0) + S), - (S = _ >> 26), - (this.words[v] = _ & 67108863); - return (this.negative = 1), this.strip(); - }), - (i.prototype._wordDiv = function (l, p) { - var y = this.length - l.length, - d = this.clone(), - v = l, - _ = v.words[v.length - 1] | 0, - S = this._countBits(_); - (y = 26 - S), - y !== 0 && - ((v = v.ushln(y)), d.iushln(y), (_ = v.words[v.length - 1] | 0)); - var b = d.length - v.length, - f; - if (p !== "mod") { - (f = new i(null)), - (f.length = b + 1), - (f.words = new Array(f.length)); - for (var x = 0; x < f.length; x++) f.words[x] = 0; - } - var C = d.clone()._ishlnsubmul(v, 1, b); - C.negative === 0 && ((d = C), f && (f.words[b] = 1)); - for (var E = b - 1; E >= 0; E--) { - var B = - (d.words[v.length + E] | 0) * 67108864 + - (d.words[v.length + E - 1] | 0); - for ( - B = Math.min((B / _) | 0, 67108863), d._ishlnsubmul(v, B, E); - d.negative !== 0; - - ) - B--, - (d.negative = 0), - d._ishlnsubmul(v, 1, E), - d.isZero() || (d.negative ^= 1); - f && (f.words[E] = B); - } - return ( - f && f.strip(), - d.strip(), - p !== "div" && y !== 0 && d.iushrn(y), - { div: f || null, mod: d } - ); - }), - (i.prototype.divmod = function (l, p, y) { - if ((r(!l.isZero()), this.isZero())) - return { div: new i(0), mod: new i(0) }; - var d, v, _; - return this.negative !== 0 && l.negative === 0 - ? ((_ = this.neg().divmod(l, p)), - p !== "mod" && (d = _.div.neg()), - p !== "div" && - ((v = _.mod.neg()), y && v.negative !== 0 && v.iadd(l)), - { div: d, mod: v }) - : this.negative === 0 && l.negative !== 0 - ? ((_ = this.divmod(l.neg(), p)), - p !== "mod" && (d = _.div.neg()), - { div: d, mod: _.mod }) - : (this.negative & l.negative) !== 0 - ? ((_ = this.neg().divmod(l.neg(), p)), - p !== "div" && - ((v = _.mod.neg()), y && v.negative !== 0 && v.isub(l)), - { div: _.div, mod: v }) - : l.length > this.length || this.cmp(l) < 0 - ? { div: new i(0), mod: this } - : l.length === 1 - ? p === "div" - ? { div: this.divn(l.words[0]), mod: null } - : p === "mod" - ? { div: null, mod: new i(this.modn(l.words[0])) } - : { - div: this.divn(l.words[0]), - mod: new i(this.modn(l.words[0])), - } - : this._wordDiv(l, p); - }), - (i.prototype.div = function (l) { - return this.divmod(l, "div", !1).div; - }), - (i.prototype.mod = function (l) { - return this.divmod(l, "mod", !1).mod; - }), - (i.prototype.umod = function (l) { - return this.divmod(l, "mod", !0).mod; - }), - (i.prototype.divRound = function (l) { - var p = this.divmod(l); - if (p.mod.isZero()) return p.div; - var y = p.div.negative !== 0 ? p.mod.isub(l) : p.mod, - d = l.ushrn(1), - v = l.andln(1), - _ = y.cmp(d); - return _ < 0 || (v === 1 && _ === 0) - ? p.div - : p.div.negative !== 0 - ? p.div.isubn(1) - : p.div.iaddn(1); - }), - (i.prototype.modn = function (l) { - r(l <= 67108863); - for (var p = (1 << 26) % l, y = 0, d = this.length - 1; d >= 0; d--) - y = (p * y + (this.words[d] | 0)) % l; - return y; - }), - (i.prototype.idivn = function (l) { - r(l <= 67108863); - for (var p = 0, y = this.length - 1; y >= 0; y--) { - var d = (this.words[y] | 0) + p * 67108864; - (this.words[y] = (d / l) | 0), (p = d % l); - } - return this.strip(); - }), - (i.prototype.divn = function (l) { - return this.clone().idivn(l); - }), - (i.prototype.egcd = function (l) { - r(l.negative === 0), r(!l.isZero()); - var p = this, - y = l.clone(); - p.negative !== 0 ? (p = p.umod(l)) : (p = p.clone()); - for ( - var d = new i(1), v = new i(0), _ = new i(0), S = new i(1), b = 0; - p.isEven() && y.isEven(); - - ) - p.iushrn(1), y.iushrn(1), ++b; - for (var f = y.clone(), x = p.clone(); !p.isZero(); ) { - for ( - var C = 0, E = 1; - (p.words[0] & E) === 0 && C < 26; - ++C, E <<= 1 - ); - if (C > 0) - for (p.iushrn(C); C-- > 0; ) - (d.isOdd() || v.isOdd()) && (d.iadd(f), v.isub(x)), - d.iushrn(1), - v.iushrn(1); - for ( - var B = 0, G = 1; - (y.words[0] & G) === 0 && B < 26; - ++B, G <<= 1 - ); - if (B > 0) - for (y.iushrn(B); B-- > 0; ) - (_.isOdd() || S.isOdd()) && (_.iadd(f), S.isub(x)), - _.iushrn(1), - S.iushrn(1); - p.cmp(y) >= 0 - ? (p.isub(y), d.isub(_), v.isub(S)) - : (y.isub(p), _.isub(d), S.isub(v)); - } - return { a: _, b: S, gcd: y.iushln(b) }; - }), - (i.prototype._invmp = function (l) { - r(l.negative === 0), r(!l.isZero()); - var p = this, - y = l.clone(); - p.negative !== 0 ? (p = p.umod(l)) : (p = p.clone()); - for ( - var d = new i(1), v = new i(0), _ = y.clone(); - p.cmpn(1) > 0 && y.cmpn(1) > 0; - - ) { - for ( - var S = 0, b = 1; - (p.words[0] & b) === 0 && S < 26; - ++S, b <<= 1 - ); - if (S > 0) - for (p.iushrn(S); S-- > 0; ) d.isOdd() && d.iadd(_), d.iushrn(1); - for ( - var f = 0, x = 1; - (y.words[0] & x) === 0 && f < 26; - ++f, x <<= 1 - ); - if (f > 0) - for (y.iushrn(f); f-- > 0; ) v.isOdd() && v.iadd(_), v.iushrn(1); - p.cmp(y) >= 0 ? (p.isub(y), d.isub(v)) : (y.isub(p), v.isub(d)); - } - var C; - return ( - p.cmpn(1) === 0 ? (C = d) : (C = v), C.cmpn(0) < 0 && C.iadd(l), C - ); - }), - (i.prototype.gcd = function (l) { - if (this.isZero()) return l.abs(); - if (l.isZero()) return this.abs(); - var p = this.clone(), - y = l.clone(); - (p.negative = 0), (y.negative = 0); - for (var d = 0; p.isEven() && y.isEven(); d++) - p.iushrn(1), y.iushrn(1); - do { - for (; p.isEven(); ) p.iushrn(1); - for (; y.isEven(); ) y.iushrn(1); - var v = p.cmp(y); - if (v < 0) { - var _ = p; - (p = y), (y = _); - } else if (v === 0 || y.cmpn(1) === 0) break; - p.isub(y); - } while (!0); - return y.iushln(d); - }), - (i.prototype.invm = function (l) { - return this.egcd(l).a.umod(l); - }), - (i.prototype.isEven = function () { - return (this.words[0] & 1) === 0; - }), - (i.prototype.isOdd = function () { - return (this.words[0] & 1) === 1; - }), - (i.prototype.andln = function (l) { - return this.words[0] & l; - }), - (i.prototype.bincn = function (l) { - r(typeof l == "number"); - var p = l % 26, - y = (l - p) / 26, - d = 1 << p; - if (this.length <= y) - return this._expand(y + 1), (this.words[y] |= d), this; - for (var v = d, _ = y; v !== 0 && _ < this.length; _++) { - var S = this.words[_] | 0; - (S += v), (v = S >>> 26), (S &= 67108863), (this.words[_] = S); - } - return v !== 0 && ((this.words[_] = v), this.length++), this; - }), - (i.prototype.isZero = function () { - return this.length === 1 && this.words[0] === 0; - }), - (i.prototype.cmpn = function (l) { - var p = l < 0; - if (this.negative !== 0 && !p) return -1; - if (this.negative === 0 && p) return 1; - this.strip(); - var y; - if (this.length > 1) y = 1; - else { - p && (l = -l), r(l <= 67108863, "Number is too big"); - var d = this.words[0] | 0; - y = d === l ? 0 : d < l ? -1 : 1; - } - return this.negative !== 0 ? -y | 0 : y; - }), - (i.prototype.cmp = function (l) { - if (this.negative !== 0 && l.negative === 0) return -1; - if (this.negative === 0 && l.negative !== 0) return 1; - var p = this.ucmp(l); - return this.negative !== 0 ? -p | 0 : p; - }), - (i.prototype.ucmp = function (l) { - if (this.length > l.length) return 1; - if (this.length < l.length) return -1; - for (var p = 0, y = this.length - 1; y >= 0; y--) { - var d = this.words[y] | 0, - v = l.words[y] | 0; - if (d !== v) { - d < v ? (p = -1) : d > v && (p = 1); - break; - } - } - return p; - }), - (i.prototype.gtn = function (l) { - return this.cmpn(l) === 1; - }), - (i.prototype.gt = function (l) { - return this.cmp(l) === 1; - }), - (i.prototype.gten = function (l) { - return this.cmpn(l) >= 0; - }), - (i.prototype.gte = function (l) { - return this.cmp(l) >= 0; - }), - (i.prototype.ltn = function (l) { - return this.cmpn(l) === -1; - }), - (i.prototype.lt = function (l) { - return this.cmp(l) === -1; - }), - (i.prototype.lten = function (l) { - return this.cmpn(l) <= 0; - }), - (i.prototype.lte = function (l) { - return this.cmp(l) <= 0; - }), - (i.prototype.eqn = function (l) { - return this.cmpn(l) === 0; - }), - (i.prototype.eq = function (l) { - return this.cmp(l) === 0; - }), - (i.red = function (l) { - return new te(l); - }), - (i.prototype.toRed = function (l) { - return ( - r(!this.red, "Already a number in reduction context"), - r(this.negative === 0, "red works only with positives"), - l.convertTo(this)._forceRed(l) - ); - }), - (i.prototype.fromRed = function () { - return ( - r(this.red, "fromRed works only with numbers in reduction context"), - this.red.convertFrom(this) - ); - }), - (i.prototype._forceRed = function (l) { - return (this.red = l), this; - }), - (i.prototype.forceRed = function (l) { - return ( - r(!this.red, "Already a number in reduction context"), - this._forceRed(l) - ); - }), - (i.prototype.redAdd = function (l) { - return ( - r(this.red, "redAdd works only with red numbers"), - this.red.add(this, l) - ); - }), - (i.prototype.redIAdd = function (l) { - return ( - r(this.red, "redIAdd works only with red numbers"), - this.red.iadd(this, l) - ); - }), - (i.prototype.redSub = function (l) { - return ( - r(this.red, "redSub works only with red numbers"), - this.red.sub(this, l) - ); - }), - (i.prototype.redISub = function (l) { - return ( - r(this.red, "redISub works only with red numbers"), - this.red.isub(this, l) - ); - }), - (i.prototype.redShl = function (l) { - return ( - r(this.red, "redShl works only with red numbers"), - this.red.shl(this, l) - ); - }), - (i.prototype.redMul = function (l) { - return ( - r(this.red, "redMul works only with red numbers"), - this.red._verify2(this, l), - this.red.mul(this, l) - ); - }), - (i.prototype.redIMul = function (l) { - return ( - r(this.red, "redMul works only with red numbers"), - this.red._verify2(this, l), - this.red.imul(this, l) - ); - }), - (i.prototype.redSqr = function () { - return ( - r(this.red, "redSqr works only with red numbers"), - this.red._verify1(this), - this.red.sqr(this) - ); - }), - (i.prototype.redISqr = function () { - return ( - r(this.red, "redISqr works only with red numbers"), - this.red._verify1(this), - this.red.isqr(this) - ); - }), - (i.prototype.redSqrt = function () { - return ( - r(this.red, "redSqrt works only with red numbers"), - this.red._verify1(this), - this.red.sqrt(this) - ); - }), - (i.prototype.redInvm = function () { - return ( - r(this.red, "redInvm works only with red numbers"), - this.red._verify1(this), - this.red.invm(this) - ); - }), - (i.prototype.redNeg = function () { - return ( - r(this.red, "redNeg works only with red numbers"), - this.red._verify1(this), - this.red.neg(this) - ); - }), - (i.prototype.redPow = function (l) { - return ( - r(this.red && !l.red, "redPow(normalNum)"), - this.red._verify1(this), - this.red.pow(this, l) - ); - }); - var q = { k256: null, p224: null, p192: null, p25519: null }; - function z(A, l) { - (this.name = A), - (this.p = new i(l, 16)), - (this.n = this.p.bitLength()), - (this.k = new i(1).iushln(this.n).isub(this.p)), - (this.tmp = this._tmp()); - } - (z.prototype._tmp = function () { - var l = new i(null); - return (l.words = new Array(Math.ceil(this.n / 13))), l; - }), - (z.prototype.ireduce = function (l) { - var p = l, - y; - do - this.split(p, this.tmp), - (p = this.imulK(p)), - (p = p.iadd(this.tmp)), - (y = p.bitLength()); - while (y > this.n); - var d = y < this.n ? -1 : p.ucmp(this.p); - return ( - d === 0 - ? ((p.words[0] = 0), (p.length = 1)) - : d > 0 - ? p.isub(this.p) - : p.strip !== void 0 - ? p.strip() - : p._strip(), - p - ); - }), - (z.prototype.split = function (l, p) { - l.iushrn(this.n, 0, p); - }), - (z.prototype.imulK = function (l) { - return l.imul(this.k); - }); - function H() { - z.call( - this, - "k256", - "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f" - ); - } - n(H, z), - (H.prototype.split = function (l, p) { - for (var y = 4194303, d = Math.min(l.length, 9), v = 0; v < d; v++) - p.words[v] = l.words[v]; - if (((p.length = d), l.length <= 9)) { - (l.words[0] = 0), (l.length = 1); - return; - } - var _ = l.words[9]; - for (p.words[p.length++] = _ & y, v = 10; v < l.length; v++) { - var S = l.words[v] | 0; - (l.words[v - 10] = ((S & y) << 4) | (_ >>> 22)), (_ = S); - } - (_ >>>= 22), - (l.words[v - 10] = _), - _ === 0 && l.length > 10 ? (l.length -= 10) : (l.length -= 9); - }), - (H.prototype.imulK = function (l) { - (l.words[l.length] = 0), (l.words[l.length + 1] = 0), (l.length += 2); - for (var p = 0, y = 0; y < l.length; y++) { - var d = l.words[y] | 0; - (p += d * 977), - (l.words[y] = p & 67108863), - (p = d * 64 + ((p / 67108864) | 0)); - } - return ( - l.words[l.length - 1] === 0 && - (l.length--, l.words[l.length - 1] === 0 && l.length--), - l - ); - }); - function Z() { - z.call( - this, - "p224", - "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001" - ); - } - n(Z, z); - function $() { - z.call( - this, - "p192", - "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff" - ); - } - n($, z); - function ue() { - z.call( - this, - "25519", - "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed" - ); - } - n(ue, z), - (ue.prototype.imulK = function (l) { - for (var p = 0, y = 0; y < l.length; y++) { - var d = (l.words[y] | 0) * 19 + p, - v = d & 67108863; - (d >>>= 26), (l.words[y] = v), (p = d); - } - return p !== 0 && (l.words[l.length++] = p), l; - }), - (i._prime = function (l) { - if (q[l]) return q[l]; - var p; - if (l === "k256") p = new H(); - else if (l === "p224") p = new Z(); - else if (l === "p192") p = new $(); - else if (l === "p25519") p = new ue(); - else throw new Error("Unknown prime " + l); - return (q[l] = p), p; - }); - function te(A) { - if (typeof A == "string") { - var l = i._prime(A); - (this.m = l.p), (this.prime = l); - } else - r(A.gtn(1), "modulus must be greater than 1"), - (this.m = A), - (this.prime = null); - } - (te.prototype._verify1 = function (l) { - r(l.negative === 0, "red works only with positives"), - r(l.red, "red works only with red numbers"); - }), - (te.prototype._verify2 = function (l, p) { - r((l.negative | p.negative) === 0, "red works only with positives"), - r(l.red && l.red === p.red, "red works only with red numbers"); - }), - (te.prototype.imod = function (l) { - return this.prime - ? this.prime.ireduce(l)._forceRed(this) - : l.umod(this.m)._forceRed(this); - }), - (te.prototype.neg = function (l) { - return l.isZero() ? l.clone() : this.m.sub(l)._forceRed(this); - }), - (te.prototype.add = function (l, p) { - this._verify2(l, p); - var y = l.add(p); - return y.cmp(this.m) >= 0 && y.isub(this.m), y._forceRed(this); - }), - (te.prototype.iadd = function (l, p) { - this._verify2(l, p); - var y = l.iadd(p); - return y.cmp(this.m) >= 0 && y.isub(this.m), y; - }), - (te.prototype.sub = function (l, p) { - this._verify2(l, p); - var y = l.sub(p); - return y.cmpn(0) < 0 && y.iadd(this.m), y._forceRed(this); - }), - (te.prototype.isub = function (l, p) { - this._verify2(l, p); - var y = l.isub(p); - return y.cmpn(0) < 0 && y.iadd(this.m), y; - }), - (te.prototype.shl = function (l, p) { - return this._verify1(l), this.imod(l.ushln(p)); - }), - (te.prototype.imul = function (l, p) { - return this._verify2(l, p), this.imod(l.imul(p)); - }), - (te.prototype.mul = function (l, p) { - return this._verify2(l, p), this.imod(l.mul(p)); - }), - (te.prototype.isqr = function (l) { - return this.imul(l, l.clone()); - }), - (te.prototype.sqr = function (l) { - return this.mul(l, l); - }), - (te.prototype.sqrt = function (l) { - if (l.isZero()) return l.clone(); - var p = this.m.andln(3); - if ((r(p % 2 === 1), p === 3)) { - var y = this.m.add(new i(1)).iushrn(2); - return this.pow(l, y); - } - for (var d = this.m.subn(1), v = 0; !d.isZero() && d.andln(1) === 0; ) - v++, d.iushrn(1); - r(!d.isZero()); - var _ = new i(1).toRed(this), - S = _.redNeg(), - b = this.m.subn(1).iushrn(1), - f = this.m.bitLength(); - for (f = new i(2 * f * f).toRed(this); this.pow(f, b).cmp(S) !== 0; ) - f.redIAdd(S); - for ( - var x = this.pow(f, d), - C = this.pow(l, d.addn(1).iushrn(1)), - E = this.pow(l, d), - B = v; - E.cmp(_) !== 0; - - ) { - for (var G = E, L = 0; G.cmp(_) !== 0; L++) G = G.redSqr(); - r(L < B); - var ee = this.pow(x, new i(1).iushln(B - L - 1)); - (C = C.redMul(ee)), (x = ee.redSqr()), (E = E.redMul(x)), (B = L); - } - return C; - }), - (te.prototype.invm = function (l) { - var p = l._invmp(this.m); - return p.negative !== 0 - ? ((p.negative = 0), this.imod(p).redNeg()) - : this.imod(p); - }), - (te.prototype.pow = function (l, p) { - if (p.isZero()) return new i(1).toRed(this); - if (p.cmpn(1) === 0) return l.clone(); - var y = 4, - d = new Array(1 << y); - (d[0] = new i(1).toRed(this)), (d[1] = l); - for (var v = 2; v < d.length; v++) d[v] = this.mul(d[v - 1], l); - var _ = d[0], - S = 0, - b = 0, - f = p.bitLength() % 26; - for (f === 0 && (f = 26), v = p.length - 1; v >= 0; v--) { - for (var x = p.words[v], C = f - 1; C >= 0; C--) { - var E = (x >> C) & 1; - if ((_ !== d[0] && (_ = this.sqr(_)), E === 0 && S === 0)) { - b = 0; - continue; - } - (S <<= 1), - (S |= E), - b++, - !(b !== y && (v !== 0 || C !== 0)) && - ((_ = this.mul(_, d[S])), (b = 0), (S = 0)); - } - f = 26; - } - return _; - }), - (te.prototype.convertTo = function (l) { - var p = l.umod(this.m); - return p === l ? p.clone() : p; - }), - (te.prototype.convertFrom = function (l) { - var p = l.clone(); - return (p.red = null), p; - }), - (i.mont = function (l) { - return new ne(l); - }); - function ne(A) { - te.call(this, A), - (this.shift = this.m.bitLength()), - this.shift % 26 !== 0 && (this.shift += 26 - (this.shift % 26)), - (this.r = new i(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)); - } - n(ne, te), - (ne.prototype.convertTo = function (l) { - return this.imod(l.ushln(this.shift)); - }), - (ne.prototype.convertFrom = function (l) { - var p = this.imod(l.mul(this.rinv)); - return (p.red = null), p; - }), - (ne.prototype.imul = function (l, p) { - if (l.isZero() || p.isZero()) - return (l.words[0] = 0), (l.length = 1), l; - var y = l.imul(p), - d = y - .maskn(this.shift) - .mul(this.minv) - .imaskn(this.shift) - .mul(this.m), - v = y.isub(d).iushrn(this.shift), - _ = v; - return ( - v.cmp(this.m) >= 0 - ? (_ = v.isub(this.m)) - : v.cmpn(0) < 0 && (_ = v.iadd(this.m)), - _._forceRed(this) - ); - }), - (ne.prototype.mul = function (l, p) { - if (l.isZero() || p.isZero()) return new i(0)._forceRed(this); - var y = l.mul(p), - d = y - .maskn(this.shift) - .mul(this.minv) - .imaskn(this.shift) - .mul(this.m), - v = y.isub(d).iushrn(this.shift), - _ = v; - return ( - v.cmp(this.m) >= 0 - ? (_ = v.isub(this.m)) - : v.cmpn(0) < 0 && (_ = v.iadd(this.m)), - _._forceRed(this) - ); - }), - (ne.prototype.invm = function (l) { - var p = this.imod(l._invmp(this.m).mul(this.r2)); - return p._forceRed(this); - }); - })(typeof $ve > "u" || $ve, _Ve); - }); - var $Z = I((jln, Yve) => { - m(); - g(); - var Zve; - Yve.exports = function (e) { - return Zve || (Zve = new h2(null)), Zve.generate(e); - }; - function h2(t) { - this.rand = t; - } - Yve.exports.Rand = h2; - h2.prototype.generate = function (e) { - return this._rand(e); - }; - h2.prototype._rand = function (e) { - if (this.rand.getBytes) return this.rand.getBytes(e); - for (var r = new Uint8Array(e), n = 0; n < r.length; n++) - r[n] = this.rand.getByte(); - return r; - }; - if (typeof self == "object") - self.crypto && self.crypto.getRandomValues - ? (h2.prototype._rand = function (e) { - var r = new Uint8Array(e); - return self.crypto.getRandomValues(r), r; - }) - : self.msCrypto && self.msCrypto.getRandomValues - ? (h2.prototype._rand = function (e) { - var r = new Uint8Array(e); - return self.msCrypto.getRandomValues(r), r; - }) - : typeof window == "object" && - (h2.prototype._rand = function () { - throw new Error("Not implemented yet"); - }); - else - try { - if (((Xve = Rp()), typeof Xve.randomBytes != "function")) - throw new Error("Not supported"); - h2.prototype._rand = function (e) { - return Xve.randomBytes(e); - }; - } catch {} - var Xve; - }); - var Qve = I((Uln, SVe) => { - m(); - g(); - var MM = xVe(), - lXt = $Z(); - function TM(t) { - this.rand = t || new lXt.Rand(); - } - SVe.exports = TM; - TM.create = function (e) { - return new TM(e); - }; - TM.prototype._randbelow = function (e) { - var r = e.bitLength(), - n = Math.ceil(r / 8); - do var i = new MM(this.rand.generate(n)); - while (i.cmp(e) >= 0); - return i; - }; - TM.prototype._randrange = function (e, r) { - var n = r.sub(e); - return e.add(this._randbelow(n)); - }; - TM.prototype.test = function (e, r, n) { - var i = e.bitLength(), - o = MM.mont(e), - a = new MM(1).toRed(o); - r || (r = Math.max(1, (i / 48) | 0)); - for (var s = e.subn(1), c = 0; !s.testn(c); c++); - for (var u = e.shrn(c), h = s.toRed(o), w = !0; r > 0; r--) { - var M = this._randrange(new MM(2), s); - n && n(M); - var k = M.toRed(o).redPow(u); - if (!(k.cmp(a) === 0 || k.cmp(h) === 0)) { - for (var O = 1; O < c; O++) { - if (((k = k.redSqr()), k.cmp(a) === 0)) return !1; - if (k.cmp(h) === 0) break; - } - if (O === c) return !1; - } - } - return w; - }; - TM.prototype.getDivisor = function (e, r) { - var n = e.bitLength(), - i = MM.mont(e), - o = new MM(1).toRed(i); - r || (r = Math.max(1, (n / 48) | 0)); - for (var a = e.subn(1), s = 0; !a.testn(s); s++); - for (var c = e.shrn(s), u = a.toRed(i); r > 0; r--) { - var h = this._randrange(new MM(2), a), - w = e.gcd(h); - if (w.cmpn(1) !== 0) return w; - var M = h.toRed(i).redPow(c); - if (!(M.cmp(o) === 0 || M.cmp(u) === 0)) { - for (var k = 1; k < s; k++) { - if (((M = M.redSqr()), M.cmp(o) === 0)) - return M.fromRed().subn(1).gcd(e); - if (M.cmp(u) === 0) break; - } - if (k === s) return (M = M.redSqr()), M.fromRed().subn(1).gcd(e); - } - } - return !1; - }; - }); - var obe = I((Gln, MVe) => { - m(); - g(); - var fXt = sM(); - MVe.exports = ibe; - ibe.simpleSieve = rbe; - ibe.fermatTest = nbe; - var Qu = Jve(), - dXt = new Qu(24), - hXt = Qve(), - AVe = new hXt(), - pXt = new Qu(1), - tbe = new Qu(2), - yXt = new Qu(5), - Kln = new Qu(16), - Hln = new Qu(8), - mXt = new Qu(10), - gXt = new Qu(3), - Vln = new Qu(7), - vXt = new Qu(11), - EVe = new Qu(4), - Wln = new Qu(12), - ebe = null; - function bXt() { - if (ebe !== null) return ebe; - var t = 1048576, - e = []; - e[0] = 2; - for (var r = 1, n = 3; n < t; n += 2) { - for ( - var i = Math.ceil(Math.sqrt(n)), o = 0; - o < r && e[o] <= i && n % e[o] !== 0; - o++ - ); - (r !== o && e[o] <= i) || (e[r++] = n); - } - return (ebe = e), e; - } - function rbe(t) { - for (var e = bXt(), r = 0; r < e.length; r++) - if (t.modn(e[r]) === 0) return t.cmpn(e[r]) === 0; - return !0; - } - function nbe(t) { - var e = Qu.mont(t); - return tbe.toRed(e).redPow(t.subn(1)).fromRed().cmpn(1) === 0; - } - function ibe(t, e) { - if (t < 16) - return e === 2 || e === 5 ? new Qu([140, 123]) : new Qu([140, 39]); - e = new Qu(e); - for (var r, n; ; ) { - for (r = new Qu(fXt(Math.ceil(t / 8))); r.bitLength() > t; ) r.ishrn(1); - if ( - (r.isEven() && r.iadd(pXt), r.testn(1) || r.iadd(tbe), e.cmp(tbe)) - ) { - if (!e.cmp(yXt)) for (; r.mod(mXt).cmp(gXt); ) r.iadd(EVe); - } else for (; r.mod(dXt).cmp(vXt); ) r.iadd(EVe); - if ( - ((n = r.shrn(1)), - rbe(n) && rbe(r) && nbe(n) && nbe(r) && AVe.test(n) && AVe.test(r)) - ) - return r; - } - } - }); - var TVe = I((Jln, wXt) => { - wXt.exports = { - modp1: { - gen: "02", - prime: - "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a63a3620ffffffffffffffff", - }, - modp2: { - gen: "02", - prime: - "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece65381ffffffffffffffff", - }, - modp5: { - gen: "02", - prime: - "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca237327ffffffffffffffff", - }, - modp14: { - gen: "02", - prime: - "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aacaa68ffffffffffffffff", - }, - modp15: { - gen: "02", - prime: - "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a93ad2caffffffffffffffff", - }, - modp16: { - gen: "02", - prime: - "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c934063199ffffffffffffffff", - }, - modp17: { - gen: "02", - prime: - "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c93402849236c3fab4d27c7026c1d4dcb2602646dec9751e763dba37bdf8ff9406ad9e530ee5db382f413001aeb06a53ed9027d831179727b0865a8918da3edbebcf9b14ed44ce6cbaced4bb1bdb7f1447e6cc254b332051512bd7af426fb8f401378cd2bf5983ca01c64b92ecf032ea15d1721d03f482d7ce6e74fef6d55e702f46980c82b5a84031900b1c9e59e7c97fbec7e8f323a97a7e36cc88be0f1d45b7ff585ac54bd407b22b4154aacc8f6d7ebf48e1d814cc5ed20f8037e0a79715eef29be32806a1d58bb7c5da76f550aa3d8a1fbff0eb19ccb1a313d55cda56c9ec2ef29632387fe8d76e3c0468043e8f663f4860ee12bf2d5b0b7474d6e694f91e6dcc4024ffffffffffffffff", - }, - modp18: { - gen: "02", - prime: - "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", - }, - }; - }); - var BVe = I(($ln, OVe) => { - m(); - g(); - var oy = Jve(), - _Xt = Qve(), - kVe = new _Xt(), - xXt = new oy(24), - SXt = new oy(11), - AXt = new oy(10), - EXt = new oy(3), - MXt = new oy(7), - PVe = obe(), - TXt = sM(); - OVe.exports = I_; - function kXt(t, e) { - return ( - (e = e || "utf8"), - Buffer.isBuffer(t) || (t = new Buffer(t, e)), - (this._pub = new oy(t)), - this - ); - } - function PXt(t, e) { - return ( - (e = e || "utf8"), - Buffer.isBuffer(t) || (t = new Buffer(t, e)), - (this._priv = new oy(t)), - this - ); - } - var ZZ = {}; - function OXt(t, e) { - var r = e.toString("hex"), - n = [r, t.toString(16)].join("_"); - if (n in ZZ) return ZZ[n]; - var i = 0; - if (t.isEven() || !PVe.simpleSieve || !PVe.fermatTest(t) || !kVe.test(t)) - return ( - (i += 1), - r === "02" || r === "05" ? (i += 8) : (i += 4), - (ZZ[n] = i), - i - ); - kVe.test(t.shrn(1)) || (i += 2); - var o; - switch (r) { - case "02": - t.mod(xXt).cmp(SXt) && (i += 8); - break; - case "05": - (o = t.mod(AXt)), o.cmp(EXt) && o.cmp(MXt) && (i += 8); - break; - default: - i += 4; - } - return (ZZ[n] = i), i; - } - function I_(t, e, r) { - this.setGenerator(e), - (this.__prime = new oy(t)), - (this._prime = oy.mont(this.__prime)), - (this._primeLen = t.length), - (this._pub = void 0), - (this._priv = void 0), - (this._primeCode = void 0), - r - ? ((this.setPublicKey = kXt), (this.setPrivateKey = PXt)) - : (this._primeCode = 8); - } - Object.defineProperty(I_.prototype, "verifyError", { - enumerable: !0, - get: function () { - return ( - typeof this._primeCode != "number" && - (this._primeCode = OXt(this.__prime, this.__gen)), - this._primeCode - ); - }, - }); - I_.prototype.generateKeys = function () { - return ( - this._priv || (this._priv = new oy(TXt(this._primeLen))), - (this._pub = this._gen.toRed(this._prime).redPow(this._priv).fromRed()), - this.getPublicKey() - ); - }; - I_.prototype.computeSecret = function (t) { - (t = new oy(t)), (t = t.toRed(this._prime)); - var e = t.redPow(this._priv).fromRed(), - r = new Buffer(e.toArray()), - n = this.getPrime(); - if (r.length < n.length) { - var i = new Buffer(n.length - r.length); - i.fill(0), (r = Buffer.concat([i, r])); - } - return r; - }; - I_.prototype.getPublicKey = function (e) { - return XZ(this._pub, e); - }; - I_.prototype.getPrivateKey = function (e) { - return XZ(this._priv, e); - }; - I_.prototype.getPrime = function (t) { - return XZ(this.__prime, t); - }; - I_.prototype.getGenerator = function (t) { - return XZ(this._gen, t); - }; - I_.prototype.setGenerator = function (t, e) { - return ( - (e = e || "utf8"), - Buffer.isBuffer(t) || (t = new Buffer(t, e)), - (this.__gen = t), - (this._gen = new oy(t)), - this - ); - }; - function XZ(t, e) { - var r = new Buffer(t.toArray()); - return e ? r.toString(e) : r; - } - }); - var RVe = I((A5) => { - m(); - g(); - var BXt = obe(), - IVe = TVe(), - abe = BVe(); - function IXt(t) { - var e = new Buffer(IVe[t].prime, "hex"), - r = new Buffer(IVe[t].gen, "hex"); - return new abe(e, r); - } - var CXt = { binary: !0, hex: !0, base64: !0 }; - function CVe(t, e, r, n) { - return Buffer.isBuffer(e) || CXt[e] === void 0 - ? CVe(t, "binary", e, r) - : ((e = e || "binary"), - (n = n || "binary"), - (r = r || new Buffer([2])), - Buffer.isBuffer(r) || (r = new Buffer(r, n)), - typeof t == "number" - ? new abe(BXt(t, r), r, !0) - : (Buffer.isBuffer(t) || (t = new Buffer(t, e)), - new abe(t, r, !0))); - } - A5.DiffieHellmanGroup = - A5.createDiffieHellmanGroup = - A5.getDiffieHellman = - IXt; - A5.createDiffieHellman = A5.DiffieHellman = CVe; - }); - var Ho = I((NVe, sbe) => { - m(); - g(); - (function (t, e) { - "use strict"; - function r(y, d) { - if (!y) throw new Error(d || "Assertion failed"); - } - function n(y, d) { - y.super_ = d; - var v = function () {}; - (v.prototype = d.prototype), - (y.prototype = new v()), - (y.prototype.constructor = y); - } - function i(y, d, v) { - if (i.isBN(y)) return y; - (this.negative = 0), - (this.words = null), - (this.length = 0), - (this.red = null), - y !== null && - ((d === "le" || d === "be") && ((v = d), (d = 10)), - this._init(y || 0, d || 10, v || "be")); - } - typeof t == "object" ? (t.exports = i) : (e.BN = i), - (i.BN = i), - (i.wordSize = 26); - var o; - try { - typeof window < "u" && typeof window.Buffer < "u" - ? (o = window.Buffer) - : (o = Qr().Buffer); - } catch {} - (i.isBN = function (d) { - return d instanceof i - ? !0 - : d !== null && - typeof d == "object" && - d.constructor.wordSize === i.wordSize && - Array.isArray(d.words); - }), - (i.max = function (d, v) { - return d.cmp(v) > 0 ? d : v; - }), - (i.min = function (d, v) { - return d.cmp(v) < 0 ? d : v; - }), - (i.prototype._init = function (d, v, _) { - if (typeof d == "number") return this._initNumber(d, v, _); - if (typeof d == "object") return this._initArray(d, v, _); - v === "hex" && (v = 16), - r(v === (v | 0) && v >= 2 && v <= 36), - (d = d.toString().replace(/\s+/g, "")); - var S = 0; - d[0] === "-" && (S++, (this.negative = 1)), - S < d.length && - (v === 16 - ? this._parseHex(d, S, _) - : (this._parseBase(d, v, S), - _ === "le" && this._initArray(this.toArray(), v, _))); - }), - (i.prototype._initNumber = function (d, v, _) { - d < 0 && ((this.negative = 1), (d = -d)), - d < 67108864 - ? ((this.words = [d & 67108863]), (this.length = 1)) - : d < 4503599627370496 - ? ((this.words = [d & 67108863, (d / 67108864) & 67108863]), - (this.length = 2)) - : (r(d < 9007199254740992), - (this.words = [d & 67108863, (d / 67108864) & 67108863, 1]), - (this.length = 3)), - _ === "le" && this._initArray(this.toArray(), v, _); - }), - (i.prototype._initArray = function (d, v, _) { - if ((r(typeof d.length == "number"), d.length <= 0)) - return (this.words = [0]), (this.length = 1), this; - (this.length = Math.ceil(d.length / 3)), - (this.words = new Array(this.length)); - for (var S = 0; S < this.length; S++) this.words[S] = 0; - var b, - f, - x = 0; - if (_ === "be") - for (S = d.length - 1, b = 0; S >= 0; S -= 3) - (f = d[S] | (d[S - 1] << 8) | (d[S - 2] << 16)), - (this.words[b] |= (f << x) & 67108863), - (this.words[b + 1] = (f >>> (26 - x)) & 67108863), - (x += 24), - x >= 26 && ((x -= 26), b++); - else if (_ === "le") - for (S = 0, b = 0; S < d.length; S += 3) - (f = d[S] | (d[S + 1] << 8) | (d[S + 2] << 16)), - (this.words[b] |= (f << x) & 67108863), - (this.words[b + 1] = (f >>> (26 - x)) & 67108863), - (x += 24), - x >= 26 && ((x -= 26), b++); - return this._strip(); - }); - function a(y, d) { - var v = y.charCodeAt(d); - if (v >= 48 && v <= 57) return v - 48; - if (v >= 65 && v <= 70) return v - 55; - if (v >= 97 && v <= 102) return v - 87; - r(!1, "Invalid character in " + y); - } - function s(y, d, v) { - var _ = a(y, v); - return v - 1 >= d && (_ |= a(y, v - 1) << 4), _; - } - i.prototype._parseHex = function (d, v, _) { - (this.length = Math.ceil((d.length - v) / 6)), - (this.words = new Array(this.length)); - for (var S = 0; S < this.length; S++) this.words[S] = 0; - var b = 0, - f = 0, - x; - if (_ === "be") - for (S = d.length - 1; S >= v; S -= 2) - (x = s(d, v, S) << b), - (this.words[f] |= x & 67108863), - b >= 18 - ? ((b -= 18), (f += 1), (this.words[f] |= x >>> 26)) - : (b += 8); - else { - var C = d.length - v; - for (S = C % 2 === 0 ? v + 1 : v; S < d.length; S += 2) - (x = s(d, v, S) << b), - (this.words[f] |= x & 67108863), - b >= 18 - ? ((b -= 18), (f += 1), (this.words[f] |= x >>> 26)) - : (b += 8); - } - this._strip(); - }; - function c(y, d, v, _) { - for (var S = 0, b = 0, f = Math.min(y.length, v), x = d; x < f; x++) { - var C = y.charCodeAt(x) - 48; - (S *= _), - C >= 49 ? (b = C - 49 + 10) : C >= 17 ? (b = C - 17 + 10) : (b = C), - r(C >= 0 && b < _, "Invalid character"), - (S += b); - } - return S; - } - (i.prototype._parseBase = function (d, v, _) { - (this.words = [0]), (this.length = 1); - for (var S = 0, b = 1; b <= 67108863; b *= v) S++; - S--, (b = (b / v) | 0); - for ( - var f = d.length - _, - x = f % S, - C = Math.min(f, f - x) + _, - E = 0, - B = _; - B < C; - B += S - ) - (E = c(d, B, B + S, v)), - this.imuln(b), - this.words[0] + E < 67108864 - ? (this.words[0] += E) - : this._iaddn(E); - if (x !== 0) { - var G = 1; - for (E = c(d, B, d.length, v), B = 0; B < x; B++) G *= v; - this.imuln(G), - this.words[0] + E < 67108864 - ? (this.words[0] += E) - : this._iaddn(E); - } - this._strip(); - }), - (i.prototype.copy = function (d) { - d.words = new Array(this.length); - for (var v = 0; v < this.length; v++) d.words[v] = this.words[v]; - (d.length = this.length), - (d.negative = this.negative), - (d.red = this.red); - }); - function u(y, d) { - (y.words = d.words), - (y.length = d.length), - (y.negative = d.negative), - (y.red = d.red); - } - if ( - ((i.prototype._move = function (d) { - u(d, this); - }), - (i.prototype.clone = function () { - var d = new i(null); - return this.copy(d), d; - }), - (i.prototype._expand = function (d) { - for (; this.length < d; ) this.words[this.length++] = 0; - return this; - }), - (i.prototype._strip = function () { - for (; this.length > 1 && this.words[this.length - 1] === 0; ) - this.length--; - return this._normSign(); - }), - (i.prototype._normSign = function () { - return ( - this.length === 1 && this.words[0] === 0 && (this.negative = 0), - this - ); - }), - typeof Symbol < "u" && typeof Symbol.for == "function") - ) - try { - i.prototype[Symbol.for("nodejs.util.inspect.custom")] = h; - } catch { - i.prototype.inspect = h; - } - else i.prototype.inspect = h; - function h() { - return (this.red ? ""; - } - var w = [ - "", - "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", - ], - M = [ - 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, - ], - k = [ - 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, - ]; - (i.prototype.toString = function (d, v) { - (d = d || 10), (v = v | 0 || 1); - var _; - if (d === 16 || d === "hex") { - _ = ""; - for (var S = 0, b = 0, f = 0; f < this.length; f++) { - var x = this.words[f], - C = (((x << S) | b) & 16777215).toString(16); - (b = (x >>> (24 - S)) & 16777215), - (S += 2), - S >= 26 && ((S -= 26), f--), - b !== 0 || f !== this.length - 1 - ? (_ = w[6 - C.length] + C + _) - : (_ = C + _); - } - for (b !== 0 && (_ = b.toString(16) + _); _.length % v !== 0; ) - _ = "0" + _; - return this.negative !== 0 && (_ = "-" + _), _; - } - if (d === (d | 0) && d >= 2 && d <= 36) { - var E = M[d], - B = k[d]; - _ = ""; - var G = this.clone(); - for (G.negative = 0; !G.isZero(); ) { - var L = G.modrn(B).toString(d); - (G = G.idivn(B)), - G.isZero() ? (_ = L + _) : (_ = w[E - L.length] + L + _); - } - for (this.isZero() && (_ = "0" + _); _.length % v !== 0; ) - _ = "0" + _; - return this.negative !== 0 && (_ = "-" + _), _; - } - r(!1, "Base should be between 2 and 36"); - }), - (i.prototype.toNumber = function () { - var d = this.words[0]; - return ( - this.length === 2 - ? (d += this.words[1] * 67108864) - : this.length === 3 && this.words[2] === 1 - ? (d += 4503599627370496 + this.words[1] * 67108864) - : this.length > 2 && - r(!1, "Number can only safely store up to 53 bits"), - this.negative !== 0 ? -d : d - ); - }), - (i.prototype.toJSON = function () { - return this.toString(16, 2); - }), - o && - (i.prototype.toBuffer = function (d, v) { - return this.toArrayLike(o, d, v); - }), - (i.prototype.toArray = function (d, v) { - return this.toArrayLike(Array, d, v); - }); - var O = function (d, v) { - return d.allocUnsafe ? d.allocUnsafe(v) : new d(v); - }; - (i.prototype.toArrayLike = function (d, v, _) { - this._strip(); - var S = this.byteLength(), - b = _ || Math.max(1, S); - r(S <= b, "byte array longer than desired length"), - r(b > 0, "Requested array length <= 0"); - var f = O(d, b), - x = v === "le" ? "LE" : "BE"; - return this["_toArrayLike" + x](f, S), f; - }), - (i.prototype._toArrayLikeLE = function (d, v) { - for (var _ = 0, S = 0, b = 0, f = 0; b < this.length; b++) { - var x = (this.words[b] << f) | S; - (d[_++] = x & 255), - _ < d.length && (d[_++] = (x >> 8) & 255), - _ < d.length && (d[_++] = (x >> 16) & 255), - f === 6 - ? (_ < d.length && (d[_++] = (x >> 24) & 255), (S = 0), (f = 0)) - : ((S = x >>> 24), (f += 2)); - } - if (_ < d.length) for (d[_++] = S; _ < d.length; ) d[_++] = 0; - }), - (i.prototype._toArrayLikeBE = function (d, v) { - for ( - var _ = d.length - 1, S = 0, b = 0, f = 0; - b < this.length; - b++ - ) { - var x = (this.words[b] << f) | S; - (d[_--] = x & 255), - _ >= 0 && (d[_--] = (x >> 8) & 255), - _ >= 0 && (d[_--] = (x >> 16) & 255), - f === 6 - ? (_ >= 0 && (d[_--] = (x >> 24) & 255), (S = 0), (f = 0)) - : ((S = x >>> 24), (f += 2)); - } - if (_ >= 0) for (d[_--] = S; _ >= 0; ) d[_--] = 0; - }), - Math.clz32 - ? (i.prototype._countBits = function (d) { - return 32 - Math.clz32(d); - }) - : (i.prototype._countBits = function (d) { - var v = d, - _ = 0; - return ( - v >= 4096 && ((_ += 13), (v >>>= 13)), - v >= 64 && ((_ += 7), (v >>>= 7)), - v >= 8 && ((_ += 4), (v >>>= 4)), - v >= 2 && ((_ += 2), (v >>>= 2)), - _ + v - ); - }), - (i.prototype._zeroBits = function (d) { - if (d === 0) return 26; - var v = d, - _ = 0; - return ( - (v & 8191) === 0 && ((_ += 13), (v >>>= 13)), - (v & 127) === 0 && ((_ += 7), (v >>>= 7)), - (v & 15) === 0 && ((_ += 4), (v >>>= 4)), - (v & 3) === 0 && ((_ += 2), (v >>>= 2)), - (v & 1) === 0 && _++, - _ - ); - }), - (i.prototype.bitLength = function () { - var d = this.words[this.length - 1], - v = this._countBits(d); - return (this.length - 1) * 26 + v; - }); - function D(y) { - for (var d = new Array(y.bitLength()), v = 0; v < d.length; v++) { - var _ = (v / 26) | 0, - S = v % 26; - d[v] = (y.words[_] >>> S) & 1; - } - return d; - } - (i.prototype.zeroBits = function () { - if (this.isZero()) return 0; - for (var d = 0, v = 0; v < this.length; v++) { - var _ = this._zeroBits(this.words[v]); - if (((d += _), _ !== 26)) break; - } - return d; - }), - (i.prototype.byteLength = function () { - return Math.ceil(this.bitLength() / 8); - }), - (i.prototype.toTwos = function (d) { - return this.negative !== 0 - ? this.abs().inotn(d).iaddn(1) - : this.clone(); - }), - (i.prototype.fromTwos = function (d) { - return this.testn(d - 1) - ? this.notn(d).iaddn(1).ineg() - : this.clone(); - }), - (i.prototype.isNeg = function () { - return this.negative !== 0; - }), - (i.prototype.neg = function () { - return this.clone().ineg(); - }), - (i.prototype.ineg = function () { - return this.isZero() || (this.negative ^= 1), this; - }), - (i.prototype.iuor = function (d) { - for (; this.length < d.length; ) this.words[this.length++] = 0; - for (var v = 0; v < d.length; v++) - this.words[v] = this.words[v] | d.words[v]; - return this._strip(); - }), - (i.prototype.ior = function (d) { - return r((this.negative | d.negative) === 0), this.iuor(d); - }), - (i.prototype.or = function (d) { - return this.length > d.length - ? this.clone().ior(d) - : d.clone().ior(this); - }), - (i.prototype.uor = function (d) { - return this.length > d.length - ? this.clone().iuor(d) - : d.clone().iuor(this); - }), - (i.prototype.iuand = function (d) { - var v; - this.length > d.length ? (v = d) : (v = this); - for (var _ = 0; _ < v.length; _++) - this.words[_] = this.words[_] & d.words[_]; - return (this.length = v.length), this._strip(); - }), - (i.prototype.iand = function (d) { - return r((this.negative | d.negative) === 0), this.iuand(d); - }), - (i.prototype.and = function (d) { - return this.length > d.length - ? this.clone().iand(d) - : d.clone().iand(this); - }), - (i.prototype.uand = function (d) { - return this.length > d.length - ? this.clone().iuand(d) - : d.clone().iuand(this); - }), - (i.prototype.iuxor = function (d) { - var v, _; - this.length > d.length - ? ((v = this), (_ = d)) - : ((v = d), (_ = this)); - for (var S = 0; S < _.length; S++) - this.words[S] = v.words[S] ^ _.words[S]; - if (this !== v) for (; S < v.length; S++) this.words[S] = v.words[S]; - return (this.length = v.length), this._strip(); - }), - (i.prototype.ixor = function (d) { - return r((this.negative | d.negative) === 0), this.iuxor(d); - }), - (i.prototype.xor = function (d) { - return this.length > d.length - ? this.clone().ixor(d) - : d.clone().ixor(this); - }), - (i.prototype.uxor = function (d) { - return this.length > d.length - ? this.clone().iuxor(d) - : d.clone().iuxor(this); - }), - (i.prototype.inotn = function (d) { - r(typeof d == "number" && d >= 0); - var v = Math.ceil(d / 26) | 0, - _ = d % 26; - this._expand(v), _ > 0 && v--; - for (var S = 0; S < v; S++) this.words[S] = ~this.words[S] & 67108863; - return ( - _ > 0 && (this.words[S] = ~this.words[S] & (67108863 >> (26 - _))), - this._strip() - ); - }), - (i.prototype.notn = function (d) { - return this.clone().inotn(d); - }), - (i.prototype.setn = function (d, v) { - r(typeof d == "number" && d >= 0); - var _ = (d / 26) | 0, - S = d % 26; - return ( - this._expand(_ + 1), - v - ? (this.words[_] = this.words[_] | (1 << S)) - : (this.words[_] = this.words[_] & ~(1 << S)), - this._strip() - ); - }), - (i.prototype.iadd = function (d) { - var v; - if (this.negative !== 0 && d.negative === 0) - return ( - (this.negative = 0), - (v = this.isub(d)), - (this.negative ^= 1), - this._normSign() - ); - if (this.negative === 0 && d.negative !== 0) - return ( - (d.negative = 0), - (v = this.isub(d)), - (d.negative = 1), - v._normSign() - ); - var _, S; - this.length > d.length - ? ((_ = this), (S = d)) - : ((_ = d), (S = this)); - for (var b = 0, f = 0; f < S.length; f++) - (v = (_.words[f] | 0) + (S.words[f] | 0) + b), - (this.words[f] = v & 67108863), - (b = v >>> 26); - for (; b !== 0 && f < _.length; f++) - (v = (_.words[f] | 0) + b), - (this.words[f] = v & 67108863), - (b = v >>> 26); - if (((this.length = _.length), b !== 0)) - (this.words[this.length] = b), this.length++; - else if (_ !== this) - for (; f < _.length; f++) this.words[f] = _.words[f]; - return this; - }), - (i.prototype.add = function (d) { - var v; - return d.negative !== 0 && this.negative === 0 - ? ((d.negative = 0), (v = this.sub(d)), (d.negative ^= 1), v) - : d.negative === 0 && this.negative !== 0 - ? ((this.negative = 0), (v = d.sub(this)), (this.negative = 1), v) - : this.length > d.length - ? this.clone().iadd(d) - : d.clone().iadd(this); - }), - (i.prototype.isub = function (d) { - if (d.negative !== 0) { - d.negative = 0; - var v = this.iadd(d); - return (d.negative = 1), v._normSign(); - } else if (this.negative !== 0) - return ( - (this.negative = 0), - this.iadd(d), - (this.negative = 1), - this._normSign() - ); - var _ = this.cmp(d); - if (_ === 0) - return ( - (this.negative = 0), (this.length = 1), (this.words[0] = 0), this - ); - var S, b; - _ > 0 ? ((S = this), (b = d)) : ((S = d), (b = this)); - for (var f = 0, x = 0; x < b.length; x++) - (v = (S.words[x] | 0) - (b.words[x] | 0) + f), - (f = v >> 26), - (this.words[x] = v & 67108863); - for (; f !== 0 && x < S.length; x++) - (v = (S.words[x] | 0) + f), - (f = v >> 26), - (this.words[x] = v & 67108863); - if (f === 0 && x < S.length && S !== this) - for (; x < S.length; x++) this.words[x] = S.words[x]; - return ( - (this.length = Math.max(this.length, x)), - S !== this && (this.negative = 1), - this._strip() - ); - }), - (i.prototype.sub = function (d) { - return this.clone().isub(d); - }); - function F(y, d, v) { - v.negative = d.negative ^ y.negative; - var _ = (y.length + d.length) | 0; - (v.length = _), (_ = (_ - 1) | 0); - var S = y.words[0] | 0, - b = d.words[0] | 0, - f = S * b, - x = f & 67108863, - C = (f / 67108864) | 0; - v.words[0] = x; - for (var E = 1; E < _; E++) { - for ( - var B = C >>> 26, - G = C & 67108863, - L = Math.min(E, d.length - 1), - ee = Math.max(0, E - y.length + 1); - ee <= L; - ee++ - ) { - var ge = (E - ee) | 0; - (S = y.words[ge] | 0), - (b = d.words[ee] | 0), - (f = S * b + G), - (B += (f / 67108864) | 0), - (G = f & 67108863); - } - (v.words[E] = G | 0), (C = B | 0); - } - return C !== 0 ? (v.words[E] = C | 0) : v.length--, v._strip(); - } - var N = function (d, v, _) { - var S = d.words, - b = v.words, - f = _.words, - x = 0, - C, - E, - B, - G = S[0] | 0, - L = G & 8191, - ee = G >>> 13, - ge = S[1] | 0, - fe = ge & 8191, - V = ge >>> 13, - ye = S[2] | 0, - ae = ye & 8191, - le = ye >>> 13, - Me = S[3] | 0, - de = Me & 8191, - ve = Me >>> 13, - De = S[4] | 0, - me = De & 8191, - _e = De >>> 13, - Ye = S[5] | 0, - Ee = Ye & 8191, - Be = Ye >>> 13, - kt = S[6] | 0, - Ve = kt & 8191, - We = kt >>> 13, - er = S[7] | 0, - Ue = er & 8191, - Y = er >>> 13, - W = S[8] | 0, - j = W & 8191, - ce = W >>> 13, - ze = S[9] | 0, - we = ze & 8191, - xe = ze >>> 13, - Ft = b[0] | 0, - Ke = Ft & 8191, - pe = Ft >>> 13, - Re = b[1] | 0, - Se = Re & 8191, - Pe = Re >>> 13, - At = b[2] | 0, - Ie = At & 8191, - je = At >>> 13, - qt = b[3] | 0, - Fe = qt & 8191, - He = qt >>> 13, - lr = b[4] | 0, - Xe = lr & 8191, - Ze = lr >>> 13, - Ir = b[5] | 0, - $e = Ir & 8191, - tt = Ir >>> 13, - oe = b[6] | 0, - ie = oe & 8191, - re = oe >>> 13, - U = b[7] | 0, - se = U & 8191, - be = U >>> 13, - Qe = b[8] | 0, - Ae = Qe & 8191, - ke = Qe >>> 13, - Ct = b[9] | 0, - ut = Ct & 8191, - St = Ct >>> 13; - (_.negative = d.negative ^ v.negative), - (_.length = 19), - (C = Math.imul(L, Ke)), - (E = Math.imul(L, pe)), - (E = (E + Math.imul(ee, Ke)) | 0), - (B = Math.imul(ee, pe)); - var wt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (wt >>> 26)) | 0), - (wt &= 67108863), - (C = Math.imul(fe, Ke)), - (E = Math.imul(fe, pe)), - (E = (E + Math.imul(V, Ke)) | 0), - (B = Math.imul(V, pe)), - (C = (C + Math.imul(L, Se)) | 0), - (E = (E + Math.imul(L, Pe)) | 0), - (E = (E + Math.imul(ee, Se)) | 0), - (B = (B + Math.imul(ee, Pe)) | 0); - var zt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (zt >>> 26)) | 0), - (zt &= 67108863), - (C = Math.imul(ae, Ke)), - (E = Math.imul(ae, pe)), - (E = (E + Math.imul(le, Ke)) | 0), - (B = Math.imul(le, pe)), - (C = (C + Math.imul(fe, Se)) | 0), - (E = (E + Math.imul(fe, Pe)) | 0), - (E = (E + Math.imul(V, Se)) | 0), - (B = (B + Math.imul(V, Pe)) | 0), - (C = (C + Math.imul(L, Ie)) | 0), - (E = (E + Math.imul(L, je)) | 0), - (E = (E + Math.imul(ee, Ie)) | 0), - (B = (B + Math.imul(ee, je)) | 0); - var jt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (jt >>> 26)) | 0), - (jt &= 67108863), - (C = Math.imul(de, Ke)), - (E = Math.imul(de, pe)), - (E = (E + Math.imul(ve, Ke)) | 0), - (B = Math.imul(ve, pe)), - (C = (C + Math.imul(ae, Se)) | 0), - (E = (E + Math.imul(ae, Pe)) | 0), - (E = (E + Math.imul(le, Se)) | 0), - (B = (B + Math.imul(le, Pe)) | 0), - (C = (C + Math.imul(fe, Ie)) | 0), - (E = (E + Math.imul(fe, je)) | 0), - (E = (E + Math.imul(V, Ie)) | 0), - (B = (B + Math.imul(V, je)) | 0), - (C = (C + Math.imul(L, Fe)) | 0), - (E = (E + Math.imul(L, He)) | 0), - (E = (E + Math.imul(ee, Fe)) | 0), - (B = (B + Math.imul(ee, He)) | 0); - var Ht = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (Ht >>> 26)) | 0), - (Ht &= 67108863), - (C = Math.imul(me, Ke)), - (E = Math.imul(me, pe)), - (E = (E + Math.imul(_e, Ke)) | 0), - (B = Math.imul(_e, pe)), - (C = (C + Math.imul(de, Se)) | 0), - (E = (E + Math.imul(de, Pe)) | 0), - (E = (E + Math.imul(ve, Se)) | 0), - (B = (B + Math.imul(ve, Pe)) | 0), - (C = (C + Math.imul(ae, Ie)) | 0), - (E = (E + Math.imul(ae, je)) | 0), - (E = (E + Math.imul(le, Ie)) | 0), - (B = (B + Math.imul(le, je)) | 0), - (C = (C + Math.imul(fe, Fe)) | 0), - (E = (E + Math.imul(fe, He)) | 0), - (E = (E + Math.imul(V, Fe)) | 0), - (B = (B + Math.imul(V, He)) | 0), - (C = (C + Math.imul(L, Xe)) | 0), - (E = (E + Math.imul(L, Ze)) | 0), - (E = (E + Math.imul(ee, Xe)) | 0), - (B = (B + Math.imul(ee, Ze)) | 0); - var Ut = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (Ut >>> 26)) | 0), - (Ut &= 67108863), - (C = Math.imul(Ee, Ke)), - (E = Math.imul(Ee, pe)), - (E = (E + Math.imul(Be, Ke)) | 0), - (B = Math.imul(Be, pe)), - (C = (C + Math.imul(me, Se)) | 0), - (E = (E + Math.imul(me, Pe)) | 0), - (E = (E + Math.imul(_e, Se)) | 0), - (B = (B + Math.imul(_e, Pe)) | 0), - (C = (C + Math.imul(de, Ie)) | 0), - (E = (E + Math.imul(de, je)) | 0), - (E = (E + Math.imul(ve, Ie)) | 0), - (B = (B + Math.imul(ve, je)) | 0), - (C = (C + Math.imul(ae, Fe)) | 0), - (E = (E + Math.imul(ae, He)) | 0), - (E = (E + Math.imul(le, Fe)) | 0), - (B = (B + Math.imul(le, He)) | 0), - (C = (C + Math.imul(fe, Xe)) | 0), - (E = (E + Math.imul(fe, Ze)) | 0), - (E = (E + Math.imul(V, Xe)) | 0), - (B = (B + Math.imul(V, Ze)) | 0), - (C = (C + Math.imul(L, $e)) | 0), - (E = (E + Math.imul(L, tt)) | 0), - (E = (E + Math.imul(ee, $e)) | 0), - (B = (B + Math.imul(ee, tt)) | 0); - var Kt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (Kt >>> 26)) | 0), - (Kt &= 67108863), - (C = Math.imul(Ve, Ke)), - (E = Math.imul(Ve, pe)), - (E = (E + Math.imul(We, Ke)) | 0), - (B = Math.imul(We, pe)), - (C = (C + Math.imul(Ee, Se)) | 0), - (E = (E + Math.imul(Ee, Pe)) | 0), - (E = (E + Math.imul(Be, Se)) | 0), - (B = (B + Math.imul(Be, Pe)) | 0), - (C = (C + Math.imul(me, Ie)) | 0), - (E = (E + Math.imul(me, je)) | 0), - (E = (E + Math.imul(_e, Ie)) | 0), - (B = (B + Math.imul(_e, je)) | 0), - (C = (C + Math.imul(de, Fe)) | 0), - (E = (E + Math.imul(de, He)) | 0), - (E = (E + Math.imul(ve, Fe)) | 0), - (B = (B + Math.imul(ve, He)) | 0), - (C = (C + Math.imul(ae, Xe)) | 0), - (E = (E + Math.imul(ae, Ze)) | 0), - (E = (E + Math.imul(le, Xe)) | 0), - (B = (B + Math.imul(le, Ze)) | 0), - (C = (C + Math.imul(fe, $e)) | 0), - (E = (E + Math.imul(fe, tt)) | 0), - (E = (E + Math.imul(V, $e)) | 0), - (B = (B + Math.imul(V, tt)) | 0), - (C = (C + Math.imul(L, ie)) | 0), - (E = (E + Math.imul(L, re)) | 0), - (E = (E + Math.imul(ee, ie)) | 0), - (B = (B + Math.imul(ee, re)) | 0); - var Ot = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (Ot >>> 26)) | 0), - (Ot &= 67108863), - (C = Math.imul(Ue, Ke)), - (E = Math.imul(Ue, pe)), - (E = (E + Math.imul(Y, Ke)) | 0), - (B = Math.imul(Y, pe)), - (C = (C + Math.imul(Ve, Se)) | 0), - (E = (E + Math.imul(Ve, Pe)) | 0), - (E = (E + Math.imul(We, Se)) | 0), - (B = (B + Math.imul(We, Pe)) | 0), - (C = (C + Math.imul(Ee, Ie)) | 0), - (E = (E + Math.imul(Ee, je)) | 0), - (E = (E + Math.imul(Be, Ie)) | 0), - (B = (B + Math.imul(Be, je)) | 0), - (C = (C + Math.imul(me, Fe)) | 0), - (E = (E + Math.imul(me, He)) | 0), - (E = (E + Math.imul(_e, Fe)) | 0), - (B = (B + Math.imul(_e, He)) | 0), - (C = (C + Math.imul(de, Xe)) | 0), - (E = (E + Math.imul(de, Ze)) | 0), - (E = (E + Math.imul(ve, Xe)) | 0), - (B = (B + Math.imul(ve, Ze)) | 0), - (C = (C + Math.imul(ae, $e)) | 0), - (E = (E + Math.imul(ae, tt)) | 0), - (E = (E + Math.imul(le, $e)) | 0), - (B = (B + Math.imul(le, tt)) | 0), - (C = (C + Math.imul(fe, ie)) | 0), - (E = (E + Math.imul(fe, re)) | 0), - (E = (E + Math.imul(V, ie)) | 0), - (B = (B + Math.imul(V, re)) | 0), - (C = (C + Math.imul(L, se)) | 0), - (E = (E + Math.imul(L, be)) | 0), - (E = (E + Math.imul(ee, se)) | 0), - (B = (B + Math.imul(ee, be)) | 0); - var Bt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (Bt >>> 26)) | 0), - (Bt &= 67108863), - (C = Math.imul(j, Ke)), - (E = Math.imul(j, pe)), - (E = (E + Math.imul(ce, Ke)) | 0), - (B = Math.imul(ce, pe)), - (C = (C + Math.imul(Ue, Se)) | 0), - (E = (E + Math.imul(Ue, Pe)) | 0), - (E = (E + Math.imul(Y, Se)) | 0), - (B = (B + Math.imul(Y, Pe)) | 0), - (C = (C + Math.imul(Ve, Ie)) | 0), - (E = (E + Math.imul(Ve, je)) | 0), - (E = (E + Math.imul(We, Ie)) | 0), - (B = (B + Math.imul(We, je)) | 0), - (C = (C + Math.imul(Ee, Fe)) | 0), - (E = (E + Math.imul(Ee, He)) | 0), - (E = (E + Math.imul(Be, Fe)) | 0), - (B = (B + Math.imul(Be, He)) | 0), - (C = (C + Math.imul(me, Xe)) | 0), - (E = (E + Math.imul(me, Ze)) | 0), - (E = (E + Math.imul(_e, Xe)) | 0), - (B = (B + Math.imul(_e, Ze)) | 0), - (C = (C + Math.imul(de, $e)) | 0), - (E = (E + Math.imul(de, tt)) | 0), - (E = (E + Math.imul(ve, $e)) | 0), - (B = (B + Math.imul(ve, tt)) | 0), - (C = (C + Math.imul(ae, ie)) | 0), - (E = (E + Math.imul(ae, re)) | 0), - (E = (E + Math.imul(le, ie)) | 0), - (B = (B + Math.imul(le, re)) | 0), - (C = (C + Math.imul(fe, se)) | 0), - (E = (E + Math.imul(fe, be)) | 0), - (E = (E + Math.imul(V, se)) | 0), - (B = (B + Math.imul(V, be)) | 0), - (C = (C + Math.imul(L, Ae)) | 0), - (E = (E + Math.imul(L, ke)) | 0), - (E = (E + Math.imul(ee, Ae)) | 0), - (B = (B + Math.imul(ee, ke)) | 0); - var Et = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (Et >>> 26)) | 0), - (Et &= 67108863), - (C = Math.imul(we, Ke)), - (E = Math.imul(we, pe)), - (E = (E + Math.imul(xe, Ke)) | 0), - (B = Math.imul(xe, pe)), - (C = (C + Math.imul(j, Se)) | 0), - (E = (E + Math.imul(j, Pe)) | 0), - (E = (E + Math.imul(ce, Se)) | 0), - (B = (B + Math.imul(ce, Pe)) | 0), - (C = (C + Math.imul(Ue, Ie)) | 0), - (E = (E + Math.imul(Ue, je)) | 0), - (E = (E + Math.imul(Y, Ie)) | 0), - (B = (B + Math.imul(Y, je)) | 0), - (C = (C + Math.imul(Ve, Fe)) | 0), - (E = (E + Math.imul(Ve, He)) | 0), - (E = (E + Math.imul(We, Fe)) | 0), - (B = (B + Math.imul(We, He)) | 0), - (C = (C + Math.imul(Ee, Xe)) | 0), - (E = (E + Math.imul(Ee, Ze)) | 0), - (E = (E + Math.imul(Be, Xe)) | 0), - (B = (B + Math.imul(Be, Ze)) | 0), - (C = (C + Math.imul(me, $e)) | 0), - (E = (E + Math.imul(me, tt)) | 0), - (E = (E + Math.imul(_e, $e)) | 0), - (B = (B + Math.imul(_e, tt)) | 0), - (C = (C + Math.imul(de, ie)) | 0), - (E = (E + Math.imul(de, re)) | 0), - (E = (E + Math.imul(ve, ie)) | 0), - (B = (B + Math.imul(ve, re)) | 0), - (C = (C + Math.imul(ae, se)) | 0), - (E = (E + Math.imul(ae, be)) | 0), - (E = (E + Math.imul(le, se)) | 0), - (B = (B + Math.imul(le, be)) | 0), - (C = (C + Math.imul(fe, Ae)) | 0), - (E = (E + Math.imul(fe, ke)) | 0), - (E = (E + Math.imul(V, Ae)) | 0), - (B = (B + Math.imul(V, ke)) | 0), - (C = (C + Math.imul(L, ut)) | 0), - (E = (E + Math.imul(L, St)) | 0), - (E = (E + Math.imul(ee, ut)) | 0), - (B = (B + Math.imul(ee, St)) | 0); - var Mt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (Mt >>> 26)) | 0), - (Mt &= 67108863), - (C = Math.imul(we, Se)), - (E = Math.imul(we, Pe)), - (E = (E + Math.imul(xe, Se)) | 0), - (B = Math.imul(xe, Pe)), - (C = (C + Math.imul(j, Ie)) | 0), - (E = (E + Math.imul(j, je)) | 0), - (E = (E + Math.imul(ce, Ie)) | 0), - (B = (B + Math.imul(ce, je)) | 0), - (C = (C + Math.imul(Ue, Fe)) | 0), - (E = (E + Math.imul(Ue, He)) | 0), - (E = (E + Math.imul(Y, Fe)) | 0), - (B = (B + Math.imul(Y, He)) | 0), - (C = (C + Math.imul(Ve, Xe)) | 0), - (E = (E + Math.imul(Ve, Ze)) | 0), - (E = (E + Math.imul(We, Xe)) | 0), - (B = (B + Math.imul(We, Ze)) | 0), - (C = (C + Math.imul(Ee, $e)) | 0), - (E = (E + Math.imul(Ee, tt)) | 0), - (E = (E + Math.imul(Be, $e)) | 0), - (B = (B + Math.imul(Be, tt)) | 0), - (C = (C + Math.imul(me, ie)) | 0), - (E = (E + Math.imul(me, re)) | 0), - (E = (E + Math.imul(_e, ie)) | 0), - (B = (B + Math.imul(_e, re)) | 0), - (C = (C + Math.imul(de, se)) | 0), - (E = (E + Math.imul(de, be)) | 0), - (E = (E + Math.imul(ve, se)) | 0), - (B = (B + Math.imul(ve, be)) | 0), - (C = (C + Math.imul(ae, Ae)) | 0), - (E = (E + Math.imul(ae, ke)) | 0), - (E = (E + Math.imul(le, Ae)) | 0), - (B = (B + Math.imul(le, ke)) | 0), - (C = (C + Math.imul(fe, ut)) | 0), - (E = (E + Math.imul(fe, St)) | 0), - (E = (E + Math.imul(V, ut)) | 0), - (B = (B + Math.imul(V, St)) | 0); - var gt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (gt >>> 26)) | 0), - (gt &= 67108863), - (C = Math.imul(we, Ie)), - (E = Math.imul(we, je)), - (E = (E + Math.imul(xe, Ie)) | 0), - (B = Math.imul(xe, je)), - (C = (C + Math.imul(j, Fe)) | 0), - (E = (E + Math.imul(j, He)) | 0), - (E = (E + Math.imul(ce, Fe)) | 0), - (B = (B + Math.imul(ce, He)) | 0), - (C = (C + Math.imul(Ue, Xe)) | 0), - (E = (E + Math.imul(Ue, Ze)) | 0), - (E = (E + Math.imul(Y, Xe)) | 0), - (B = (B + Math.imul(Y, Ze)) | 0), - (C = (C + Math.imul(Ve, $e)) | 0), - (E = (E + Math.imul(Ve, tt)) | 0), - (E = (E + Math.imul(We, $e)) | 0), - (B = (B + Math.imul(We, tt)) | 0), - (C = (C + Math.imul(Ee, ie)) | 0), - (E = (E + Math.imul(Ee, re)) | 0), - (E = (E + Math.imul(Be, ie)) | 0), - (B = (B + Math.imul(Be, re)) | 0), - (C = (C + Math.imul(me, se)) | 0), - (E = (E + Math.imul(me, be)) | 0), - (E = (E + Math.imul(_e, se)) | 0), - (B = (B + Math.imul(_e, be)) | 0), - (C = (C + Math.imul(de, Ae)) | 0), - (E = (E + Math.imul(de, ke)) | 0), - (E = (E + Math.imul(ve, Ae)) | 0), - (B = (B + Math.imul(ve, ke)) | 0), - (C = (C + Math.imul(ae, ut)) | 0), - (E = (E + Math.imul(ae, St)) | 0), - (E = (E + Math.imul(le, ut)) | 0), - (B = (B + Math.imul(le, St)) | 0); - var Pt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (Pt >>> 26)) | 0), - (Pt &= 67108863), - (C = Math.imul(we, Fe)), - (E = Math.imul(we, He)), - (E = (E + Math.imul(xe, Fe)) | 0), - (B = Math.imul(xe, He)), - (C = (C + Math.imul(j, Xe)) | 0), - (E = (E + Math.imul(j, Ze)) | 0), - (E = (E + Math.imul(ce, Xe)) | 0), - (B = (B + Math.imul(ce, Ze)) | 0), - (C = (C + Math.imul(Ue, $e)) | 0), - (E = (E + Math.imul(Ue, tt)) | 0), - (E = (E + Math.imul(Y, $e)) | 0), - (B = (B + Math.imul(Y, tt)) | 0), - (C = (C + Math.imul(Ve, ie)) | 0), - (E = (E + Math.imul(Ve, re)) | 0), - (E = (E + Math.imul(We, ie)) | 0), - (B = (B + Math.imul(We, re)) | 0), - (C = (C + Math.imul(Ee, se)) | 0), - (E = (E + Math.imul(Ee, be)) | 0), - (E = (E + Math.imul(Be, se)) | 0), - (B = (B + Math.imul(Be, be)) | 0), - (C = (C + Math.imul(me, Ae)) | 0), - (E = (E + Math.imul(me, ke)) | 0), - (E = (E + Math.imul(_e, Ae)) | 0), - (B = (B + Math.imul(_e, ke)) | 0), - (C = (C + Math.imul(de, ut)) | 0), - (E = (E + Math.imul(de, St)) | 0), - (E = (E + Math.imul(ve, ut)) | 0), - (B = (B + Math.imul(ve, St)) | 0); - var It = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (It >>> 26)) | 0), - (It &= 67108863), - (C = Math.imul(we, Xe)), - (E = Math.imul(we, Ze)), - (E = (E + Math.imul(xe, Xe)) | 0), - (B = Math.imul(xe, Ze)), - (C = (C + Math.imul(j, $e)) | 0), - (E = (E + Math.imul(j, tt)) | 0), - (E = (E + Math.imul(ce, $e)) | 0), - (B = (B + Math.imul(ce, tt)) | 0), - (C = (C + Math.imul(Ue, ie)) | 0), - (E = (E + Math.imul(Ue, re)) | 0), - (E = (E + Math.imul(Y, ie)) | 0), - (B = (B + Math.imul(Y, re)) | 0), - (C = (C + Math.imul(Ve, se)) | 0), - (E = (E + Math.imul(Ve, be)) | 0), - (E = (E + Math.imul(We, se)) | 0), - (B = (B + Math.imul(We, be)) | 0), - (C = (C + Math.imul(Ee, Ae)) | 0), - (E = (E + Math.imul(Ee, ke)) | 0), - (E = (E + Math.imul(Be, Ae)) | 0), - (B = (B + Math.imul(Be, ke)) | 0), - (C = (C + Math.imul(me, ut)) | 0), - (E = (E + Math.imul(me, St)) | 0), - (E = (E + Math.imul(_e, ut)) | 0), - (B = (B + Math.imul(_e, St)) | 0); - var yt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (yt >>> 26)) | 0), - (yt &= 67108863), - (C = Math.imul(we, $e)), - (E = Math.imul(we, tt)), - (E = (E + Math.imul(xe, $e)) | 0), - (B = Math.imul(xe, tt)), - (C = (C + Math.imul(j, ie)) | 0), - (E = (E + Math.imul(j, re)) | 0), - (E = (E + Math.imul(ce, ie)) | 0), - (B = (B + Math.imul(ce, re)) | 0), - (C = (C + Math.imul(Ue, se)) | 0), - (E = (E + Math.imul(Ue, be)) | 0), - (E = (E + Math.imul(Y, se)) | 0), - (B = (B + Math.imul(Y, be)) | 0), - (C = (C + Math.imul(Ve, Ae)) | 0), - (E = (E + Math.imul(Ve, ke)) | 0), - (E = (E + Math.imul(We, Ae)) | 0), - (B = (B + Math.imul(We, ke)) | 0), - (C = (C + Math.imul(Ee, ut)) | 0), - (E = (E + Math.imul(Ee, St)) | 0), - (E = (E + Math.imul(Be, ut)) | 0), - (B = (B + Math.imul(Be, St)) | 0); - var nt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (nt >>> 26)) | 0), - (nt &= 67108863), - (C = Math.imul(we, ie)), - (E = Math.imul(we, re)), - (E = (E + Math.imul(xe, ie)) | 0), - (B = Math.imul(xe, re)), - (C = (C + Math.imul(j, se)) | 0), - (E = (E + Math.imul(j, be)) | 0), - (E = (E + Math.imul(ce, se)) | 0), - (B = (B + Math.imul(ce, be)) | 0), - (C = (C + Math.imul(Ue, Ae)) | 0), - (E = (E + Math.imul(Ue, ke)) | 0), - (E = (E + Math.imul(Y, Ae)) | 0), - (B = (B + Math.imul(Y, ke)) | 0), - (C = (C + Math.imul(Ve, ut)) | 0), - (E = (E + Math.imul(Ve, St)) | 0), - (E = (E + Math.imul(We, ut)) | 0), - (B = (B + Math.imul(We, St)) | 0); - var it = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (it >>> 26)) | 0), - (it &= 67108863), - (C = Math.imul(we, se)), - (E = Math.imul(we, be)), - (E = (E + Math.imul(xe, se)) | 0), - (B = Math.imul(xe, be)), - (C = (C + Math.imul(j, Ae)) | 0), - (E = (E + Math.imul(j, ke)) | 0), - (E = (E + Math.imul(ce, Ae)) | 0), - (B = (B + Math.imul(ce, ke)) | 0), - (C = (C + Math.imul(Ue, ut)) | 0), - (E = (E + Math.imul(Ue, St)) | 0), - (E = (E + Math.imul(Y, ut)) | 0), - (B = (B + Math.imul(Y, St)) | 0); - var _t = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (_t >>> 26)) | 0), - (_t &= 67108863), - (C = Math.imul(we, Ae)), - (E = Math.imul(we, ke)), - (E = (E + Math.imul(xe, Ae)) | 0), - (B = Math.imul(xe, ke)), - (C = (C + Math.imul(j, ut)) | 0), - (E = (E + Math.imul(j, St)) | 0), - (E = (E + Math.imul(ce, ut)) | 0), - (B = (B + Math.imul(ce, St)) | 0); - var ht = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (ht >>> 26)) | 0), - (ht &= 67108863), - (C = Math.imul(we, ut)), - (E = Math.imul(we, St)), - (E = (E + Math.imul(xe, ut)) | 0), - (B = Math.imul(xe, St)); - var mt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - return ( - (x = (((B + (E >>> 13)) | 0) + (mt >>> 26)) | 0), - (mt &= 67108863), - (f[0] = wt), - (f[1] = zt), - (f[2] = jt), - (f[3] = Ht), - (f[4] = Ut), - (f[5] = Kt), - (f[6] = Ot), - (f[7] = Bt), - (f[8] = Et), - (f[9] = Mt), - (f[10] = gt), - (f[11] = Pt), - (f[12] = It), - (f[13] = yt), - (f[14] = nt), - (f[15] = it), - (f[16] = _t), - (f[17] = ht), - (f[18] = mt), - x !== 0 && ((f[19] = x), _.length++), - _ - ); - }; - Math.imul || (N = F); - function q(y, d, v) { - (v.negative = d.negative ^ y.negative), - (v.length = y.length + d.length); - for (var _ = 0, S = 0, b = 0; b < v.length - 1; b++) { - var f = S; - S = 0; - for ( - var x = _ & 67108863, - C = Math.min(b, d.length - 1), - E = Math.max(0, b - y.length + 1); - E <= C; - E++ - ) { - var B = b - E, - G = y.words[B] | 0, - L = d.words[E] | 0, - ee = G * L, - ge = ee & 67108863; - (f = (f + ((ee / 67108864) | 0)) | 0), - (ge = (ge + x) | 0), - (x = ge & 67108863), - (f = (f + (ge >>> 26)) | 0), - (S += f >>> 26), - (f &= 67108863); - } - (v.words[b] = x), (_ = f), (f = S); - } - return _ !== 0 ? (v.words[b] = _) : v.length--, v._strip(); - } - function z(y, d, v) { - return q(y, d, v); - } - i.prototype.mulTo = function (d, v) { - var _, - S = this.length + d.length; - return ( - this.length === 10 && d.length === 10 - ? (_ = N(this, d, v)) - : S < 63 - ? (_ = F(this, d, v)) - : S < 1024 - ? (_ = q(this, d, v)) - : (_ = z(this, d, v)), - _ - ); - }; - function H(y, d) { - (this.x = y), (this.y = d); - } - (H.prototype.makeRBT = function (d) { - for ( - var v = new Array(d), _ = i.prototype._countBits(d) - 1, S = 0; - S < d; - S++ - ) - v[S] = this.revBin(S, _, d); - return v; - }), - (H.prototype.revBin = function (d, v, _) { - if (d === 0 || d === _ - 1) return d; - for (var S = 0, b = 0; b < v; b++) - (S |= (d & 1) << (v - b - 1)), (d >>= 1); - return S; - }), - (H.prototype.permute = function (d, v, _, S, b, f) { - for (var x = 0; x < f; x++) (S[x] = v[d[x]]), (b[x] = _[d[x]]); - }), - (H.prototype.transform = function (d, v, _, S, b, f) { - this.permute(f, d, v, _, S, b); - for (var x = 1; x < b; x <<= 1) - for ( - var C = x << 1, - E = Math.cos((2 * Math.PI) / C), - B = Math.sin((2 * Math.PI) / C), - G = 0; - G < b; - G += C - ) - for (var L = E, ee = B, ge = 0; ge < x; ge++) { - var fe = _[G + ge], - V = S[G + ge], - ye = _[G + ge + x], - ae = S[G + ge + x], - le = L * ye - ee * ae; - (ae = L * ae + ee * ye), - (ye = le), - (_[G + ge] = fe + ye), - (S[G + ge] = V + ae), - (_[G + ge + x] = fe - ye), - (S[G + ge + x] = V - ae), - ge !== C && - ((le = E * L - B * ee), (ee = E * ee + B * L), (L = le)); - } - }), - (H.prototype.guessLen13b = function (d, v) { - var _ = Math.max(v, d) | 1, - S = _ & 1, - b = 0; - for (_ = (_ / 2) | 0; _; _ = _ >>> 1) b++; - return 1 << (b + 1 + S); - }), - (H.prototype.conjugate = function (d, v, _) { - if (!(_ <= 1)) - for (var S = 0; S < _ / 2; S++) { - var b = d[S]; - (d[S] = d[_ - S - 1]), - (d[_ - S - 1] = b), - (b = v[S]), - (v[S] = -v[_ - S - 1]), - (v[_ - S - 1] = -b); - } - }), - (H.prototype.normalize13b = function (d, v) { - for (var _ = 0, S = 0; S < v / 2; S++) { - var b = - Math.round(d[2 * S + 1] / v) * 8192 + - Math.round(d[2 * S] / v) + - _; - (d[S] = b & 67108863), - b < 67108864 ? (_ = 0) : (_ = (b / 67108864) | 0); - } - return d; - }), - (H.prototype.convert13b = function (d, v, _, S) { - for (var b = 0, f = 0; f < v; f++) - (b = b + (d[f] | 0)), - (_[2 * f] = b & 8191), - (b = b >>> 13), - (_[2 * f + 1] = b & 8191), - (b = b >>> 13); - for (f = 2 * v; f < S; ++f) _[f] = 0; - r(b === 0), r((b & -8192) === 0); - }), - (H.prototype.stub = function (d) { - for (var v = new Array(d), _ = 0; _ < d; _++) v[_] = 0; - return v; - }), - (H.prototype.mulp = function (d, v, _) { - var S = 2 * this.guessLen13b(d.length, v.length), - b = this.makeRBT(S), - f = this.stub(S), - x = new Array(S), - C = new Array(S), - E = new Array(S), - B = new Array(S), - G = new Array(S), - L = new Array(S), - ee = _.words; - (ee.length = S), - this.convert13b(d.words, d.length, x, S), - this.convert13b(v.words, v.length, B, S), - this.transform(x, f, C, E, S, b), - this.transform(B, f, G, L, S, b); - for (var ge = 0; ge < S; ge++) { - var fe = C[ge] * G[ge] - E[ge] * L[ge]; - (E[ge] = C[ge] * L[ge] + E[ge] * G[ge]), (C[ge] = fe); - } - return ( - this.conjugate(C, E, S), - this.transform(C, E, ee, f, S, b), - this.conjugate(ee, f, S), - this.normalize13b(ee, S), - (_.negative = d.negative ^ v.negative), - (_.length = d.length + v.length), - _._strip() - ); - }), - (i.prototype.mul = function (d) { - var v = new i(null); - return ( - (v.words = new Array(this.length + d.length)), this.mulTo(d, v) - ); - }), - (i.prototype.mulf = function (d) { - var v = new i(null); - return (v.words = new Array(this.length + d.length)), z(this, d, v); - }), - (i.prototype.imul = function (d) { - return this.clone().mulTo(d, this); - }), - (i.prototype.imuln = function (d) { - var v = d < 0; - v && (d = -d), r(typeof d == "number"), r(d < 67108864); - for (var _ = 0, S = 0; S < this.length; S++) { - var b = (this.words[S] | 0) * d, - f = (b & 67108863) + (_ & 67108863); - (_ >>= 26), - (_ += (b / 67108864) | 0), - (_ += f >>> 26), - (this.words[S] = f & 67108863); - } - return ( - _ !== 0 && ((this.words[S] = _), this.length++), - v ? this.ineg() : this - ); - }), - (i.prototype.muln = function (d) { - return this.clone().imuln(d); - }), - (i.prototype.sqr = function () { - return this.mul(this); - }), - (i.prototype.isqr = function () { - return this.imul(this.clone()); - }), - (i.prototype.pow = function (d) { - var v = D(d); - if (v.length === 0) return new i(1); - for ( - var _ = this, S = 0; - S < v.length && v[S] === 0; - S++, _ = _.sqr() - ); - if (++S < v.length) - for (var b = _.sqr(); S < v.length; S++, b = b.sqr()) - v[S] !== 0 && (_ = _.mul(b)); - return _; - }), - (i.prototype.iushln = function (d) { - r(typeof d == "number" && d >= 0); - var v = d % 26, - _ = (d - v) / 26, - S = (67108863 >>> (26 - v)) << (26 - v), - b; - if (v !== 0) { - var f = 0; - for (b = 0; b < this.length; b++) { - var x = this.words[b] & S, - C = ((this.words[b] | 0) - x) << v; - (this.words[b] = C | f), (f = x >>> (26 - v)); - } - f && ((this.words[b] = f), this.length++); - } - if (_ !== 0) { - for (b = this.length - 1; b >= 0; b--) - this.words[b + _] = this.words[b]; - for (b = 0; b < _; b++) this.words[b] = 0; - this.length += _; - } - return this._strip(); - }), - (i.prototype.ishln = function (d) { - return r(this.negative === 0), this.iushln(d); - }), - (i.prototype.iushrn = function (d, v, _) { - r(typeof d == "number" && d >= 0); - var S; - v ? (S = (v - (v % 26)) / 26) : (S = 0); - var b = d % 26, - f = Math.min((d - b) / 26, this.length), - x = 67108863 ^ ((67108863 >>> b) << b), - C = _; - if (((S -= f), (S = Math.max(0, S)), C)) { - for (var E = 0; E < f; E++) C.words[E] = this.words[E]; - C.length = f; - } - if (f !== 0) - if (this.length > f) - for (this.length -= f, E = 0; E < this.length; E++) - this.words[E] = this.words[E + f]; - else (this.words[0] = 0), (this.length = 1); - var B = 0; - for (E = this.length - 1; E >= 0 && (B !== 0 || E >= S); E--) { - var G = this.words[E] | 0; - (this.words[E] = (B << (26 - b)) | (G >>> b)), (B = G & x); - } - return ( - C && B !== 0 && (C.words[C.length++] = B), - this.length === 0 && ((this.words[0] = 0), (this.length = 1)), - this._strip() - ); - }), - (i.prototype.ishrn = function (d, v, _) { - return r(this.negative === 0), this.iushrn(d, v, _); - }), - (i.prototype.shln = function (d) { - return this.clone().ishln(d); - }), - (i.prototype.ushln = function (d) { - return this.clone().iushln(d); - }), - (i.prototype.shrn = function (d) { - return this.clone().ishrn(d); - }), - (i.prototype.ushrn = function (d) { - return this.clone().iushrn(d); - }), - (i.prototype.testn = function (d) { - r(typeof d == "number" && d >= 0); - var v = d % 26, - _ = (d - v) / 26, - S = 1 << v; - if (this.length <= _) return !1; - var b = this.words[_]; - return !!(b & S); - }), - (i.prototype.imaskn = function (d) { - r(typeof d == "number" && d >= 0); - var v = d % 26, - _ = (d - v) / 26; - if ( - (r(this.negative === 0, "imaskn works only with positive numbers"), - this.length <= _) - ) - return this; - if ( - (v !== 0 && _++, (this.length = Math.min(_, this.length)), v !== 0) - ) { - var S = 67108863 ^ ((67108863 >>> v) << v); - this.words[this.length - 1] &= S; - } - return this._strip(); - }), - (i.prototype.maskn = function (d) { - return this.clone().imaskn(d); - }), - (i.prototype.iaddn = function (d) { - return ( - r(typeof d == "number"), - r(d < 67108864), - d < 0 - ? this.isubn(-d) - : this.negative !== 0 - ? this.length === 1 && (this.words[0] | 0) <= d - ? ((this.words[0] = d - (this.words[0] | 0)), - (this.negative = 0), - this) - : ((this.negative = 0), - this.isubn(d), - (this.negative = 1), - this) - : this._iaddn(d) - ); - }), - (i.prototype._iaddn = function (d) { - this.words[0] += d; - for (var v = 0; v < this.length && this.words[v] >= 67108864; v++) - (this.words[v] -= 67108864), - v === this.length - 1 - ? (this.words[v + 1] = 1) - : this.words[v + 1]++; - return (this.length = Math.max(this.length, v + 1)), this; - }), - (i.prototype.isubn = function (d) { - if ((r(typeof d == "number"), r(d < 67108864), d < 0)) - return this.iaddn(-d); - if (this.negative !== 0) - return ( - (this.negative = 0), this.iaddn(d), (this.negative = 1), this - ); - if (((this.words[0] -= d), this.length === 1 && this.words[0] < 0)) - (this.words[0] = -this.words[0]), (this.negative = 1); - else - for (var v = 0; v < this.length && this.words[v] < 0; v++) - (this.words[v] += 67108864), (this.words[v + 1] -= 1); - return this._strip(); - }), - (i.prototype.addn = function (d) { - return this.clone().iaddn(d); - }), - (i.prototype.subn = function (d) { - return this.clone().isubn(d); - }), - (i.prototype.iabs = function () { - return (this.negative = 0), this; - }), - (i.prototype.abs = function () { - return this.clone().iabs(); - }), - (i.prototype._ishlnsubmul = function (d, v, _) { - var S = d.length + _, - b; - this._expand(S); - var f, - x = 0; - for (b = 0; b < d.length; b++) { - f = (this.words[b + _] | 0) + x; - var C = (d.words[b] | 0) * v; - (f -= C & 67108863), - (x = (f >> 26) - ((C / 67108864) | 0)), - (this.words[b + _] = f & 67108863); - } - for (; b < this.length - _; b++) - (f = (this.words[b + _] | 0) + x), - (x = f >> 26), - (this.words[b + _] = f & 67108863); - if (x === 0) return this._strip(); - for (r(x === -1), x = 0, b = 0; b < this.length; b++) - (f = -(this.words[b] | 0) + x), - (x = f >> 26), - (this.words[b] = f & 67108863); - return (this.negative = 1), this._strip(); - }), - (i.prototype._wordDiv = function (d, v) { - var _ = this.length - d.length, - S = this.clone(), - b = d, - f = b.words[b.length - 1] | 0, - x = this._countBits(f); - (_ = 26 - x), - _ !== 0 && - ((b = b.ushln(_)), S.iushln(_), (f = b.words[b.length - 1] | 0)); - var C = S.length - b.length, - E; - if (v !== "mod") { - (E = new i(null)), - (E.length = C + 1), - (E.words = new Array(E.length)); - for (var B = 0; B < E.length; B++) E.words[B] = 0; - } - var G = S.clone()._ishlnsubmul(b, 1, C); - G.negative === 0 && ((S = G), E && (E.words[C] = 1)); - for (var L = C - 1; L >= 0; L--) { - var ee = - (S.words[b.length + L] | 0) * 67108864 + - (S.words[b.length + L - 1] | 0); - for ( - ee = Math.min((ee / f) | 0, 67108863), S._ishlnsubmul(b, ee, L); - S.negative !== 0; - - ) - ee--, - (S.negative = 0), - S._ishlnsubmul(b, 1, L), - S.isZero() || (S.negative ^= 1); - E && (E.words[L] = ee); - } - return ( - E && E._strip(), - S._strip(), - v !== "div" && _ !== 0 && S.iushrn(_), - { div: E || null, mod: S } - ); - }), - (i.prototype.divmod = function (d, v, _) { - if ((r(!d.isZero()), this.isZero())) - return { div: new i(0), mod: new i(0) }; - var S, b, f; - return this.negative !== 0 && d.negative === 0 - ? ((f = this.neg().divmod(d, v)), - v !== "mod" && (S = f.div.neg()), - v !== "div" && - ((b = f.mod.neg()), _ && b.negative !== 0 && b.iadd(d)), - { div: S, mod: b }) - : this.negative === 0 && d.negative !== 0 - ? ((f = this.divmod(d.neg(), v)), - v !== "mod" && (S = f.div.neg()), - { div: S, mod: f.mod }) - : (this.negative & d.negative) !== 0 - ? ((f = this.neg().divmod(d.neg(), v)), - v !== "div" && - ((b = f.mod.neg()), _ && b.negative !== 0 && b.isub(d)), - { div: f.div, mod: b }) - : d.length > this.length || this.cmp(d) < 0 - ? { div: new i(0), mod: this } - : d.length === 1 - ? v === "div" - ? { div: this.divn(d.words[0]), mod: null } - : v === "mod" - ? { div: null, mod: new i(this.modrn(d.words[0])) } - : { - div: this.divn(d.words[0]), - mod: new i(this.modrn(d.words[0])), - } - : this._wordDiv(d, v); - }), - (i.prototype.div = function (d) { - return this.divmod(d, "div", !1).div; - }), - (i.prototype.mod = function (d) { - return this.divmod(d, "mod", !1).mod; - }), - (i.prototype.umod = function (d) { - return this.divmod(d, "mod", !0).mod; - }), - (i.prototype.divRound = function (d) { - var v = this.divmod(d); - if (v.mod.isZero()) return v.div; - var _ = v.div.negative !== 0 ? v.mod.isub(d) : v.mod, - S = d.ushrn(1), - b = d.andln(1), - f = _.cmp(S); - return f < 0 || (b === 1 && f === 0) - ? v.div - : v.div.negative !== 0 - ? v.div.isubn(1) - : v.div.iaddn(1); - }), - (i.prototype.modrn = function (d) { - var v = d < 0; - v && (d = -d), r(d <= 67108863); - for (var _ = (1 << 26) % d, S = 0, b = this.length - 1; b >= 0; b--) - S = (_ * S + (this.words[b] | 0)) % d; - return v ? -S : S; - }), - (i.prototype.modn = function (d) { - return this.modrn(d); - }), - (i.prototype.idivn = function (d) { - var v = d < 0; - v && (d = -d), r(d <= 67108863); - for (var _ = 0, S = this.length - 1; S >= 0; S--) { - var b = (this.words[S] | 0) + _ * 67108864; - (this.words[S] = (b / d) | 0), (_ = b % d); - } - return this._strip(), v ? this.ineg() : this; - }), - (i.prototype.divn = function (d) { - return this.clone().idivn(d); - }), - (i.prototype.egcd = function (d) { - r(d.negative === 0), r(!d.isZero()); - var v = this, - _ = d.clone(); - v.negative !== 0 ? (v = v.umod(d)) : (v = v.clone()); - for ( - var S = new i(1), b = new i(0), f = new i(0), x = new i(1), C = 0; - v.isEven() && _.isEven(); - - ) - v.iushrn(1), _.iushrn(1), ++C; - for (var E = _.clone(), B = v.clone(); !v.isZero(); ) { - for ( - var G = 0, L = 1; - (v.words[0] & L) === 0 && G < 26; - ++G, L <<= 1 - ); - if (G > 0) - for (v.iushrn(G); G-- > 0; ) - (S.isOdd() || b.isOdd()) && (S.iadd(E), b.isub(B)), - S.iushrn(1), - b.iushrn(1); - for ( - var ee = 0, ge = 1; - (_.words[0] & ge) === 0 && ee < 26; - ++ee, ge <<= 1 - ); - if (ee > 0) - for (_.iushrn(ee); ee-- > 0; ) - (f.isOdd() || x.isOdd()) && (f.iadd(E), x.isub(B)), - f.iushrn(1), - x.iushrn(1); - v.cmp(_) >= 0 - ? (v.isub(_), S.isub(f), b.isub(x)) - : (_.isub(v), f.isub(S), x.isub(b)); - } - return { a: f, b: x, gcd: _.iushln(C) }; - }), - (i.prototype._invmp = function (d) { - r(d.negative === 0), r(!d.isZero()); - var v = this, - _ = d.clone(); - v.negative !== 0 ? (v = v.umod(d)) : (v = v.clone()); - for ( - var S = new i(1), b = new i(0), f = _.clone(); - v.cmpn(1) > 0 && _.cmpn(1) > 0; - - ) { - for ( - var x = 0, C = 1; - (v.words[0] & C) === 0 && x < 26; - ++x, C <<= 1 - ); - if (x > 0) - for (v.iushrn(x); x-- > 0; ) S.isOdd() && S.iadd(f), S.iushrn(1); - for ( - var E = 0, B = 1; - (_.words[0] & B) === 0 && E < 26; - ++E, B <<= 1 - ); - if (E > 0) - for (_.iushrn(E); E-- > 0; ) b.isOdd() && b.iadd(f), b.iushrn(1); - v.cmp(_) >= 0 ? (v.isub(_), S.isub(b)) : (_.isub(v), b.isub(S)); - } - var G; - return ( - v.cmpn(1) === 0 ? (G = S) : (G = b), G.cmpn(0) < 0 && G.iadd(d), G - ); - }), - (i.prototype.gcd = function (d) { - if (this.isZero()) return d.abs(); - if (d.isZero()) return this.abs(); - var v = this.clone(), - _ = d.clone(); - (v.negative = 0), (_.negative = 0); - for (var S = 0; v.isEven() && _.isEven(); S++) - v.iushrn(1), _.iushrn(1); - do { - for (; v.isEven(); ) v.iushrn(1); - for (; _.isEven(); ) _.iushrn(1); - var b = v.cmp(_); - if (b < 0) { - var f = v; - (v = _), (_ = f); - } else if (b === 0 || _.cmpn(1) === 0) break; - v.isub(_); - } while (!0); - return _.iushln(S); - }), - (i.prototype.invm = function (d) { - return this.egcd(d).a.umod(d); - }), - (i.prototype.isEven = function () { - return (this.words[0] & 1) === 0; - }), - (i.prototype.isOdd = function () { - return (this.words[0] & 1) === 1; - }), - (i.prototype.andln = function (d) { - return this.words[0] & d; - }), - (i.prototype.bincn = function (d) { - r(typeof d == "number"); - var v = d % 26, - _ = (d - v) / 26, - S = 1 << v; - if (this.length <= _) - return this._expand(_ + 1), (this.words[_] |= S), this; - for (var b = S, f = _; b !== 0 && f < this.length; f++) { - var x = this.words[f] | 0; - (x += b), (b = x >>> 26), (x &= 67108863), (this.words[f] = x); - } - return b !== 0 && ((this.words[f] = b), this.length++), this; - }), - (i.prototype.isZero = function () { - return this.length === 1 && this.words[0] === 0; - }), - (i.prototype.cmpn = function (d) { - var v = d < 0; - if (this.negative !== 0 && !v) return -1; - if (this.negative === 0 && v) return 1; - this._strip(); - var _; - if (this.length > 1) _ = 1; - else { - v && (d = -d), r(d <= 67108863, "Number is too big"); - var S = this.words[0] | 0; - _ = S === d ? 0 : S < d ? -1 : 1; - } - return this.negative !== 0 ? -_ | 0 : _; - }), - (i.prototype.cmp = function (d) { - if (this.negative !== 0 && d.negative === 0) return -1; - if (this.negative === 0 && d.negative !== 0) return 1; - var v = this.ucmp(d); - return this.negative !== 0 ? -v | 0 : v; - }), - (i.prototype.ucmp = function (d) { - if (this.length > d.length) return 1; - if (this.length < d.length) return -1; - for (var v = 0, _ = this.length - 1; _ >= 0; _--) { - var S = this.words[_] | 0, - b = d.words[_] | 0; - if (S !== b) { - S < b ? (v = -1) : S > b && (v = 1); - break; - } - } - return v; - }), - (i.prototype.gtn = function (d) { - return this.cmpn(d) === 1; - }), - (i.prototype.gt = function (d) { - return this.cmp(d) === 1; - }), - (i.prototype.gten = function (d) { - return this.cmpn(d) >= 0; - }), - (i.prototype.gte = function (d) { - return this.cmp(d) >= 0; - }), - (i.prototype.ltn = function (d) { - return this.cmpn(d) === -1; - }), - (i.prototype.lt = function (d) { - return this.cmp(d) === -1; - }), - (i.prototype.lten = function (d) { - return this.cmpn(d) <= 0; - }), - (i.prototype.lte = function (d) { - return this.cmp(d) <= 0; - }), - (i.prototype.eqn = function (d) { - return this.cmpn(d) === 0; - }), - (i.prototype.eq = function (d) { - return this.cmp(d) === 0; - }), - (i.red = function (d) { - return new l(d); - }), - (i.prototype.toRed = function (d) { - return ( - r(!this.red, "Already a number in reduction context"), - r(this.negative === 0, "red works only with positives"), - d.convertTo(this)._forceRed(d) - ); - }), - (i.prototype.fromRed = function () { - return ( - r(this.red, "fromRed works only with numbers in reduction context"), - this.red.convertFrom(this) - ); - }), - (i.prototype._forceRed = function (d) { - return (this.red = d), this; - }), - (i.prototype.forceRed = function (d) { - return ( - r(!this.red, "Already a number in reduction context"), - this._forceRed(d) - ); - }), - (i.prototype.redAdd = function (d) { - return ( - r(this.red, "redAdd works only with red numbers"), - this.red.add(this, d) - ); - }), - (i.prototype.redIAdd = function (d) { - return ( - r(this.red, "redIAdd works only with red numbers"), - this.red.iadd(this, d) - ); - }), - (i.prototype.redSub = function (d) { - return ( - r(this.red, "redSub works only with red numbers"), - this.red.sub(this, d) - ); - }), - (i.prototype.redISub = function (d) { - return ( - r(this.red, "redISub works only with red numbers"), - this.red.isub(this, d) - ); - }), - (i.prototype.redShl = function (d) { - return ( - r(this.red, "redShl works only with red numbers"), - this.red.shl(this, d) - ); - }), - (i.prototype.redMul = function (d) { - return ( - r(this.red, "redMul works only with red numbers"), - this.red._verify2(this, d), - this.red.mul(this, d) - ); - }), - (i.prototype.redIMul = function (d) { - return ( - r(this.red, "redMul works only with red numbers"), - this.red._verify2(this, d), - this.red.imul(this, d) - ); - }), - (i.prototype.redSqr = function () { - return ( - r(this.red, "redSqr works only with red numbers"), - this.red._verify1(this), - this.red.sqr(this) - ); - }), - (i.prototype.redISqr = function () { - return ( - r(this.red, "redISqr works only with red numbers"), - this.red._verify1(this), - this.red.isqr(this) - ); - }), - (i.prototype.redSqrt = function () { - return ( - r(this.red, "redSqrt works only with red numbers"), - this.red._verify1(this), - this.red.sqrt(this) - ); - }), - (i.prototype.redInvm = function () { - return ( - r(this.red, "redInvm works only with red numbers"), - this.red._verify1(this), - this.red.invm(this) - ); - }), - (i.prototype.redNeg = function () { - return ( - r(this.red, "redNeg works only with red numbers"), - this.red._verify1(this), - this.red.neg(this) - ); - }), - (i.prototype.redPow = function (d) { - return ( - r(this.red && !d.red, "redPow(normalNum)"), - this.red._verify1(this), - this.red.pow(this, d) - ); - }); - var Z = { k256: null, p224: null, p192: null, p25519: null }; - function $(y, d) { - (this.name = y), - (this.p = new i(d, 16)), - (this.n = this.p.bitLength()), - (this.k = new i(1).iushln(this.n).isub(this.p)), - (this.tmp = this._tmp()); - } - ($.prototype._tmp = function () { - var d = new i(null); - return (d.words = new Array(Math.ceil(this.n / 13))), d; - }), - ($.prototype.ireduce = function (d) { - var v = d, - _; - do - this.split(v, this.tmp), - (v = this.imulK(v)), - (v = v.iadd(this.tmp)), - (_ = v.bitLength()); - while (_ > this.n); - var S = _ < this.n ? -1 : v.ucmp(this.p); - return ( - S === 0 - ? ((v.words[0] = 0), (v.length = 1)) - : S > 0 - ? v.isub(this.p) - : v.strip !== void 0 - ? v.strip() - : v._strip(), - v - ); - }), - ($.prototype.split = function (d, v) { - d.iushrn(this.n, 0, v); - }), - ($.prototype.imulK = function (d) { - return d.imul(this.k); - }); - function ue() { - $.call( - this, - "k256", - "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f" - ); - } - n(ue, $), - (ue.prototype.split = function (d, v) { - for (var _ = 4194303, S = Math.min(d.length, 9), b = 0; b < S; b++) - v.words[b] = d.words[b]; - if (((v.length = S), d.length <= 9)) { - (d.words[0] = 0), (d.length = 1); - return; - } - var f = d.words[9]; - for (v.words[v.length++] = f & _, b = 10; b < d.length; b++) { - var x = d.words[b] | 0; - (d.words[b - 10] = ((x & _) << 4) | (f >>> 22)), (f = x); - } - (f >>>= 22), - (d.words[b - 10] = f), - f === 0 && d.length > 10 ? (d.length -= 10) : (d.length -= 9); - }), - (ue.prototype.imulK = function (d) { - (d.words[d.length] = 0), (d.words[d.length + 1] = 0), (d.length += 2); - for (var v = 0, _ = 0; _ < d.length; _++) { - var S = d.words[_] | 0; - (v += S * 977), - (d.words[_] = v & 67108863), - (v = S * 64 + ((v / 67108864) | 0)); - } - return ( - d.words[d.length - 1] === 0 && - (d.length--, d.words[d.length - 1] === 0 && d.length--), - d - ); - }); - function te() { - $.call( - this, - "p224", - "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001" - ); - } - n(te, $); - function ne() { - $.call( - this, - "p192", - "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff" - ); - } - n(ne, $); - function A() { - $.call( - this, - "25519", - "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed" - ); - } - n(A, $), - (A.prototype.imulK = function (d) { - for (var v = 0, _ = 0; _ < d.length; _++) { - var S = (d.words[_] | 0) * 19 + v, - b = S & 67108863; - (S >>>= 26), (d.words[_] = b), (v = S); - } - return v !== 0 && (d.words[d.length++] = v), d; - }), - (i._prime = function (d) { - if (Z[d]) return Z[d]; - var v; - if (d === "k256") v = new ue(); - else if (d === "p224") v = new te(); - else if (d === "p192") v = new ne(); - else if (d === "p25519") v = new A(); - else throw new Error("Unknown prime " + d); - return (Z[d] = v), v; - }); - function l(y) { - if (typeof y == "string") { - var d = i._prime(y); - (this.m = d.p), (this.prime = d); - } else - r(y.gtn(1), "modulus must be greater than 1"), - (this.m = y), - (this.prime = null); - } - (l.prototype._verify1 = function (d) { - r(d.negative === 0, "red works only with positives"), - r(d.red, "red works only with red numbers"); - }), - (l.prototype._verify2 = function (d, v) { - r((d.negative | v.negative) === 0, "red works only with positives"), - r(d.red && d.red === v.red, "red works only with red numbers"); - }), - (l.prototype.imod = function (d) { - return this.prime - ? this.prime.ireduce(d)._forceRed(this) - : (u(d, d.umod(this.m)._forceRed(this)), d); - }), - (l.prototype.neg = function (d) { - return d.isZero() ? d.clone() : this.m.sub(d)._forceRed(this); - }), - (l.prototype.add = function (d, v) { - this._verify2(d, v); - var _ = d.add(v); - return _.cmp(this.m) >= 0 && _.isub(this.m), _._forceRed(this); - }), - (l.prototype.iadd = function (d, v) { - this._verify2(d, v); - var _ = d.iadd(v); - return _.cmp(this.m) >= 0 && _.isub(this.m), _; - }), - (l.prototype.sub = function (d, v) { - this._verify2(d, v); - var _ = d.sub(v); - return _.cmpn(0) < 0 && _.iadd(this.m), _._forceRed(this); - }), - (l.prototype.isub = function (d, v) { - this._verify2(d, v); - var _ = d.isub(v); - return _.cmpn(0) < 0 && _.iadd(this.m), _; - }), - (l.prototype.shl = function (d, v) { - return this._verify1(d), this.imod(d.ushln(v)); - }), - (l.prototype.imul = function (d, v) { - return this._verify2(d, v), this.imod(d.imul(v)); - }), - (l.prototype.mul = function (d, v) { - return this._verify2(d, v), this.imod(d.mul(v)); - }), - (l.prototype.isqr = function (d) { - return this.imul(d, d.clone()); - }), - (l.prototype.sqr = function (d) { - return this.mul(d, d); - }), - (l.prototype.sqrt = function (d) { - if (d.isZero()) return d.clone(); - var v = this.m.andln(3); - if ((r(v % 2 === 1), v === 3)) { - var _ = this.m.add(new i(1)).iushrn(2); - return this.pow(d, _); - } - for (var S = this.m.subn(1), b = 0; !S.isZero() && S.andln(1) === 0; ) - b++, S.iushrn(1); - r(!S.isZero()); - var f = new i(1).toRed(this), - x = f.redNeg(), - C = this.m.subn(1).iushrn(1), - E = this.m.bitLength(); - for (E = new i(2 * E * E).toRed(this); this.pow(E, C).cmp(x) !== 0; ) - E.redIAdd(x); - for ( - var B = this.pow(E, S), - G = this.pow(d, S.addn(1).iushrn(1)), - L = this.pow(d, S), - ee = b; - L.cmp(f) !== 0; - - ) { - for (var ge = L, fe = 0; ge.cmp(f) !== 0; fe++) ge = ge.redSqr(); - r(fe < ee); - var V = this.pow(B, new i(1).iushln(ee - fe - 1)); - (G = G.redMul(V)), (B = V.redSqr()), (L = L.redMul(B)), (ee = fe); - } - return G; - }), - (l.prototype.invm = function (d) { - var v = d._invmp(this.m); - return v.negative !== 0 - ? ((v.negative = 0), this.imod(v).redNeg()) - : this.imod(v); - }), - (l.prototype.pow = function (d, v) { - if (v.isZero()) return new i(1).toRed(this); - if (v.cmpn(1) === 0) return d.clone(); - var _ = 4, - S = new Array(1 << _); - (S[0] = new i(1).toRed(this)), (S[1] = d); - for (var b = 2; b < S.length; b++) S[b] = this.mul(S[b - 1], d); - var f = S[0], - x = 0, - C = 0, - E = v.bitLength() % 26; - for (E === 0 && (E = 26), b = v.length - 1; b >= 0; b--) { - for (var B = v.words[b], G = E - 1; G >= 0; G--) { - var L = (B >> G) & 1; - if ((f !== S[0] && (f = this.sqr(f)), L === 0 && x === 0)) { - C = 0; - continue; - } - (x <<= 1), - (x |= L), - C++, - !(C !== _ && (b !== 0 || G !== 0)) && - ((f = this.mul(f, S[x])), (C = 0), (x = 0)); - } - E = 26; - } - return f; - }), - (l.prototype.convertTo = function (d) { - var v = d.umod(this.m); - return v === d ? v.clone() : v; - }), - (l.prototype.convertFrom = function (d) { - var v = d.clone(); - return (v.red = null), v; - }), - (i.mont = function (d) { - return new p(d); - }); - function p(y) { - l.call(this, y), - (this.shift = this.m.bitLength()), - this.shift % 26 !== 0 && (this.shift += 26 - (this.shift % 26)), - (this.r = new i(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)); - } - n(p, l), - (p.prototype.convertTo = function (d) { - return this.imod(d.ushln(this.shift)); - }), - (p.prototype.convertFrom = function (d) { - var v = this.imod(d.mul(this.rinv)); - return (v.red = null), v; - }), - (p.prototype.imul = function (d, v) { - if (d.isZero() || v.isZero()) - return (d.words[0] = 0), (d.length = 1), d; - var _ = d.imul(v), - S = _.maskn(this.shift) - .mul(this.minv) - .imaskn(this.shift) - .mul(this.m), - b = _.isub(S).iushrn(this.shift), - f = b; - return ( - b.cmp(this.m) >= 0 - ? (f = b.isub(this.m)) - : b.cmpn(0) < 0 && (f = b.iadd(this.m)), - f._forceRed(this) - ); - }), - (p.prototype.mul = function (d, v) { - if (d.isZero() || v.isZero()) return new i(0)._forceRed(this); - var _ = d.mul(v), - S = _.maskn(this.shift) - .mul(this.minv) - .imaskn(this.shift) - .mul(this.m), - b = _.isub(S).iushrn(this.shift), - f = b; - return ( - b.cmp(this.m) >= 0 - ? (f = b.isub(this.m)) - : b.cmpn(0) < 0 && (f = b.iadd(this.m)), - f._forceRed(this) - ); - }), - (p.prototype.invm = function (d) { - var v = this.imod(d._invmp(this.m).mul(this.r2)); - return v._forceRed(this); - }); - })(typeof sbe > "u" || sbe, NVe); - }); - var YZ = I((Xln, LVe) => { - m(); - g(); - var E5 = Ho(), - RXt = sM(); - function NXt(t) { - var e = DVe(t), - r = e - .toRed(E5.mont(t.modulus)) - .redPow(new E5(t.publicExponent)) - .fromRed(); - return { blinder: r, unblinder: e.invm(t.modulus) }; - } - function DVe(t) { - var e = t.modulus.byteLength(), - r; - do r = new E5(RXt(e)); - while (r.cmp(t.modulus) >= 0 || !r.umod(t.prime1) || !r.umod(t.prime2)); - return r; - } - function FVe(t, e) { - var r = NXt(e), - n = e.modulus.byteLength(), - i = new E5(t).mul(r.blinder).umod(e.modulus), - o = i.toRed(E5.mont(e.prime1)), - a = i.toRed(E5.mont(e.prime2)), - s = e.coefficient, - c = e.prime1, - u = e.prime2, - h = o.redPow(e.exponent1).fromRed(), - w = a.redPow(e.exponent2).fromRed(), - M = h.isub(w).imul(s).umod(c).imul(u); - return w - .iadd(M) - .imul(r.unblinder) - .umod(e.modulus) - .toArrayLike(Buffer, "be", n); - } - FVe.getr = DVe; - LVe.exports = FVe; - }); - var qVe = I((Yln, DXt) => { - DXt.exports = { - name: "elliptic", - version: "6.5.4", - description: "EC cryptography", - main: "lib/elliptic.js", - files: ["lib"], - scripts: { - lint: "eslint lib test", - "lint:fix": "npm run lint -- --fix", - unit: "istanbul test _mocha --reporter=spec test/index.js", - test: "npm run lint && npm run unit", - version: "grunt dist && git add dist/", - }, - repository: { type: "git", url: "git@github.com:indutny/elliptic" }, - keywords: ["EC", "Elliptic", "curve", "Cryptography"], - author: "Fedor Indutny ", - license: "MIT", - bugs: { url: "https://github.com/indutny/elliptic/issues" }, - homepage: "https://github.com/indutny/elliptic", - devDependencies: { - brfs: "^2.0.2", - coveralls: "^3.1.0", - eslint: "^7.6.0", - grunt: "^1.2.1", - "grunt-browserify": "^5.3.0", - "grunt-cli": "^1.3.2", - "grunt-contrib-connect": "^3.0.0", - "grunt-contrib-copy": "^1.0.0", - "grunt-contrib-uglify": "^5.0.0", - "grunt-mocha-istanbul": "^5.0.2", - "grunt-saucelabs": "^9.0.1", - istanbul: "^0.4.5", - mocha: "^8.0.1", - }, - dependencies: { - "bn.js": "^4.11.9", - brorand: "^1.1.0", - "hash.js": "^1.0.0", - "hmac-drbg": "^1.0.1", - inherits: "^2.0.4", - "minimalistic-assert": "^1.0.1", - "minimalistic-crypto-utils": "^1.0.1", - }, - }; - }); - var hv = I((zVe, ube) => { - m(); - g(); - (function (t, e) { - "use strict"; - function r(A, l) { - if (!A) throw new Error(l || "Assertion failed"); - } - function n(A, l) { - A.super_ = l; - var p = function () {}; - (p.prototype = l.prototype), - (A.prototype = new p()), - (A.prototype.constructor = A); - } - function i(A, l, p) { - if (i.isBN(A)) return A; - (this.negative = 0), - (this.words = null), - (this.length = 0), - (this.red = null), - A !== null && - ((l === "le" || l === "be") && ((p = l), (l = 10)), - this._init(A || 0, l || 10, p || "be")); - } - typeof t == "object" ? (t.exports = i) : (e.BN = i), - (i.BN = i), - (i.wordSize = 26); - var o; - try { - typeof window < "u" && typeof window.Buffer < "u" - ? (o = window.Buffer) - : (o = Qr().Buffer); - } catch {} - (i.isBN = function (l) { - return l instanceof i - ? !0 - : l !== null && - typeof l == "object" && - l.constructor.wordSize === i.wordSize && - Array.isArray(l.words); - }), - (i.max = function (l, p) { - return l.cmp(p) > 0 ? l : p; - }), - (i.min = function (l, p) { - return l.cmp(p) < 0 ? l : p; - }), - (i.prototype._init = function (l, p, y) { - if (typeof l == "number") return this._initNumber(l, p, y); - if (typeof l == "object") return this._initArray(l, p, y); - p === "hex" && (p = 16), - r(p === (p | 0) && p >= 2 && p <= 36), - (l = l.toString().replace(/\s+/g, "")); - var d = 0; - l[0] === "-" && (d++, (this.negative = 1)), - d < l.length && - (p === 16 - ? this._parseHex(l, d, y) - : (this._parseBase(l, p, d), - y === "le" && this._initArray(this.toArray(), p, y))); - }), - (i.prototype._initNumber = function (l, p, y) { - l < 0 && ((this.negative = 1), (l = -l)), - l < 67108864 - ? ((this.words = [l & 67108863]), (this.length = 1)) - : l < 4503599627370496 - ? ((this.words = [l & 67108863, (l / 67108864) & 67108863]), - (this.length = 2)) - : (r(l < 9007199254740992), - (this.words = [l & 67108863, (l / 67108864) & 67108863, 1]), - (this.length = 3)), - y === "le" && this._initArray(this.toArray(), p, y); - }), - (i.prototype._initArray = function (l, p, y) { - if ((r(typeof l.length == "number"), l.length <= 0)) - return (this.words = [0]), (this.length = 1), this; - (this.length = Math.ceil(l.length / 3)), - (this.words = new Array(this.length)); - for (var d = 0; d < this.length; d++) this.words[d] = 0; - var v, - _, - S = 0; - if (y === "be") - for (d = l.length - 1, v = 0; d >= 0; d -= 3) - (_ = l[d] | (l[d - 1] << 8) | (l[d - 2] << 16)), - (this.words[v] |= (_ << S) & 67108863), - (this.words[v + 1] = (_ >>> (26 - S)) & 67108863), - (S += 24), - S >= 26 && ((S -= 26), v++); - else if (y === "le") - for (d = 0, v = 0; d < l.length; d += 3) - (_ = l[d] | (l[d + 1] << 8) | (l[d + 2] << 16)), - (this.words[v] |= (_ << S) & 67108863), - (this.words[v + 1] = (_ >>> (26 - S)) & 67108863), - (S += 24), - S >= 26 && ((S -= 26), v++); - return this.strip(); - }); - function a(A, l) { - var p = A.charCodeAt(l); - return p >= 65 && p <= 70 - ? p - 55 - : p >= 97 && p <= 102 - ? p - 87 - : (p - 48) & 15; - } - function s(A, l, p) { - var y = a(A, p); - return p - 1 >= l && (y |= a(A, p - 1) << 4), y; - } - i.prototype._parseHex = function (l, p, y) { - (this.length = Math.ceil((l.length - p) / 6)), - (this.words = new Array(this.length)); - for (var d = 0; d < this.length; d++) this.words[d] = 0; - var v = 0, - _ = 0, - S; - if (y === "be") - for (d = l.length - 1; d >= p; d -= 2) - (S = s(l, p, d) << v), - (this.words[_] |= S & 67108863), - v >= 18 - ? ((v -= 18), (_ += 1), (this.words[_] |= S >>> 26)) - : (v += 8); - else { - var b = l.length - p; - for (d = b % 2 === 0 ? p + 1 : p; d < l.length; d += 2) - (S = s(l, p, d) << v), - (this.words[_] |= S & 67108863), - v >= 18 - ? ((v -= 18), (_ += 1), (this.words[_] |= S >>> 26)) - : (v += 8); - } - this.strip(); - }; - function c(A, l, p, y) { - for (var d = 0, v = Math.min(A.length, p), _ = l; _ < v; _++) { - var S = A.charCodeAt(_) - 48; - (d *= y), - S >= 49 - ? (d += S - 49 + 10) - : S >= 17 - ? (d += S - 17 + 10) - : (d += S); - } - return d; - } - (i.prototype._parseBase = function (l, p, y) { - (this.words = [0]), (this.length = 1); - for (var d = 0, v = 1; v <= 67108863; v *= p) d++; - d--, (v = (v / p) | 0); - for ( - var _ = l.length - y, - S = _ % d, - b = Math.min(_, _ - S) + y, - f = 0, - x = y; - x < b; - x += d - ) - (f = c(l, x, x + d, p)), - this.imuln(v), - this.words[0] + f < 67108864 - ? (this.words[0] += f) - : this._iaddn(f); - if (S !== 0) { - var C = 1; - for (f = c(l, x, l.length, p), x = 0; x < S; x++) C *= p; - this.imuln(C), - this.words[0] + f < 67108864 - ? (this.words[0] += f) - : this._iaddn(f); - } - this.strip(); - }), - (i.prototype.copy = function (l) { - l.words = new Array(this.length); - for (var p = 0; p < this.length; p++) l.words[p] = this.words[p]; - (l.length = this.length), - (l.negative = this.negative), - (l.red = this.red); - }), - (i.prototype.clone = function () { - var l = new i(null); - return this.copy(l), l; - }), - (i.prototype._expand = function (l) { - for (; this.length < l; ) this.words[this.length++] = 0; - return this; - }), - (i.prototype.strip = function () { - for (; this.length > 1 && this.words[this.length - 1] === 0; ) - this.length--; - return this._normSign(); - }), - (i.prototype._normSign = function () { - return ( - this.length === 1 && this.words[0] === 0 && (this.negative = 0), - this - ); - }), - (i.prototype.inspect = function () { - return (this.red ? ""; - }); - var u = [ - "", - "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", - ], - h = [ - 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, - ], - w = [ - 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, - ]; - (i.prototype.toString = function (l, p) { - (l = l || 10), (p = p | 0 || 1); - var y; - if (l === 16 || l === "hex") { - y = ""; - for (var d = 0, v = 0, _ = 0; _ < this.length; _++) { - var S = this.words[_], - b = (((S << d) | v) & 16777215).toString(16); - (v = (S >>> (24 - d)) & 16777215), - v !== 0 || _ !== this.length - 1 - ? (y = u[6 - b.length] + b + y) - : (y = b + y), - (d += 2), - d >= 26 && ((d -= 26), _--); - } - for (v !== 0 && (y = v.toString(16) + y); y.length % p !== 0; ) - y = "0" + y; - return this.negative !== 0 && (y = "-" + y), y; - } - if (l === (l | 0) && l >= 2 && l <= 36) { - var f = h[l], - x = w[l]; - y = ""; - var C = this.clone(); - for (C.negative = 0; !C.isZero(); ) { - var E = C.modn(x).toString(l); - (C = C.idivn(x)), - C.isZero() ? (y = E + y) : (y = u[f - E.length] + E + y); - } - for (this.isZero() && (y = "0" + y); y.length % p !== 0; ) - y = "0" + y; - return this.negative !== 0 && (y = "-" + y), y; - } - r(!1, "Base should be between 2 and 36"); - }), - (i.prototype.toNumber = function () { - var l = this.words[0]; - return ( - this.length === 2 - ? (l += this.words[1] * 67108864) - : this.length === 3 && this.words[2] === 1 - ? (l += 4503599627370496 + this.words[1] * 67108864) - : this.length > 2 && - r(!1, "Number can only safely store up to 53 bits"), - this.negative !== 0 ? -l : l - ); - }), - (i.prototype.toJSON = function () { - return this.toString(16); - }), - (i.prototype.toBuffer = function (l, p) { - return r(typeof o < "u"), this.toArrayLike(o, l, p); - }), - (i.prototype.toArray = function (l, p) { - return this.toArrayLike(Array, l, p); - }), - (i.prototype.toArrayLike = function (l, p, y) { - var d = this.byteLength(), - v = y || Math.max(1, d); - r(d <= v, "byte array longer than desired length"), - r(v > 0, "Requested array length <= 0"), - this.strip(); - var _ = p === "le", - S = new l(v), - b, - f, - x = this.clone(); - if (_) { - for (f = 0; !x.isZero(); f++) - (b = x.andln(255)), x.iushrn(8), (S[f] = b); - for (; f < v; f++) S[f] = 0; - } else { - for (f = 0; f < v - d; f++) S[f] = 0; - for (f = 0; !x.isZero(); f++) - (b = x.andln(255)), x.iushrn(8), (S[v - f - 1] = b); - } - return S; - }), - Math.clz32 - ? (i.prototype._countBits = function (l) { - return 32 - Math.clz32(l); - }) - : (i.prototype._countBits = function (l) { - var p = l, - y = 0; - return ( - p >= 4096 && ((y += 13), (p >>>= 13)), - p >= 64 && ((y += 7), (p >>>= 7)), - p >= 8 && ((y += 4), (p >>>= 4)), - p >= 2 && ((y += 2), (p >>>= 2)), - y + p - ); - }), - (i.prototype._zeroBits = function (l) { - if (l === 0) return 26; - var p = l, - y = 0; - return ( - (p & 8191) === 0 && ((y += 13), (p >>>= 13)), - (p & 127) === 0 && ((y += 7), (p >>>= 7)), - (p & 15) === 0 && ((y += 4), (p >>>= 4)), - (p & 3) === 0 && ((y += 2), (p >>>= 2)), - (p & 1) === 0 && y++, - y - ); - }), - (i.prototype.bitLength = function () { - var l = this.words[this.length - 1], - p = this._countBits(l); - return (this.length - 1) * 26 + p; - }); - function M(A) { - for (var l = new Array(A.bitLength()), p = 0; p < l.length; p++) { - var y = (p / 26) | 0, - d = p % 26; - l[p] = (A.words[y] & (1 << d)) >>> d; - } - return l; - } - (i.prototype.zeroBits = function () { - if (this.isZero()) return 0; - for (var l = 0, p = 0; p < this.length; p++) { - var y = this._zeroBits(this.words[p]); - if (((l += y), y !== 26)) break; - } - return l; - }), - (i.prototype.byteLength = function () { - return Math.ceil(this.bitLength() / 8); - }), - (i.prototype.toTwos = function (l) { - return this.negative !== 0 - ? this.abs().inotn(l).iaddn(1) - : this.clone(); - }), - (i.prototype.fromTwos = function (l) { - return this.testn(l - 1) - ? this.notn(l).iaddn(1).ineg() - : this.clone(); - }), - (i.prototype.isNeg = function () { - return this.negative !== 0; - }), - (i.prototype.neg = function () { - return this.clone().ineg(); - }), - (i.prototype.ineg = function () { - return this.isZero() || (this.negative ^= 1), this; - }), - (i.prototype.iuor = function (l) { - for (; this.length < l.length; ) this.words[this.length++] = 0; - for (var p = 0; p < l.length; p++) - this.words[p] = this.words[p] | l.words[p]; - return this.strip(); - }), - (i.prototype.ior = function (l) { - return r((this.negative | l.negative) === 0), this.iuor(l); - }), - (i.prototype.or = function (l) { - return this.length > l.length - ? this.clone().ior(l) - : l.clone().ior(this); - }), - (i.prototype.uor = function (l) { - return this.length > l.length - ? this.clone().iuor(l) - : l.clone().iuor(this); - }), - (i.prototype.iuand = function (l) { - var p; - this.length > l.length ? (p = l) : (p = this); - for (var y = 0; y < p.length; y++) - this.words[y] = this.words[y] & l.words[y]; - return (this.length = p.length), this.strip(); - }), - (i.prototype.iand = function (l) { - return r((this.negative | l.negative) === 0), this.iuand(l); - }), - (i.prototype.and = function (l) { - return this.length > l.length - ? this.clone().iand(l) - : l.clone().iand(this); - }), - (i.prototype.uand = function (l) { - return this.length > l.length - ? this.clone().iuand(l) - : l.clone().iuand(this); - }), - (i.prototype.iuxor = function (l) { - var p, y; - this.length > l.length - ? ((p = this), (y = l)) - : ((p = l), (y = this)); - for (var d = 0; d < y.length; d++) - this.words[d] = p.words[d] ^ y.words[d]; - if (this !== p) for (; d < p.length; d++) this.words[d] = p.words[d]; - return (this.length = p.length), this.strip(); - }), - (i.prototype.ixor = function (l) { - return r((this.negative | l.negative) === 0), this.iuxor(l); - }), - (i.prototype.xor = function (l) { - return this.length > l.length - ? this.clone().ixor(l) - : l.clone().ixor(this); - }), - (i.prototype.uxor = function (l) { - return this.length > l.length - ? this.clone().iuxor(l) - : l.clone().iuxor(this); - }), - (i.prototype.inotn = function (l) { - r(typeof l == "number" && l >= 0); - var p = Math.ceil(l / 26) | 0, - y = l % 26; - this._expand(p), y > 0 && p--; - for (var d = 0; d < p; d++) this.words[d] = ~this.words[d] & 67108863; - return ( - y > 0 && (this.words[d] = ~this.words[d] & (67108863 >> (26 - y))), - this.strip() - ); - }), - (i.prototype.notn = function (l) { - return this.clone().inotn(l); - }), - (i.prototype.setn = function (l, p) { - r(typeof l == "number" && l >= 0); - var y = (l / 26) | 0, - d = l % 26; - return ( - this._expand(y + 1), - p - ? (this.words[y] = this.words[y] | (1 << d)) - : (this.words[y] = this.words[y] & ~(1 << d)), - this.strip() - ); - }), - (i.prototype.iadd = function (l) { - var p; - if (this.negative !== 0 && l.negative === 0) - return ( - (this.negative = 0), - (p = this.isub(l)), - (this.negative ^= 1), - this._normSign() - ); - if (this.negative === 0 && l.negative !== 0) - return ( - (l.negative = 0), - (p = this.isub(l)), - (l.negative = 1), - p._normSign() - ); - var y, d; - this.length > l.length - ? ((y = this), (d = l)) - : ((y = l), (d = this)); - for (var v = 0, _ = 0; _ < d.length; _++) - (p = (y.words[_] | 0) + (d.words[_] | 0) + v), - (this.words[_] = p & 67108863), - (v = p >>> 26); - for (; v !== 0 && _ < y.length; _++) - (p = (y.words[_] | 0) + v), - (this.words[_] = p & 67108863), - (v = p >>> 26); - if (((this.length = y.length), v !== 0)) - (this.words[this.length] = v), this.length++; - else if (y !== this) - for (; _ < y.length; _++) this.words[_] = y.words[_]; - return this; - }), - (i.prototype.add = function (l) { - var p; - return l.negative !== 0 && this.negative === 0 - ? ((l.negative = 0), (p = this.sub(l)), (l.negative ^= 1), p) - : l.negative === 0 && this.negative !== 0 - ? ((this.negative = 0), (p = l.sub(this)), (this.negative = 1), p) - : this.length > l.length - ? this.clone().iadd(l) - : l.clone().iadd(this); - }), - (i.prototype.isub = function (l) { - if (l.negative !== 0) { - l.negative = 0; - var p = this.iadd(l); - return (l.negative = 1), p._normSign(); - } else if (this.negative !== 0) - return ( - (this.negative = 0), - this.iadd(l), - (this.negative = 1), - this._normSign() - ); - var y = this.cmp(l); - if (y === 0) - return ( - (this.negative = 0), (this.length = 1), (this.words[0] = 0), this - ); - var d, v; - y > 0 ? ((d = this), (v = l)) : ((d = l), (v = this)); - for (var _ = 0, S = 0; S < v.length; S++) - (p = (d.words[S] | 0) - (v.words[S] | 0) + _), - (_ = p >> 26), - (this.words[S] = p & 67108863); - for (; _ !== 0 && S < d.length; S++) - (p = (d.words[S] | 0) + _), - (_ = p >> 26), - (this.words[S] = p & 67108863); - if (_ === 0 && S < d.length && d !== this) - for (; S < d.length; S++) this.words[S] = d.words[S]; - return ( - (this.length = Math.max(this.length, S)), - d !== this && (this.negative = 1), - this.strip() - ); - }), - (i.prototype.sub = function (l) { - return this.clone().isub(l); - }); - function k(A, l, p) { - p.negative = l.negative ^ A.negative; - var y = (A.length + l.length) | 0; - (p.length = y), (y = (y - 1) | 0); - var d = A.words[0] | 0, - v = l.words[0] | 0, - _ = d * v, - S = _ & 67108863, - b = (_ / 67108864) | 0; - p.words[0] = S; - for (var f = 1; f < y; f++) { - for ( - var x = b >>> 26, - C = b & 67108863, - E = Math.min(f, l.length - 1), - B = Math.max(0, f - A.length + 1); - B <= E; - B++ - ) { - var G = (f - B) | 0; - (d = A.words[G] | 0), - (v = l.words[B] | 0), - (_ = d * v + C), - (x += (_ / 67108864) | 0), - (C = _ & 67108863); - } - (p.words[f] = C | 0), (b = x | 0); - } - return b !== 0 ? (p.words[f] = b | 0) : p.length--, p.strip(); - } - var O = function (l, p, y) { - var d = l.words, - v = p.words, - _ = y.words, - S = 0, - b, - f, - x, - C = d[0] | 0, - E = C & 8191, - B = C >>> 13, - G = d[1] | 0, - L = G & 8191, - ee = G >>> 13, - ge = d[2] | 0, - fe = ge & 8191, - V = ge >>> 13, - ye = d[3] | 0, - ae = ye & 8191, - le = ye >>> 13, - Me = d[4] | 0, - de = Me & 8191, - ve = Me >>> 13, - De = d[5] | 0, - me = De & 8191, - _e = De >>> 13, - Ye = d[6] | 0, - Ee = Ye & 8191, - Be = Ye >>> 13, - kt = d[7] | 0, - Ve = kt & 8191, - We = kt >>> 13, - er = d[8] | 0, - Ue = er & 8191, - Y = er >>> 13, - W = d[9] | 0, - j = W & 8191, - ce = W >>> 13, - ze = v[0] | 0, - we = ze & 8191, - xe = ze >>> 13, - Ft = v[1] | 0, - Ke = Ft & 8191, - pe = Ft >>> 13, - Re = v[2] | 0, - Se = Re & 8191, - Pe = Re >>> 13, - At = v[3] | 0, - Ie = At & 8191, - je = At >>> 13, - qt = v[4] | 0, - Fe = qt & 8191, - He = qt >>> 13, - lr = v[5] | 0, - Xe = lr & 8191, - Ze = lr >>> 13, - Ir = v[6] | 0, - $e = Ir & 8191, - tt = Ir >>> 13, - oe = v[7] | 0, - ie = oe & 8191, - re = oe >>> 13, - U = v[8] | 0, - se = U & 8191, - be = U >>> 13, - Qe = v[9] | 0, - Ae = Qe & 8191, - ke = Qe >>> 13; - (y.negative = l.negative ^ p.negative), - (y.length = 19), - (b = Math.imul(E, we)), - (f = Math.imul(E, xe)), - (f = (f + Math.imul(B, we)) | 0), - (x = Math.imul(B, xe)); - var Ct = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ct >>> 26)) | 0), - (Ct &= 67108863), - (b = Math.imul(L, we)), - (f = Math.imul(L, xe)), - (f = (f + Math.imul(ee, we)) | 0), - (x = Math.imul(ee, xe)), - (b = (b + Math.imul(E, Ke)) | 0), - (f = (f + Math.imul(E, pe)) | 0), - (f = (f + Math.imul(B, Ke)) | 0), - (x = (x + Math.imul(B, pe)) | 0); - var ut = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (ut >>> 26)) | 0), - (ut &= 67108863), - (b = Math.imul(fe, we)), - (f = Math.imul(fe, xe)), - (f = (f + Math.imul(V, we)) | 0), - (x = Math.imul(V, xe)), - (b = (b + Math.imul(L, Ke)) | 0), - (f = (f + Math.imul(L, pe)) | 0), - (f = (f + Math.imul(ee, Ke)) | 0), - (x = (x + Math.imul(ee, pe)) | 0), - (b = (b + Math.imul(E, Se)) | 0), - (f = (f + Math.imul(E, Pe)) | 0), - (f = (f + Math.imul(B, Se)) | 0), - (x = (x + Math.imul(B, Pe)) | 0); - var St = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (St >>> 26)) | 0), - (St &= 67108863), - (b = Math.imul(ae, we)), - (f = Math.imul(ae, xe)), - (f = (f + Math.imul(le, we)) | 0), - (x = Math.imul(le, xe)), - (b = (b + Math.imul(fe, Ke)) | 0), - (f = (f + Math.imul(fe, pe)) | 0), - (f = (f + Math.imul(V, Ke)) | 0), - (x = (x + Math.imul(V, pe)) | 0), - (b = (b + Math.imul(L, Se)) | 0), - (f = (f + Math.imul(L, Pe)) | 0), - (f = (f + Math.imul(ee, Se)) | 0), - (x = (x + Math.imul(ee, Pe)) | 0), - (b = (b + Math.imul(E, Ie)) | 0), - (f = (f + Math.imul(E, je)) | 0), - (f = (f + Math.imul(B, Ie)) | 0), - (x = (x + Math.imul(B, je)) | 0); - var wt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (wt >>> 26)) | 0), - (wt &= 67108863), - (b = Math.imul(de, we)), - (f = Math.imul(de, xe)), - (f = (f + Math.imul(ve, we)) | 0), - (x = Math.imul(ve, xe)), - (b = (b + Math.imul(ae, Ke)) | 0), - (f = (f + Math.imul(ae, pe)) | 0), - (f = (f + Math.imul(le, Ke)) | 0), - (x = (x + Math.imul(le, pe)) | 0), - (b = (b + Math.imul(fe, Se)) | 0), - (f = (f + Math.imul(fe, Pe)) | 0), - (f = (f + Math.imul(V, Se)) | 0), - (x = (x + Math.imul(V, Pe)) | 0), - (b = (b + Math.imul(L, Ie)) | 0), - (f = (f + Math.imul(L, je)) | 0), - (f = (f + Math.imul(ee, Ie)) | 0), - (x = (x + Math.imul(ee, je)) | 0), - (b = (b + Math.imul(E, Fe)) | 0), - (f = (f + Math.imul(E, He)) | 0), - (f = (f + Math.imul(B, Fe)) | 0), - (x = (x + Math.imul(B, He)) | 0); - var zt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (zt >>> 26)) | 0), - (zt &= 67108863), - (b = Math.imul(me, we)), - (f = Math.imul(me, xe)), - (f = (f + Math.imul(_e, we)) | 0), - (x = Math.imul(_e, xe)), - (b = (b + Math.imul(de, Ke)) | 0), - (f = (f + Math.imul(de, pe)) | 0), - (f = (f + Math.imul(ve, Ke)) | 0), - (x = (x + Math.imul(ve, pe)) | 0), - (b = (b + Math.imul(ae, Se)) | 0), - (f = (f + Math.imul(ae, Pe)) | 0), - (f = (f + Math.imul(le, Se)) | 0), - (x = (x + Math.imul(le, Pe)) | 0), - (b = (b + Math.imul(fe, Ie)) | 0), - (f = (f + Math.imul(fe, je)) | 0), - (f = (f + Math.imul(V, Ie)) | 0), - (x = (x + Math.imul(V, je)) | 0), - (b = (b + Math.imul(L, Fe)) | 0), - (f = (f + Math.imul(L, He)) | 0), - (f = (f + Math.imul(ee, Fe)) | 0), - (x = (x + Math.imul(ee, He)) | 0), - (b = (b + Math.imul(E, Xe)) | 0), - (f = (f + Math.imul(E, Ze)) | 0), - (f = (f + Math.imul(B, Xe)) | 0), - (x = (x + Math.imul(B, Ze)) | 0); - var jt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (jt >>> 26)) | 0), - (jt &= 67108863), - (b = Math.imul(Ee, we)), - (f = Math.imul(Ee, xe)), - (f = (f + Math.imul(Be, we)) | 0), - (x = Math.imul(Be, xe)), - (b = (b + Math.imul(me, Ke)) | 0), - (f = (f + Math.imul(me, pe)) | 0), - (f = (f + Math.imul(_e, Ke)) | 0), - (x = (x + Math.imul(_e, pe)) | 0), - (b = (b + Math.imul(de, Se)) | 0), - (f = (f + Math.imul(de, Pe)) | 0), - (f = (f + Math.imul(ve, Se)) | 0), - (x = (x + Math.imul(ve, Pe)) | 0), - (b = (b + Math.imul(ae, Ie)) | 0), - (f = (f + Math.imul(ae, je)) | 0), - (f = (f + Math.imul(le, Ie)) | 0), - (x = (x + Math.imul(le, je)) | 0), - (b = (b + Math.imul(fe, Fe)) | 0), - (f = (f + Math.imul(fe, He)) | 0), - (f = (f + Math.imul(V, Fe)) | 0), - (x = (x + Math.imul(V, He)) | 0), - (b = (b + Math.imul(L, Xe)) | 0), - (f = (f + Math.imul(L, Ze)) | 0), - (f = (f + Math.imul(ee, Xe)) | 0), - (x = (x + Math.imul(ee, Ze)) | 0), - (b = (b + Math.imul(E, $e)) | 0), - (f = (f + Math.imul(E, tt)) | 0), - (f = (f + Math.imul(B, $e)) | 0), - (x = (x + Math.imul(B, tt)) | 0); - var Ht = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ht >>> 26)) | 0), - (Ht &= 67108863), - (b = Math.imul(Ve, we)), - (f = Math.imul(Ve, xe)), - (f = (f + Math.imul(We, we)) | 0), - (x = Math.imul(We, xe)), - (b = (b + Math.imul(Ee, Ke)) | 0), - (f = (f + Math.imul(Ee, pe)) | 0), - (f = (f + Math.imul(Be, Ke)) | 0), - (x = (x + Math.imul(Be, pe)) | 0), - (b = (b + Math.imul(me, Se)) | 0), - (f = (f + Math.imul(me, Pe)) | 0), - (f = (f + Math.imul(_e, Se)) | 0), - (x = (x + Math.imul(_e, Pe)) | 0), - (b = (b + Math.imul(de, Ie)) | 0), - (f = (f + Math.imul(de, je)) | 0), - (f = (f + Math.imul(ve, Ie)) | 0), - (x = (x + Math.imul(ve, je)) | 0), - (b = (b + Math.imul(ae, Fe)) | 0), - (f = (f + Math.imul(ae, He)) | 0), - (f = (f + Math.imul(le, Fe)) | 0), - (x = (x + Math.imul(le, He)) | 0), - (b = (b + Math.imul(fe, Xe)) | 0), - (f = (f + Math.imul(fe, Ze)) | 0), - (f = (f + Math.imul(V, Xe)) | 0), - (x = (x + Math.imul(V, Ze)) | 0), - (b = (b + Math.imul(L, $e)) | 0), - (f = (f + Math.imul(L, tt)) | 0), - (f = (f + Math.imul(ee, $e)) | 0), - (x = (x + Math.imul(ee, tt)) | 0), - (b = (b + Math.imul(E, ie)) | 0), - (f = (f + Math.imul(E, re)) | 0), - (f = (f + Math.imul(B, ie)) | 0), - (x = (x + Math.imul(B, re)) | 0); - var Ut = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ut >>> 26)) | 0), - (Ut &= 67108863), - (b = Math.imul(Ue, we)), - (f = Math.imul(Ue, xe)), - (f = (f + Math.imul(Y, we)) | 0), - (x = Math.imul(Y, xe)), - (b = (b + Math.imul(Ve, Ke)) | 0), - (f = (f + Math.imul(Ve, pe)) | 0), - (f = (f + Math.imul(We, Ke)) | 0), - (x = (x + Math.imul(We, pe)) | 0), - (b = (b + Math.imul(Ee, Se)) | 0), - (f = (f + Math.imul(Ee, Pe)) | 0), - (f = (f + Math.imul(Be, Se)) | 0), - (x = (x + Math.imul(Be, Pe)) | 0), - (b = (b + Math.imul(me, Ie)) | 0), - (f = (f + Math.imul(me, je)) | 0), - (f = (f + Math.imul(_e, Ie)) | 0), - (x = (x + Math.imul(_e, je)) | 0), - (b = (b + Math.imul(de, Fe)) | 0), - (f = (f + Math.imul(de, He)) | 0), - (f = (f + Math.imul(ve, Fe)) | 0), - (x = (x + Math.imul(ve, He)) | 0), - (b = (b + Math.imul(ae, Xe)) | 0), - (f = (f + Math.imul(ae, Ze)) | 0), - (f = (f + Math.imul(le, Xe)) | 0), - (x = (x + Math.imul(le, Ze)) | 0), - (b = (b + Math.imul(fe, $e)) | 0), - (f = (f + Math.imul(fe, tt)) | 0), - (f = (f + Math.imul(V, $e)) | 0), - (x = (x + Math.imul(V, tt)) | 0), - (b = (b + Math.imul(L, ie)) | 0), - (f = (f + Math.imul(L, re)) | 0), - (f = (f + Math.imul(ee, ie)) | 0), - (x = (x + Math.imul(ee, re)) | 0), - (b = (b + Math.imul(E, se)) | 0), - (f = (f + Math.imul(E, be)) | 0), - (f = (f + Math.imul(B, se)) | 0), - (x = (x + Math.imul(B, be)) | 0); - var Kt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Kt >>> 26)) | 0), - (Kt &= 67108863), - (b = Math.imul(j, we)), - (f = Math.imul(j, xe)), - (f = (f + Math.imul(ce, we)) | 0), - (x = Math.imul(ce, xe)), - (b = (b + Math.imul(Ue, Ke)) | 0), - (f = (f + Math.imul(Ue, pe)) | 0), - (f = (f + Math.imul(Y, Ke)) | 0), - (x = (x + Math.imul(Y, pe)) | 0), - (b = (b + Math.imul(Ve, Se)) | 0), - (f = (f + Math.imul(Ve, Pe)) | 0), - (f = (f + Math.imul(We, Se)) | 0), - (x = (x + Math.imul(We, Pe)) | 0), - (b = (b + Math.imul(Ee, Ie)) | 0), - (f = (f + Math.imul(Ee, je)) | 0), - (f = (f + Math.imul(Be, Ie)) | 0), - (x = (x + Math.imul(Be, je)) | 0), - (b = (b + Math.imul(me, Fe)) | 0), - (f = (f + Math.imul(me, He)) | 0), - (f = (f + Math.imul(_e, Fe)) | 0), - (x = (x + Math.imul(_e, He)) | 0), - (b = (b + Math.imul(de, Xe)) | 0), - (f = (f + Math.imul(de, Ze)) | 0), - (f = (f + Math.imul(ve, Xe)) | 0), - (x = (x + Math.imul(ve, Ze)) | 0), - (b = (b + Math.imul(ae, $e)) | 0), - (f = (f + Math.imul(ae, tt)) | 0), - (f = (f + Math.imul(le, $e)) | 0), - (x = (x + Math.imul(le, tt)) | 0), - (b = (b + Math.imul(fe, ie)) | 0), - (f = (f + Math.imul(fe, re)) | 0), - (f = (f + Math.imul(V, ie)) | 0), - (x = (x + Math.imul(V, re)) | 0), - (b = (b + Math.imul(L, se)) | 0), - (f = (f + Math.imul(L, be)) | 0), - (f = (f + Math.imul(ee, se)) | 0), - (x = (x + Math.imul(ee, be)) | 0), - (b = (b + Math.imul(E, Ae)) | 0), - (f = (f + Math.imul(E, ke)) | 0), - (f = (f + Math.imul(B, Ae)) | 0), - (x = (x + Math.imul(B, ke)) | 0); - var Ot = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ot >>> 26)) | 0), - (Ot &= 67108863), - (b = Math.imul(j, Ke)), - (f = Math.imul(j, pe)), - (f = (f + Math.imul(ce, Ke)) | 0), - (x = Math.imul(ce, pe)), - (b = (b + Math.imul(Ue, Se)) | 0), - (f = (f + Math.imul(Ue, Pe)) | 0), - (f = (f + Math.imul(Y, Se)) | 0), - (x = (x + Math.imul(Y, Pe)) | 0), - (b = (b + Math.imul(Ve, Ie)) | 0), - (f = (f + Math.imul(Ve, je)) | 0), - (f = (f + Math.imul(We, Ie)) | 0), - (x = (x + Math.imul(We, je)) | 0), - (b = (b + Math.imul(Ee, Fe)) | 0), - (f = (f + Math.imul(Ee, He)) | 0), - (f = (f + Math.imul(Be, Fe)) | 0), - (x = (x + Math.imul(Be, He)) | 0), - (b = (b + Math.imul(me, Xe)) | 0), - (f = (f + Math.imul(me, Ze)) | 0), - (f = (f + Math.imul(_e, Xe)) | 0), - (x = (x + Math.imul(_e, Ze)) | 0), - (b = (b + Math.imul(de, $e)) | 0), - (f = (f + Math.imul(de, tt)) | 0), - (f = (f + Math.imul(ve, $e)) | 0), - (x = (x + Math.imul(ve, tt)) | 0), - (b = (b + Math.imul(ae, ie)) | 0), - (f = (f + Math.imul(ae, re)) | 0), - (f = (f + Math.imul(le, ie)) | 0), - (x = (x + Math.imul(le, re)) | 0), - (b = (b + Math.imul(fe, se)) | 0), - (f = (f + Math.imul(fe, be)) | 0), - (f = (f + Math.imul(V, se)) | 0), - (x = (x + Math.imul(V, be)) | 0), - (b = (b + Math.imul(L, Ae)) | 0), - (f = (f + Math.imul(L, ke)) | 0), - (f = (f + Math.imul(ee, Ae)) | 0), - (x = (x + Math.imul(ee, ke)) | 0); - var Bt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Bt >>> 26)) | 0), - (Bt &= 67108863), - (b = Math.imul(j, Se)), - (f = Math.imul(j, Pe)), - (f = (f + Math.imul(ce, Se)) | 0), - (x = Math.imul(ce, Pe)), - (b = (b + Math.imul(Ue, Ie)) | 0), - (f = (f + Math.imul(Ue, je)) | 0), - (f = (f + Math.imul(Y, Ie)) | 0), - (x = (x + Math.imul(Y, je)) | 0), - (b = (b + Math.imul(Ve, Fe)) | 0), - (f = (f + Math.imul(Ve, He)) | 0), - (f = (f + Math.imul(We, Fe)) | 0), - (x = (x + Math.imul(We, He)) | 0), - (b = (b + Math.imul(Ee, Xe)) | 0), - (f = (f + Math.imul(Ee, Ze)) | 0), - (f = (f + Math.imul(Be, Xe)) | 0), - (x = (x + Math.imul(Be, Ze)) | 0), - (b = (b + Math.imul(me, $e)) | 0), - (f = (f + Math.imul(me, tt)) | 0), - (f = (f + Math.imul(_e, $e)) | 0), - (x = (x + Math.imul(_e, tt)) | 0), - (b = (b + Math.imul(de, ie)) | 0), - (f = (f + Math.imul(de, re)) | 0), - (f = (f + Math.imul(ve, ie)) | 0), - (x = (x + Math.imul(ve, re)) | 0), - (b = (b + Math.imul(ae, se)) | 0), - (f = (f + Math.imul(ae, be)) | 0), - (f = (f + Math.imul(le, se)) | 0), - (x = (x + Math.imul(le, be)) | 0), - (b = (b + Math.imul(fe, Ae)) | 0), - (f = (f + Math.imul(fe, ke)) | 0), - (f = (f + Math.imul(V, Ae)) | 0), - (x = (x + Math.imul(V, ke)) | 0); - var Et = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Et >>> 26)) | 0), - (Et &= 67108863), - (b = Math.imul(j, Ie)), - (f = Math.imul(j, je)), - (f = (f + Math.imul(ce, Ie)) | 0), - (x = Math.imul(ce, je)), - (b = (b + Math.imul(Ue, Fe)) | 0), - (f = (f + Math.imul(Ue, He)) | 0), - (f = (f + Math.imul(Y, Fe)) | 0), - (x = (x + Math.imul(Y, He)) | 0), - (b = (b + Math.imul(Ve, Xe)) | 0), - (f = (f + Math.imul(Ve, Ze)) | 0), - (f = (f + Math.imul(We, Xe)) | 0), - (x = (x + Math.imul(We, Ze)) | 0), - (b = (b + Math.imul(Ee, $e)) | 0), - (f = (f + Math.imul(Ee, tt)) | 0), - (f = (f + Math.imul(Be, $e)) | 0), - (x = (x + Math.imul(Be, tt)) | 0), - (b = (b + Math.imul(me, ie)) | 0), - (f = (f + Math.imul(me, re)) | 0), - (f = (f + Math.imul(_e, ie)) | 0), - (x = (x + Math.imul(_e, re)) | 0), - (b = (b + Math.imul(de, se)) | 0), - (f = (f + Math.imul(de, be)) | 0), - (f = (f + Math.imul(ve, se)) | 0), - (x = (x + Math.imul(ve, be)) | 0), - (b = (b + Math.imul(ae, Ae)) | 0), - (f = (f + Math.imul(ae, ke)) | 0), - (f = (f + Math.imul(le, Ae)) | 0), - (x = (x + Math.imul(le, ke)) | 0); - var Mt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Mt >>> 26)) | 0), - (Mt &= 67108863), - (b = Math.imul(j, Fe)), - (f = Math.imul(j, He)), - (f = (f + Math.imul(ce, Fe)) | 0), - (x = Math.imul(ce, He)), - (b = (b + Math.imul(Ue, Xe)) | 0), - (f = (f + Math.imul(Ue, Ze)) | 0), - (f = (f + Math.imul(Y, Xe)) | 0), - (x = (x + Math.imul(Y, Ze)) | 0), - (b = (b + Math.imul(Ve, $e)) | 0), - (f = (f + Math.imul(Ve, tt)) | 0), - (f = (f + Math.imul(We, $e)) | 0), - (x = (x + Math.imul(We, tt)) | 0), - (b = (b + Math.imul(Ee, ie)) | 0), - (f = (f + Math.imul(Ee, re)) | 0), - (f = (f + Math.imul(Be, ie)) | 0), - (x = (x + Math.imul(Be, re)) | 0), - (b = (b + Math.imul(me, se)) | 0), - (f = (f + Math.imul(me, be)) | 0), - (f = (f + Math.imul(_e, se)) | 0), - (x = (x + Math.imul(_e, be)) | 0), - (b = (b + Math.imul(de, Ae)) | 0), - (f = (f + Math.imul(de, ke)) | 0), - (f = (f + Math.imul(ve, Ae)) | 0), - (x = (x + Math.imul(ve, ke)) | 0); - var gt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (gt >>> 26)) | 0), - (gt &= 67108863), - (b = Math.imul(j, Xe)), - (f = Math.imul(j, Ze)), - (f = (f + Math.imul(ce, Xe)) | 0), - (x = Math.imul(ce, Ze)), - (b = (b + Math.imul(Ue, $e)) | 0), - (f = (f + Math.imul(Ue, tt)) | 0), - (f = (f + Math.imul(Y, $e)) | 0), - (x = (x + Math.imul(Y, tt)) | 0), - (b = (b + Math.imul(Ve, ie)) | 0), - (f = (f + Math.imul(Ve, re)) | 0), - (f = (f + Math.imul(We, ie)) | 0), - (x = (x + Math.imul(We, re)) | 0), - (b = (b + Math.imul(Ee, se)) | 0), - (f = (f + Math.imul(Ee, be)) | 0), - (f = (f + Math.imul(Be, se)) | 0), - (x = (x + Math.imul(Be, be)) | 0), - (b = (b + Math.imul(me, Ae)) | 0), - (f = (f + Math.imul(me, ke)) | 0), - (f = (f + Math.imul(_e, Ae)) | 0), - (x = (x + Math.imul(_e, ke)) | 0); - var Pt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Pt >>> 26)) | 0), - (Pt &= 67108863), - (b = Math.imul(j, $e)), - (f = Math.imul(j, tt)), - (f = (f + Math.imul(ce, $e)) | 0), - (x = Math.imul(ce, tt)), - (b = (b + Math.imul(Ue, ie)) | 0), - (f = (f + Math.imul(Ue, re)) | 0), - (f = (f + Math.imul(Y, ie)) | 0), - (x = (x + Math.imul(Y, re)) | 0), - (b = (b + Math.imul(Ve, se)) | 0), - (f = (f + Math.imul(Ve, be)) | 0), - (f = (f + Math.imul(We, se)) | 0), - (x = (x + Math.imul(We, be)) | 0), - (b = (b + Math.imul(Ee, Ae)) | 0), - (f = (f + Math.imul(Ee, ke)) | 0), - (f = (f + Math.imul(Be, Ae)) | 0), - (x = (x + Math.imul(Be, ke)) | 0); - var It = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (It >>> 26)) | 0), - (It &= 67108863), - (b = Math.imul(j, ie)), - (f = Math.imul(j, re)), - (f = (f + Math.imul(ce, ie)) | 0), - (x = Math.imul(ce, re)), - (b = (b + Math.imul(Ue, se)) | 0), - (f = (f + Math.imul(Ue, be)) | 0), - (f = (f + Math.imul(Y, se)) | 0), - (x = (x + Math.imul(Y, be)) | 0), - (b = (b + Math.imul(Ve, Ae)) | 0), - (f = (f + Math.imul(Ve, ke)) | 0), - (f = (f + Math.imul(We, Ae)) | 0), - (x = (x + Math.imul(We, ke)) | 0); - var yt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (yt >>> 26)) | 0), - (yt &= 67108863), - (b = Math.imul(j, se)), - (f = Math.imul(j, be)), - (f = (f + Math.imul(ce, se)) | 0), - (x = Math.imul(ce, be)), - (b = (b + Math.imul(Ue, Ae)) | 0), - (f = (f + Math.imul(Ue, ke)) | 0), - (f = (f + Math.imul(Y, Ae)) | 0), - (x = (x + Math.imul(Y, ke)) | 0); - var nt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (nt >>> 26)) | 0), - (nt &= 67108863), - (b = Math.imul(j, Ae)), - (f = Math.imul(j, ke)), - (f = (f + Math.imul(ce, Ae)) | 0), - (x = Math.imul(ce, ke)); - var it = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - return ( - (S = (((x + (f >>> 13)) | 0) + (it >>> 26)) | 0), - (it &= 67108863), - (_[0] = Ct), - (_[1] = ut), - (_[2] = St), - (_[3] = wt), - (_[4] = zt), - (_[5] = jt), - (_[6] = Ht), - (_[7] = Ut), - (_[8] = Kt), - (_[9] = Ot), - (_[10] = Bt), - (_[11] = Et), - (_[12] = Mt), - (_[13] = gt), - (_[14] = Pt), - (_[15] = It), - (_[16] = yt), - (_[17] = nt), - (_[18] = it), - S !== 0 && ((_[19] = S), y.length++), - y - ); - }; - Math.imul || (O = k); - function D(A, l, p) { - (p.negative = l.negative ^ A.negative), - (p.length = A.length + l.length); - for (var y = 0, d = 0, v = 0; v < p.length - 1; v++) { - var _ = d; - d = 0; - for ( - var S = y & 67108863, - b = Math.min(v, l.length - 1), - f = Math.max(0, v - A.length + 1); - f <= b; - f++ - ) { - var x = v - f, - C = A.words[x] | 0, - E = l.words[f] | 0, - B = C * E, - G = B & 67108863; - (_ = (_ + ((B / 67108864) | 0)) | 0), - (G = (G + S) | 0), - (S = G & 67108863), - (_ = (_ + (G >>> 26)) | 0), - (d += _ >>> 26), - (_ &= 67108863); - } - (p.words[v] = S), (y = _), (_ = d); - } - return y !== 0 ? (p.words[v] = y) : p.length--, p.strip(); - } - function F(A, l, p) { - var y = new N(); - return y.mulp(A, l, p); - } - i.prototype.mulTo = function (l, p) { - var y, - d = this.length + l.length; - return ( - this.length === 10 && l.length === 10 - ? (y = O(this, l, p)) - : d < 63 - ? (y = k(this, l, p)) - : d < 1024 - ? (y = D(this, l, p)) - : (y = F(this, l, p)), - y - ); - }; - function N(A, l) { - (this.x = A), (this.y = l); - } - (N.prototype.makeRBT = function (l) { - for ( - var p = new Array(l), y = i.prototype._countBits(l) - 1, d = 0; - d < l; - d++ - ) - p[d] = this.revBin(d, y, l); - return p; - }), - (N.prototype.revBin = function (l, p, y) { - if (l === 0 || l === y - 1) return l; - for (var d = 0, v = 0; v < p; v++) - (d |= (l & 1) << (p - v - 1)), (l >>= 1); - return d; - }), - (N.prototype.permute = function (l, p, y, d, v, _) { - for (var S = 0; S < _; S++) (d[S] = p[l[S]]), (v[S] = y[l[S]]); - }), - (N.prototype.transform = function (l, p, y, d, v, _) { - this.permute(_, l, p, y, d, v); - for (var S = 1; S < v; S <<= 1) - for ( - var b = S << 1, - f = Math.cos((2 * Math.PI) / b), - x = Math.sin((2 * Math.PI) / b), - C = 0; - C < v; - C += b - ) - for (var E = f, B = x, G = 0; G < S; G++) { - var L = y[C + G], - ee = d[C + G], - ge = y[C + G + S], - fe = d[C + G + S], - V = E * ge - B * fe; - (fe = E * fe + B * ge), - (ge = V), - (y[C + G] = L + ge), - (d[C + G] = ee + fe), - (y[C + G + S] = L - ge), - (d[C + G + S] = ee - fe), - G !== b && - ((V = f * E - x * B), (B = f * B + x * E), (E = V)); - } - }), - (N.prototype.guessLen13b = function (l, p) { - var y = Math.max(p, l) | 1, - d = y & 1, - v = 0; - for (y = (y / 2) | 0; y; y = y >>> 1) v++; - return 1 << (v + 1 + d); - }), - (N.prototype.conjugate = function (l, p, y) { - if (!(y <= 1)) - for (var d = 0; d < y / 2; d++) { - var v = l[d]; - (l[d] = l[y - d - 1]), - (l[y - d - 1] = v), - (v = p[d]), - (p[d] = -p[y - d - 1]), - (p[y - d - 1] = -v); - } - }), - (N.prototype.normalize13b = function (l, p) { - for (var y = 0, d = 0; d < p / 2; d++) { - var v = - Math.round(l[2 * d + 1] / p) * 8192 + - Math.round(l[2 * d] / p) + - y; - (l[d] = v & 67108863), - v < 67108864 ? (y = 0) : (y = (v / 67108864) | 0); - } - return l; - }), - (N.prototype.convert13b = function (l, p, y, d) { - for (var v = 0, _ = 0; _ < p; _++) - (v = v + (l[_] | 0)), - (y[2 * _] = v & 8191), - (v = v >>> 13), - (y[2 * _ + 1] = v & 8191), - (v = v >>> 13); - for (_ = 2 * p; _ < d; ++_) y[_] = 0; - r(v === 0), r((v & -8192) === 0); - }), - (N.prototype.stub = function (l) { - for (var p = new Array(l), y = 0; y < l; y++) p[y] = 0; - return p; - }), - (N.prototype.mulp = function (l, p, y) { - var d = 2 * this.guessLen13b(l.length, p.length), - v = this.makeRBT(d), - _ = this.stub(d), - S = new Array(d), - b = new Array(d), - f = new Array(d), - x = new Array(d), - C = new Array(d), - E = new Array(d), - B = y.words; - (B.length = d), - this.convert13b(l.words, l.length, S, d), - this.convert13b(p.words, p.length, x, d), - this.transform(S, _, b, f, d, v), - this.transform(x, _, C, E, d, v); - for (var G = 0; G < d; G++) { - var L = b[G] * C[G] - f[G] * E[G]; - (f[G] = b[G] * E[G] + f[G] * C[G]), (b[G] = L); - } - return ( - this.conjugate(b, f, d), - this.transform(b, f, B, _, d, v), - this.conjugate(B, _, d), - this.normalize13b(B, d), - (y.negative = l.negative ^ p.negative), - (y.length = l.length + p.length), - y.strip() - ); - }), - (i.prototype.mul = function (l) { - var p = new i(null); - return ( - (p.words = new Array(this.length + l.length)), this.mulTo(l, p) - ); - }), - (i.prototype.mulf = function (l) { - var p = new i(null); - return (p.words = new Array(this.length + l.length)), F(this, l, p); - }), - (i.prototype.imul = function (l) { - return this.clone().mulTo(l, this); - }), - (i.prototype.imuln = function (l) { - r(typeof l == "number"), r(l < 67108864); - for (var p = 0, y = 0; y < this.length; y++) { - var d = (this.words[y] | 0) * l, - v = (d & 67108863) + (p & 67108863); - (p >>= 26), - (p += (d / 67108864) | 0), - (p += v >>> 26), - (this.words[y] = v & 67108863); - } - return p !== 0 && ((this.words[y] = p), this.length++), this; - }), - (i.prototype.muln = function (l) { - return this.clone().imuln(l); - }), - (i.prototype.sqr = function () { - return this.mul(this); - }), - (i.prototype.isqr = function () { - return this.imul(this.clone()); - }), - (i.prototype.pow = function (l) { - var p = M(l); - if (p.length === 0) return new i(1); - for ( - var y = this, d = 0; - d < p.length && p[d] === 0; - d++, y = y.sqr() - ); - if (++d < p.length) - for (var v = y.sqr(); d < p.length; d++, v = v.sqr()) - p[d] !== 0 && (y = y.mul(v)); - return y; - }), - (i.prototype.iushln = function (l) { - r(typeof l == "number" && l >= 0); - var p = l % 26, - y = (l - p) / 26, - d = (67108863 >>> (26 - p)) << (26 - p), - v; - if (p !== 0) { - var _ = 0; - for (v = 0; v < this.length; v++) { - var S = this.words[v] & d, - b = ((this.words[v] | 0) - S) << p; - (this.words[v] = b | _), (_ = S >>> (26 - p)); - } - _ && ((this.words[v] = _), this.length++); - } - if (y !== 0) { - for (v = this.length - 1; v >= 0; v--) - this.words[v + y] = this.words[v]; - for (v = 0; v < y; v++) this.words[v] = 0; - this.length += y; - } - return this.strip(); - }), - (i.prototype.ishln = function (l) { - return r(this.negative === 0), this.iushln(l); - }), - (i.prototype.iushrn = function (l, p, y) { - r(typeof l == "number" && l >= 0); - var d; - p ? (d = (p - (p % 26)) / 26) : (d = 0); - var v = l % 26, - _ = Math.min((l - v) / 26, this.length), - S = 67108863 ^ ((67108863 >>> v) << v), - b = y; - if (((d -= _), (d = Math.max(0, d)), b)) { - for (var f = 0; f < _; f++) b.words[f] = this.words[f]; - b.length = _; - } - if (_ !== 0) - if (this.length > _) - for (this.length -= _, f = 0; f < this.length; f++) - this.words[f] = this.words[f + _]; - else (this.words[0] = 0), (this.length = 1); - var x = 0; - for (f = this.length - 1; f >= 0 && (x !== 0 || f >= d); f--) { - var C = this.words[f] | 0; - (this.words[f] = (x << (26 - v)) | (C >>> v)), (x = C & S); - } - return ( - b && x !== 0 && (b.words[b.length++] = x), - this.length === 0 && ((this.words[0] = 0), (this.length = 1)), - this.strip() - ); - }), - (i.prototype.ishrn = function (l, p, y) { - return r(this.negative === 0), this.iushrn(l, p, y); - }), - (i.prototype.shln = function (l) { - return this.clone().ishln(l); - }), - (i.prototype.ushln = function (l) { - return this.clone().iushln(l); - }), - (i.prototype.shrn = function (l) { - return this.clone().ishrn(l); - }), - (i.prototype.ushrn = function (l) { - return this.clone().iushrn(l); - }), - (i.prototype.testn = function (l) { - r(typeof l == "number" && l >= 0); - var p = l % 26, - y = (l - p) / 26, - d = 1 << p; - if (this.length <= y) return !1; - var v = this.words[y]; - return !!(v & d); - }), - (i.prototype.imaskn = function (l) { - r(typeof l == "number" && l >= 0); - var p = l % 26, - y = (l - p) / 26; - if ( - (r(this.negative === 0, "imaskn works only with positive numbers"), - this.length <= y) - ) - return this; - if ( - (p !== 0 && y++, (this.length = Math.min(y, this.length)), p !== 0) - ) { - var d = 67108863 ^ ((67108863 >>> p) << p); - this.words[this.length - 1] &= d; - } - return this.strip(); - }), - (i.prototype.maskn = function (l) { - return this.clone().imaskn(l); - }), - (i.prototype.iaddn = function (l) { - return ( - r(typeof l == "number"), - r(l < 67108864), - l < 0 - ? this.isubn(-l) - : this.negative !== 0 - ? this.length === 1 && (this.words[0] | 0) < l - ? ((this.words[0] = l - (this.words[0] | 0)), - (this.negative = 0), - this) - : ((this.negative = 0), - this.isubn(l), - (this.negative = 1), - this) - : this._iaddn(l) - ); - }), - (i.prototype._iaddn = function (l) { - this.words[0] += l; - for (var p = 0; p < this.length && this.words[p] >= 67108864; p++) - (this.words[p] -= 67108864), - p === this.length - 1 - ? (this.words[p + 1] = 1) - : this.words[p + 1]++; - return (this.length = Math.max(this.length, p + 1)), this; - }), - (i.prototype.isubn = function (l) { - if ((r(typeof l == "number"), r(l < 67108864), l < 0)) - return this.iaddn(-l); - if (this.negative !== 0) - return ( - (this.negative = 0), this.iaddn(l), (this.negative = 1), this - ); - if (((this.words[0] -= l), this.length === 1 && this.words[0] < 0)) - (this.words[0] = -this.words[0]), (this.negative = 1); - else - for (var p = 0; p < this.length && this.words[p] < 0; p++) - (this.words[p] += 67108864), (this.words[p + 1] -= 1); - return this.strip(); - }), - (i.prototype.addn = function (l) { - return this.clone().iaddn(l); - }), - (i.prototype.subn = function (l) { - return this.clone().isubn(l); - }), - (i.prototype.iabs = function () { - return (this.negative = 0), this; - }), - (i.prototype.abs = function () { - return this.clone().iabs(); - }), - (i.prototype._ishlnsubmul = function (l, p, y) { - var d = l.length + y, - v; - this._expand(d); - var _, - S = 0; - for (v = 0; v < l.length; v++) { - _ = (this.words[v + y] | 0) + S; - var b = (l.words[v] | 0) * p; - (_ -= b & 67108863), - (S = (_ >> 26) - ((b / 67108864) | 0)), - (this.words[v + y] = _ & 67108863); - } - for (; v < this.length - y; v++) - (_ = (this.words[v + y] | 0) + S), - (S = _ >> 26), - (this.words[v + y] = _ & 67108863); - if (S === 0) return this.strip(); - for (r(S === -1), S = 0, v = 0; v < this.length; v++) - (_ = -(this.words[v] | 0) + S), - (S = _ >> 26), - (this.words[v] = _ & 67108863); - return (this.negative = 1), this.strip(); - }), - (i.prototype._wordDiv = function (l, p) { - var y = this.length - l.length, - d = this.clone(), - v = l, - _ = v.words[v.length - 1] | 0, - S = this._countBits(_); - (y = 26 - S), - y !== 0 && - ((v = v.ushln(y)), d.iushln(y), (_ = v.words[v.length - 1] | 0)); - var b = d.length - v.length, - f; - if (p !== "mod") { - (f = new i(null)), - (f.length = b + 1), - (f.words = new Array(f.length)); - for (var x = 0; x < f.length; x++) f.words[x] = 0; - } - var C = d.clone()._ishlnsubmul(v, 1, b); - C.negative === 0 && ((d = C), f && (f.words[b] = 1)); - for (var E = b - 1; E >= 0; E--) { - var B = - (d.words[v.length + E] | 0) * 67108864 + - (d.words[v.length + E - 1] | 0); - for ( - B = Math.min((B / _) | 0, 67108863), d._ishlnsubmul(v, B, E); - d.negative !== 0; - - ) - B--, - (d.negative = 0), - d._ishlnsubmul(v, 1, E), - d.isZero() || (d.negative ^= 1); - f && (f.words[E] = B); - } - return ( - f && f.strip(), - d.strip(), - p !== "div" && y !== 0 && d.iushrn(y), - { div: f || null, mod: d } - ); - }), - (i.prototype.divmod = function (l, p, y) { - if ((r(!l.isZero()), this.isZero())) - return { div: new i(0), mod: new i(0) }; - var d, v, _; - return this.negative !== 0 && l.negative === 0 - ? ((_ = this.neg().divmod(l, p)), - p !== "mod" && (d = _.div.neg()), - p !== "div" && - ((v = _.mod.neg()), y && v.negative !== 0 && v.iadd(l)), - { div: d, mod: v }) - : this.negative === 0 && l.negative !== 0 - ? ((_ = this.divmod(l.neg(), p)), - p !== "mod" && (d = _.div.neg()), - { div: d, mod: _.mod }) - : (this.negative & l.negative) !== 0 - ? ((_ = this.neg().divmod(l.neg(), p)), - p !== "div" && - ((v = _.mod.neg()), y && v.negative !== 0 && v.isub(l)), - { div: _.div, mod: v }) - : l.length > this.length || this.cmp(l) < 0 - ? { div: new i(0), mod: this } - : l.length === 1 - ? p === "div" - ? { div: this.divn(l.words[0]), mod: null } - : p === "mod" - ? { div: null, mod: new i(this.modn(l.words[0])) } - : { - div: this.divn(l.words[0]), - mod: new i(this.modn(l.words[0])), - } - : this._wordDiv(l, p); - }), - (i.prototype.div = function (l) { - return this.divmod(l, "div", !1).div; - }), - (i.prototype.mod = function (l) { - return this.divmod(l, "mod", !1).mod; - }), - (i.prototype.umod = function (l) { - return this.divmod(l, "mod", !0).mod; - }), - (i.prototype.divRound = function (l) { - var p = this.divmod(l); - if (p.mod.isZero()) return p.div; - var y = p.div.negative !== 0 ? p.mod.isub(l) : p.mod, - d = l.ushrn(1), - v = l.andln(1), - _ = y.cmp(d); - return _ < 0 || (v === 1 && _ === 0) - ? p.div - : p.div.negative !== 0 - ? p.div.isubn(1) - : p.div.iaddn(1); - }), - (i.prototype.modn = function (l) { - r(l <= 67108863); - for (var p = (1 << 26) % l, y = 0, d = this.length - 1; d >= 0; d--) - y = (p * y + (this.words[d] | 0)) % l; - return y; - }), - (i.prototype.idivn = function (l) { - r(l <= 67108863); - for (var p = 0, y = this.length - 1; y >= 0; y--) { - var d = (this.words[y] | 0) + p * 67108864; - (this.words[y] = (d / l) | 0), (p = d % l); - } - return this.strip(); - }), - (i.prototype.divn = function (l) { - return this.clone().idivn(l); - }), - (i.prototype.egcd = function (l) { - r(l.negative === 0), r(!l.isZero()); - var p = this, - y = l.clone(); - p.negative !== 0 ? (p = p.umod(l)) : (p = p.clone()); - for ( - var d = new i(1), v = new i(0), _ = new i(0), S = new i(1), b = 0; - p.isEven() && y.isEven(); - - ) - p.iushrn(1), y.iushrn(1), ++b; - for (var f = y.clone(), x = p.clone(); !p.isZero(); ) { - for ( - var C = 0, E = 1; - (p.words[0] & E) === 0 && C < 26; - ++C, E <<= 1 - ); - if (C > 0) - for (p.iushrn(C); C-- > 0; ) - (d.isOdd() || v.isOdd()) && (d.iadd(f), v.isub(x)), - d.iushrn(1), - v.iushrn(1); - for ( - var B = 0, G = 1; - (y.words[0] & G) === 0 && B < 26; - ++B, G <<= 1 - ); - if (B > 0) - for (y.iushrn(B); B-- > 0; ) - (_.isOdd() || S.isOdd()) && (_.iadd(f), S.isub(x)), - _.iushrn(1), - S.iushrn(1); - p.cmp(y) >= 0 - ? (p.isub(y), d.isub(_), v.isub(S)) - : (y.isub(p), _.isub(d), S.isub(v)); - } - return { a: _, b: S, gcd: y.iushln(b) }; - }), - (i.prototype._invmp = function (l) { - r(l.negative === 0), r(!l.isZero()); - var p = this, - y = l.clone(); - p.negative !== 0 ? (p = p.umod(l)) : (p = p.clone()); - for ( - var d = new i(1), v = new i(0), _ = y.clone(); - p.cmpn(1) > 0 && y.cmpn(1) > 0; - - ) { - for ( - var S = 0, b = 1; - (p.words[0] & b) === 0 && S < 26; - ++S, b <<= 1 - ); - if (S > 0) - for (p.iushrn(S); S-- > 0; ) d.isOdd() && d.iadd(_), d.iushrn(1); - for ( - var f = 0, x = 1; - (y.words[0] & x) === 0 && f < 26; - ++f, x <<= 1 - ); - if (f > 0) - for (y.iushrn(f); f-- > 0; ) v.isOdd() && v.iadd(_), v.iushrn(1); - p.cmp(y) >= 0 ? (p.isub(y), d.isub(v)) : (y.isub(p), v.isub(d)); - } - var C; - return ( - p.cmpn(1) === 0 ? (C = d) : (C = v), C.cmpn(0) < 0 && C.iadd(l), C - ); - }), - (i.prototype.gcd = function (l) { - if (this.isZero()) return l.abs(); - if (l.isZero()) return this.abs(); - var p = this.clone(), - y = l.clone(); - (p.negative = 0), (y.negative = 0); - for (var d = 0; p.isEven() && y.isEven(); d++) - p.iushrn(1), y.iushrn(1); - do { - for (; p.isEven(); ) p.iushrn(1); - for (; y.isEven(); ) y.iushrn(1); - var v = p.cmp(y); - if (v < 0) { - var _ = p; - (p = y), (y = _); - } else if (v === 0 || y.cmpn(1) === 0) break; - p.isub(y); - } while (!0); - return y.iushln(d); - }), - (i.prototype.invm = function (l) { - return this.egcd(l).a.umod(l); - }), - (i.prototype.isEven = function () { - return (this.words[0] & 1) === 0; - }), - (i.prototype.isOdd = function () { - return (this.words[0] & 1) === 1; - }), - (i.prototype.andln = function (l) { - return this.words[0] & l; - }), - (i.prototype.bincn = function (l) { - r(typeof l == "number"); - var p = l % 26, - y = (l - p) / 26, - d = 1 << p; - if (this.length <= y) - return this._expand(y + 1), (this.words[y] |= d), this; - for (var v = d, _ = y; v !== 0 && _ < this.length; _++) { - var S = this.words[_] | 0; - (S += v), (v = S >>> 26), (S &= 67108863), (this.words[_] = S); - } - return v !== 0 && ((this.words[_] = v), this.length++), this; - }), - (i.prototype.isZero = function () { - return this.length === 1 && this.words[0] === 0; - }), - (i.prototype.cmpn = function (l) { - var p = l < 0; - if (this.negative !== 0 && !p) return -1; - if (this.negative === 0 && p) return 1; - this.strip(); - var y; - if (this.length > 1) y = 1; - else { - p && (l = -l), r(l <= 67108863, "Number is too big"); - var d = this.words[0] | 0; - y = d === l ? 0 : d < l ? -1 : 1; - } - return this.negative !== 0 ? -y | 0 : y; - }), - (i.prototype.cmp = function (l) { - if (this.negative !== 0 && l.negative === 0) return -1; - if (this.negative === 0 && l.negative !== 0) return 1; - var p = this.ucmp(l); - return this.negative !== 0 ? -p | 0 : p; - }), - (i.prototype.ucmp = function (l) { - if (this.length > l.length) return 1; - if (this.length < l.length) return -1; - for (var p = 0, y = this.length - 1; y >= 0; y--) { - var d = this.words[y] | 0, - v = l.words[y] | 0; - if (d !== v) { - d < v ? (p = -1) : d > v && (p = 1); - break; - } - } - return p; - }), - (i.prototype.gtn = function (l) { - return this.cmpn(l) === 1; - }), - (i.prototype.gt = function (l) { - return this.cmp(l) === 1; - }), - (i.prototype.gten = function (l) { - return this.cmpn(l) >= 0; - }), - (i.prototype.gte = function (l) { - return this.cmp(l) >= 0; - }), - (i.prototype.ltn = function (l) { - return this.cmpn(l) === -1; - }), - (i.prototype.lt = function (l) { - return this.cmp(l) === -1; - }), - (i.prototype.lten = function (l) { - return this.cmpn(l) <= 0; - }), - (i.prototype.lte = function (l) { - return this.cmp(l) <= 0; - }), - (i.prototype.eqn = function (l) { - return this.cmpn(l) === 0; - }), - (i.prototype.eq = function (l) { - return this.cmp(l) === 0; - }), - (i.red = function (l) { - return new te(l); - }), - (i.prototype.toRed = function (l) { - return ( - r(!this.red, "Already a number in reduction context"), - r(this.negative === 0, "red works only with positives"), - l.convertTo(this)._forceRed(l) - ); - }), - (i.prototype.fromRed = function () { - return ( - r(this.red, "fromRed works only with numbers in reduction context"), - this.red.convertFrom(this) - ); - }), - (i.prototype._forceRed = function (l) { - return (this.red = l), this; - }), - (i.prototype.forceRed = function (l) { - return ( - r(!this.red, "Already a number in reduction context"), - this._forceRed(l) - ); - }), - (i.prototype.redAdd = function (l) { - return ( - r(this.red, "redAdd works only with red numbers"), - this.red.add(this, l) - ); - }), - (i.prototype.redIAdd = function (l) { - return ( - r(this.red, "redIAdd works only with red numbers"), - this.red.iadd(this, l) - ); - }), - (i.prototype.redSub = function (l) { - return ( - r(this.red, "redSub works only with red numbers"), - this.red.sub(this, l) - ); - }), - (i.prototype.redISub = function (l) { - return ( - r(this.red, "redISub works only with red numbers"), - this.red.isub(this, l) - ); - }), - (i.prototype.redShl = function (l) { - return ( - r(this.red, "redShl works only with red numbers"), - this.red.shl(this, l) - ); - }), - (i.prototype.redMul = function (l) { - return ( - r(this.red, "redMul works only with red numbers"), - this.red._verify2(this, l), - this.red.mul(this, l) - ); - }), - (i.prototype.redIMul = function (l) { - return ( - r(this.red, "redMul works only with red numbers"), - this.red._verify2(this, l), - this.red.imul(this, l) - ); - }), - (i.prototype.redSqr = function () { - return ( - r(this.red, "redSqr works only with red numbers"), - this.red._verify1(this), - this.red.sqr(this) - ); - }), - (i.prototype.redISqr = function () { - return ( - r(this.red, "redISqr works only with red numbers"), - this.red._verify1(this), - this.red.isqr(this) - ); - }), - (i.prototype.redSqrt = function () { - return ( - r(this.red, "redSqrt works only with red numbers"), - this.red._verify1(this), - this.red.sqrt(this) - ); - }), - (i.prototype.redInvm = function () { - return ( - r(this.red, "redInvm works only with red numbers"), - this.red._verify1(this), - this.red.invm(this) - ); - }), - (i.prototype.redNeg = function () { - return ( - r(this.red, "redNeg works only with red numbers"), - this.red._verify1(this), - this.red.neg(this) - ); - }), - (i.prototype.redPow = function (l) { - return ( - r(this.red && !l.red, "redPow(normalNum)"), - this.red._verify1(this), - this.red.pow(this, l) - ); - }); - var q = { k256: null, p224: null, p192: null, p25519: null }; - function z(A, l) { - (this.name = A), - (this.p = new i(l, 16)), - (this.n = this.p.bitLength()), - (this.k = new i(1).iushln(this.n).isub(this.p)), - (this.tmp = this._tmp()); - } - (z.prototype._tmp = function () { - var l = new i(null); - return (l.words = new Array(Math.ceil(this.n / 13))), l; - }), - (z.prototype.ireduce = function (l) { - var p = l, - y; - do - this.split(p, this.tmp), - (p = this.imulK(p)), - (p = p.iadd(this.tmp)), - (y = p.bitLength()); - while (y > this.n); - var d = y < this.n ? -1 : p.ucmp(this.p); - return ( - d === 0 - ? ((p.words[0] = 0), (p.length = 1)) - : d > 0 - ? p.isub(this.p) - : p.strip !== void 0 - ? p.strip() - : p._strip(), - p - ); - }), - (z.prototype.split = function (l, p) { - l.iushrn(this.n, 0, p); - }), - (z.prototype.imulK = function (l) { - return l.imul(this.k); - }); - function H() { - z.call( - this, - "k256", - "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f" - ); - } - n(H, z), - (H.prototype.split = function (l, p) { - for (var y = 4194303, d = Math.min(l.length, 9), v = 0; v < d; v++) - p.words[v] = l.words[v]; - if (((p.length = d), l.length <= 9)) { - (l.words[0] = 0), (l.length = 1); - return; - } - var _ = l.words[9]; - for (p.words[p.length++] = _ & y, v = 10; v < l.length; v++) { - var S = l.words[v] | 0; - (l.words[v - 10] = ((S & y) << 4) | (_ >>> 22)), (_ = S); - } - (_ >>>= 22), - (l.words[v - 10] = _), - _ === 0 && l.length > 10 ? (l.length -= 10) : (l.length -= 9); - }), - (H.prototype.imulK = function (l) { - (l.words[l.length] = 0), (l.words[l.length + 1] = 0), (l.length += 2); - for (var p = 0, y = 0; y < l.length; y++) { - var d = l.words[y] | 0; - (p += d * 977), - (l.words[y] = p & 67108863), - (p = d * 64 + ((p / 67108864) | 0)); - } - return ( - l.words[l.length - 1] === 0 && - (l.length--, l.words[l.length - 1] === 0 && l.length--), - l - ); - }); - function Z() { - z.call( - this, - "p224", - "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001" - ); - } - n(Z, z); - function $() { - z.call( - this, - "p192", - "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff" - ); - } - n($, z); - function ue() { - z.call( - this, - "25519", - "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed" - ); - } - n(ue, z), - (ue.prototype.imulK = function (l) { - for (var p = 0, y = 0; y < l.length; y++) { - var d = (l.words[y] | 0) * 19 + p, - v = d & 67108863; - (d >>>= 26), (l.words[y] = v), (p = d); - } - return p !== 0 && (l.words[l.length++] = p), l; - }), - (i._prime = function (l) { - if (q[l]) return q[l]; - var p; - if (l === "k256") p = new H(); - else if (l === "p224") p = new Z(); - else if (l === "p192") p = new $(); - else if (l === "p25519") p = new ue(); - else throw new Error("Unknown prime " + l); - return (q[l] = p), p; - }); - function te(A) { - if (typeof A == "string") { - var l = i._prime(A); - (this.m = l.p), (this.prime = l); - } else - r(A.gtn(1), "modulus must be greater than 1"), - (this.m = A), - (this.prime = null); - } - (te.prototype._verify1 = function (l) { - r(l.negative === 0, "red works only with positives"), - r(l.red, "red works only with red numbers"); - }), - (te.prototype._verify2 = function (l, p) { - r((l.negative | p.negative) === 0, "red works only with positives"), - r(l.red && l.red === p.red, "red works only with red numbers"); - }), - (te.prototype.imod = function (l) { - return this.prime - ? this.prime.ireduce(l)._forceRed(this) - : l.umod(this.m)._forceRed(this); - }), - (te.prototype.neg = function (l) { - return l.isZero() ? l.clone() : this.m.sub(l)._forceRed(this); - }), - (te.prototype.add = function (l, p) { - this._verify2(l, p); - var y = l.add(p); - return y.cmp(this.m) >= 0 && y.isub(this.m), y._forceRed(this); - }), - (te.prototype.iadd = function (l, p) { - this._verify2(l, p); - var y = l.iadd(p); - return y.cmp(this.m) >= 0 && y.isub(this.m), y; - }), - (te.prototype.sub = function (l, p) { - this._verify2(l, p); - var y = l.sub(p); - return y.cmpn(0) < 0 && y.iadd(this.m), y._forceRed(this); - }), - (te.prototype.isub = function (l, p) { - this._verify2(l, p); - var y = l.isub(p); - return y.cmpn(0) < 0 && y.iadd(this.m), y; - }), - (te.prototype.shl = function (l, p) { - return this._verify1(l), this.imod(l.ushln(p)); - }), - (te.prototype.imul = function (l, p) { - return this._verify2(l, p), this.imod(l.imul(p)); - }), - (te.prototype.mul = function (l, p) { - return this._verify2(l, p), this.imod(l.mul(p)); - }), - (te.prototype.isqr = function (l) { - return this.imul(l, l.clone()); - }), - (te.prototype.sqr = function (l) { - return this.mul(l, l); - }), - (te.prototype.sqrt = function (l) { - if (l.isZero()) return l.clone(); - var p = this.m.andln(3); - if ((r(p % 2 === 1), p === 3)) { - var y = this.m.add(new i(1)).iushrn(2); - return this.pow(l, y); - } - for (var d = this.m.subn(1), v = 0; !d.isZero() && d.andln(1) === 0; ) - v++, d.iushrn(1); - r(!d.isZero()); - var _ = new i(1).toRed(this), - S = _.redNeg(), - b = this.m.subn(1).iushrn(1), - f = this.m.bitLength(); - for (f = new i(2 * f * f).toRed(this); this.pow(f, b).cmp(S) !== 0; ) - f.redIAdd(S); - for ( - var x = this.pow(f, d), - C = this.pow(l, d.addn(1).iushrn(1)), - E = this.pow(l, d), - B = v; - E.cmp(_) !== 0; - - ) { - for (var G = E, L = 0; G.cmp(_) !== 0; L++) G = G.redSqr(); - r(L < B); - var ee = this.pow(x, new i(1).iushln(B - L - 1)); - (C = C.redMul(ee)), (x = ee.redSqr()), (E = E.redMul(x)), (B = L); - } - return C; - }), - (te.prototype.invm = function (l) { - var p = l._invmp(this.m); - return p.negative !== 0 - ? ((p.negative = 0), this.imod(p).redNeg()) - : this.imod(p); - }), - (te.prototype.pow = function (l, p) { - if (p.isZero()) return new i(1).toRed(this); - if (p.cmpn(1) === 0) return l.clone(); - var y = 4, - d = new Array(1 << y); - (d[0] = new i(1).toRed(this)), (d[1] = l); - for (var v = 2; v < d.length; v++) d[v] = this.mul(d[v - 1], l); - var _ = d[0], - S = 0, - b = 0, - f = p.bitLength() % 26; - for (f === 0 && (f = 26), v = p.length - 1; v >= 0; v--) { - for (var x = p.words[v], C = f - 1; C >= 0; C--) { - var E = (x >> C) & 1; - if ((_ !== d[0] && (_ = this.sqr(_)), E === 0 && S === 0)) { - b = 0; - continue; - } - (S <<= 1), - (S |= E), - b++, - !(b !== y && (v !== 0 || C !== 0)) && - ((_ = this.mul(_, d[S])), (b = 0), (S = 0)); - } - f = 26; - } - return _; - }), - (te.prototype.convertTo = function (l) { - var p = l.umod(this.m); - return p === l ? p.clone() : p; - }), - (te.prototype.convertFrom = function (l) { - var p = l.clone(); - return (p.red = null), p; - }), - (i.mont = function (l) { - return new ne(l); - }); - function ne(A) { - te.call(this, A), - (this.shift = this.m.bitLength()), - this.shift % 26 !== 0 && (this.shift += 26 - (this.shift % 26)), - (this.r = new i(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)); - } - n(ne, te), - (ne.prototype.convertTo = function (l) { - return this.imod(l.ushln(this.shift)); - }), - (ne.prototype.convertFrom = function (l) { - var p = this.imod(l.mul(this.rinv)); - return (p.red = null), p; - }), - (ne.prototype.imul = function (l, p) { - if (l.isZero() || p.isZero()) - return (l.words[0] = 0), (l.length = 1), l; - var y = l.imul(p), - d = y - .maskn(this.shift) - .mul(this.minv) - .imaskn(this.shift) - .mul(this.m), - v = y.isub(d).iushrn(this.shift), - _ = v; - return ( - v.cmp(this.m) >= 0 - ? (_ = v.isub(this.m)) - : v.cmpn(0) < 0 && (_ = v.iadd(this.m)), - _._forceRed(this) - ); - }), - (ne.prototype.mul = function (l, p) { - if (l.isZero() || p.isZero()) return new i(0)._forceRed(this); - var y = l.mul(p), - d = y - .maskn(this.shift) - .mul(this.minv) - .imaskn(this.shift) - .mul(this.m), - v = y.isub(d).iushrn(this.shift), - _ = v; - return ( - v.cmp(this.m) >= 0 - ? (_ = v.isub(this.m)) - : v.cmpn(0) < 0 && (_ = v.iadd(this.m)), - _._forceRed(this) - ); - }), - (ne.prototype.invm = function (l) { - var p = this.imod(l._invmp(this.m).mul(this.r2)); - return p._forceRed(this); - }); - })(typeof ube > "u" || ube, zVe); - }); - var cbe = I((KVe) => { - "use strict"; - m(); - g(); - var QZ = KVe; - function FXt(t, e) { - if (Array.isArray(t)) return t.slice(); - if (!t) return []; - var r = []; - if (typeof t != "string") { - for (var n = 0; n < t.length; n++) r[n] = t[n] | 0; - return r; - } - if (e === "hex") { - (t = t.replace(/[^a-z0-9]+/gi, "")), - t.length % 2 !== 0 && (t = "0" + t); - for (var n = 0; n < t.length; n += 2) - r.push(parseInt(t[n] + t[n + 1], 16)); - } else - for (var n = 0; n < t.length; n++) { - var i = t.charCodeAt(n), - o = i >> 8, - a = i & 255; - o ? r.push(o, a) : r.push(a); - } - return r; - } - QZ.toArray = FXt; - function jVe(t) { - return t.length === 1 ? "0" + t : t; - } - QZ.zero2 = jVe; - function UVe(t) { - for (var e = "", r = 0; r < t.length; r++) e += jVe(t[r].toString(16)); - return e; - } - QZ.toHex = UVe; - QZ.encode = function (e, r) { - return r === "hex" ? UVe(e) : e; - }; - }); - var Np = I((HVe) => { - "use strict"; - m(); - g(); - var Dm = HVe, - LXt = hv(), - qXt = Cp(), - eX = cbe(); - Dm.assert = qXt; - Dm.toArray = eX.toArray; - Dm.zero2 = eX.zero2; - Dm.toHex = eX.toHex; - Dm.encode = eX.encode; - function zXt(t, e, r) { - var n = new Array(Math.max(t.bitLength(), r) + 1); - n.fill(0); - for (var i = 1 << (e + 1), o = t.clone(), a = 0; a < n.length; a++) { - var s, - c = o.andln(i - 1); - o.isOdd() - ? (c > (i >> 1) - 1 ? (s = (i >> 1) - c) : (s = c), o.isubn(s)) - : (s = 0), - (n[a] = s), - o.iushrn(1); - } - return n; - } - Dm.getNAF = zXt; - function jXt(t, e) { - var r = [[], []]; - (t = t.clone()), (e = e.clone()); - for (var n = 0, i = 0, o; t.cmpn(-n) > 0 || e.cmpn(-i) > 0; ) { - var a = (t.andln(3) + n) & 3, - s = (e.andln(3) + i) & 3; - a === 3 && (a = -1), s === 3 && (s = -1); - var c; - (a & 1) === 0 - ? (c = 0) - : ((o = (t.andln(7) + n) & 7), - (o === 3 || o === 5) && s === 2 ? (c = -a) : (c = a)), - r[0].push(c); - var u; - (s & 1) === 0 - ? (u = 0) - : ((o = (e.andln(7) + i) & 7), - (o === 3 || o === 5) && a === 2 ? (u = -s) : (u = s)), - r[1].push(u), - 2 * n === c + 1 && (n = 1 - n), - 2 * i === u + 1 && (i = 1 - i), - t.iushrn(1), - e.iushrn(1); - } - return r; - } - Dm.getJSF = jXt; - function UXt(t, e, r) { - var n = "_" + e; - t.prototype[e] = function () { - return this[n] !== void 0 ? this[n] : (this[n] = r.call(this)); - }; - } - Dm.cachedProperty = UXt; - function KXt(t) { - return typeof t == "string" ? Dm.toArray(t, "hex") : t; - } - Dm.parseBytes = KXt; - function HXt(t) { - return new LXt(t, "hex", "le"); - } - Dm.intFromLE = HXt; - }); - var Lq = I((tfn, VVe) => { - "use strict"; - m(); - g(); - var kM = hv(), - Fq = Np(), - tX = Fq.getNAF, - VXt = Fq.getJSF, - rX = Fq.assert; - function p2(t, e) { - (this.type = t), - (this.p = new kM(e.p, 16)), - (this.red = e.prime ? kM.red(e.prime) : kM.mont(this.p)), - (this.zero = new kM(0).toRed(this.red)), - (this.one = new kM(1).toRed(this.red)), - (this.two = new kM(2).toRed(this.red)), - (this.n = e.n && new kM(e.n, 16)), - (this.g = e.g && this.pointFromJSON(e.g, e.gRed)), - (this._wnafT1 = new Array(4)), - (this._wnafT2 = new Array(4)), - (this._wnafT3 = new Array(4)), - (this._wnafT4 = new Array(4)), - (this._bitLength = this.n ? this.n.bitLength() : 0); - var r = this.n && this.p.div(this.n); - !r || r.cmpn(100) > 0 - ? (this.redN = null) - : ((this._maxwellTrick = !0), (this.redN = this.n.toRed(this.red))); - } - VVe.exports = p2; - p2.prototype.point = function () { - throw new Error("Not implemented"); - }; - p2.prototype.validate = function () { - throw new Error("Not implemented"); - }; - p2.prototype._fixedNafMul = function (e, r) { - rX(e.precomputed); - var n = e._getDoubles(), - i = tX(r, 1, this._bitLength), - o = (1 << (n.step + 1)) - (n.step % 2 === 0 ? 2 : 1); - o /= 3; - var a = [], - s, - c; - for (s = 0; s < i.length; s += n.step) { - c = 0; - for (var u = s + n.step - 1; u >= s; u--) c = (c << 1) + i[u]; - a.push(c); - } - for ( - var h = this.jpoint(null, null, null), - w = this.jpoint(null, null, null), - M = o; - M > 0; - M-- - ) { - for (s = 0; s < a.length; s++) - (c = a[s]), - c === M - ? (w = w.mixedAdd(n.points[s])) - : c === -M && (w = w.mixedAdd(n.points[s].neg())); - h = h.add(w); - } - return h.toP(); - }; - p2.prototype._wnafMul = function (e, r) { - var n = 4, - i = e._getNAFPoints(n); - n = i.wnd; - for ( - var o = i.points, - a = tX(r, n, this._bitLength), - s = this.jpoint(null, null, null), - c = a.length - 1; - c >= 0; - c-- - ) { - for (var u = 0; c >= 0 && a[c] === 0; c--) u++; - if ((c >= 0 && u++, (s = s.dblp(u)), c < 0)) break; - var h = a[c]; - rX(h !== 0), - e.type === "affine" - ? h > 0 - ? (s = s.mixedAdd(o[(h - 1) >> 1])) - : (s = s.mixedAdd(o[(-h - 1) >> 1].neg())) - : h > 0 - ? (s = s.add(o[(h - 1) >> 1])) - : (s = s.add(o[(-h - 1) >> 1].neg())); - } - return e.type === "affine" ? s.toP() : s; - }; - p2.prototype._wnafMulAdd = function (e, r, n, i, o) { - var a = this._wnafT1, - s = this._wnafT2, - c = this._wnafT3, - u = 0, - h, - w, - M; - for (h = 0; h < i; h++) { - M = r[h]; - var k = M._getNAFPoints(e); - (a[h] = k.wnd), (s[h] = k.points); - } - for (h = i - 1; h >= 1; h -= 2) { - var O = h - 1, - D = h; - if (a[O] !== 1 || a[D] !== 1) { - (c[O] = tX(n[O], a[O], this._bitLength)), - (c[D] = tX(n[D], a[D], this._bitLength)), - (u = Math.max(c[O].length, u)), - (u = Math.max(c[D].length, u)); - continue; - } - var F = [r[O], null, null, r[D]]; - r[O].y.cmp(r[D].y) === 0 - ? ((F[1] = r[O].add(r[D])), (F[2] = r[O].toJ().mixedAdd(r[D].neg()))) - : r[O].y.cmp(r[D].y.redNeg()) === 0 - ? ((F[1] = r[O].toJ().mixedAdd(r[D])), (F[2] = r[O].add(r[D].neg()))) - : ((F[1] = r[O].toJ().mixedAdd(r[D])), - (F[2] = r[O].toJ().mixedAdd(r[D].neg()))); - var N = [-3, -1, -5, -7, 0, 7, 5, 1, 3], - q = VXt(n[O], n[D]); - for ( - u = Math.max(q[0].length, u), - c[O] = new Array(u), - c[D] = new Array(u), - w = 0; - w < u; - w++ - ) { - var z = q[0][w] | 0, - H = q[1][w] | 0; - (c[O][w] = N[(z + 1) * 3 + (H + 1)]), (c[D][w] = 0), (s[O] = F); - } - } - var Z = this.jpoint(null, null, null), - $ = this._wnafT4; - for (h = u; h >= 0; h--) { - for (var ue = 0; h >= 0; ) { - var te = !0; - for (w = 0; w < i; w++) ($[w] = c[w][h] | 0), $[w] !== 0 && (te = !1); - if (!te) break; - ue++, h--; - } - if ((h >= 0 && ue++, (Z = Z.dblp(ue)), h < 0)) break; - for (w = 0; w < i; w++) { - var ne = $[w]; - ne !== 0 && - (ne > 0 - ? (M = s[w][(ne - 1) >> 1]) - : ne < 0 && (M = s[w][(-ne - 1) >> 1].neg()), - M.type === "affine" ? (Z = Z.mixedAdd(M)) : (Z = Z.add(M))); - } - } - for (h = 0; h < i; h++) s[h] = null; - return o ? Z : Z.toP(); - }; - function ay(t, e) { - (this.curve = t), (this.type = e), (this.precomputed = null); - } - p2.BasePoint = ay; - ay.prototype.eq = function () { - throw new Error("Not implemented"); - }; - ay.prototype.validate = function () { - return this.curve.validate(this); - }; - p2.prototype.decodePoint = function (e, r) { - e = Fq.toArray(e, r); - var n = this.p.byteLength(); - if ((e[0] === 4 || e[0] === 6 || e[0] === 7) && e.length - 1 === 2 * n) { - e[0] === 6 - ? rX(e[e.length - 1] % 2 === 0) - : e[0] === 7 && rX(e[e.length - 1] % 2 === 1); - var i = this.point(e.slice(1, 1 + n), e.slice(1 + n, 1 + 2 * n)); - return i; - } else if ((e[0] === 2 || e[0] === 3) && e.length - 1 === n) - return this.pointFromX(e.slice(1, 1 + n), e[0] === 3); - throw new Error("Unknown point format"); - }; - ay.prototype.encodeCompressed = function (e) { - return this.encode(e, !0); - }; - ay.prototype._encode = function (e) { - var r = this.curve.p.byteLength(), - n = this.getX().toArray("be", r); - return e - ? [this.getY().isEven() ? 2 : 3].concat(n) - : [4].concat(n, this.getY().toArray("be", r)); - }; - ay.prototype.encode = function (e, r) { - return Fq.encode(this._encode(r), e); - }; - ay.prototype.precompute = function (e) { - if (this.precomputed) return this; - var r = { doubles: null, naf: null, beta: null }; - return ( - (r.naf = this._getNAFPoints(8)), - (r.doubles = this._getDoubles(4, e)), - (r.beta = this._getBeta()), - (this.precomputed = r), - this - ); - }; - ay.prototype._hasDoubles = function (e) { - if (!this.precomputed) return !1; - var r = this.precomputed.doubles; - return r - ? r.points.length >= Math.ceil((e.bitLength() + 1) / r.step) - : !1; - }; - ay.prototype._getDoubles = function (e, r) { - if (this.precomputed && this.precomputed.doubles) - return this.precomputed.doubles; - for (var n = [this], i = this, o = 0; o < r; o += e) { - for (var a = 0; a < e; a++) i = i.dbl(); - n.push(i); - } - return { step: e, points: n }; - }; - ay.prototype._getNAFPoints = function (e) { - if (this.precomputed && this.precomputed.naf) return this.precomputed.naf; - for ( - var r = [this], - n = (1 << e) - 1, - i = n === 1 ? null : this.dbl(), - o = 1; - o < n; - o++ - ) - r[o] = r[o - 1].add(i); - return { wnd: e, points: r }; - }; - ay.prototype._getBeta = function () { - return null; - }; - ay.prototype.dblp = function (e) { - for (var r = this, n = 0; n < e; n++) r = r.dbl(); - return r; - }; - }); - var GVe = I((rfn, WVe) => { - "use strict"; - m(); - g(); - var WXt = Np(), - Ra = hv(), - lbe = dn(), - M5 = Lq(), - GXt = WXt.assert; - function sy(t) { - M5.call(this, "short", t), - (this.a = new Ra(t.a, 16).toRed(this.red)), - (this.b = new Ra(t.b, 16).toRed(this.red)), - (this.tinv = this.two.redInvm()), - (this.zeroA = this.a.fromRed().cmpn(0) === 0), - (this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0), - (this.endo = this._getEndomorphism(t)), - (this._endoWnafT1 = new Array(4)), - (this._endoWnafT2 = new Array(4)); - } - lbe(sy, M5); - WVe.exports = sy; - sy.prototype._getEndomorphism = function (e) { - if (!(!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1)) { - var r, n; - if (e.beta) r = new Ra(e.beta, 16).toRed(this.red); - else { - var i = this._getEndoRoots(this.p); - (r = i[0].cmp(i[1]) < 0 ? i[0] : i[1]), (r = r.toRed(this.red)); - } - if (e.lambda) n = new Ra(e.lambda, 16); - else { - var o = this._getEndoRoots(this.n); - this.g.mul(o[0]).x.cmp(this.g.x.redMul(r)) === 0 - ? (n = o[0]) - : ((n = o[1]), GXt(this.g.mul(n).x.cmp(this.g.x.redMul(r)) === 0)); - } - var a; - return ( - e.basis - ? (a = e.basis.map(function (s) { - return { a: new Ra(s.a, 16), b: new Ra(s.b, 16) }; - })) - : (a = this._getEndoBasis(n)), - { beta: r, lambda: n, basis: a } - ); - } - }; - sy.prototype._getEndoRoots = function (e) { - var r = e === this.p ? this.red : Ra.mont(e), - n = new Ra(2).toRed(r).redInvm(), - i = n.redNeg(), - o = new Ra(3).toRed(r).redNeg().redSqrt().redMul(n), - a = i.redAdd(o).fromRed(), - s = i.redSub(o).fromRed(); - return [a, s]; - }; - sy.prototype._getEndoBasis = function (e) { - for ( - var r = this.n.ushrn(Math.floor(this.n.bitLength() / 2)), - n = e, - i = this.n.clone(), - o = new Ra(1), - a = new Ra(0), - s = new Ra(0), - c = new Ra(1), - u, - h, - w, - M, - k, - O, - D, - F = 0, - N, - q; - n.cmpn(0) !== 0; - - ) { - var z = i.div(n); - (N = i.sub(z.mul(n))), (q = s.sub(z.mul(o))); - var H = c.sub(z.mul(a)); - if (!w && N.cmp(r) < 0) (u = D.neg()), (h = o), (w = N.neg()), (M = q); - else if (w && ++F === 2) break; - (D = N), (i = n), (n = N), (s = o), (o = q), (c = a), (a = H); - } - (k = N.neg()), (O = q); - var Z = w.sqr().add(M.sqr()), - $ = k.sqr().add(O.sqr()); - return ( - $.cmp(Z) >= 0 && ((k = u), (O = h)), - w.negative && ((w = w.neg()), (M = M.neg())), - k.negative && ((k = k.neg()), (O = O.neg())), - [ - { a: w, b: M }, - { a: k, b: O }, - ] - ); - }; - sy.prototype._endoSplit = function (e) { - var r = this.endo.basis, - n = r[0], - i = r[1], - o = i.b.mul(e).divRound(this.n), - a = n.b.neg().mul(e).divRound(this.n), - s = o.mul(n.a), - c = a.mul(i.a), - u = o.mul(n.b), - h = a.mul(i.b), - w = e.sub(s).sub(c), - M = u.add(h).neg(); - return { k1: w, k2: M }; - }; - sy.prototype.pointFromX = function (e, r) { - (e = new Ra(e, 16)), e.red || (e = e.toRed(this.red)); - var n = e.redSqr().redMul(e).redIAdd(e.redMul(this.a)).redIAdd(this.b), - i = n.redSqrt(); - if (i.redSqr().redSub(n).cmp(this.zero) !== 0) - throw new Error("invalid point"); - var o = i.fromRed().isOdd(); - return ((r && !o) || (!r && o)) && (i = i.redNeg()), this.point(e, i); - }; - sy.prototype.validate = function (e) { - if (e.inf) return !0; - var r = e.x, - n = e.y, - i = this.a.redMul(r), - o = r.redSqr().redMul(r).redIAdd(i).redIAdd(this.b); - return n.redSqr().redISub(o).cmpn(0) === 0; - }; - sy.prototype._endoWnafMulAdd = function (e, r, n) { - for ( - var i = this._endoWnafT1, o = this._endoWnafT2, a = 0; - a < e.length; - a++ - ) { - var s = this._endoSplit(r[a]), - c = e[a], - u = c._getBeta(); - s.k1.negative && (s.k1.ineg(), (c = c.neg(!0))), - s.k2.negative && (s.k2.ineg(), (u = u.neg(!0))), - (i[a * 2] = c), - (i[a * 2 + 1] = u), - (o[a * 2] = s.k1), - (o[a * 2 + 1] = s.k2); - } - for (var h = this._wnafMulAdd(1, i, o, a * 2, n), w = 0; w < a * 2; w++) - (i[w] = null), (o[w] = null); - return h; - }; - function wu(t, e, r, n) { - M5.BasePoint.call(this, t, "affine"), - e === null && r === null - ? ((this.x = null), (this.y = null), (this.inf = !0)) - : ((this.x = new Ra(e, 16)), - (this.y = new Ra(r, 16)), - n && - (this.x.forceRed(this.curve.red), - this.y.forceRed(this.curve.red)), - this.x.red || (this.x = this.x.toRed(this.curve.red)), - this.y.red || (this.y = this.y.toRed(this.curve.red)), - (this.inf = !1)); - } - lbe(wu, M5.BasePoint); - sy.prototype.point = function (e, r, n) { - return new wu(this, e, r, n); - }; - sy.prototype.pointFromJSON = function (e, r) { - return wu.fromJSON(this, e, r); - }; - wu.prototype._getBeta = function () { - if (!!this.curve.endo) { - var e = this.precomputed; - if (e && e.beta) return e.beta; - var r = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y); - if (e) { - var n = this.curve, - i = function (o) { - return n.point(o.x.redMul(n.endo.beta), o.y); - }; - (e.beta = r), - (r.precomputed = { - beta: null, - naf: e.naf && { wnd: e.naf.wnd, points: e.naf.points.map(i) }, - doubles: e.doubles && { - step: e.doubles.step, - points: e.doubles.points.map(i), - }, - }); - } - return r; - } - }; - wu.prototype.toJSON = function () { - return this.precomputed - ? [ - this.x, - this.y, - this.precomputed && { - doubles: this.precomputed.doubles && { - step: this.precomputed.doubles.step, - points: this.precomputed.doubles.points.slice(1), - }, - naf: this.precomputed.naf && { - wnd: this.precomputed.naf.wnd, - points: this.precomputed.naf.points.slice(1), - }, - }, - ] - : [this.x, this.y]; - }; - wu.fromJSON = function (e, r, n) { - typeof r == "string" && (r = JSON.parse(r)); - var i = e.point(r[0], r[1], n); - if (!r[2]) return i; - function o(s) { - return e.point(s[0], s[1], n); - } - var a = r[2]; - return ( - (i.precomputed = { - beta: null, - doubles: a.doubles && { - step: a.doubles.step, - points: [i].concat(a.doubles.points.map(o)), - }, - naf: a.naf && { - wnd: a.naf.wnd, - points: [i].concat(a.naf.points.map(o)), - }, - }), - i - ); - }; - wu.prototype.inspect = function () { - return this.isInfinity() - ? "" - : ""; - }; - wu.prototype.isInfinity = function () { - return this.inf; - }; - wu.prototype.add = function (e) { - if (this.inf) return e; - if (e.inf) return this; - if (this.eq(e)) return this.dbl(); - if (this.neg().eq(e)) return this.curve.point(null, null); - if (this.x.cmp(e.x) === 0) return this.curve.point(null, null); - var r = this.y.redSub(e.y); - r.cmpn(0) !== 0 && (r = r.redMul(this.x.redSub(e.x).redInvm())); - var n = r.redSqr().redISub(this.x).redISub(e.x), - i = r.redMul(this.x.redSub(n)).redISub(this.y); - return this.curve.point(n, i); - }; - wu.prototype.dbl = function () { - if (this.inf) return this; - var e = this.y.redAdd(this.y); - if (e.cmpn(0) === 0) return this.curve.point(null, null); - var r = this.curve.a, - n = this.x.redSqr(), - i = e.redInvm(), - o = n.redAdd(n).redIAdd(n).redIAdd(r).redMul(i), - a = o.redSqr().redISub(this.x.redAdd(this.x)), - s = o.redMul(this.x.redSub(a)).redISub(this.y); - return this.curve.point(a, s); - }; - wu.prototype.getX = function () { - return this.x.fromRed(); - }; - wu.prototype.getY = function () { - return this.y.fromRed(); - }; - wu.prototype.mul = function (e) { - return ( - (e = new Ra(e, 16)), - this.isInfinity() - ? this - : this._hasDoubles(e) - ? this.curve._fixedNafMul(this, e) - : this.curve.endo - ? this.curve._endoWnafMulAdd([this], [e]) - : this.curve._wnafMul(this, e) - ); - }; - wu.prototype.mulAdd = function (e, r, n) { - var i = [this, r], - o = [e, n]; - return this.curve.endo - ? this.curve._endoWnafMulAdd(i, o) - : this.curve._wnafMulAdd(1, i, o, 2); - }; - wu.prototype.jmulAdd = function (e, r, n) { - var i = [this, r], - o = [e, n]; - return this.curve.endo - ? this.curve._endoWnafMulAdd(i, o, !0) - : this.curve._wnafMulAdd(1, i, o, 2, !0); - }; - wu.prototype.eq = function (e) { - return ( - this === e || - (this.inf === e.inf && - (this.inf || (this.x.cmp(e.x) === 0 && this.y.cmp(e.y) === 0))) - ); - }; - wu.prototype.neg = function (e) { - if (this.inf) return this; - var r = this.curve.point(this.x, this.y.redNeg()); - if (e && this.precomputed) { - var n = this.precomputed, - i = function (o) { - return o.neg(); - }; - r.precomputed = { - naf: n.naf && { wnd: n.naf.wnd, points: n.naf.points.map(i) }, - doubles: n.doubles && { - step: n.doubles.step, - points: n.doubles.points.map(i), - }, - }; - } - return r; - }; - wu.prototype.toJ = function () { - if (this.inf) return this.curve.jpoint(null, null, null); - var e = this.curve.jpoint(this.x, this.y, this.curve.one); - return e; - }; - function ec(t, e, r, n) { - M5.BasePoint.call(this, t, "jacobian"), - e === null && r === null && n === null - ? ((this.x = this.curve.one), - (this.y = this.curve.one), - (this.z = new Ra(0))) - : ((this.x = new Ra(e, 16)), - (this.y = new Ra(r, 16)), - (this.z = new Ra(n, 16))), - this.x.red || (this.x = this.x.toRed(this.curve.red)), - this.y.red || (this.y = this.y.toRed(this.curve.red)), - this.z.red || (this.z = this.z.toRed(this.curve.red)), - (this.zOne = this.z === this.curve.one); - } - lbe(ec, M5.BasePoint); - sy.prototype.jpoint = function (e, r, n) { - return new ec(this, e, r, n); - }; - ec.prototype.toP = function () { - if (this.isInfinity()) return this.curve.point(null, null); - var e = this.z.redInvm(), - r = e.redSqr(), - n = this.x.redMul(r), - i = this.y.redMul(r).redMul(e); - return this.curve.point(n, i); - }; - ec.prototype.neg = function () { - return this.curve.jpoint(this.x, this.y.redNeg(), this.z); - }; - ec.prototype.add = function (e) { - if (this.isInfinity()) return e; - if (e.isInfinity()) return this; - var r = e.z.redSqr(), - n = this.z.redSqr(), - i = this.x.redMul(r), - o = e.x.redMul(n), - a = this.y.redMul(r.redMul(e.z)), - s = e.y.redMul(n.redMul(this.z)), - c = i.redSub(o), - u = a.redSub(s); - if (c.cmpn(0) === 0) - return u.cmpn(0) !== 0 - ? this.curve.jpoint(null, null, null) - : this.dbl(); - var h = c.redSqr(), - w = h.redMul(c), - M = i.redMul(h), - k = u.redSqr().redIAdd(w).redISub(M).redISub(M), - O = u.redMul(M.redISub(k)).redISub(a.redMul(w)), - D = this.z.redMul(e.z).redMul(c); - return this.curve.jpoint(k, O, D); - }; - ec.prototype.mixedAdd = function (e) { - if (this.isInfinity()) return e.toJ(); - if (e.isInfinity()) return this; - var r = this.z.redSqr(), - n = this.x, - i = e.x.redMul(r), - o = this.y, - a = e.y.redMul(r).redMul(this.z), - s = n.redSub(i), - c = o.redSub(a); - if (s.cmpn(0) === 0) - return c.cmpn(0) !== 0 - ? this.curve.jpoint(null, null, null) - : this.dbl(); - var u = s.redSqr(), - h = u.redMul(s), - w = n.redMul(u), - M = c.redSqr().redIAdd(h).redISub(w).redISub(w), - k = c.redMul(w.redISub(M)).redISub(o.redMul(h)), - O = this.z.redMul(s); - return this.curve.jpoint(M, k, O); - }; - ec.prototype.dblp = function (e) { - if (e === 0) return this; - if (this.isInfinity()) return this; - if (!e) return this.dbl(); - var r; - if (this.curve.zeroA || this.curve.threeA) { - var n = this; - for (r = 0; r < e; r++) n = n.dbl(); - return n; - } - var i = this.curve.a, - o = this.curve.tinv, - a = this.x, - s = this.y, - c = this.z, - u = c.redSqr().redSqr(), - h = s.redAdd(s); - for (r = 0; r < e; r++) { - var w = a.redSqr(), - M = h.redSqr(), - k = M.redSqr(), - O = w.redAdd(w).redIAdd(w).redIAdd(i.redMul(u)), - D = a.redMul(M), - F = O.redSqr().redISub(D.redAdd(D)), - N = D.redISub(F), - q = O.redMul(N); - q = q.redIAdd(q).redISub(k); - var z = h.redMul(c); - r + 1 < e && (u = u.redMul(k)), (a = F), (c = z), (h = q); - } - return this.curve.jpoint(a, h.redMul(o), c); - }; - ec.prototype.dbl = function () { - return this.isInfinity() - ? this - : this.curve.zeroA - ? this._zeroDbl() - : this.curve.threeA - ? this._threeDbl() - : this._dbl(); - }; - ec.prototype._zeroDbl = function () { - var e, r, n; - if (this.zOne) { - var i = this.x.redSqr(), - o = this.y.redSqr(), - a = o.redSqr(), - s = this.x.redAdd(o).redSqr().redISub(i).redISub(a); - s = s.redIAdd(s); - var c = i.redAdd(i).redIAdd(i), - u = c.redSqr().redISub(s).redISub(s), - h = a.redIAdd(a); - (h = h.redIAdd(h)), - (h = h.redIAdd(h)), - (e = u), - (r = c.redMul(s.redISub(u)).redISub(h)), - (n = this.y.redAdd(this.y)); - } else { - var w = this.x.redSqr(), - M = this.y.redSqr(), - k = M.redSqr(), - O = this.x.redAdd(M).redSqr().redISub(w).redISub(k); - O = O.redIAdd(O); - var D = w.redAdd(w).redIAdd(w), - F = D.redSqr(), - N = k.redIAdd(k); - (N = N.redIAdd(N)), - (N = N.redIAdd(N)), - (e = F.redISub(O).redISub(O)), - (r = D.redMul(O.redISub(e)).redISub(N)), - (n = this.y.redMul(this.z)), - (n = n.redIAdd(n)); - } - return this.curve.jpoint(e, r, n); - }; - ec.prototype._threeDbl = function () { - var e, r, n; - if (this.zOne) { - var i = this.x.redSqr(), - o = this.y.redSqr(), - a = o.redSqr(), - s = this.x.redAdd(o).redSqr().redISub(i).redISub(a); - s = s.redIAdd(s); - var c = i.redAdd(i).redIAdd(i).redIAdd(this.curve.a), - u = c.redSqr().redISub(s).redISub(s); - e = u; - var h = a.redIAdd(a); - (h = h.redIAdd(h)), - (h = h.redIAdd(h)), - (r = c.redMul(s.redISub(u)).redISub(h)), - (n = this.y.redAdd(this.y)); - } else { - var w = this.z.redSqr(), - M = this.y.redSqr(), - k = this.x.redMul(M), - O = this.x.redSub(w).redMul(this.x.redAdd(w)); - O = O.redAdd(O).redIAdd(O); - var D = k.redIAdd(k); - D = D.redIAdd(D); - var F = D.redAdd(D); - (e = O.redSqr().redISub(F)), - (n = this.y.redAdd(this.z).redSqr().redISub(M).redISub(w)); - var N = M.redSqr(); - (N = N.redIAdd(N)), - (N = N.redIAdd(N)), - (N = N.redIAdd(N)), - (r = O.redMul(D.redISub(e)).redISub(N)); - } - return this.curve.jpoint(e, r, n); - }; - ec.prototype._dbl = function () { - var e = this.curve.a, - r = this.x, - n = this.y, - i = this.z, - o = i.redSqr().redSqr(), - a = r.redSqr(), - s = n.redSqr(), - c = a.redAdd(a).redIAdd(a).redIAdd(e.redMul(o)), - u = r.redAdd(r); - u = u.redIAdd(u); - var h = u.redMul(s), - w = c.redSqr().redISub(h.redAdd(h)), - M = h.redISub(w), - k = s.redSqr(); - (k = k.redIAdd(k)), (k = k.redIAdd(k)), (k = k.redIAdd(k)); - var O = c.redMul(M).redISub(k), - D = n.redAdd(n).redMul(i); - return this.curve.jpoint(w, O, D); - }; - ec.prototype.trpl = function () { - if (!this.curve.zeroA) return this.dbl().add(this); - var e = this.x.redSqr(), - r = this.y.redSqr(), - n = this.z.redSqr(), - i = r.redSqr(), - o = e.redAdd(e).redIAdd(e), - a = o.redSqr(), - s = this.x.redAdd(r).redSqr().redISub(e).redISub(i); - (s = s.redIAdd(s)), (s = s.redAdd(s).redIAdd(s)), (s = s.redISub(a)); - var c = s.redSqr(), - u = i.redIAdd(i); - (u = u.redIAdd(u)), (u = u.redIAdd(u)), (u = u.redIAdd(u)); - var h = o.redIAdd(s).redSqr().redISub(a).redISub(c).redISub(u), - w = r.redMul(h); - (w = w.redIAdd(w)), (w = w.redIAdd(w)); - var M = this.x.redMul(c).redISub(w); - (M = M.redIAdd(M)), (M = M.redIAdd(M)); - var k = this.y.redMul(h.redMul(u.redISub(h)).redISub(s.redMul(c))); - (k = k.redIAdd(k)), (k = k.redIAdd(k)), (k = k.redIAdd(k)); - var O = this.z.redAdd(s).redSqr().redISub(n).redISub(c); - return this.curve.jpoint(M, k, O); - }; - ec.prototype.mul = function (e, r) { - return (e = new Ra(e, r)), this.curve._wnafMul(this, e); - }; - ec.prototype.eq = function (e) { - if (e.type === "affine") return this.eq(e.toJ()); - if (this === e) return !0; - var r = this.z.redSqr(), - n = e.z.redSqr(); - if (this.x.redMul(n).redISub(e.x.redMul(r)).cmpn(0) !== 0) return !1; - var i = r.redMul(this.z), - o = n.redMul(e.z); - return this.y.redMul(o).redISub(e.y.redMul(i)).cmpn(0) === 0; - }; - ec.prototype.eqXToP = function (e) { - var r = this.z.redSqr(), - n = e.toRed(this.curve.red).redMul(r); - if (this.x.cmp(n) === 0) return !0; - for (var i = e.clone(), o = this.curve.redN.redMul(r); ; ) { - if ((i.iadd(this.curve.n), i.cmp(this.curve.p) >= 0)) return !1; - if ((n.redIAdd(o), this.x.cmp(n) === 0)) return !0; - } - }; - ec.prototype.inspect = function () { - return this.isInfinity() - ? "" - : ""; - }; - ec.prototype.isInfinity = function () { - return this.z.cmpn(0) === 0; - }; - }); - var ZVe = I((nfn, $Ve) => { - "use strict"; - m(); - g(); - var T5 = hv(), - JVe = dn(), - nX = Lq(), - JXt = Np(); - function k5(t) { - nX.call(this, "mont", t), - (this.a = new T5(t.a, 16).toRed(this.red)), - (this.b = new T5(t.b, 16).toRed(this.red)), - (this.i4 = new T5(4).toRed(this.red).redInvm()), - (this.two = new T5(2).toRed(this.red)), - (this.a24 = this.i4.redMul(this.a.redAdd(this.two))); - } - JVe(k5, nX); - $Ve.exports = k5; - k5.prototype.validate = function (e) { - var r = e.normalize().x, - n = r.redSqr(), - i = n.redMul(r).redAdd(n.redMul(this.a)).redAdd(r), - o = i.redSqrt(); - return o.redSqr().cmp(i) === 0; - }; - function _u(t, e, r) { - nX.BasePoint.call(this, t, "projective"), - e === null && r === null - ? ((this.x = this.curve.one), (this.z = this.curve.zero)) - : ((this.x = new T5(e, 16)), - (this.z = new T5(r, 16)), - this.x.red || (this.x = this.x.toRed(this.curve.red)), - this.z.red || (this.z = this.z.toRed(this.curve.red))); - } - JVe(_u, nX.BasePoint); - k5.prototype.decodePoint = function (e, r) { - return this.point(JXt.toArray(e, r), 1); - }; - k5.prototype.point = function (e, r) { - return new _u(this, e, r); - }; - k5.prototype.pointFromJSON = function (e) { - return _u.fromJSON(this, e); - }; - _u.prototype.precompute = function () {}; - _u.prototype._encode = function () { - return this.getX().toArray("be", this.curve.p.byteLength()); - }; - _u.fromJSON = function (e, r) { - return new _u(e, r[0], r[1] || e.one); - }; - _u.prototype.inspect = function () { - return this.isInfinity() - ? "" - : ""; - }; - _u.prototype.isInfinity = function () { - return this.z.cmpn(0) === 0; - }; - _u.prototype.dbl = function () { - var e = this.x.redAdd(this.z), - r = e.redSqr(), - n = this.x.redSub(this.z), - i = n.redSqr(), - o = r.redSub(i), - a = r.redMul(i), - s = o.redMul(i.redAdd(this.curve.a24.redMul(o))); - return this.curve.point(a, s); - }; - _u.prototype.add = function () { - throw new Error("Not supported on Montgomery curve"); - }; - _u.prototype.diffAdd = function (e, r) { - var n = this.x.redAdd(this.z), - i = this.x.redSub(this.z), - o = e.x.redAdd(e.z), - a = e.x.redSub(e.z), - s = a.redMul(n), - c = o.redMul(i), - u = r.z.redMul(s.redAdd(c).redSqr()), - h = r.x.redMul(s.redISub(c).redSqr()); - return this.curve.point(u, h); - }; - _u.prototype.mul = function (e) { - for ( - var r = e.clone(), - n = this, - i = this.curve.point(null, null), - o = this, - a = []; - r.cmpn(0) !== 0; - r.iushrn(1) - ) - a.push(r.andln(1)); - for (var s = a.length - 1; s >= 0; s--) - a[s] === 0 - ? ((n = n.diffAdd(i, o)), (i = i.dbl())) - : ((i = n.diffAdd(i, o)), (n = n.dbl())); - return i; - }; - _u.prototype.mulAdd = function () { - throw new Error("Not supported on Montgomery curve"); - }; - _u.prototype.jumlAdd = function () { - throw new Error("Not supported on Montgomery curve"); - }; - _u.prototype.eq = function (e) { - return this.getX().cmp(e.getX()) === 0; - }; - _u.prototype.normalize = function () { - return ( - (this.x = this.x.redMul(this.z.redInvm())), - (this.z = this.curve.one), - this - ); - }; - _u.prototype.getX = function () { - return this.normalize(), this.x.fromRed(); - }; - }); - var QVe = I((ifn, YVe) => { - "use strict"; - m(); - g(); - var $Xt = Np(), - C_ = hv(), - XVe = dn(), - iX = Lq(), - ZXt = $Xt.assert; - function pv(t) { - (this.twisted = (t.a | 0) !== 1), - (this.mOneA = this.twisted && (t.a | 0) === -1), - (this.extended = this.mOneA), - iX.call(this, "edwards", t), - (this.a = new C_(t.a, 16).umod(this.red.m)), - (this.a = this.a.toRed(this.red)), - (this.c = new C_(t.c, 16).toRed(this.red)), - (this.c2 = this.c.redSqr()), - (this.d = new C_(t.d, 16).toRed(this.red)), - (this.dd = this.d.redAdd(this.d)), - ZXt(!this.twisted || this.c.fromRed().cmpn(1) === 0), - (this.oneC = (t.c | 0) === 1); - } - XVe(pv, iX); - YVe.exports = pv; - pv.prototype._mulA = function (e) { - return this.mOneA ? e.redNeg() : this.a.redMul(e); - }; - pv.prototype._mulC = function (e) { - return this.oneC ? e : this.c.redMul(e); - }; - pv.prototype.jpoint = function (e, r, n, i) { - return this.point(e, r, n, i); - }; - pv.prototype.pointFromX = function (e, r) { - (e = new C_(e, 16)), e.red || (e = e.toRed(this.red)); - var n = e.redSqr(), - i = this.c2.redSub(this.a.redMul(n)), - o = this.one.redSub(this.c2.redMul(this.d).redMul(n)), - a = i.redMul(o.redInvm()), - s = a.redSqrt(); - if (s.redSqr().redSub(a).cmp(this.zero) !== 0) - throw new Error("invalid point"); - var c = s.fromRed().isOdd(); - return ((r && !c) || (!r && c)) && (s = s.redNeg()), this.point(e, s); - }; - pv.prototype.pointFromY = function (e, r) { - (e = new C_(e, 16)), e.red || (e = e.toRed(this.red)); - var n = e.redSqr(), - i = n.redSub(this.c2), - o = n.redMul(this.d).redMul(this.c2).redSub(this.a), - a = i.redMul(o.redInvm()); - if (a.cmp(this.zero) === 0) { - if (r) throw new Error("invalid point"); - return this.point(this.zero, e); - } - var s = a.redSqrt(); - if (s.redSqr().redSub(a).cmp(this.zero) !== 0) - throw new Error("invalid point"); - return s.fromRed().isOdd() !== r && (s = s.redNeg()), this.point(s, e); - }; - pv.prototype.validate = function (e) { - if (e.isInfinity()) return !0; - e.normalize(); - var r = e.x.redSqr(), - n = e.y.redSqr(), - i = r.redMul(this.a).redAdd(n), - o = this.c2.redMul(this.one.redAdd(this.d.redMul(r).redMul(n))); - return i.cmp(o) === 0; - }; - function Oo(t, e, r, n, i) { - iX.BasePoint.call(this, t, "projective"), - e === null && r === null && n === null - ? ((this.x = this.curve.zero), - (this.y = this.curve.one), - (this.z = this.curve.one), - (this.t = this.curve.zero), - (this.zOne = !0)) - : ((this.x = new C_(e, 16)), - (this.y = new C_(r, 16)), - (this.z = n ? new C_(n, 16) : this.curve.one), - (this.t = i && new C_(i, 16)), - this.x.red || (this.x = this.x.toRed(this.curve.red)), - this.y.red || (this.y = this.y.toRed(this.curve.red)), - this.z.red || (this.z = this.z.toRed(this.curve.red)), - this.t && !this.t.red && (this.t = this.t.toRed(this.curve.red)), - (this.zOne = this.z === this.curve.one), - this.curve.extended && - !this.t && - ((this.t = this.x.redMul(this.y)), - this.zOne || (this.t = this.t.redMul(this.z.redInvm())))); - } - XVe(Oo, iX.BasePoint); - pv.prototype.pointFromJSON = function (e) { - return Oo.fromJSON(this, e); - }; - pv.prototype.point = function (e, r, n, i) { - return new Oo(this, e, r, n, i); - }; - Oo.fromJSON = function (e, r) { - return new Oo(e, r[0], r[1], r[2]); - }; - Oo.prototype.inspect = function () { - return this.isInfinity() - ? "" - : ""; - }; - Oo.prototype.isInfinity = function () { - return ( - this.x.cmpn(0) === 0 && - (this.y.cmp(this.z) === 0 || - (this.zOne && this.y.cmp(this.curve.c) === 0)) - ); - }; - Oo.prototype._extDbl = function () { - var e = this.x.redSqr(), - r = this.y.redSqr(), - n = this.z.redSqr(); - n = n.redIAdd(n); - var i = this.curve._mulA(e), - o = this.x.redAdd(this.y).redSqr().redISub(e).redISub(r), - a = i.redAdd(r), - s = a.redSub(n), - c = i.redSub(r), - u = o.redMul(s), - h = a.redMul(c), - w = o.redMul(c), - M = s.redMul(a); - return this.curve.point(u, h, M, w); - }; - Oo.prototype._projDbl = function () { - var e = this.x.redAdd(this.y).redSqr(), - r = this.x.redSqr(), - n = this.y.redSqr(), - i, - o, - a, - s, - c, - u; - if (this.curve.twisted) { - s = this.curve._mulA(r); - var h = s.redAdd(n); - this.zOne - ? ((i = e.redSub(r).redSub(n).redMul(h.redSub(this.curve.two))), - (o = h.redMul(s.redSub(n))), - (a = h.redSqr().redSub(h).redSub(h))) - : ((c = this.z.redSqr()), - (u = h.redSub(c).redISub(c)), - (i = e.redSub(r).redISub(n).redMul(u)), - (o = h.redMul(s.redSub(n))), - (a = h.redMul(u))); - } else - (s = r.redAdd(n)), - (c = this.curve._mulC(this.z).redSqr()), - (u = s.redSub(c).redSub(c)), - (i = this.curve._mulC(e.redISub(s)).redMul(u)), - (o = this.curve._mulC(s).redMul(r.redISub(n))), - (a = s.redMul(u)); - return this.curve.point(i, o, a); - }; - Oo.prototype.dbl = function () { - return this.isInfinity() - ? this - : this.curve.extended - ? this._extDbl() - : this._projDbl(); - }; - Oo.prototype._extAdd = function (e) { - var r = this.y.redSub(this.x).redMul(e.y.redSub(e.x)), - n = this.y.redAdd(this.x).redMul(e.y.redAdd(e.x)), - i = this.t.redMul(this.curve.dd).redMul(e.t), - o = this.z.redMul(e.z.redAdd(e.z)), - a = n.redSub(r), - s = o.redSub(i), - c = o.redAdd(i), - u = n.redAdd(r), - h = a.redMul(s), - w = c.redMul(u), - M = a.redMul(u), - k = s.redMul(c); - return this.curve.point(h, w, k, M); - }; - Oo.prototype._projAdd = function (e) { - var r = this.z.redMul(e.z), - n = r.redSqr(), - i = this.x.redMul(e.x), - o = this.y.redMul(e.y), - a = this.curve.d.redMul(i).redMul(o), - s = n.redSub(a), - c = n.redAdd(a), - u = this.x.redAdd(this.y).redMul(e.x.redAdd(e.y)).redISub(i).redISub(o), - h = r.redMul(s).redMul(u), - w, - M; - return ( - this.curve.twisted - ? ((w = r.redMul(c).redMul(o.redSub(this.curve._mulA(i)))), - (M = s.redMul(c))) - : ((w = r.redMul(c).redMul(o.redSub(i))), - (M = this.curve._mulC(s).redMul(c))), - this.curve.point(h, w, M) - ); - }; - Oo.prototype.add = function (e) { - return this.isInfinity() - ? e - : e.isInfinity() - ? this - : this.curve.extended - ? this._extAdd(e) - : this._projAdd(e); - }; - Oo.prototype.mul = function (e) { - return this._hasDoubles(e) - ? this.curve._fixedNafMul(this, e) - : this.curve._wnafMul(this, e); - }; - Oo.prototype.mulAdd = function (e, r, n) { - return this.curve._wnafMulAdd(1, [this, r], [e, n], 2, !1); - }; - Oo.prototype.jmulAdd = function (e, r, n) { - return this.curve._wnafMulAdd(1, [this, r], [e, n], 2, !0); - }; - Oo.prototype.normalize = function () { - if (this.zOne) return this; - var e = this.z.redInvm(); - return ( - (this.x = this.x.redMul(e)), - (this.y = this.y.redMul(e)), - this.t && (this.t = this.t.redMul(e)), - (this.z = this.curve.one), - (this.zOne = !0), - this - ); - }; - Oo.prototype.neg = function () { - return this.curve.point( - this.x.redNeg(), - this.y, - this.z, - this.t && this.t.redNeg() - ); - }; - Oo.prototype.getX = function () { - return this.normalize(), this.x.fromRed(); - }; - Oo.prototype.getY = function () { - return this.normalize(), this.y.fromRed(); - }; - Oo.prototype.eq = function (e) { - return ( - this === e || - (this.getX().cmp(e.getX()) === 0 && this.getY().cmp(e.getY()) === 0) - ); - }; - Oo.prototype.eqXToP = function (e) { - var r = e.toRed(this.curve.red).redMul(this.z); - if (this.x.cmp(r) === 0) return !0; - for (var n = e.clone(), i = this.curve.redN.redMul(this.z); ; ) { - if ((n.iadd(this.curve.n), n.cmp(this.curve.p) >= 0)) return !1; - if ((r.redIAdd(i), this.x.cmp(r) === 0)) return !0; - } - }; - Oo.prototype.toP = Oo.prototype.normalize; - Oo.prototype.mixedAdd = Oo.prototype.add; - }); - var fbe = I((eWe) => { - "use strict"; - m(); - g(); - var oX = eWe; - oX.base = Lq(); - oX.short = GVe(); - oX.mont = ZVe(); - oX.edwards = QVe(); - }); - var Fm = I((So) => { - "use strict"; - m(); - g(); - var XXt = Cp(), - YXt = dn(); - So.inherits = YXt; - function QXt(t, e) { - return (t.charCodeAt(e) & 64512) !== 55296 || e < 0 || e + 1 >= t.length - ? !1 - : (t.charCodeAt(e + 1) & 64512) === 56320; - } - function eYt(t, e) { - if (Array.isArray(t)) return t.slice(); - if (!t) return []; - var r = []; - if (typeof t == "string") - if (e) { - if (e === "hex") - for ( - t = t.replace(/[^a-z0-9]+/gi, ""), - t.length % 2 !== 0 && (t = "0" + t), - i = 0; - i < t.length; - i += 2 - ) - r.push(parseInt(t[i] + t[i + 1], 16)); - } else - for (var n = 0, i = 0; i < t.length; i++) { - var o = t.charCodeAt(i); - o < 128 - ? (r[n++] = o) - : o < 2048 - ? ((r[n++] = (o >> 6) | 192), (r[n++] = (o & 63) | 128)) - : QXt(t, i) - ? ((o = 65536 + ((o & 1023) << 10) + (t.charCodeAt(++i) & 1023)), - (r[n++] = (o >> 18) | 240), - (r[n++] = ((o >> 12) & 63) | 128), - (r[n++] = ((o >> 6) & 63) | 128), - (r[n++] = (o & 63) | 128)) - : ((r[n++] = (o >> 12) | 224), - (r[n++] = ((o >> 6) & 63) | 128), - (r[n++] = (o & 63) | 128)); - } - else for (i = 0; i < t.length; i++) r[i] = t[i] | 0; - return r; - } - So.toArray = eYt; - function tYt(t) { - for (var e = "", r = 0; r < t.length; r++) e += rWe(t[r].toString(16)); - return e; - } - So.toHex = tYt; - function tWe(t) { - var e = - (t >>> 24) | - ((t >>> 8) & 65280) | - ((t << 8) & 16711680) | - ((t & 255) << 24); - return e >>> 0; - } - So.htonl = tWe; - function rYt(t, e) { - for (var r = "", n = 0; n < t.length; n++) { - var i = t[n]; - e === "little" && (i = tWe(i)), (r += nWe(i.toString(16))); - } - return r; - } - So.toHex32 = rYt; - function rWe(t) { - return t.length === 1 ? "0" + t : t; - } - So.zero2 = rWe; - function nWe(t) { - return t.length === 7 - ? "0" + t - : t.length === 6 - ? "00" + t - : t.length === 5 - ? "000" + t - : t.length === 4 - ? "0000" + t - : t.length === 3 - ? "00000" + t - : t.length === 2 - ? "000000" + t - : t.length === 1 - ? "0000000" + t - : t; - } - So.zero8 = nWe; - function nYt(t, e, r, n) { - var i = r - e; - XXt(i % 4 === 0); - for (var o = new Array(i / 4), a = 0, s = e; a < o.length; a++, s += 4) { - var c; - n === "big" - ? (c = (t[s] << 24) | (t[s + 1] << 16) | (t[s + 2] << 8) | t[s + 3]) - : (c = (t[s + 3] << 24) | (t[s + 2] << 16) | (t[s + 1] << 8) | t[s]), - (o[a] = c >>> 0); - } - return o; - } - So.join32 = nYt; - function iYt(t, e) { - for ( - var r = new Array(t.length * 4), n = 0, i = 0; - n < t.length; - n++, i += 4 - ) { - var o = t[n]; - e === "big" - ? ((r[i] = o >>> 24), - (r[i + 1] = (o >>> 16) & 255), - (r[i + 2] = (o >>> 8) & 255), - (r[i + 3] = o & 255)) - : ((r[i + 3] = o >>> 24), - (r[i + 2] = (o >>> 16) & 255), - (r[i + 1] = (o >>> 8) & 255), - (r[i] = o & 255)); - } - return r; - } - So.split32 = iYt; - function oYt(t, e) { - return (t >>> e) | (t << (32 - e)); - } - So.rotr32 = oYt; - function aYt(t, e) { - return (t << e) | (t >>> (32 - e)); - } - So.rotl32 = aYt; - function sYt(t, e) { - return (t + e) >>> 0; - } - So.sum32 = sYt; - function uYt(t, e, r) { - return (t + e + r) >>> 0; - } - So.sum32_3 = uYt; - function cYt(t, e, r, n) { - return (t + e + r + n) >>> 0; - } - So.sum32_4 = cYt; - function lYt(t, e, r, n, i) { - return (t + e + r + n + i) >>> 0; - } - So.sum32_5 = lYt; - function fYt(t, e, r, n) { - var i = t[e], - o = t[e + 1], - a = (n + o) >>> 0, - s = (a < n ? 1 : 0) + r + i; - (t[e] = s >>> 0), (t[e + 1] = a); - } - So.sum64 = fYt; - function dYt(t, e, r, n) { - var i = (e + n) >>> 0, - o = (i < e ? 1 : 0) + t + r; - return o >>> 0; - } - So.sum64_hi = dYt; - function hYt(t, e, r, n) { - var i = e + n; - return i >>> 0; - } - So.sum64_lo = hYt; - function pYt(t, e, r, n, i, o, a, s) { - var c = 0, - u = e; - (u = (u + n) >>> 0), - (c += u < e ? 1 : 0), - (u = (u + o) >>> 0), - (c += u < o ? 1 : 0), - (u = (u + s) >>> 0), - (c += u < s ? 1 : 0); - var h = t + r + i + a + c; - return h >>> 0; - } - So.sum64_4_hi = pYt; - function yYt(t, e, r, n, i, o, a, s) { - var c = e + n + o + s; - return c >>> 0; - } - So.sum64_4_lo = yYt; - function mYt(t, e, r, n, i, o, a, s, c, u) { - var h = 0, - w = e; - (w = (w + n) >>> 0), - (h += w < e ? 1 : 0), - (w = (w + o) >>> 0), - (h += w < o ? 1 : 0), - (w = (w + s) >>> 0), - (h += w < s ? 1 : 0), - (w = (w + u) >>> 0), - (h += w < u ? 1 : 0); - var M = t + r + i + a + c + h; - return M >>> 0; - } - So.sum64_5_hi = mYt; - function gYt(t, e, r, n, i, o, a, s, c, u) { - var h = e + n + o + s + u; - return h >>> 0; - } - So.sum64_5_lo = gYt; - function vYt(t, e, r) { - var n = (e << (32 - r)) | (t >>> r); - return n >>> 0; - } - So.rotr64_hi = vYt; - function bYt(t, e, r) { - var n = (t << (32 - r)) | (e >>> r); - return n >>> 0; - } - So.rotr64_lo = bYt; - function wYt(t, e, r) { - return t >>> r; - } - So.shr64_hi = wYt; - function _Yt(t, e, r) { - var n = (t << (32 - r)) | (e >>> r); - return n >>> 0; - } - So.shr64_lo = _Yt; - }); - var P5 = I((oWe) => { - "use strict"; - m(); - g(); - var iWe = Fm(), - xYt = Cp(); - function aX() { - (this.pending = null), - (this.pendingTotal = 0), - (this.blockSize = this.constructor.blockSize), - (this.outSize = this.constructor.outSize), - (this.hmacStrength = this.constructor.hmacStrength), - (this.padLength = this.constructor.padLength / 8), - (this.endian = "big"), - (this._delta8 = this.blockSize / 8), - (this._delta32 = this.blockSize / 32); - } - oWe.BlockHash = aX; - aX.prototype.update = function (e, r) { - if ( - ((e = iWe.toArray(e, r)), - this.pending - ? (this.pending = this.pending.concat(e)) - : (this.pending = e), - (this.pendingTotal += e.length), - this.pending.length >= this._delta8) - ) { - e = this.pending; - var n = e.length % this._delta8; - (this.pending = e.slice(e.length - n, e.length)), - this.pending.length === 0 && (this.pending = null), - (e = iWe.join32(e, 0, e.length - n, this.endian)); - for (var i = 0; i < e.length; i += this._delta32) - this._update(e, i, i + this._delta32); - } - return this; - }; - aX.prototype.digest = function (e) { - return ( - this.update(this._pad()), xYt(this.pending === null), this._digest(e) - ); - }; - aX.prototype._pad = function () { - var e = this.pendingTotal, - r = this._delta8, - n = r - ((e + this.padLength) % r), - i = new Array(n + this.padLength); - i[0] = 128; - for (var o = 1; o < n; o++) i[o] = 0; - if (((e <<= 3), this.endian === "big")) { - for (var a = 8; a < this.padLength; a++) i[o++] = 0; - (i[o++] = 0), - (i[o++] = 0), - (i[o++] = 0), - (i[o++] = 0), - (i[o++] = (e >>> 24) & 255), - (i[o++] = (e >>> 16) & 255), - (i[o++] = (e >>> 8) & 255), - (i[o++] = e & 255); - } else - for ( - i[o++] = e & 255, - i[o++] = (e >>> 8) & 255, - i[o++] = (e >>> 16) & 255, - i[o++] = (e >>> 24) & 255, - i[o++] = 0, - i[o++] = 0, - i[o++] = 0, - i[o++] = 0, - a = 8; - a < this.padLength; - a++ - ) - i[o++] = 0; - return i; - }; - }); - var dbe = I((R_) => { - "use strict"; - m(); - g(); - var SYt = Fm(), - yv = SYt.rotr32; - function AYt(t, e, r, n) { - if (t === 0) return aWe(e, r, n); - if (t === 1 || t === 3) return uWe(e, r, n); - if (t === 2) return sWe(e, r, n); - } - R_.ft_1 = AYt; - function aWe(t, e, r) { - return (t & e) ^ (~t & r); - } - R_.ch32 = aWe; - function sWe(t, e, r) { - return (t & e) ^ (t & r) ^ (e & r); - } - R_.maj32 = sWe; - function uWe(t, e, r) { - return t ^ e ^ r; - } - R_.p32 = uWe; - function EYt(t) { - return yv(t, 2) ^ yv(t, 13) ^ yv(t, 22); - } - R_.s0_256 = EYt; - function MYt(t) { - return yv(t, 6) ^ yv(t, 11) ^ yv(t, 25); - } - R_.s1_256 = MYt; - function TYt(t) { - return yv(t, 7) ^ yv(t, 18) ^ (t >>> 3); - } - R_.g0_256 = TYt; - function kYt(t) { - return yv(t, 17) ^ yv(t, 19) ^ (t >>> 10); - } - R_.g1_256 = kYt; - }); - var fWe = I((cfn, lWe) => { - "use strict"; - m(); - g(); - var O5 = Fm(), - PYt = P5(), - OYt = dbe(), - hbe = O5.rotl32, - qq = O5.sum32, - BYt = O5.sum32_5, - IYt = OYt.ft_1, - cWe = PYt.BlockHash, - CYt = [1518500249, 1859775393, 2400959708, 3395469782]; - function mv() { - if (!(this instanceof mv)) return new mv(); - cWe.call(this), - (this.h = [1732584193, 4023233417, 2562383102, 271733878, 3285377520]), - (this.W = new Array(80)); - } - O5.inherits(mv, cWe); - lWe.exports = mv; - mv.blockSize = 512; - mv.outSize = 160; - mv.hmacStrength = 80; - mv.padLength = 64; - mv.prototype._update = function (e, r) { - for (var n = this.W, i = 0; i < 16; i++) n[i] = e[r + i]; - for (; i < n.length; i++) - n[i] = hbe(n[i - 3] ^ n[i - 8] ^ n[i - 14] ^ n[i - 16], 1); - var o = this.h[0], - a = this.h[1], - s = this.h[2], - c = this.h[3], - u = this.h[4]; - for (i = 0; i < n.length; i++) { - var h = ~~(i / 20), - w = BYt(hbe(o, 5), IYt(h, a, s, c), u, n[i], CYt[h]); - (u = c), (c = s), (s = hbe(a, 30)), (a = o), (o = w); - } - (this.h[0] = qq(this.h[0], o)), - (this.h[1] = qq(this.h[1], a)), - (this.h[2] = qq(this.h[2], s)), - (this.h[3] = qq(this.h[3], c)), - (this.h[4] = qq(this.h[4], u)); - }; - mv.prototype._digest = function (e) { - return e === "hex" - ? O5.toHex32(this.h, "big") - : O5.split32(this.h, "big"); - }; - }); - var pbe = I((lfn, hWe) => { - "use strict"; - m(); - g(); - var B5 = Fm(), - RYt = P5(), - I5 = dbe(), - NYt = Cp(), - Lm = B5.sum32, - DYt = B5.sum32_4, - FYt = B5.sum32_5, - LYt = I5.ch32, - qYt = I5.maj32, - zYt = I5.s0_256, - jYt = I5.s1_256, - UYt = I5.g0_256, - KYt = I5.g1_256, - dWe = RYt.BlockHash, - HYt = [ - 1116352408, 1899447441, 3049323471, 3921009573, 961987163, 1508970993, - 2453635748, 2870763221, 3624381080, 310598401, 607225278, 1426881987, - 1925078388, 2162078206, 2614888103, 3248222580, 3835390401, 4022224774, - 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986, - 2554220882, 2821834349, 2952996808, 3210313671, 3336571891, 3584528711, - 113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291, - 1695183700, 1986661051, 2177026350, 2456956037, 2730485921, 2820302411, - 3259730800, 3345764771, 3516065817, 3600352804, 4094571909, 275423344, - 430227734, 506948616, 659060556, 883997877, 958139571, 1322822218, - 1537002063, 1747873779, 1955562222, 2024104815, 2227730452, 2361852424, - 2428436474, 2756734187, 3204031479, 3329325298, - ]; - function gv() { - if (!(this instanceof gv)) return new gv(); - dWe.call(this), - (this.h = [ - 1779033703, 3144134277, 1013904242, 2773480762, 1359893119, - 2600822924, 528734635, 1541459225, - ]), - (this.k = HYt), - (this.W = new Array(64)); - } - B5.inherits(gv, dWe); - hWe.exports = gv; - gv.blockSize = 512; - gv.outSize = 256; - gv.hmacStrength = 192; - gv.padLength = 64; - gv.prototype._update = function (e, r) { - for (var n = this.W, i = 0; i < 16; i++) n[i] = e[r + i]; - for (; i < n.length; i++) - n[i] = DYt(KYt(n[i - 2]), n[i - 7], UYt(n[i - 15]), n[i - 16]); - var o = this.h[0], - a = this.h[1], - s = this.h[2], - c = this.h[3], - u = this.h[4], - h = this.h[5], - w = this.h[6], - M = this.h[7]; - for (NYt(this.k.length === n.length), i = 0; i < n.length; i++) { - var k = FYt(M, jYt(u), LYt(u, h, w), this.k[i], n[i]), - O = Lm(zYt(o), qYt(o, a, s)); - (M = w), - (w = h), - (h = u), - (u = Lm(c, k)), - (c = s), - (s = a), - (a = o), - (o = Lm(k, O)); - } - (this.h[0] = Lm(this.h[0], o)), - (this.h[1] = Lm(this.h[1], a)), - (this.h[2] = Lm(this.h[2], s)), - (this.h[3] = Lm(this.h[3], c)), - (this.h[4] = Lm(this.h[4], u)), - (this.h[5] = Lm(this.h[5], h)), - (this.h[6] = Lm(this.h[6], w)), - (this.h[7] = Lm(this.h[7], M)); - }; - gv.prototype._digest = function (e) { - return e === "hex" - ? B5.toHex32(this.h, "big") - : B5.split32(this.h, "big"); - }; - }); - var mWe = I((ffn, yWe) => { - "use strict"; - m(); - g(); - var ybe = Fm(), - pWe = pbe(); - function N_() { - if (!(this instanceof N_)) return new N_(); - pWe.call(this), - (this.h = [ - 3238371032, 914150663, 812702999, 4144912697, 4290775857, 1750603025, - 1694076839, 3204075428, - ]); - } - ybe.inherits(N_, pWe); - yWe.exports = N_; - N_.blockSize = 512; - N_.outSize = 224; - N_.hmacStrength = 192; - N_.padLength = 64; - N_.prototype._digest = function (e) { - return e === "hex" - ? ybe.toHex32(this.h.slice(0, 7), "big") - : ybe.split32(this.h.slice(0, 7), "big"); - }; - }); - var vbe = I((dfn, wWe) => { - "use strict"; - m(); - g(); - var Ph = Fm(), - VYt = P5(), - WYt = Cp(), - vv = Ph.rotr64_hi, - bv = Ph.rotr64_lo, - gWe = Ph.shr64_hi, - vWe = Ph.shr64_lo, - y2 = Ph.sum64, - mbe = Ph.sum64_hi, - gbe = Ph.sum64_lo, - GYt = Ph.sum64_4_hi, - JYt = Ph.sum64_4_lo, - $Yt = Ph.sum64_5_hi, - ZYt = Ph.sum64_5_lo, - bWe = VYt.BlockHash, - XYt = [ - 1116352408, 3609767458, 1899447441, 602891725, 3049323471, 3964484399, - 3921009573, 2173295548, 961987163, 4081628472, 1508970993, 3053834265, - 2453635748, 2937671579, 2870763221, 3664609560, 3624381080, 2734883394, - 310598401, 1164996542, 607225278, 1323610764, 1426881987, 3590304994, - 1925078388, 4068182383, 2162078206, 991336113, 2614888103, 633803317, - 3248222580, 3479774868, 3835390401, 2666613458, 4022224774, 944711139, - 264347078, 2341262773, 604807628, 2007800933, 770255983, 1495990901, - 1249150122, 1856431235, 1555081692, 3175218132, 1996064986, 2198950837, - 2554220882, 3999719339, 2821834349, 766784016, 2952996808, 2566594879, - 3210313671, 3203337956, 3336571891, 1034457026, 3584528711, 2466948901, - 113926993, 3758326383, 338241895, 168717936, 666307205, 1188179964, - 773529912, 1546045734, 1294757372, 1522805485, 1396182291, 2643833823, - 1695183700, 2343527390, 1986661051, 1014477480, 2177026350, 1206759142, - 2456956037, 344077627, 2730485921, 1290863460, 2820302411, 3158454273, - 3259730800, 3505952657, 3345764771, 106217008, 3516065817, 3606008344, - 3600352804, 1432725776, 4094571909, 1467031594, 275423344, 851169720, - 430227734, 3100823752, 506948616, 1363258195, 659060556, 3750685593, - 883997877, 3785050280, 958139571, 3318307427, 1322822218, 3812723403, - 1537002063, 2003034995, 1747873779, 3602036899, 1955562222, 1575990012, - 2024104815, 1125592928, 2227730452, 2716904306, 2361852424, 442776044, - 2428436474, 593698344, 2756734187, 3733110249, 3204031479, 2999351573, - 3329325298, 3815920427, 3391569614, 3928383900, 3515267271, 566280711, - 3940187606, 3454069534, 4118630271, 4000239992, 116418474, 1914138554, - 174292421, 2731055270, 289380356, 3203993006, 460393269, 320620315, - 685471733, 587496836, 852142971, 1086792851, 1017036298, 365543100, - 1126000580, 2618297676, 1288033470, 3409855158, 1501505948, 4234509866, - 1607167915, 987167468, 1816402316, 1246189591, - ]; - function qm() { - if (!(this instanceof qm)) return new qm(); - bWe.call(this), - (this.h = [ - 1779033703, 4089235720, 3144134277, 2227873595, 1013904242, - 4271175723, 2773480762, 1595750129, 1359893119, 2917565137, - 2600822924, 725511199, 528734635, 4215389547, 1541459225, 327033209, - ]), - (this.k = XYt), - (this.W = new Array(160)); - } - Ph.inherits(qm, bWe); - wWe.exports = qm; - qm.blockSize = 1024; - qm.outSize = 512; - qm.hmacStrength = 192; - qm.padLength = 128; - qm.prototype._prepareBlock = function (e, r) { - for (var n = this.W, i = 0; i < 32; i++) n[i] = e[r + i]; - for (; i < n.length; i += 2) { - var o = uQt(n[i - 4], n[i - 3]), - a = cQt(n[i - 4], n[i - 3]), - s = n[i - 14], - c = n[i - 13], - u = aQt(n[i - 30], n[i - 29]), - h = sQt(n[i - 30], n[i - 29]), - w = n[i - 32], - M = n[i - 31]; - (n[i] = GYt(o, a, s, c, u, h, w, M)), - (n[i + 1] = JYt(o, a, s, c, u, h, w, M)); - } - }; - qm.prototype._update = function (e, r) { - this._prepareBlock(e, r); - var n = this.W, - i = this.h[0], - o = this.h[1], - a = this.h[2], - s = this.h[3], - c = this.h[4], - u = this.h[5], - h = this.h[6], - w = this.h[7], - M = this.h[8], - k = this.h[9], - O = this.h[10], - D = this.h[11], - F = this.h[12], - N = this.h[13], - q = this.h[14], - z = this.h[15]; - WYt(this.k.length === n.length); - for (var H = 0; H < n.length; H += 2) { - var Z = q, - $ = z, - ue = iQt(M, k), - te = oQt(M, k), - ne = YYt(M, k, O, D, F, N), - A = QYt(M, k, O, D, F, N), - l = this.k[H], - p = this.k[H + 1], - y = n[H], - d = n[H + 1], - v = $Yt(Z, $, ue, te, ne, A, l, p, y, d), - _ = ZYt(Z, $, ue, te, ne, A, l, p, y, d); - (Z = rQt(i, o)), - ($ = nQt(i, o)), - (ue = eQt(i, o, a, s, c, u)), - (te = tQt(i, o, a, s, c, u)); - var S = mbe(Z, $, ue, te), - b = gbe(Z, $, ue, te); - (q = F), - (z = N), - (F = O), - (N = D), - (O = M), - (D = k), - (M = mbe(h, w, v, _)), - (k = gbe(w, w, v, _)), - (h = c), - (w = u), - (c = a), - (u = s), - (a = i), - (s = o), - (i = mbe(v, _, S, b)), - (o = gbe(v, _, S, b)); - } - y2(this.h, 0, i, o), - y2(this.h, 2, a, s), - y2(this.h, 4, c, u), - y2(this.h, 6, h, w), - y2(this.h, 8, M, k), - y2(this.h, 10, O, D), - y2(this.h, 12, F, N), - y2(this.h, 14, q, z); - }; - qm.prototype._digest = function (e) { - return e === "hex" - ? Ph.toHex32(this.h, "big") - : Ph.split32(this.h, "big"); - }; - function YYt(t, e, r, n, i) { - var o = (t & r) ^ (~t & i); - return o < 0 && (o += 4294967296), o; - } - function QYt(t, e, r, n, i, o) { - var a = (e & n) ^ (~e & o); - return a < 0 && (a += 4294967296), a; - } - function eQt(t, e, r, n, i) { - var o = (t & r) ^ (t & i) ^ (r & i); - return o < 0 && (o += 4294967296), o; - } - function tQt(t, e, r, n, i, o) { - var a = (e & n) ^ (e & o) ^ (n & o); - return a < 0 && (a += 4294967296), a; - } - function rQt(t, e) { - var r = vv(t, e, 28), - n = vv(e, t, 2), - i = vv(e, t, 7), - o = r ^ n ^ i; - return o < 0 && (o += 4294967296), o; - } - function nQt(t, e) { - var r = bv(t, e, 28), - n = bv(e, t, 2), - i = bv(e, t, 7), - o = r ^ n ^ i; - return o < 0 && (o += 4294967296), o; - } - function iQt(t, e) { - var r = vv(t, e, 14), - n = vv(t, e, 18), - i = vv(e, t, 9), - o = r ^ n ^ i; - return o < 0 && (o += 4294967296), o; - } - function oQt(t, e) { - var r = bv(t, e, 14), - n = bv(t, e, 18), - i = bv(e, t, 9), - o = r ^ n ^ i; - return o < 0 && (o += 4294967296), o; - } - function aQt(t, e) { - var r = vv(t, e, 1), - n = vv(t, e, 8), - i = gWe(t, e, 7), - o = r ^ n ^ i; - return o < 0 && (o += 4294967296), o; - } - function sQt(t, e) { - var r = bv(t, e, 1), - n = bv(t, e, 8), - i = vWe(t, e, 7), - o = r ^ n ^ i; - return o < 0 && (o += 4294967296), o; - } - function uQt(t, e) { - var r = vv(t, e, 19), - n = vv(e, t, 29), - i = gWe(t, e, 6), - o = r ^ n ^ i; - return o < 0 && (o += 4294967296), o; - } - function cQt(t, e) { - var r = bv(t, e, 19), - n = bv(e, t, 29), - i = vWe(t, e, 6), - o = r ^ n ^ i; - return o < 0 && (o += 4294967296), o; - } - }); - var SWe = I((hfn, xWe) => { - "use strict"; - m(); - g(); - var bbe = Fm(), - _We = vbe(); - function D_() { - if (!(this instanceof D_)) return new D_(); - _We.call(this), - (this.h = [ - 3418070365, 3238371032, 1654270250, 914150663, 2438529370, 812702999, - 355462360, 4144912697, 1731405415, 4290775857, 2394180231, 1750603025, - 3675008525, 1694076839, 1203062813, 3204075428, - ]); - } - bbe.inherits(D_, _We); - xWe.exports = D_; - D_.blockSize = 1024; - D_.outSize = 384; - D_.hmacStrength = 192; - D_.padLength = 128; - D_.prototype._digest = function (e) { - return e === "hex" - ? bbe.toHex32(this.h.slice(0, 12), "big") - : bbe.split32(this.h.slice(0, 12), "big"); - }; - }); - var AWe = I((C5) => { - "use strict"; - m(); - g(); - C5.sha1 = fWe(); - C5.sha224 = mWe(); - C5.sha256 = pbe(); - C5.sha384 = SWe(); - C5.sha512 = vbe(); - }); - var OWe = I((PWe) => { - "use strict"; - m(); - g(); - var PM = Fm(), - lQt = P5(), - sX = PM.rotl32, - EWe = PM.sum32, - zq = PM.sum32_3, - MWe = PM.sum32_4, - kWe = lQt.BlockHash; - function wv() { - if (!(this instanceof wv)) return new wv(); - kWe.call(this), - (this.h = [1732584193, 4023233417, 2562383102, 271733878, 3285377520]), - (this.endian = "little"); - } - PM.inherits(wv, kWe); - PWe.ripemd160 = wv; - wv.blockSize = 512; - wv.outSize = 160; - wv.hmacStrength = 192; - wv.padLength = 64; - wv.prototype._update = function (e, r) { - for ( - var n = this.h[0], - i = this.h[1], - o = this.h[2], - a = this.h[3], - s = this.h[4], - c = n, - u = i, - h = o, - w = a, - M = s, - k = 0; - k < 80; - k++ - ) { - var O = EWe( - sX(MWe(n, TWe(k, i, o, a), e[hQt[k] + r], fQt(k)), yQt[k]), - s - ); - (n = s), - (s = a), - (a = sX(o, 10)), - (o = i), - (i = O), - (O = EWe( - sX(MWe(c, TWe(79 - k, u, h, w), e[pQt[k] + r], dQt(k)), mQt[k]), - M - )), - (c = M), - (M = w), - (w = sX(h, 10)), - (h = u), - (u = O); - } - (O = zq(this.h[1], o, w)), - (this.h[1] = zq(this.h[2], a, M)), - (this.h[2] = zq(this.h[3], s, c)), - (this.h[3] = zq(this.h[4], n, u)), - (this.h[4] = zq(this.h[0], i, h)), - (this.h[0] = O); - }; - wv.prototype._digest = function (e) { - return e === "hex" - ? PM.toHex32(this.h, "little") - : PM.split32(this.h, "little"); - }; - function TWe(t, e, r, n) { - return t <= 15 - ? e ^ r ^ n - : t <= 31 - ? (e & r) | (~e & n) - : t <= 47 - ? (e | ~r) ^ n - : t <= 63 - ? (e & n) | (r & ~n) - : e ^ (r | ~n); - } - function fQt(t) { - return t <= 15 - ? 0 - : t <= 31 - ? 1518500249 - : t <= 47 - ? 1859775393 - : t <= 63 - ? 2400959708 - : 2840853838; - } - function dQt(t) { - return t <= 15 - ? 1352829926 - : t <= 31 - ? 1548603684 - : t <= 47 - ? 1836072691 - : t <= 63 - ? 2053994217 - : 0; - } - var hQt = [ - 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 7, 4, 13, 1, 10, - 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8, 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, - 6, 13, 11, 5, 12, 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2, - 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13, - ], - pQt = [ - 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12, 6, 11, 3, 7, 0, - 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2, 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, - 12, 2, 10, 0, 4, 13, 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, - 14, 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11, - ], - yQt = [ - 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8, 7, 6, 8, 13, 11, - 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12, 11, 13, 6, 7, 14, 9, 13, 15, 14, - 8, 13, 6, 5, 12, 7, 5, 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, - 5, 12, 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6, - ], - mQt = [ - 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6, 9, 13, 15, 7, - 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11, 9, 7, 15, 11, 8, 6, 6, 14, 12, - 13, 5, 14, 13, 13, 7, 5, 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, - 5, 15, 8, 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11, - ]; - }); - var IWe = I((mfn, BWe) => { - "use strict"; - m(); - g(); - var gQt = Fm(), - vQt = Cp(); - function R5(t, e, r) { - if (!(this instanceof R5)) return new R5(t, e, r); - (this.Hash = t), - (this.blockSize = t.blockSize / 8), - (this.outSize = t.outSize / 8), - (this.inner = null), - (this.outer = null), - this._init(gQt.toArray(e, r)); - } - BWe.exports = R5; - R5.prototype._init = function (e) { - e.length > this.blockSize && (e = new this.Hash().update(e).digest()), - vQt(e.length <= this.blockSize); - for (var r = e.length; r < this.blockSize; r++) e.push(0); - for (r = 0; r < e.length; r++) e[r] ^= 54; - for (this.inner = new this.Hash().update(e), r = 0; r < e.length; r++) - e[r] ^= 106; - this.outer = new this.Hash().update(e); - }; - R5.prototype.update = function (e, r) { - return this.inner.update(e, r), this; - }; - R5.prototype.digest = function (e) { - return this.outer.update(this.inner.digest()), this.outer.digest(e); - }; - }); - var jq = I((CWe) => { - m(); - g(); - var tc = CWe; - tc.utils = Fm(); - tc.common = P5(); - tc.sha = AWe(); - tc.ripemd = OWe(); - tc.hmac = IWe(); - tc.sha1 = tc.sha.sha1; - tc.sha256 = tc.sha.sha256; - tc.sha224 = tc.sha.sha224; - tc.sha384 = tc.sha.sha384; - tc.sha512 = tc.sha.sha512; - tc.ripemd160 = tc.ripemd.ripemd160; - }); - var NWe = I((vfn, RWe) => { - m(); - g(); - RWe.exports = { - doubles: { - step: 4, - points: [ - [ - "e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a", - "f7e3507399e595929db99f34f57937101296891e44d23f0be1f32cce69616821", - ], - [ - "8282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508", - "11f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf", - ], - [ - "175e159f728b865a72f99cc6c6fc846de0b93833fd2222ed73fce5b551e5b739", - "d3506e0d9e3c79eba4ef97a51ff71f5eacb5955add24345c6efa6ffee9fed695", - ], - [ - "363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640", - "4e273adfc732221953b445397f3363145b9a89008199ecb62003c7f3bee9de9", - ], - [ - "8b4b5f165df3c2be8c6244b5b745638843e4a781a15bcd1b69f79a55dffdf80c", - "4aad0a6f68d308b4b3fbd7813ab0da04f9e336546162ee56b3eff0c65fd4fd36", - ], - [ - "723cbaa6e5db996d6bf771c00bd548c7b700dbffa6c0e77bcb6115925232fcda", - "96e867b5595cc498a921137488824d6e2660a0653779494801dc069d9eb39f5f", - ], - [ - "eebfa4d493bebf98ba5feec812c2d3b50947961237a919839a533eca0e7dd7fa", - "5d9a8ca3970ef0f269ee7edaf178089d9ae4cdc3a711f712ddfd4fdae1de8999", - ], - [ - "100f44da696e71672791d0a09b7bde459f1215a29b3c03bfefd7835b39a48db0", - "cdd9e13192a00b772ec8f3300c090666b7ff4a18ff5195ac0fbd5cd62bc65a09", - ], - [ - "e1031be262c7ed1b1dc9227a4a04c017a77f8d4464f3b3852c8acde6e534fd2d", - "9d7061928940405e6bb6a4176597535af292dd419e1ced79a44f18f29456a00d", - ], - [ - "feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d", - "e57c6b6c97dce1bab06e4e12bf3ecd5c981c8957cc41442d3155debf18090088", - ], - [ - "da67a91d91049cdcb367be4be6ffca3cfeed657d808583de33fa978bc1ec6cb1", - "9bacaa35481642bc41f463f7ec9780e5dec7adc508f740a17e9ea8e27a68be1d", - ], - [ - "53904faa0b334cdda6e000935ef22151ec08d0f7bb11069f57545ccc1a37b7c0", - "5bc087d0bc80106d88c9eccac20d3c1c13999981e14434699dcb096b022771c8", - ], - [ - "8e7bcd0bd35983a7719cca7764ca906779b53a043a9b8bcaeff959f43ad86047", - "10b7770b2a3da4b3940310420ca9514579e88e2e47fd68b3ea10047e8460372a", - ], - [ - "385eed34c1cdff21e6d0818689b81bde71a7f4f18397e6690a841e1599c43862", - "283bebc3e8ea23f56701de19e9ebf4576b304eec2086dc8cc0458fe5542e5453", - ], - [ - "6f9d9b803ecf191637c73a4413dfa180fddf84a5947fbc9c606ed86c3fac3a7", - "7c80c68e603059ba69b8e2a30e45c4d47ea4dd2f5c281002d86890603a842160", - ], - [ - "3322d401243c4e2582a2147c104d6ecbf774d163db0f5e5313b7e0e742d0e6bd", - "56e70797e9664ef5bfb019bc4ddaf9b72805f63ea2873af624f3a2e96c28b2a0", - ], - [ - "85672c7d2de0b7da2bd1770d89665868741b3f9af7643397721d74d28134ab83", - "7c481b9b5b43b2eb6374049bfa62c2e5e77f17fcc5298f44c8e3094f790313a6", - ], - [ - "948bf809b1988a46b06c9f1919413b10f9226c60f668832ffd959af60c82a0a", - "53a562856dcb6646dc6b74c5d1c3418c6d4dff08c97cd2bed4cb7f88d8c8e589", - ], - [ - "6260ce7f461801c34f067ce0f02873a8f1b0e44dfc69752accecd819f38fd8e8", - "bc2da82b6fa5b571a7f09049776a1ef7ecd292238051c198c1a84e95b2b4ae17", - ], - [ - "e5037de0afc1d8d43d8348414bbf4103043ec8f575bfdc432953cc8d2037fa2d", - "4571534baa94d3b5f9f98d09fb990bddbd5f5b03ec481f10e0e5dc841d755bda", - ], - [ - "e06372b0f4a207adf5ea905e8f1771b4e7e8dbd1c6a6c5b725866a0ae4fce725", - "7a908974bce18cfe12a27bb2ad5a488cd7484a7787104870b27034f94eee31dd", - ], - [ - "213c7a715cd5d45358d0bbf9dc0ce02204b10bdde2a3f58540ad6908d0559754", - "4b6dad0b5ae462507013ad06245ba190bb4850f5f36a7eeddff2c27534b458f2", - ], - [ - "4e7c272a7af4b34e8dbb9352a5419a87e2838c70adc62cddf0cc3a3b08fbd53c", - "17749c766c9d0b18e16fd09f6def681b530b9614bff7dd33e0b3941817dcaae6", - ], - [ - "fea74e3dbe778b1b10f238ad61686aa5c76e3db2be43057632427e2840fb27b6", - "6e0568db9b0b13297cf674deccb6af93126b596b973f7b77701d3db7f23cb96f", - ], - [ - "76e64113f677cf0e10a2570d599968d31544e179b760432952c02a4417bdde39", - "c90ddf8dee4e95cf577066d70681f0d35e2a33d2b56d2032b4b1752d1901ac01", - ], - [ - "c738c56b03b2abe1e8281baa743f8f9a8f7cc643df26cbee3ab150242bcbb891", - "893fb578951ad2537f718f2eacbfbbbb82314eef7880cfe917e735d9699a84c3", - ], - [ - "d895626548b65b81e264c7637c972877d1d72e5f3a925014372e9f6588f6c14b", - "febfaa38f2bc7eae728ec60818c340eb03428d632bb067e179363ed75d7d991f", - ], - [ - "b8da94032a957518eb0f6433571e8761ceffc73693e84edd49150a564f676e03", - "2804dfa44805a1e4d7c99cc9762808b092cc584d95ff3b511488e4e74efdf6e7", - ], - [ - "e80fea14441fb33a7d8adab9475d7fab2019effb5156a792f1a11778e3c0df5d", - "eed1de7f638e00771e89768ca3ca94472d155e80af322ea9fcb4291b6ac9ec78", - ], - [ - "a301697bdfcd704313ba48e51d567543f2a182031efd6915ddc07bbcc4e16070", - "7370f91cfb67e4f5081809fa25d40f9b1735dbf7c0a11a130c0d1a041e177ea1", - ], - [ - "90ad85b389d6b936463f9d0512678de208cc330b11307fffab7ac63e3fb04ed4", - "e507a3620a38261affdcbd9427222b839aefabe1582894d991d4d48cb6ef150", - ], - [ - "8f68b9d2f63b5f339239c1ad981f162ee88c5678723ea3351b7b444c9ec4c0da", - "662a9f2dba063986de1d90c2b6be215dbbea2cfe95510bfdf23cbf79501fff82", - ], - [ - "e4f3fb0176af85d65ff99ff9198c36091f48e86503681e3e6686fd5053231e11", - "1e63633ad0ef4f1c1661a6d0ea02b7286cc7e74ec951d1c9822c38576feb73bc", - ], - [ - "8c00fa9b18ebf331eb961537a45a4266c7034f2f0d4e1d0716fb6eae20eae29e", - "efa47267fea521a1a9dc343a3736c974c2fadafa81e36c54e7d2a4c66702414b", - ], - [ - "e7a26ce69dd4829f3e10cec0a9e98ed3143d084f308b92c0997fddfc60cb3e41", - "2a758e300fa7984b471b006a1aafbb18d0a6b2c0420e83e20e8a9421cf2cfd51", - ], - [ - "b6459e0ee3662ec8d23540c223bcbdc571cbcb967d79424f3cf29eb3de6b80ef", - "67c876d06f3e06de1dadf16e5661db3c4b3ae6d48e35b2ff30bf0b61a71ba45", - ], - [ - "d68a80c8280bb840793234aa118f06231d6f1fc67e73c5a5deda0f5b496943e8", - "db8ba9fff4b586d00c4b1f9177b0e28b5b0e7b8f7845295a294c84266b133120", - ], - [ - "324aed7df65c804252dc0270907a30b09612aeb973449cea4095980fc28d3d5d", - "648a365774b61f2ff130c0c35aec1f4f19213b0c7e332843967224af96ab7c84", - ], - [ - "4df9c14919cde61f6d51dfdbe5fee5dceec4143ba8d1ca888e8bd373fd054c96", - "35ec51092d8728050974c23a1d85d4b5d506cdc288490192ebac06cad10d5d", - ], - [ - "9c3919a84a474870faed8a9c1cc66021523489054d7f0308cbfc99c8ac1f98cd", - "ddb84f0f4a4ddd57584f044bf260e641905326f76c64c8e6be7e5e03d4fc599d", - ], - [ - "6057170b1dd12fdf8de05f281d8e06bb91e1493a8b91d4cc5a21382120a959e5", - "9a1af0b26a6a4807add9a2daf71df262465152bc3ee24c65e899be932385a2a8", - ], - [ - "a576df8e23a08411421439a4518da31880cef0fba7d4df12b1a6973eecb94266", - "40a6bf20e76640b2c92b97afe58cd82c432e10a7f514d9f3ee8be11ae1b28ec8", - ], - [ - "7778a78c28dec3e30a05fe9629de8c38bb30d1f5cf9a3a208f763889be58ad71", - "34626d9ab5a5b22ff7098e12f2ff580087b38411ff24ac563b513fc1fd9f43ac", - ], - [ - "928955ee637a84463729fd30e7afd2ed5f96274e5ad7e5cb09eda9c06d903ac", - "c25621003d3f42a827b78a13093a95eeac3d26efa8a8d83fc5180e935bcd091f", - ], - [ - "85d0fef3ec6db109399064f3a0e3b2855645b4a907ad354527aae75163d82751", - "1f03648413a38c0be29d496e582cf5663e8751e96877331582c237a24eb1f962", - ], - [ - "ff2b0dce97eece97c1c9b6041798b85dfdfb6d8882da20308f5404824526087e", - "493d13fef524ba188af4c4dc54d07936c7b7ed6fb90e2ceb2c951e01f0c29907", - ], - [ - "827fbbe4b1e880ea9ed2b2e6301b212b57f1ee148cd6dd28780e5e2cf856e241", - "c60f9c923c727b0b71bef2c67d1d12687ff7a63186903166d605b68baec293ec", - ], - [ - "eaa649f21f51bdbae7be4ae34ce6e5217a58fdce7f47f9aa7f3b58fa2120e2b3", - "be3279ed5bbbb03ac69a80f89879aa5a01a6b965f13f7e59d47a5305ba5ad93d", - ], - [ - "e4a42d43c5cf169d9391df6decf42ee541b6d8f0c9a137401e23632dda34d24f", - "4d9f92e716d1c73526fc99ccfb8ad34ce886eedfa8d8e4f13a7f7131deba9414", - ], - [ - "1ec80fef360cbdd954160fadab352b6b92b53576a88fea4947173b9d4300bf19", - "aeefe93756b5340d2f3a4958a7abbf5e0146e77f6295a07b671cdc1cc107cefd", - ], - [ - "146a778c04670c2f91b00af4680dfa8bce3490717d58ba889ddb5928366642be", - "b318e0ec3354028add669827f9d4b2870aaa971d2f7e5ed1d0b297483d83efd0", - ], - [ - "fa50c0f61d22e5f07e3acebb1aa07b128d0012209a28b9776d76a8793180eef9", - "6b84c6922397eba9b72cd2872281a68a5e683293a57a213b38cd8d7d3f4f2811", - ], - [ - "da1d61d0ca721a11b1a5bf6b7d88e8421a288ab5d5bba5220e53d32b5f067ec2", - "8157f55a7c99306c79c0766161c91e2966a73899d279b48a655fba0f1ad836f1", - ], - [ - "a8e282ff0c9706907215ff98e8fd416615311de0446f1e062a73b0610d064e13", - "7f97355b8db81c09abfb7f3c5b2515888b679a3e50dd6bd6cef7c73111f4cc0c", - ], - [ - "174a53b9c9a285872d39e56e6913cab15d59b1fa512508c022f382de8319497c", - "ccc9dc37abfc9c1657b4155f2c47f9e6646b3a1d8cb9854383da13ac079afa73", - ], - [ - "959396981943785c3d3e57edf5018cdbe039e730e4918b3d884fdff09475b7ba", - "2e7e552888c331dd8ba0386a4b9cd6849c653f64c8709385e9b8abf87524f2fd", - ], - [ - "d2a63a50ae401e56d645a1153b109a8fcca0a43d561fba2dbb51340c9d82b151", - "e82d86fb6443fcb7565aee58b2948220a70f750af484ca52d4142174dcf89405", - ], - [ - "64587e2335471eb890ee7896d7cfdc866bacbdbd3839317b3436f9b45617e073", - "d99fcdd5bf6902e2ae96dd6447c299a185b90a39133aeab358299e5e9faf6589", - ], - [ - "8481bde0e4e4d885b3a546d3e549de042f0aa6cea250e7fd358d6c86dd45e458", - "38ee7b8cba5404dd84a25bf39cecb2ca900a79c42b262e556d64b1b59779057e", - ], - [ - "13464a57a78102aa62b6979ae817f4637ffcfed3c4b1ce30bcd6303f6caf666b", - "69be159004614580ef7e433453ccb0ca48f300a81d0942e13f495a907f6ecc27", - ], - [ - "bc4a9df5b713fe2e9aef430bcc1dc97a0cd9ccede2f28588cada3a0d2d83f366", - "d3a81ca6e785c06383937adf4b798caa6e8a9fbfa547b16d758d666581f33c1", - ], - [ - "8c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa", - "40a30463a3305193378fedf31f7cc0eb7ae784f0451cb9459e71dc73cbef9482", - ], - [ - "8ea9666139527a8c1dd94ce4f071fd23c8b350c5a4bb33748c4ba111faccae0", - "620efabbc8ee2782e24e7c0cfb95c5d735b783be9cf0f8e955af34a30e62b945", - ], - [ - "dd3625faef5ba06074669716bbd3788d89bdde815959968092f76cc4eb9a9787", - "7a188fa3520e30d461da2501045731ca941461982883395937f68d00c644a573", - ], - [ - "f710d79d9eb962297e4f6232b40e8f7feb2bc63814614d692c12de752408221e", - "ea98e67232d3b3295d3b535532115ccac8612c721851617526ae47a9c77bfc82", - ], - ], - }, - naf: { - wnd: 7, - points: [ - [ - "f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9", - "388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672", - ], - [ - "2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4", - "d8ac222636e5e3d6d4dba9dda6c9c426f788271bab0d6840dca87d3aa6ac62d6", - ], - [ - "5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc", - "6aebca40ba255960a3178d6d861a54dba813d0b813fde7b5a5082628087264da", - ], - [ - "acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbe", - "cc338921b0a7d9fd64380971763b61e9add888a4375f8e0f05cc262ac64f9c37", - ], - [ - "774ae7f858a9411e5ef4246b70c65aac5649980be5c17891bbec17895da008cb", - "d984a032eb6b5e190243dd56d7b7b365372db1e2dff9d6a8301d74c9c953c61b", - ], - [ - "f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8", - "ab0902e8d880a89758212eb65cdaf473a1a06da521fa91f29b5cb52db03ed81", - ], - [ - "d7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e", - "581e2872a86c72a683842ec228cc6defea40af2bd896d3a5c504dc9ff6a26b58", - ], - [ - "defdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34", - "4211ab0694635168e997b0ead2a93daeced1f4a04a95c0f6cfb199f69e56eb77", - ], - [ - "2b4ea0a797a443d293ef5cff444f4979f06acfebd7e86d277475656138385b6c", - "85e89bc037945d93b343083b5a1c86131a01f60c50269763b570c854e5c09b7a", - ], - [ - "352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5", - "321eb4075348f534d59c18259dda3e1f4a1b3b2e71b1039c67bd3d8bcf81998c", - ], - [ - "2fa2104d6b38d11b0230010559879124e42ab8dfeff5ff29dc9cdadd4ecacc3f", - "2de1068295dd865b64569335bd5dd80181d70ecfc882648423ba76b532b7d67", - ], - [ - "9248279b09b4d68dab21a9b066edda83263c3d84e09572e269ca0cd7f5453714", - "73016f7bf234aade5d1aa71bdea2b1ff3fc0de2a887912ffe54a32ce97cb3402", - ], - [ - "daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729", - "a69dce4a7d6c98e8d4a1aca87ef8d7003f83c230f3afa726ab40e52290be1c55", - ], - [ - "c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db", - "2119a460ce326cdc76c45926c982fdac0e106e861edf61c5a039063f0e0e6482", - ], - [ - "6a245bf6dc698504c89a20cfded60853152b695336c28063b61c65cbd269e6b4", - "e022cf42c2bd4a708b3f5126f16a24ad8b33ba48d0423b6efd5e6348100d8a82", - ], - [ - "1697ffa6fd9de627c077e3d2fe541084ce13300b0bec1146f95ae57f0d0bd6a5", - "b9c398f186806f5d27561506e4557433a2cf15009e498ae7adee9d63d01b2396", - ], - [ - "605bdb019981718b986d0f07e834cb0d9deb8360ffb7f61df982345ef27a7479", - "2972d2de4f8d20681a78d93ec96fe23c26bfae84fb14db43b01e1e9056b8c49", - ], - [ - "62d14dab4150bf497402fdc45a215e10dcb01c354959b10cfe31c7e9d87ff33d", - "80fc06bd8cc5b01098088a1950eed0db01aa132967ab472235f5642483b25eaf", - ], - [ - "80c60ad0040f27dade5b4b06c408e56b2c50e9f56b9b8b425e555c2f86308b6f", - "1c38303f1cc5c30f26e66bad7fe72f70a65eed4cbe7024eb1aa01f56430bd57a", - ], - [ - "7a9375ad6167ad54aa74c6348cc54d344cc5dc9487d847049d5eabb0fa03c8fb", - "d0e3fa9eca8726909559e0d79269046bdc59ea10c70ce2b02d499ec224dc7f7", - ], - [ - "d528ecd9b696b54c907a9ed045447a79bb408ec39b68df504bb51f459bc3ffc9", - "eecf41253136e5f99966f21881fd656ebc4345405c520dbc063465b521409933", - ], - [ - "49370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963", - "758f3f41afd6ed428b3081b0512fd62a54c3f3afbb5b6764b653052a12949c9a", - ], - [ - "77f230936ee88cbbd73df930d64702ef881d811e0e1498e2f1c13eb1fc345d74", - "958ef42a7886b6400a08266e9ba1b37896c95330d97077cbbe8eb3c7671c60d6", - ], - [ - "f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530", - "e0dedc9b3b2f8dad4da1f32dec2531df9eb5fbeb0598e4fd1a117dba703a3c37", - ], - [ - "463b3d9f662621fb1b4be8fbbe2520125a216cdfc9dae3debcba4850c690d45b", - "5ed430d78c296c3543114306dd8622d7c622e27c970a1de31cb377b01af7307e", - ], - [ - "f16f804244e46e2a09232d4aff3b59976b98fac14328a2d1a32496b49998f247", - "cedabd9b82203f7e13d206fcdf4e33d92a6c53c26e5cce26d6579962c4e31df6", - ], - [ - "caf754272dc84563b0352b7a14311af55d245315ace27c65369e15f7151d41d1", - "cb474660ef35f5f2a41b643fa5e460575f4fa9b7962232a5c32f908318a04476", - ], - [ - "2600ca4b282cb986f85d0f1709979d8b44a09c07cb86d7c124497bc86f082120", - "4119b88753c15bd6a693b03fcddbb45d5ac6be74ab5f0ef44b0be9475a7e4b40", - ], - [ - "7635ca72d7e8432c338ec53cd12220bc01c48685e24f7dc8c602a7746998e435", - "91b649609489d613d1d5e590f78e6d74ecfc061d57048bad9e76f302c5b9c61", - ], - [ - "754e3239f325570cdbbf4a87deee8a66b7f2b33479d468fbc1a50743bf56cc18", - "673fb86e5bda30fb3cd0ed304ea49a023ee33d0197a695d0c5d98093c536683", - ], - [ - "e3e6bd1071a1e96aff57859c82d570f0330800661d1c952f9fe2694691d9b9e8", - "59c9e0bba394e76f40c0aa58379a3cb6a5a2283993e90c4167002af4920e37f5", - ], - [ - "186b483d056a033826ae73d88f732985c4ccb1f32ba35f4b4cc47fdcf04aa6eb", - "3b952d32c67cf77e2e17446e204180ab21fb8090895138b4a4a797f86e80888b", - ], - [ - "df9d70a6b9876ce544c98561f4be4f725442e6d2b737d9c91a8321724ce0963f", - "55eb2dafd84d6ccd5f862b785dc39d4ab157222720ef9da217b8c45cf2ba2417", - ], - [ - "5edd5cc23c51e87a497ca815d5dce0f8ab52554f849ed8995de64c5f34ce7143", - "efae9c8dbc14130661e8cec030c89ad0c13c66c0d17a2905cdc706ab7399a868", - ], - [ - "290798c2b6476830da12fe02287e9e777aa3fba1c355b17a722d362f84614fba", - "e38da76dcd440621988d00bcf79af25d5b29c094db2a23146d003afd41943e7a", - ], - [ - "af3c423a95d9f5b3054754efa150ac39cd29552fe360257362dfdecef4053b45", - "f98a3fd831eb2b749a93b0e6f35cfb40c8cd5aa667a15581bc2feded498fd9c6", - ], - [ - "766dbb24d134e745cccaa28c99bf274906bb66b26dcf98df8d2fed50d884249a", - "744b1152eacbe5e38dcc887980da38b897584a65fa06cedd2c924f97cbac5996", - ], - [ - "59dbf46f8c94759ba21277c33784f41645f7b44f6c596a58ce92e666191abe3e", - "c534ad44175fbc300f4ea6ce648309a042ce739a7919798cd85e216c4a307f6e", - ], - [ - "f13ada95103c4537305e691e74e9a4a8dd647e711a95e73cb62dc6018cfd87b8", - "e13817b44ee14de663bf4bc808341f326949e21a6a75c2570778419bdaf5733d", - ], - [ - "7754b4fa0e8aced06d4167a2c59cca4cda1869c06ebadfb6488550015a88522c", - "30e93e864e669d82224b967c3020b8fa8d1e4e350b6cbcc537a48b57841163a2", - ], - [ - "948dcadf5990e048aa3874d46abef9d701858f95de8041d2a6828c99e2262519", - "e491a42537f6e597d5d28a3224b1bc25df9154efbd2ef1d2cbba2cae5347d57e", - ], - [ - "7962414450c76c1689c7b48f8202ec37fb224cf5ac0bfa1570328a8a3d7c77ab", - "100b610ec4ffb4760d5c1fc133ef6f6b12507a051f04ac5760afa5b29db83437", - ], - [ - "3514087834964b54b15b160644d915485a16977225b8847bb0dd085137ec47ca", - "ef0afbb2056205448e1652c48e8127fc6039e77c15c2378b7e7d15a0de293311", - ], - [ - "d3cc30ad6b483e4bc79ce2c9dd8bc54993e947eb8df787b442943d3f7b527eaf", - "8b378a22d827278d89c5e9be8f9508ae3c2ad46290358630afb34db04eede0a4", - ], - [ - "1624d84780732860ce1c78fcbfefe08b2b29823db913f6493975ba0ff4847610", - "68651cf9b6da903e0914448c6cd9d4ca896878f5282be4c8cc06e2a404078575", - ], - [ - "733ce80da955a8a26902c95633e62a985192474b5af207da6df7b4fd5fc61cd4", - "f5435a2bd2badf7d485a4d8b8db9fcce3e1ef8e0201e4578c54673bc1dc5ea1d", - ], - [ - "15d9441254945064cf1a1c33bbd3b49f8966c5092171e699ef258dfab81c045c", - "d56eb30b69463e7234f5137b73b84177434800bacebfc685fc37bbe9efe4070d", - ], - [ - "a1d0fcf2ec9de675b612136e5ce70d271c21417c9d2b8aaaac138599d0717940", - "edd77f50bcb5a3cab2e90737309667f2641462a54070f3d519212d39c197a629", - ], - [ - "e22fbe15c0af8ccc5780c0735f84dbe9a790badee8245c06c7ca37331cb36980", - "a855babad5cd60c88b430a69f53a1a7a38289154964799be43d06d77d31da06", - ], - [ - "311091dd9860e8e20ee13473c1155f5f69635e394704eaa74009452246cfa9b3", - "66db656f87d1f04fffd1f04788c06830871ec5a64feee685bd80f0b1286d8374", - ], - [ - "34c1fd04d301be89b31c0442d3e6ac24883928b45a9340781867d4232ec2dbdf", - "9414685e97b1b5954bd46f730174136d57f1ceeb487443dc5321857ba73abee", - ], - [ - "f219ea5d6b54701c1c14de5b557eb42a8d13f3abbcd08affcc2a5e6b049b8d63", - "4cb95957e83d40b0f73af4544cccf6b1f4b08d3c07b27fb8d8c2962a400766d1", - ], - [ - "d7b8740f74a8fbaab1f683db8f45de26543a5490bca627087236912469a0b448", - "fa77968128d9c92ee1010f337ad4717eff15db5ed3c049b3411e0315eaa4593b", - ], - [ - "32d31c222f8f6f0ef86f7c98d3a3335ead5bcd32abdd94289fe4d3091aa824bf", - "5f3032f5892156e39ccd3d7915b9e1da2e6dac9e6f26e961118d14b8462e1661", - ], - [ - "7461f371914ab32671045a155d9831ea8793d77cd59592c4340f86cbc18347b5", - "8ec0ba238b96bec0cbdddcae0aa442542eee1ff50c986ea6b39847b3cc092ff6", - ], - [ - "ee079adb1df1860074356a25aa38206a6d716b2c3e67453d287698bad7b2b2d6", - "8dc2412aafe3be5c4c5f37e0ecc5f9f6a446989af04c4e25ebaac479ec1c8c1e", - ], - [ - "16ec93e447ec83f0467b18302ee620f7e65de331874c9dc72bfd8616ba9da6b5", - "5e4631150e62fb40d0e8c2a7ca5804a39d58186a50e497139626778e25b0674d", - ], - [ - "eaa5f980c245f6f038978290afa70b6bd8855897f98b6aa485b96065d537bd99", - "f65f5d3e292c2e0819a528391c994624d784869d7e6ea67fb18041024edc07dc", - ], - [ - "78c9407544ac132692ee1910a02439958ae04877151342ea96c4b6b35a49f51", - "f3e0319169eb9b85d5404795539a5e68fa1fbd583c064d2462b675f194a3ddb4", - ], - [ - "494f4be219a1a77016dcd838431aea0001cdc8ae7a6fc688726578d9702857a5", - "42242a969283a5f339ba7f075e36ba2af925ce30d767ed6e55f4b031880d562c", - ], - [ - "a598a8030da6d86c6bc7f2f5144ea549d28211ea58faa70ebf4c1e665c1fe9b5", - "204b5d6f84822c307e4b4a7140737aec23fc63b65b35f86a10026dbd2d864e6b", - ], - [ - "c41916365abb2b5d09192f5f2dbeafec208f020f12570a184dbadc3e58595997", - "4f14351d0087efa49d245b328984989d5caf9450f34bfc0ed16e96b58fa9913", - ], - [ - "841d6063a586fa475a724604da03bc5b92a2e0d2e0a36acfe4c73a5514742881", - "73867f59c0659e81904f9a1c7543698e62562d6744c169ce7a36de01a8d6154", - ], - [ - "5e95bb399a6971d376026947f89bde2f282b33810928be4ded112ac4d70e20d5", - "39f23f366809085beebfc71181313775a99c9aed7d8ba38b161384c746012865", - ], - [ - "36e4641a53948fd476c39f8a99fd974e5ec07564b5315d8bf99471bca0ef2f66", - "d2424b1b1abe4eb8164227b085c9aa9456ea13493fd563e06fd51cf5694c78fc", - ], - [ - "336581ea7bfbbb290c191a2f507a41cf5643842170e914faeab27c2c579f726", - "ead12168595fe1be99252129b6e56b3391f7ab1410cd1e0ef3dcdcabd2fda224", - ], - [ - "8ab89816dadfd6b6a1f2634fcf00ec8403781025ed6890c4849742706bd43ede", - "6fdcef09f2f6d0a044e654aef624136f503d459c3e89845858a47a9129cdd24e", - ], - [ - "1e33f1a746c9c5778133344d9299fcaa20b0938e8acff2544bb40284b8c5fb94", - "60660257dd11b3aa9c8ed618d24edff2306d320f1d03010e33a7d2057f3b3b6", - ], - [ - "85b7c1dcb3cec1b7ee7f30ded79dd20a0ed1f4cc18cbcfcfa410361fd8f08f31", - "3d98a9cdd026dd43f39048f25a8847f4fcafad1895d7a633c6fed3c35e999511", - ], - [ - "29df9fbd8d9e46509275f4b125d6d45d7fbe9a3b878a7af872a2800661ac5f51", - "b4c4fe99c775a606e2d8862179139ffda61dc861c019e55cd2876eb2a27d84b", - ], - [ - "a0b1cae06b0a847a3fea6e671aaf8adfdfe58ca2f768105c8082b2e449fce252", - "ae434102edde0958ec4b19d917a6a28e6b72da1834aff0e650f049503a296cf2", - ], - [ - "4e8ceafb9b3e9a136dc7ff67e840295b499dfb3b2133e4ba113f2e4c0e121e5", - "cf2174118c8b6d7a4b48f6d534ce5c79422c086a63460502b827ce62a326683c", - ], - [ - "d24a44e047e19b6f5afb81c7ca2f69080a5076689a010919f42725c2b789a33b", - "6fb8d5591b466f8fc63db50f1c0f1c69013f996887b8244d2cdec417afea8fa3", - ], - [ - "ea01606a7a6c9cdd249fdfcfacb99584001edd28abbab77b5104e98e8e3b35d4", - "322af4908c7312b0cfbfe369f7a7b3cdb7d4494bc2823700cfd652188a3ea98d", - ], - [ - "af8addbf2b661c8a6c6328655eb96651252007d8c5ea31be4ad196de8ce2131f", - "6749e67c029b85f52a034eafd096836b2520818680e26ac8f3dfbcdb71749700", - ], - [ - "e3ae1974566ca06cc516d47e0fb165a674a3dabcfca15e722f0e3450f45889", - "2aeabe7e4531510116217f07bf4d07300de97e4874f81f533420a72eeb0bd6a4", - ], - [ - "591ee355313d99721cf6993ffed1e3e301993ff3ed258802075ea8ced397e246", - "b0ea558a113c30bea60fc4775460c7901ff0b053d25ca2bdeee98f1a4be5d196", - ], - [ - "11396d55fda54c49f19aa97318d8da61fa8584e47b084945077cf03255b52984", - "998c74a8cd45ac01289d5833a7beb4744ff536b01b257be4c5767bea93ea57a4", - ], - [ - "3c5d2a1ba39c5a1790000738c9e0c40b8dcdfd5468754b6405540157e017aa7a", - "b2284279995a34e2f9d4de7396fc18b80f9b8b9fdd270f6661f79ca4c81bd257", - ], - [ - "cc8704b8a60a0defa3a99a7299f2e9c3fbc395afb04ac078425ef8a1793cc030", - "bdd46039feed17881d1e0862db347f8cf395b74fc4bcdc4e940b74e3ac1f1b13", - ], - [ - "c533e4f7ea8555aacd9777ac5cad29b97dd4defccc53ee7ea204119b2889b197", - "6f0a256bc5efdf429a2fb6242f1a43a2d9b925bb4a4b3a26bb8e0f45eb596096", - ], - [ - "c14f8f2ccb27d6f109f6d08d03cc96a69ba8c34eec07bbcf566d48e33da6593", - "c359d6923bb398f7fd4473e16fe1c28475b740dd098075e6c0e8649113dc3a38", - ], - [ - "a6cbc3046bc6a450bac24789fa17115a4c9739ed75f8f21ce441f72e0b90e6ef", - "21ae7f4680e889bb130619e2c0f95a360ceb573c70603139862afd617fa9b9f", - ], - [ - "347d6d9a02c48927ebfb86c1359b1caf130a3c0267d11ce6344b39f99d43cc38", - "60ea7f61a353524d1c987f6ecec92f086d565ab687870cb12689ff1e31c74448", - ], - [ - "da6545d2181db8d983f7dcb375ef5866d47c67b1bf31c8cf855ef7437b72656a", - "49b96715ab6878a79e78f07ce5680c5d6673051b4935bd897fea824b77dc208a", - ], - [ - "c40747cc9d012cb1a13b8148309c6de7ec25d6945d657146b9d5994b8feb1111", - "5ca560753be2a12fc6de6caf2cb489565db936156b9514e1bb5e83037e0fa2d4", - ], - [ - "4e42c8ec82c99798ccf3a610be870e78338c7f713348bd34c8203ef4037f3502", - "7571d74ee5e0fb92a7a8b33a07783341a5492144cc54bcc40a94473693606437", - ], - [ - "3775ab7089bc6af823aba2e1af70b236d251cadb0c86743287522a1b3b0dedea", - "be52d107bcfa09d8bcb9736a828cfa7fac8db17bf7a76a2c42ad961409018cf7", - ], - [ - "cee31cbf7e34ec379d94fb814d3d775ad954595d1314ba8846959e3e82f74e26", - "8fd64a14c06b589c26b947ae2bcf6bfa0149ef0be14ed4d80f448a01c43b1c6d", - ], - [ - "b4f9eaea09b6917619f6ea6a4eb5464efddb58fd45b1ebefcdc1a01d08b47986", - "39e5c9925b5a54b07433a4f18c61726f8bb131c012ca542eb24a8ac07200682a", - ], - [ - "d4263dfc3d2df923a0179a48966d30ce84e2515afc3dccc1b77907792ebcc60e", - "62dfaf07a0f78feb30e30d6295853ce189e127760ad6cf7fae164e122a208d54", - ], - [ - "48457524820fa65a4f8d35eb6930857c0032acc0a4a2de422233eeda897612c4", - "25a748ab367979d98733c38a1fa1c2e7dc6cc07db2d60a9ae7a76aaa49bd0f77", - ], - [ - "dfeeef1881101f2cb11644f3a2afdfc2045e19919152923f367a1767c11cceda", - "ecfb7056cf1de042f9420bab396793c0c390bde74b4bbdff16a83ae09a9a7517", - ], - [ - "6d7ef6b17543f8373c573f44e1f389835d89bcbc6062ced36c82df83b8fae859", - "cd450ec335438986dfefa10c57fea9bcc521a0959b2d80bbf74b190dca712d10", - ], - [ - "e75605d59102a5a2684500d3b991f2e3f3c88b93225547035af25af66e04541f", - "f5c54754a8f71ee540b9b48728473e314f729ac5308b06938360990e2bfad125", - ], - [ - "eb98660f4c4dfaa06a2be453d5020bc99a0c2e60abe388457dd43fefb1ed620c", - "6cb9a8876d9cb8520609af3add26cd20a0a7cd8a9411131ce85f44100099223e", - ], - [ - "13e87b027d8514d35939f2e6892b19922154596941888336dc3563e3b8dba942", - "fef5a3c68059a6dec5d624114bf1e91aac2b9da568d6abeb2570d55646b8adf1", - ], - [ - "ee163026e9fd6fe017c38f06a5be6fc125424b371ce2708e7bf4491691e5764a", - "1acb250f255dd61c43d94ccc670d0f58f49ae3fa15b96623e5430da0ad6c62b2", - ], - [ - "b268f5ef9ad51e4d78de3a750c2dc89b1e626d43505867999932e5db33af3d80", - "5f310d4b3c99b9ebb19f77d41c1dee018cf0d34fd4191614003e945a1216e423", - ], - [ - "ff07f3118a9df035e9fad85eb6c7bfe42b02f01ca99ceea3bf7ffdba93c4750d", - "438136d603e858a3a5c440c38eccbaddc1d2942114e2eddd4740d098ced1f0d8", - ], - [ - "8d8b9855c7c052a34146fd20ffb658bea4b9f69e0d825ebec16e8c3ce2b526a1", - "cdb559eedc2d79f926baf44fb84ea4d44bcf50fee51d7ceb30e2e7f463036758", - ], - [ - "52db0b5384dfbf05bfa9d472d7ae26dfe4b851ceca91b1eba54263180da32b63", - "c3b997d050ee5d423ebaf66a6db9f57b3180c902875679de924b69d84a7b375", - ], - [ - "e62f9490d3d51da6395efd24e80919cc7d0f29c3f3fa48c6fff543becbd43352", - "6d89ad7ba4876b0b22c2ca280c682862f342c8591f1daf5170e07bfd9ccafa7d", - ], - [ - "7f30ea2476b399b4957509c88f77d0191afa2ff5cb7b14fd6d8e7d65aaab1193", - "ca5ef7d4b231c94c3b15389a5f6311e9daff7bb67b103e9880ef4bff637acaec", - ], - [ - "5098ff1e1d9f14fb46a210fada6c903fef0fb7b4a1dd1d9ac60a0361800b7a00", - "9731141d81fc8f8084d37c6e7542006b3ee1b40d60dfe5362a5b132fd17ddc0", - ], - [ - "32b78c7de9ee512a72895be6b9cbefa6e2f3c4ccce445c96b9f2c81e2778ad58", - "ee1849f513df71e32efc3896ee28260c73bb80547ae2275ba497237794c8753c", - ], - [ - "e2cb74fddc8e9fbcd076eef2a7c72b0ce37d50f08269dfc074b581550547a4f7", - "d3aa2ed71c9dd2247a62df062736eb0baddea9e36122d2be8641abcb005cc4a4", - ], - [ - "8438447566d4d7bedadc299496ab357426009a35f235cb141be0d99cd10ae3a8", - "c4e1020916980a4da5d01ac5e6ad330734ef0d7906631c4f2390426b2edd791f", - ], - [ - "4162d488b89402039b584c6fc6c308870587d9c46f660b878ab65c82c711d67e", - "67163e903236289f776f22c25fb8a3afc1732f2b84b4e95dbda47ae5a0852649", - ], - [ - "3fad3fa84caf0f34f0f89bfd2dcf54fc175d767aec3e50684f3ba4a4bf5f683d", - "cd1bc7cb6cc407bb2f0ca647c718a730cf71872e7d0d2a53fa20efcdfe61826", - ], - [ - "674f2600a3007a00568c1a7ce05d0816c1fb84bf1370798f1c69532faeb1a86b", - "299d21f9413f33b3edf43b257004580b70db57da0b182259e09eecc69e0d38a5", - ], - [ - "d32f4da54ade74abb81b815ad1fb3b263d82d6c692714bcff87d29bd5ee9f08f", - "f9429e738b8e53b968e99016c059707782e14f4535359d582fc416910b3eea87", - ], - [ - "30e4e670435385556e593657135845d36fbb6931f72b08cb1ed954f1e3ce3ff6", - "462f9bce619898638499350113bbc9b10a878d35da70740dc695a559eb88db7b", - ], - [ - "be2062003c51cc3004682904330e4dee7f3dcd10b01e580bf1971b04d4cad297", - "62188bc49d61e5428573d48a74e1c655b1c61090905682a0d5558ed72dccb9bc", - ], - [ - "93144423ace3451ed29e0fb9ac2af211cb6e84a601df5993c419859fff5df04a", - "7c10dfb164c3425f5c71a3f9d7992038f1065224f72bb9d1d902a6d13037b47c", - ], - [ - "b015f8044f5fcbdcf21ca26d6c34fb8197829205c7b7d2a7cb66418c157b112c", - "ab8c1e086d04e813744a655b2df8d5f83b3cdc6faa3088c1d3aea1454e3a1d5f", - ], - [ - "d5e9e1da649d97d89e4868117a465a3a4f8a18de57a140d36b3f2af341a21b52", - "4cb04437f391ed73111a13cc1d4dd0db1693465c2240480d8955e8592f27447a", - ], - [ - "d3ae41047dd7ca065dbf8ed77b992439983005cd72e16d6f996a5316d36966bb", - "bd1aeb21ad22ebb22a10f0303417c6d964f8cdd7df0aca614b10dc14d125ac46", - ], - [ - "463e2763d885f958fc66cdd22800f0a487197d0a82e377b49f80af87c897b065", - "bfefacdb0e5d0fd7df3a311a94de062b26b80c61fbc97508b79992671ef7ca7f", - ], - [ - "7985fdfd127c0567c6f53ec1bb63ec3158e597c40bfe747c83cddfc910641917", - "603c12daf3d9862ef2b25fe1de289aed24ed291e0ec6708703a5bd567f32ed03", - ], - [ - "74a1ad6b5f76e39db2dd249410eac7f99e74c59cb83d2d0ed5ff1543da7703e9", - "cc6157ef18c9c63cd6193d83631bbea0093e0968942e8c33d5737fd790e0db08", - ], - [ - "30682a50703375f602d416664ba19b7fc9bab42c72747463a71d0896b22f6da3", - "553e04f6b018b4fa6c8f39e7f311d3176290d0e0f19ca73f17714d9977a22ff8", - ], - [ - "9e2158f0d7c0d5f26c3791efefa79597654e7a2b2464f52b1ee6c1347769ef57", - "712fcdd1b9053f09003a3481fa7762e9ffd7c8ef35a38509e2fbf2629008373", - ], - [ - "176e26989a43c9cfeba4029c202538c28172e566e3c4fce7322857f3be327d66", - "ed8cc9d04b29eb877d270b4878dc43c19aefd31f4eee09ee7b47834c1fa4b1c3", - ], - [ - "75d46efea3771e6e68abb89a13ad747ecf1892393dfc4f1b7004788c50374da8", - "9852390a99507679fd0b86fd2b39a868d7efc22151346e1a3ca4726586a6bed8", - ], - [ - "809a20c67d64900ffb698c4c825f6d5f2310fb0451c869345b7319f645605721", - "9e994980d9917e22b76b061927fa04143d096ccc54963e6a5ebfa5f3f8e286c1", - ], - [ - "1b38903a43f7f114ed4500b4eac7083fdefece1cf29c63528d563446f972c180", - "4036edc931a60ae889353f77fd53de4a2708b26b6f5da72ad3394119daf408f9", - ], - ], - }, - }; - }); - var uX = I((LWe) => { - "use strict"; - m(); - g(); - var _be = LWe, - m2 = jq(), - wbe = fbe(), - bQt = Np(), - DWe = bQt.assert; - function FWe(t) { - t.type === "short" - ? (this.curve = new wbe.short(t)) - : t.type === "edwards" - ? (this.curve = new wbe.edwards(t)) - : (this.curve = new wbe.mont(t)), - (this.g = this.curve.g), - (this.n = this.curve.n), - (this.hash = t.hash), - DWe(this.g.validate(), "Invalid curve"), - DWe(this.g.mul(this.n).isInfinity(), "Invalid curve, G*N != O"); - } - _be.PresetCurve = FWe; - function g2(t, e) { - Object.defineProperty(_be, t, { - configurable: !0, - enumerable: !0, - get: function () { - var r = new FWe(e); - return ( - Object.defineProperty(_be, t, { - configurable: !0, - enumerable: !0, - value: r, - }), - r - ); - }, - }); - } - g2("p192", { - type: "short", - prime: "p192", - p: "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff", - a: "ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc", - b: "64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1", - n: "ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831", - hash: m2.sha256, - gRed: !1, - g: [ - "188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012", - "07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811", - ], - }); - g2("p224", { - type: "short", - prime: "p224", - p: "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001", - a: "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe", - b: "b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4", - n: "ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d", - hash: m2.sha256, - gRed: !1, - g: [ - "b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21", - "bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34", - ], - }); - g2("p256", { - type: "short", - prime: null, - p: "ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff", - a: "ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc", - b: "5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b", - n: "ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551", - hash: m2.sha256, - gRed: !1, - g: [ - "6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296", - "4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5", - ], - }); - g2("p384", { - type: "short", - prime: null, - p: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe ffffffff 00000000 00000000 ffffffff", - a: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe ffffffff 00000000 00000000 fffffffc", - b: "b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f 5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef", - n: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 f4372ddf 581a0db2 48b0a77a ecec196a ccc52973", - hash: m2.sha384, - gRed: !1, - g: [ - "aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 5502f25d bf55296c 3a545e38 72760ab7", - "3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 0a60b1ce 1d7e819d 7a431d7c 90ea0e5f", - ], - }); - g2("p521", { - type: "short", - prime: null, - p: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff", - a: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffc", - b: "00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b 99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd 3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00", - n: "000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409", - hash: m2.sha512, - gRed: !1, - g: [ - "000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66", - "00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 3fad0761 353c7086 a272c240 88be9476 9fd16650", - ], - }); - g2("curve25519", { - type: "mont", - prime: "p25519", - p: "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed", - a: "76d06", - b: "1", - n: "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed", - hash: m2.sha256, - gRed: !1, - g: ["9"], - }); - g2("ed25519", { - type: "edwards", - prime: "p25519", - p: "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed", - a: "-1", - c: "1", - d: "52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3", - n: "1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed", - hash: m2.sha256, - gRed: !1, - g: [ - "216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a", - "6666666666666666666666666666666666666666666666666666666666666658", - ], - }); - var xbe; - try { - xbe = NWe(); - } catch { - xbe = void 0; - } - g2("secp256k1", { - type: "short", - prime: "k256", - p: "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f", - a: "0", - b: "7", - n: "ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141", - h: "1", - hash: m2.sha256, - beta: "7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee", - lambda: - "5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72", - basis: [ - { - a: "3086d221a7d46bcde86c90e49284eb15", - b: "-e4437ed6010e88286f547fa90abfe4c3", - }, - { - a: "114ca50f7a8e2f3f657c1108d9d44cfd8", - b: "3086d221a7d46bcde86c90e49284eb15", - }, - ], - gRed: !1, - g: [ - "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798", - "483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8", - xbe, - ], - }); - }); - var jWe = I((wfn, zWe) => { - "use strict"; - m(); - g(); - var wQt = jq(), - OM = cbe(), - qWe = Cp(); - function v2(t) { - if (!(this instanceof v2)) return new v2(t); - (this.hash = t.hash), - (this.predResist = !!t.predResist), - (this.outLen = this.hash.outSize), - (this.minEntropy = t.minEntropy || this.hash.hmacStrength), - (this._reseed = null), - (this.reseedInterval = null), - (this.K = null), - (this.V = null); - var e = OM.toArray(t.entropy, t.entropyEnc || "hex"), - r = OM.toArray(t.nonce, t.nonceEnc || "hex"), - n = OM.toArray(t.pers, t.persEnc || "hex"); - qWe( - e.length >= this.minEntropy / 8, - "Not enough entropy. Minimum is: " + this.minEntropy + " bits" - ), - this._init(e, r, n); - } - zWe.exports = v2; - v2.prototype._init = function (e, r, n) { - var i = e.concat(r).concat(n); - (this.K = new Array(this.outLen / 8)), - (this.V = new Array(this.outLen / 8)); - for (var o = 0; o < this.V.length; o++) (this.K[o] = 0), (this.V[o] = 1); - this._update(i), - (this._reseed = 1), - (this.reseedInterval = 281474976710656); - }; - v2.prototype._hmac = function () { - return new wQt.hmac(this.hash, this.K); - }; - v2.prototype._update = function (e) { - var r = this._hmac().update(this.V).update([0]); - e && (r = r.update(e)), - (this.K = r.digest()), - (this.V = this._hmac().update(this.V).digest()), - e && - ((this.K = this._hmac() - .update(this.V) - .update([1]) - .update(e) - .digest()), - (this.V = this._hmac().update(this.V).digest())); - }; - v2.prototype.reseed = function (e, r, n, i) { - typeof r != "string" && ((i = n), (n = r), (r = null)), - (e = OM.toArray(e, r)), - (n = OM.toArray(n, i)), - qWe( - e.length >= this.minEntropy / 8, - "Not enough entropy. Minimum is: " + this.minEntropy + " bits" - ), - this._update(e.concat(n || [])), - (this._reseed = 1); - }; - v2.prototype.generate = function (e, r, n, i) { - if (this._reseed > this.reseedInterval) - throw new Error("Reseed is required"); - typeof r != "string" && ((i = n), (n = r), (r = null)), - n && ((n = OM.toArray(n, i || "hex")), this._update(n)); - for (var o = []; o.length < e; ) - (this.V = this._hmac().update(this.V).digest()), (o = o.concat(this.V)); - var a = o.slice(0, e); - return this._update(n), this._reseed++, OM.encode(a, r); - }; - }); - var KWe = I((_fn, UWe) => { - "use strict"; - m(); - g(); - var _Qt = hv(), - xQt = Np(), - Sbe = xQt.assert; - function qc(t, e) { - (this.ec = t), - (this.priv = null), - (this.pub = null), - e.priv && this._importPrivate(e.priv, e.privEnc), - e.pub && this._importPublic(e.pub, e.pubEnc); - } - UWe.exports = qc; - qc.fromPublic = function (e, r, n) { - return r instanceof qc ? r : new qc(e, { pub: r, pubEnc: n }); - }; - qc.fromPrivate = function (e, r, n) { - return r instanceof qc ? r : new qc(e, { priv: r, privEnc: n }); - }; - qc.prototype.validate = function () { - var e = this.getPublic(); - return e.isInfinity() - ? { result: !1, reason: "Invalid public key" } - : e.validate() - ? e.mul(this.ec.curve.n).isInfinity() - ? { result: !0, reason: null } - : { result: !1, reason: "Public key * N != O" } - : { result: !1, reason: "Public key is not a point" }; - }; - qc.prototype.getPublic = function (e, r) { - return ( - typeof e == "string" && ((r = e), (e = null)), - this.pub || (this.pub = this.ec.g.mul(this.priv)), - r ? this.pub.encode(r, e) : this.pub - ); - }; - qc.prototype.getPrivate = function (e) { - return e === "hex" ? this.priv.toString(16, 2) : this.priv; - }; - qc.prototype._importPrivate = function (e, r) { - (this.priv = new _Qt(e, r || 16)), - (this.priv = this.priv.umod(this.ec.curve.n)); - }; - qc.prototype._importPublic = function (e, r) { - if (e.x || e.y) { - this.ec.curve.type === "mont" - ? Sbe(e.x, "Need x coordinate") - : (this.ec.curve.type === "short" || - this.ec.curve.type === "edwards") && - Sbe(e.x && e.y, "Need both x and y coordinate"), - (this.pub = this.ec.curve.point(e.x, e.y)); - return; - } - this.pub = this.ec.curve.decodePoint(e, r); - }; - qc.prototype.derive = function (e) { - return ( - e.validate() || Sbe(e.validate(), "public point not validated"), - e.mul(this.priv).getX() - ); - }; - qc.prototype.sign = function (e, r, n) { - return this.ec.sign(e, this, r, n); - }; - qc.prototype.verify = function (e, r) { - return this.ec.verify(e, r, this); - }; - qc.prototype.inspect = function () { - return ( - "" - ); - }; - }); - var WWe = I((xfn, VWe) => { - "use strict"; - m(); - g(); - var cX = hv(), - Mbe = Np(), - SQt = Mbe.assert; - function lX(t, e) { - if (t instanceof lX) return t; - this._importDER(t, e) || - (SQt(t.r && t.s, "Signature without r or s"), - (this.r = new cX(t.r, 16)), - (this.s = new cX(t.s, 16)), - t.recoveryParam === void 0 - ? (this.recoveryParam = null) - : (this.recoveryParam = t.recoveryParam)); - } - VWe.exports = lX; - function AQt() { - this.place = 0; - } - function Abe(t, e) { - var r = t[e.place++]; - if (!(r & 128)) return r; - var n = r & 15; - if (n === 0 || n > 4) return !1; - for (var i = 0, o = 0, a = e.place; o < n; o++, a++) - (i <<= 8), (i |= t[a]), (i >>>= 0); - return i <= 127 ? !1 : ((e.place = a), i); - } - function HWe(t) { - for (var e = 0, r = t.length - 1; !t[e] && !(t[e + 1] & 128) && e < r; ) - e++; - return e === 0 ? t : t.slice(e); - } - lX.prototype._importDER = function (e, r) { - e = Mbe.toArray(e, r); - var n = new AQt(); - if (e[n.place++] !== 48) return !1; - var i = Abe(e, n); - if (i === !1 || i + n.place !== e.length || e[n.place++] !== 2) return !1; - var o = Abe(e, n); - if (o === !1) return !1; - var a = e.slice(n.place, o + n.place); - if (((n.place += o), e[n.place++] !== 2)) return !1; - var s = Abe(e, n); - if (s === !1 || e.length !== s + n.place) return !1; - var c = e.slice(n.place, s + n.place); - if (a[0] === 0) - if (a[1] & 128) a = a.slice(1); - else return !1; - if (c[0] === 0) - if (c[1] & 128) c = c.slice(1); - else return !1; - return ( - (this.r = new cX(a)), - (this.s = new cX(c)), - (this.recoveryParam = null), - !0 - ); - }; - function Ebe(t, e) { - if (e < 128) { - t.push(e); - return; - } - var r = 1 + ((Math.log(e) / Math.LN2) >>> 3); - for (t.push(r | 128); --r; ) t.push((e >>> (r << 3)) & 255); - t.push(e); - } - lX.prototype.toDER = function (e) { - var r = this.r.toArray(), - n = this.s.toArray(); - for ( - r[0] & 128 && (r = [0].concat(r)), - n[0] & 128 && (n = [0].concat(n)), - r = HWe(r), - n = HWe(n); - !n[0] && !(n[1] & 128); - - ) - n = n.slice(1); - var i = [2]; - Ebe(i, r.length), (i = i.concat(r)), i.push(2), Ebe(i, n.length); - var o = i.concat(n), - a = [48]; - return Ebe(a, o.length), (a = a.concat(o)), Mbe.encode(a, e); - }; - }); - var ZWe = I((Sfn, $We) => { - "use strict"; - m(); - g(); - var BM = hv(), - GWe = jWe(), - EQt = Np(), - Tbe = uX(), - MQt = $Z(), - JWe = EQt.assert, - kbe = KWe(), - fX = WWe(); - function uy(t) { - if (!(this instanceof uy)) return new uy(t); - typeof t == "string" && - (JWe( - Object.prototype.hasOwnProperty.call(Tbe, t), - "Unknown curve " + t - ), - (t = Tbe[t])), - t instanceof Tbe.PresetCurve && (t = { curve: t }), - (this.curve = t.curve.curve), - (this.n = this.curve.n), - (this.nh = this.n.ushrn(1)), - (this.g = this.curve.g), - (this.g = t.curve.g), - this.g.precompute(t.curve.n.bitLength() + 1), - (this.hash = t.hash || t.curve.hash); - } - $We.exports = uy; - uy.prototype.keyPair = function (e) { - return new kbe(this, e); - }; - uy.prototype.keyFromPrivate = function (e, r) { - return kbe.fromPrivate(this, e, r); - }; - uy.prototype.keyFromPublic = function (e, r) { - return kbe.fromPublic(this, e, r); - }; - uy.prototype.genKeyPair = function (e) { - e || (e = {}); - for ( - var r = new GWe({ - hash: this.hash, - pers: e.pers, - persEnc: e.persEnc || "utf8", - entropy: e.entropy || MQt(this.hash.hmacStrength), - entropyEnc: (e.entropy && e.entropyEnc) || "utf8", - nonce: this.n.toArray(), - }), - n = this.n.byteLength(), - i = this.n.sub(new BM(2)); - ; - - ) { - var o = new BM(r.generate(n)); - if (!(o.cmp(i) > 0)) return o.iaddn(1), this.keyFromPrivate(o); - } - }; - uy.prototype._truncateToN = function (e, r) { - var n = e.byteLength() * 8 - this.n.bitLength(); - return ( - n > 0 && (e = e.ushrn(n)), !r && e.cmp(this.n) >= 0 ? e.sub(this.n) : e - ); - }; - uy.prototype.sign = function (e, r, n, i) { - typeof n == "object" && ((i = n), (n = null)), - i || (i = {}), - (r = this.keyFromPrivate(r, n)), - (e = this._truncateToN(new BM(e, 16))); - for ( - var o = this.n.byteLength(), - a = r.getPrivate().toArray("be", o), - s = e.toArray("be", o), - c = new GWe({ - hash: this.hash, - entropy: a, - nonce: s, - pers: i.pers, - persEnc: i.persEnc || "utf8", - }), - u = this.n.sub(new BM(1)), - h = 0; - ; - h++ - ) { - var w = i.k ? i.k(h) : new BM(c.generate(this.n.byteLength())); - if ( - ((w = this._truncateToN(w, !0)), !(w.cmpn(1) <= 0 || w.cmp(u) >= 0)) - ) { - var M = this.g.mul(w); - if (!M.isInfinity()) { - var k = M.getX(), - O = k.umod(this.n); - if (O.cmpn(0) !== 0) { - var D = w.invm(this.n).mul(O.mul(r.getPrivate()).iadd(e)); - if (((D = D.umod(this.n)), D.cmpn(0) !== 0)) { - var F = (M.getY().isOdd() ? 1 : 0) | (k.cmp(O) !== 0 ? 2 : 0); - return ( - i.canonical && - D.cmp(this.nh) > 0 && - ((D = this.n.sub(D)), (F ^= 1)), - new fX({ r: O, s: D, recoveryParam: F }) - ); - } - } - } - } - } - }; - uy.prototype.verify = function (e, r, n, i) { - (e = this._truncateToN(new BM(e, 16))), - (n = this.keyFromPublic(n, i)), - (r = new fX(r, "hex")); - var o = r.r, - a = r.s; - if ( - o.cmpn(1) < 0 || - o.cmp(this.n) >= 0 || - a.cmpn(1) < 0 || - a.cmp(this.n) >= 0 - ) - return !1; - var s = a.invm(this.n), - c = s.mul(e).umod(this.n), - u = s.mul(o).umod(this.n), - h; - return this.curve._maxwellTrick - ? ((h = this.g.jmulAdd(c, n.getPublic(), u)), - h.isInfinity() ? !1 : h.eqXToP(o)) - : ((h = this.g.mulAdd(c, n.getPublic(), u)), - h.isInfinity() ? !1 : h.getX().umod(this.n).cmp(o) === 0); - }; - uy.prototype.recoverPubKey = function (t, e, r, n) { - JWe((3 & r) === r, "The recovery param is more than two bits"), - (e = new fX(e, n)); - var i = this.n, - o = new BM(t), - a = e.r, - s = e.s, - c = r & 1, - u = r >> 1; - if (a.cmp(this.curve.p.umod(this.curve.n)) >= 0 && u) - throw new Error("Unable to find sencond key candinate"); - u - ? (a = this.curve.pointFromX(a.add(this.curve.n), c)) - : (a = this.curve.pointFromX(a, c)); - var h = e.r.invm(i), - w = i.sub(o).mul(h).umod(i), - M = s.mul(h).umod(i); - return this.g.mulAdd(w, a, M); - }; - uy.prototype.getKeyRecoveryParam = function (t, e, r, n) { - if (((e = new fX(e, n)), e.recoveryParam !== null)) - return e.recoveryParam; - for (var i = 0; i < 4; i++) { - var o; - try { - o = this.recoverPubKey(t, e, i); - } catch { - continue; - } - if (o.eq(r)) return i; - } - throw new Error("Unable to find valid recovery factor"); - }; - }); - var eGe = I((Afn, QWe) => { - "use strict"; - m(); - g(); - var Uq = Np(), - YWe = Uq.assert, - XWe = Uq.parseBytes, - N5 = Uq.cachedProperty; - function xu(t, e) { - (this.eddsa = t), - (this._secret = XWe(e.secret)), - t.isPoint(e.pub) ? (this._pub = e.pub) : (this._pubBytes = XWe(e.pub)); - } - xu.fromPublic = function (e, r) { - return r instanceof xu ? r : new xu(e, { pub: r }); - }; - xu.fromSecret = function (e, r) { - return r instanceof xu ? r : new xu(e, { secret: r }); - }; - xu.prototype.secret = function () { - return this._secret; - }; - N5(xu, "pubBytes", function () { - return this.eddsa.encodePoint(this.pub()); - }); - N5(xu, "pub", function () { - return this._pubBytes - ? this.eddsa.decodePoint(this._pubBytes) - : this.eddsa.g.mul(this.priv()); - }); - N5(xu, "privBytes", function () { - var e = this.eddsa, - r = this.hash(), - n = e.encodingLength - 1, - i = r.slice(0, e.encodingLength); - return (i[0] &= 248), (i[n] &= 127), (i[n] |= 64), i; - }); - N5(xu, "priv", function () { - return this.eddsa.decodeInt(this.privBytes()); - }); - N5(xu, "hash", function () { - return this.eddsa.hash().update(this.secret()).digest(); - }); - N5(xu, "messagePrefix", function () { - return this.hash().slice(this.eddsa.encodingLength); - }); - xu.prototype.sign = function (e) { - return ( - YWe(this._secret, "KeyPair can only verify"), this.eddsa.sign(e, this) - ); - }; - xu.prototype.verify = function (e, r) { - return this.eddsa.verify(e, r, this); - }; - xu.prototype.getSecret = function (e) { - return ( - YWe(this._secret, "KeyPair is public only"), Uq.encode(this.secret(), e) - ); - }; - xu.prototype.getPublic = function (e) { - return Uq.encode(this.pubBytes(), e); - }; - QWe.exports = xu; - }); - var rGe = I((Efn, tGe) => { - "use strict"; - m(); - g(); - var TQt = hv(), - dX = Np(), - kQt = dX.assert, - hX = dX.cachedProperty, - PQt = dX.parseBytes; - function IM(t, e) { - (this.eddsa = t), - typeof e != "object" && (e = PQt(e)), - Array.isArray(e) && - (e = { - R: e.slice(0, t.encodingLength), - S: e.slice(t.encodingLength), - }), - kQt(e.R && e.S, "Signature without R or S"), - t.isPoint(e.R) && (this._R = e.R), - e.S instanceof TQt && (this._S = e.S), - (this._Rencoded = Array.isArray(e.R) ? e.R : e.Rencoded), - (this._Sencoded = Array.isArray(e.S) ? e.S : e.Sencoded); - } - hX(IM, "S", function () { - return this.eddsa.decodeInt(this.Sencoded()); - }); - hX(IM, "R", function () { - return this.eddsa.decodePoint(this.Rencoded()); - }); - hX(IM, "Rencoded", function () { - return this.eddsa.encodePoint(this.R()); - }); - hX(IM, "Sencoded", function () { - return this.eddsa.encodeInt(this.S()); - }); - IM.prototype.toBytes = function () { - return this.Rencoded().concat(this.Sencoded()); - }; - IM.prototype.toHex = function () { - return dX.encode(this.toBytes(), "hex").toUpperCase(); - }; - tGe.exports = IM; - }); - var sGe = I((Mfn, aGe) => { - "use strict"; - m(); - g(); - var OQt = jq(), - BQt = uX(), - D5 = Np(), - IQt = D5.assert, - iGe = D5.parseBytes, - oGe = eGe(), - nGe = rGe(); - function Oh(t) { - if ( - (IQt(t === "ed25519", "only tested with ed25519 so far"), - !(this instanceof Oh)) - ) - return new Oh(t); - (t = BQt[t].curve), - (this.curve = t), - (this.g = t.g), - this.g.precompute(t.n.bitLength() + 1), - (this.pointClass = t.point().constructor), - (this.encodingLength = Math.ceil(t.n.bitLength() / 8)), - (this.hash = OQt.sha512); - } - aGe.exports = Oh; - Oh.prototype.sign = function (e, r) { - e = iGe(e); - var n = this.keyFromSecret(r), - i = this.hashInt(n.messagePrefix(), e), - o = this.g.mul(i), - a = this.encodePoint(o), - s = this.hashInt(a, n.pubBytes(), e).mul(n.priv()), - c = i.add(s).umod(this.curve.n); - return this.makeSignature({ R: o, S: c, Rencoded: a }); - }; - Oh.prototype.verify = function (e, r, n) { - (e = iGe(e)), (r = this.makeSignature(r)); - var i = this.keyFromPublic(n), - o = this.hashInt(r.Rencoded(), i.pubBytes(), e), - a = this.g.mul(r.S()), - s = r.R().add(i.pub().mul(o)); - return s.eq(a); - }; - Oh.prototype.hashInt = function () { - for (var e = this.hash(), r = 0; r < arguments.length; r++) - e.update(arguments[r]); - return D5.intFromLE(e.digest()).umod(this.curve.n); - }; - Oh.prototype.keyFromPublic = function (e) { - return oGe.fromPublic(this, e); - }; - Oh.prototype.keyFromSecret = function (e) { - return oGe.fromSecret(this, e); - }; - Oh.prototype.makeSignature = function (e) { - return e instanceof nGe ? e : new nGe(this, e); - }; - Oh.prototype.encodePoint = function (e) { - var r = e.getY().toArray("le", this.encodingLength); - return (r[this.encodingLength - 1] |= e.getX().isOdd() ? 128 : 0), r; - }; - Oh.prototype.decodePoint = function (e) { - e = D5.parseBytes(e); - var r = e.length - 1, - n = e.slice(0, r).concat(e[r] & -129), - i = (e[r] & 128) !== 0, - o = D5.intFromLE(n); - return this.curve.pointFromY(o, i); - }; - Oh.prototype.encodeInt = function (e) { - return e.toArray("le", this.encodingLength); - }; - Oh.prototype.decodeInt = function (e) { - return D5.intFromLE(e); - }; - Oh.prototype.isPoint = function (e) { - return e instanceof this.pointClass; - }; - }); - var F5 = I((uGe) => { - "use strict"; - m(); - g(); - var CM = uGe; - CM.version = qVe().version; - CM.utils = Np(); - CM.rand = $Z(); - CM.curve = fbe(); - CM.curves = uX(); - CM.ec = ZWe(); - CM.eddsa = sGe(); - }); - var Obe = I((cGe, Pbe) => { - m(); - g(); - (function (t, e) { - "use strict"; - function r(A, l) { - if (!A) throw new Error(l || "Assertion failed"); - } - function n(A, l) { - A.super_ = l; - var p = function () {}; - (p.prototype = l.prototype), - (A.prototype = new p()), - (A.prototype.constructor = A); - } - function i(A, l, p) { - if (i.isBN(A)) return A; - (this.negative = 0), - (this.words = null), - (this.length = 0), - (this.red = null), - A !== null && - ((l === "le" || l === "be") && ((p = l), (l = 10)), - this._init(A || 0, l || 10, p || "be")); - } - typeof t == "object" ? (t.exports = i) : (e.BN = i), - (i.BN = i), - (i.wordSize = 26); - var o; - try { - typeof window < "u" && typeof window.Buffer < "u" - ? (o = window.Buffer) - : (o = Qr().Buffer); - } catch {} - (i.isBN = function (l) { - return l instanceof i - ? !0 - : l !== null && - typeof l == "object" && - l.constructor.wordSize === i.wordSize && - Array.isArray(l.words); - }), - (i.max = function (l, p) { - return l.cmp(p) > 0 ? l : p; - }), - (i.min = function (l, p) { - return l.cmp(p) < 0 ? l : p; - }), - (i.prototype._init = function (l, p, y) { - if (typeof l == "number") return this._initNumber(l, p, y); - if (typeof l == "object") return this._initArray(l, p, y); - p === "hex" && (p = 16), - r(p === (p | 0) && p >= 2 && p <= 36), - (l = l.toString().replace(/\s+/g, "")); - var d = 0; - l[0] === "-" && (d++, (this.negative = 1)), - d < l.length && - (p === 16 - ? this._parseHex(l, d, y) - : (this._parseBase(l, p, d), - y === "le" && this._initArray(this.toArray(), p, y))); - }), - (i.prototype._initNumber = function (l, p, y) { - l < 0 && ((this.negative = 1), (l = -l)), - l < 67108864 - ? ((this.words = [l & 67108863]), (this.length = 1)) - : l < 4503599627370496 - ? ((this.words = [l & 67108863, (l / 67108864) & 67108863]), - (this.length = 2)) - : (r(l < 9007199254740992), - (this.words = [l & 67108863, (l / 67108864) & 67108863, 1]), - (this.length = 3)), - y === "le" && this._initArray(this.toArray(), p, y); - }), - (i.prototype._initArray = function (l, p, y) { - if ((r(typeof l.length == "number"), l.length <= 0)) - return (this.words = [0]), (this.length = 1), this; - (this.length = Math.ceil(l.length / 3)), - (this.words = new Array(this.length)); - for (var d = 0; d < this.length; d++) this.words[d] = 0; - var v, - _, - S = 0; - if (y === "be") - for (d = l.length - 1, v = 0; d >= 0; d -= 3) - (_ = l[d] | (l[d - 1] << 8) | (l[d - 2] << 16)), - (this.words[v] |= (_ << S) & 67108863), - (this.words[v + 1] = (_ >>> (26 - S)) & 67108863), - (S += 24), - S >= 26 && ((S -= 26), v++); - else if (y === "le") - for (d = 0, v = 0; d < l.length; d += 3) - (_ = l[d] | (l[d + 1] << 8) | (l[d + 2] << 16)), - (this.words[v] |= (_ << S) & 67108863), - (this.words[v + 1] = (_ >>> (26 - S)) & 67108863), - (S += 24), - S >= 26 && ((S -= 26), v++); - return this.strip(); - }); - function a(A, l) { - var p = A.charCodeAt(l); - return p >= 65 && p <= 70 - ? p - 55 - : p >= 97 && p <= 102 - ? p - 87 - : (p - 48) & 15; - } - function s(A, l, p) { - var y = a(A, p); - return p - 1 >= l && (y |= a(A, p - 1) << 4), y; - } - i.prototype._parseHex = function (l, p, y) { - (this.length = Math.ceil((l.length - p) / 6)), - (this.words = new Array(this.length)); - for (var d = 0; d < this.length; d++) this.words[d] = 0; - var v = 0, - _ = 0, - S; - if (y === "be") - for (d = l.length - 1; d >= p; d -= 2) - (S = s(l, p, d) << v), - (this.words[_] |= S & 67108863), - v >= 18 - ? ((v -= 18), (_ += 1), (this.words[_] |= S >>> 26)) - : (v += 8); - else { - var b = l.length - p; - for (d = b % 2 === 0 ? p + 1 : p; d < l.length; d += 2) - (S = s(l, p, d) << v), - (this.words[_] |= S & 67108863), - v >= 18 - ? ((v -= 18), (_ += 1), (this.words[_] |= S >>> 26)) - : (v += 8); - } - this.strip(); - }; - function c(A, l, p, y) { - for (var d = 0, v = Math.min(A.length, p), _ = l; _ < v; _++) { - var S = A.charCodeAt(_) - 48; - (d *= y), - S >= 49 - ? (d += S - 49 + 10) - : S >= 17 - ? (d += S - 17 + 10) - : (d += S); - } - return d; - } - (i.prototype._parseBase = function (l, p, y) { - (this.words = [0]), (this.length = 1); - for (var d = 0, v = 1; v <= 67108863; v *= p) d++; - d--, (v = (v / p) | 0); - for ( - var _ = l.length - y, - S = _ % d, - b = Math.min(_, _ - S) + y, - f = 0, - x = y; - x < b; - x += d - ) - (f = c(l, x, x + d, p)), - this.imuln(v), - this.words[0] + f < 67108864 - ? (this.words[0] += f) - : this._iaddn(f); - if (S !== 0) { - var C = 1; - for (f = c(l, x, l.length, p), x = 0; x < S; x++) C *= p; - this.imuln(C), - this.words[0] + f < 67108864 - ? (this.words[0] += f) - : this._iaddn(f); - } - this.strip(); - }), - (i.prototype.copy = function (l) { - l.words = new Array(this.length); - for (var p = 0; p < this.length; p++) l.words[p] = this.words[p]; - (l.length = this.length), - (l.negative = this.negative), - (l.red = this.red); - }), - (i.prototype.clone = function () { - var l = new i(null); - return this.copy(l), l; - }), - (i.prototype._expand = function (l) { - for (; this.length < l; ) this.words[this.length++] = 0; - return this; - }), - (i.prototype.strip = function () { - for (; this.length > 1 && this.words[this.length - 1] === 0; ) - this.length--; - return this._normSign(); - }), - (i.prototype._normSign = function () { - return ( - this.length === 1 && this.words[0] === 0 && (this.negative = 0), - this - ); - }), - (i.prototype.inspect = function () { - return (this.red ? ""; - }); - var u = [ - "", - "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", - ], - h = [ - 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, - ], - w = [ - 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, - ]; - (i.prototype.toString = function (l, p) { - (l = l || 10), (p = p | 0 || 1); - var y; - if (l === 16 || l === "hex") { - y = ""; - for (var d = 0, v = 0, _ = 0; _ < this.length; _++) { - var S = this.words[_], - b = (((S << d) | v) & 16777215).toString(16); - (v = (S >>> (24 - d)) & 16777215), - v !== 0 || _ !== this.length - 1 - ? (y = u[6 - b.length] + b + y) - : (y = b + y), - (d += 2), - d >= 26 && ((d -= 26), _--); - } - for (v !== 0 && (y = v.toString(16) + y); y.length % p !== 0; ) - y = "0" + y; - return this.negative !== 0 && (y = "-" + y), y; - } - if (l === (l | 0) && l >= 2 && l <= 36) { - var f = h[l], - x = w[l]; - y = ""; - var C = this.clone(); - for (C.negative = 0; !C.isZero(); ) { - var E = C.modn(x).toString(l); - (C = C.idivn(x)), - C.isZero() ? (y = E + y) : (y = u[f - E.length] + E + y); - } - for (this.isZero() && (y = "0" + y); y.length % p !== 0; ) - y = "0" + y; - return this.negative !== 0 && (y = "-" + y), y; - } - r(!1, "Base should be between 2 and 36"); - }), - (i.prototype.toNumber = function () { - var l = this.words[0]; - return ( - this.length === 2 - ? (l += this.words[1] * 67108864) - : this.length === 3 && this.words[2] === 1 - ? (l += 4503599627370496 + this.words[1] * 67108864) - : this.length > 2 && - r(!1, "Number can only safely store up to 53 bits"), - this.negative !== 0 ? -l : l - ); - }), - (i.prototype.toJSON = function () { - return this.toString(16); - }), - (i.prototype.toBuffer = function (l, p) { - return r(typeof o < "u"), this.toArrayLike(o, l, p); - }), - (i.prototype.toArray = function (l, p) { - return this.toArrayLike(Array, l, p); - }), - (i.prototype.toArrayLike = function (l, p, y) { - var d = this.byteLength(), - v = y || Math.max(1, d); - r(d <= v, "byte array longer than desired length"), - r(v > 0, "Requested array length <= 0"), - this.strip(); - var _ = p === "le", - S = new l(v), - b, - f, - x = this.clone(); - if (_) { - for (f = 0; !x.isZero(); f++) - (b = x.andln(255)), x.iushrn(8), (S[f] = b); - for (; f < v; f++) S[f] = 0; - } else { - for (f = 0; f < v - d; f++) S[f] = 0; - for (f = 0; !x.isZero(); f++) - (b = x.andln(255)), x.iushrn(8), (S[v - f - 1] = b); - } - return S; - }), - Math.clz32 - ? (i.prototype._countBits = function (l) { - return 32 - Math.clz32(l); - }) - : (i.prototype._countBits = function (l) { - var p = l, - y = 0; - return ( - p >= 4096 && ((y += 13), (p >>>= 13)), - p >= 64 && ((y += 7), (p >>>= 7)), - p >= 8 && ((y += 4), (p >>>= 4)), - p >= 2 && ((y += 2), (p >>>= 2)), - y + p - ); - }), - (i.prototype._zeroBits = function (l) { - if (l === 0) return 26; - var p = l, - y = 0; - return ( - (p & 8191) === 0 && ((y += 13), (p >>>= 13)), - (p & 127) === 0 && ((y += 7), (p >>>= 7)), - (p & 15) === 0 && ((y += 4), (p >>>= 4)), - (p & 3) === 0 && ((y += 2), (p >>>= 2)), - (p & 1) === 0 && y++, - y - ); - }), - (i.prototype.bitLength = function () { - var l = this.words[this.length - 1], - p = this._countBits(l); - return (this.length - 1) * 26 + p; - }); - function M(A) { - for (var l = new Array(A.bitLength()), p = 0; p < l.length; p++) { - var y = (p / 26) | 0, - d = p % 26; - l[p] = (A.words[y] & (1 << d)) >>> d; - } - return l; - } - (i.prototype.zeroBits = function () { - if (this.isZero()) return 0; - for (var l = 0, p = 0; p < this.length; p++) { - var y = this._zeroBits(this.words[p]); - if (((l += y), y !== 26)) break; - } - return l; - }), - (i.prototype.byteLength = function () { - return Math.ceil(this.bitLength() / 8); - }), - (i.prototype.toTwos = function (l) { - return this.negative !== 0 - ? this.abs().inotn(l).iaddn(1) - : this.clone(); - }), - (i.prototype.fromTwos = function (l) { - return this.testn(l - 1) - ? this.notn(l).iaddn(1).ineg() - : this.clone(); - }), - (i.prototype.isNeg = function () { - return this.negative !== 0; - }), - (i.prototype.neg = function () { - return this.clone().ineg(); - }), - (i.prototype.ineg = function () { - return this.isZero() || (this.negative ^= 1), this; - }), - (i.prototype.iuor = function (l) { - for (; this.length < l.length; ) this.words[this.length++] = 0; - for (var p = 0; p < l.length; p++) - this.words[p] = this.words[p] | l.words[p]; - return this.strip(); - }), - (i.prototype.ior = function (l) { - return r((this.negative | l.negative) === 0), this.iuor(l); - }), - (i.prototype.or = function (l) { - return this.length > l.length - ? this.clone().ior(l) - : l.clone().ior(this); - }), - (i.prototype.uor = function (l) { - return this.length > l.length - ? this.clone().iuor(l) - : l.clone().iuor(this); - }), - (i.prototype.iuand = function (l) { - var p; - this.length > l.length ? (p = l) : (p = this); - for (var y = 0; y < p.length; y++) - this.words[y] = this.words[y] & l.words[y]; - return (this.length = p.length), this.strip(); - }), - (i.prototype.iand = function (l) { - return r((this.negative | l.negative) === 0), this.iuand(l); - }), - (i.prototype.and = function (l) { - return this.length > l.length - ? this.clone().iand(l) - : l.clone().iand(this); - }), - (i.prototype.uand = function (l) { - return this.length > l.length - ? this.clone().iuand(l) - : l.clone().iuand(this); - }), - (i.prototype.iuxor = function (l) { - var p, y; - this.length > l.length - ? ((p = this), (y = l)) - : ((p = l), (y = this)); - for (var d = 0; d < y.length; d++) - this.words[d] = p.words[d] ^ y.words[d]; - if (this !== p) for (; d < p.length; d++) this.words[d] = p.words[d]; - return (this.length = p.length), this.strip(); - }), - (i.prototype.ixor = function (l) { - return r((this.negative | l.negative) === 0), this.iuxor(l); - }), - (i.prototype.xor = function (l) { - return this.length > l.length - ? this.clone().ixor(l) - : l.clone().ixor(this); - }), - (i.prototype.uxor = function (l) { - return this.length > l.length - ? this.clone().iuxor(l) - : l.clone().iuxor(this); - }), - (i.prototype.inotn = function (l) { - r(typeof l == "number" && l >= 0); - var p = Math.ceil(l / 26) | 0, - y = l % 26; - this._expand(p), y > 0 && p--; - for (var d = 0; d < p; d++) this.words[d] = ~this.words[d] & 67108863; - return ( - y > 0 && (this.words[d] = ~this.words[d] & (67108863 >> (26 - y))), - this.strip() - ); - }), - (i.prototype.notn = function (l) { - return this.clone().inotn(l); - }), - (i.prototype.setn = function (l, p) { - r(typeof l == "number" && l >= 0); - var y = (l / 26) | 0, - d = l % 26; - return ( - this._expand(y + 1), - p - ? (this.words[y] = this.words[y] | (1 << d)) - : (this.words[y] = this.words[y] & ~(1 << d)), - this.strip() - ); - }), - (i.prototype.iadd = function (l) { - var p; - if (this.negative !== 0 && l.negative === 0) - return ( - (this.negative = 0), - (p = this.isub(l)), - (this.negative ^= 1), - this._normSign() - ); - if (this.negative === 0 && l.negative !== 0) - return ( - (l.negative = 0), - (p = this.isub(l)), - (l.negative = 1), - p._normSign() - ); - var y, d; - this.length > l.length - ? ((y = this), (d = l)) - : ((y = l), (d = this)); - for (var v = 0, _ = 0; _ < d.length; _++) - (p = (y.words[_] | 0) + (d.words[_] | 0) + v), - (this.words[_] = p & 67108863), - (v = p >>> 26); - for (; v !== 0 && _ < y.length; _++) - (p = (y.words[_] | 0) + v), - (this.words[_] = p & 67108863), - (v = p >>> 26); - if (((this.length = y.length), v !== 0)) - (this.words[this.length] = v), this.length++; - else if (y !== this) - for (; _ < y.length; _++) this.words[_] = y.words[_]; - return this; - }), - (i.prototype.add = function (l) { - var p; - return l.negative !== 0 && this.negative === 0 - ? ((l.negative = 0), (p = this.sub(l)), (l.negative ^= 1), p) - : l.negative === 0 && this.negative !== 0 - ? ((this.negative = 0), (p = l.sub(this)), (this.negative = 1), p) - : this.length > l.length - ? this.clone().iadd(l) - : l.clone().iadd(this); - }), - (i.prototype.isub = function (l) { - if (l.negative !== 0) { - l.negative = 0; - var p = this.iadd(l); - return (l.negative = 1), p._normSign(); - } else if (this.negative !== 0) - return ( - (this.negative = 0), - this.iadd(l), - (this.negative = 1), - this._normSign() - ); - var y = this.cmp(l); - if (y === 0) - return ( - (this.negative = 0), (this.length = 1), (this.words[0] = 0), this - ); - var d, v; - y > 0 ? ((d = this), (v = l)) : ((d = l), (v = this)); - for (var _ = 0, S = 0; S < v.length; S++) - (p = (d.words[S] | 0) - (v.words[S] | 0) + _), - (_ = p >> 26), - (this.words[S] = p & 67108863); - for (; _ !== 0 && S < d.length; S++) - (p = (d.words[S] | 0) + _), - (_ = p >> 26), - (this.words[S] = p & 67108863); - if (_ === 0 && S < d.length && d !== this) - for (; S < d.length; S++) this.words[S] = d.words[S]; - return ( - (this.length = Math.max(this.length, S)), - d !== this && (this.negative = 1), - this.strip() - ); - }), - (i.prototype.sub = function (l) { - return this.clone().isub(l); - }); - function k(A, l, p) { - p.negative = l.negative ^ A.negative; - var y = (A.length + l.length) | 0; - (p.length = y), (y = (y - 1) | 0); - var d = A.words[0] | 0, - v = l.words[0] | 0, - _ = d * v, - S = _ & 67108863, - b = (_ / 67108864) | 0; - p.words[0] = S; - for (var f = 1; f < y; f++) { - for ( - var x = b >>> 26, - C = b & 67108863, - E = Math.min(f, l.length - 1), - B = Math.max(0, f - A.length + 1); - B <= E; - B++ - ) { - var G = (f - B) | 0; - (d = A.words[G] | 0), - (v = l.words[B] | 0), - (_ = d * v + C), - (x += (_ / 67108864) | 0), - (C = _ & 67108863); - } - (p.words[f] = C | 0), (b = x | 0); - } - return b !== 0 ? (p.words[f] = b | 0) : p.length--, p.strip(); - } - var O = function (l, p, y) { - var d = l.words, - v = p.words, - _ = y.words, - S = 0, - b, - f, - x, - C = d[0] | 0, - E = C & 8191, - B = C >>> 13, - G = d[1] | 0, - L = G & 8191, - ee = G >>> 13, - ge = d[2] | 0, - fe = ge & 8191, - V = ge >>> 13, - ye = d[3] | 0, - ae = ye & 8191, - le = ye >>> 13, - Me = d[4] | 0, - de = Me & 8191, - ve = Me >>> 13, - De = d[5] | 0, - me = De & 8191, - _e = De >>> 13, - Ye = d[6] | 0, - Ee = Ye & 8191, - Be = Ye >>> 13, - kt = d[7] | 0, - Ve = kt & 8191, - We = kt >>> 13, - er = d[8] | 0, - Ue = er & 8191, - Y = er >>> 13, - W = d[9] | 0, - j = W & 8191, - ce = W >>> 13, - ze = v[0] | 0, - we = ze & 8191, - xe = ze >>> 13, - Ft = v[1] | 0, - Ke = Ft & 8191, - pe = Ft >>> 13, - Re = v[2] | 0, - Se = Re & 8191, - Pe = Re >>> 13, - At = v[3] | 0, - Ie = At & 8191, - je = At >>> 13, - qt = v[4] | 0, - Fe = qt & 8191, - He = qt >>> 13, - lr = v[5] | 0, - Xe = lr & 8191, - Ze = lr >>> 13, - Ir = v[6] | 0, - $e = Ir & 8191, - tt = Ir >>> 13, - oe = v[7] | 0, - ie = oe & 8191, - re = oe >>> 13, - U = v[8] | 0, - se = U & 8191, - be = U >>> 13, - Qe = v[9] | 0, - Ae = Qe & 8191, - ke = Qe >>> 13; - (y.negative = l.negative ^ p.negative), - (y.length = 19), - (b = Math.imul(E, we)), - (f = Math.imul(E, xe)), - (f = (f + Math.imul(B, we)) | 0), - (x = Math.imul(B, xe)); - var Ct = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ct >>> 26)) | 0), - (Ct &= 67108863), - (b = Math.imul(L, we)), - (f = Math.imul(L, xe)), - (f = (f + Math.imul(ee, we)) | 0), - (x = Math.imul(ee, xe)), - (b = (b + Math.imul(E, Ke)) | 0), - (f = (f + Math.imul(E, pe)) | 0), - (f = (f + Math.imul(B, Ke)) | 0), - (x = (x + Math.imul(B, pe)) | 0); - var ut = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (ut >>> 26)) | 0), - (ut &= 67108863), - (b = Math.imul(fe, we)), - (f = Math.imul(fe, xe)), - (f = (f + Math.imul(V, we)) | 0), - (x = Math.imul(V, xe)), - (b = (b + Math.imul(L, Ke)) | 0), - (f = (f + Math.imul(L, pe)) | 0), - (f = (f + Math.imul(ee, Ke)) | 0), - (x = (x + Math.imul(ee, pe)) | 0), - (b = (b + Math.imul(E, Se)) | 0), - (f = (f + Math.imul(E, Pe)) | 0), - (f = (f + Math.imul(B, Se)) | 0), - (x = (x + Math.imul(B, Pe)) | 0); - var St = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (St >>> 26)) | 0), - (St &= 67108863), - (b = Math.imul(ae, we)), - (f = Math.imul(ae, xe)), - (f = (f + Math.imul(le, we)) | 0), - (x = Math.imul(le, xe)), - (b = (b + Math.imul(fe, Ke)) | 0), - (f = (f + Math.imul(fe, pe)) | 0), - (f = (f + Math.imul(V, Ke)) | 0), - (x = (x + Math.imul(V, pe)) | 0), - (b = (b + Math.imul(L, Se)) | 0), - (f = (f + Math.imul(L, Pe)) | 0), - (f = (f + Math.imul(ee, Se)) | 0), - (x = (x + Math.imul(ee, Pe)) | 0), - (b = (b + Math.imul(E, Ie)) | 0), - (f = (f + Math.imul(E, je)) | 0), - (f = (f + Math.imul(B, Ie)) | 0), - (x = (x + Math.imul(B, je)) | 0); - var wt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (wt >>> 26)) | 0), - (wt &= 67108863), - (b = Math.imul(de, we)), - (f = Math.imul(de, xe)), - (f = (f + Math.imul(ve, we)) | 0), - (x = Math.imul(ve, xe)), - (b = (b + Math.imul(ae, Ke)) | 0), - (f = (f + Math.imul(ae, pe)) | 0), - (f = (f + Math.imul(le, Ke)) | 0), - (x = (x + Math.imul(le, pe)) | 0), - (b = (b + Math.imul(fe, Se)) | 0), - (f = (f + Math.imul(fe, Pe)) | 0), - (f = (f + Math.imul(V, Se)) | 0), - (x = (x + Math.imul(V, Pe)) | 0), - (b = (b + Math.imul(L, Ie)) | 0), - (f = (f + Math.imul(L, je)) | 0), - (f = (f + Math.imul(ee, Ie)) | 0), - (x = (x + Math.imul(ee, je)) | 0), - (b = (b + Math.imul(E, Fe)) | 0), - (f = (f + Math.imul(E, He)) | 0), - (f = (f + Math.imul(B, Fe)) | 0), - (x = (x + Math.imul(B, He)) | 0); - var zt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (zt >>> 26)) | 0), - (zt &= 67108863), - (b = Math.imul(me, we)), - (f = Math.imul(me, xe)), - (f = (f + Math.imul(_e, we)) | 0), - (x = Math.imul(_e, xe)), - (b = (b + Math.imul(de, Ke)) | 0), - (f = (f + Math.imul(de, pe)) | 0), - (f = (f + Math.imul(ve, Ke)) | 0), - (x = (x + Math.imul(ve, pe)) | 0), - (b = (b + Math.imul(ae, Se)) | 0), - (f = (f + Math.imul(ae, Pe)) | 0), - (f = (f + Math.imul(le, Se)) | 0), - (x = (x + Math.imul(le, Pe)) | 0), - (b = (b + Math.imul(fe, Ie)) | 0), - (f = (f + Math.imul(fe, je)) | 0), - (f = (f + Math.imul(V, Ie)) | 0), - (x = (x + Math.imul(V, je)) | 0), - (b = (b + Math.imul(L, Fe)) | 0), - (f = (f + Math.imul(L, He)) | 0), - (f = (f + Math.imul(ee, Fe)) | 0), - (x = (x + Math.imul(ee, He)) | 0), - (b = (b + Math.imul(E, Xe)) | 0), - (f = (f + Math.imul(E, Ze)) | 0), - (f = (f + Math.imul(B, Xe)) | 0), - (x = (x + Math.imul(B, Ze)) | 0); - var jt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (jt >>> 26)) | 0), - (jt &= 67108863), - (b = Math.imul(Ee, we)), - (f = Math.imul(Ee, xe)), - (f = (f + Math.imul(Be, we)) | 0), - (x = Math.imul(Be, xe)), - (b = (b + Math.imul(me, Ke)) | 0), - (f = (f + Math.imul(me, pe)) | 0), - (f = (f + Math.imul(_e, Ke)) | 0), - (x = (x + Math.imul(_e, pe)) | 0), - (b = (b + Math.imul(de, Se)) | 0), - (f = (f + Math.imul(de, Pe)) | 0), - (f = (f + Math.imul(ve, Se)) | 0), - (x = (x + Math.imul(ve, Pe)) | 0), - (b = (b + Math.imul(ae, Ie)) | 0), - (f = (f + Math.imul(ae, je)) | 0), - (f = (f + Math.imul(le, Ie)) | 0), - (x = (x + Math.imul(le, je)) | 0), - (b = (b + Math.imul(fe, Fe)) | 0), - (f = (f + Math.imul(fe, He)) | 0), - (f = (f + Math.imul(V, Fe)) | 0), - (x = (x + Math.imul(V, He)) | 0), - (b = (b + Math.imul(L, Xe)) | 0), - (f = (f + Math.imul(L, Ze)) | 0), - (f = (f + Math.imul(ee, Xe)) | 0), - (x = (x + Math.imul(ee, Ze)) | 0), - (b = (b + Math.imul(E, $e)) | 0), - (f = (f + Math.imul(E, tt)) | 0), - (f = (f + Math.imul(B, $e)) | 0), - (x = (x + Math.imul(B, tt)) | 0); - var Ht = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ht >>> 26)) | 0), - (Ht &= 67108863), - (b = Math.imul(Ve, we)), - (f = Math.imul(Ve, xe)), - (f = (f + Math.imul(We, we)) | 0), - (x = Math.imul(We, xe)), - (b = (b + Math.imul(Ee, Ke)) | 0), - (f = (f + Math.imul(Ee, pe)) | 0), - (f = (f + Math.imul(Be, Ke)) | 0), - (x = (x + Math.imul(Be, pe)) | 0), - (b = (b + Math.imul(me, Se)) | 0), - (f = (f + Math.imul(me, Pe)) | 0), - (f = (f + Math.imul(_e, Se)) | 0), - (x = (x + Math.imul(_e, Pe)) | 0), - (b = (b + Math.imul(de, Ie)) | 0), - (f = (f + Math.imul(de, je)) | 0), - (f = (f + Math.imul(ve, Ie)) | 0), - (x = (x + Math.imul(ve, je)) | 0), - (b = (b + Math.imul(ae, Fe)) | 0), - (f = (f + Math.imul(ae, He)) | 0), - (f = (f + Math.imul(le, Fe)) | 0), - (x = (x + Math.imul(le, He)) | 0), - (b = (b + Math.imul(fe, Xe)) | 0), - (f = (f + Math.imul(fe, Ze)) | 0), - (f = (f + Math.imul(V, Xe)) | 0), - (x = (x + Math.imul(V, Ze)) | 0), - (b = (b + Math.imul(L, $e)) | 0), - (f = (f + Math.imul(L, tt)) | 0), - (f = (f + Math.imul(ee, $e)) | 0), - (x = (x + Math.imul(ee, tt)) | 0), - (b = (b + Math.imul(E, ie)) | 0), - (f = (f + Math.imul(E, re)) | 0), - (f = (f + Math.imul(B, ie)) | 0), - (x = (x + Math.imul(B, re)) | 0); - var Ut = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ut >>> 26)) | 0), - (Ut &= 67108863), - (b = Math.imul(Ue, we)), - (f = Math.imul(Ue, xe)), - (f = (f + Math.imul(Y, we)) | 0), - (x = Math.imul(Y, xe)), - (b = (b + Math.imul(Ve, Ke)) | 0), - (f = (f + Math.imul(Ve, pe)) | 0), - (f = (f + Math.imul(We, Ke)) | 0), - (x = (x + Math.imul(We, pe)) | 0), - (b = (b + Math.imul(Ee, Se)) | 0), - (f = (f + Math.imul(Ee, Pe)) | 0), - (f = (f + Math.imul(Be, Se)) | 0), - (x = (x + Math.imul(Be, Pe)) | 0), - (b = (b + Math.imul(me, Ie)) | 0), - (f = (f + Math.imul(me, je)) | 0), - (f = (f + Math.imul(_e, Ie)) | 0), - (x = (x + Math.imul(_e, je)) | 0), - (b = (b + Math.imul(de, Fe)) | 0), - (f = (f + Math.imul(de, He)) | 0), - (f = (f + Math.imul(ve, Fe)) | 0), - (x = (x + Math.imul(ve, He)) | 0), - (b = (b + Math.imul(ae, Xe)) | 0), - (f = (f + Math.imul(ae, Ze)) | 0), - (f = (f + Math.imul(le, Xe)) | 0), - (x = (x + Math.imul(le, Ze)) | 0), - (b = (b + Math.imul(fe, $e)) | 0), - (f = (f + Math.imul(fe, tt)) | 0), - (f = (f + Math.imul(V, $e)) | 0), - (x = (x + Math.imul(V, tt)) | 0), - (b = (b + Math.imul(L, ie)) | 0), - (f = (f + Math.imul(L, re)) | 0), - (f = (f + Math.imul(ee, ie)) | 0), - (x = (x + Math.imul(ee, re)) | 0), - (b = (b + Math.imul(E, se)) | 0), - (f = (f + Math.imul(E, be)) | 0), - (f = (f + Math.imul(B, se)) | 0), - (x = (x + Math.imul(B, be)) | 0); - var Kt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Kt >>> 26)) | 0), - (Kt &= 67108863), - (b = Math.imul(j, we)), - (f = Math.imul(j, xe)), - (f = (f + Math.imul(ce, we)) | 0), - (x = Math.imul(ce, xe)), - (b = (b + Math.imul(Ue, Ke)) | 0), - (f = (f + Math.imul(Ue, pe)) | 0), - (f = (f + Math.imul(Y, Ke)) | 0), - (x = (x + Math.imul(Y, pe)) | 0), - (b = (b + Math.imul(Ve, Se)) | 0), - (f = (f + Math.imul(Ve, Pe)) | 0), - (f = (f + Math.imul(We, Se)) | 0), - (x = (x + Math.imul(We, Pe)) | 0), - (b = (b + Math.imul(Ee, Ie)) | 0), - (f = (f + Math.imul(Ee, je)) | 0), - (f = (f + Math.imul(Be, Ie)) | 0), - (x = (x + Math.imul(Be, je)) | 0), - (b = (b + Math.imul(me, Fe)) | 0), - (f = (f + Math.imul(me, He)) | 0), - (f = (f + Math.imul(_e, Fe)) | 0), - (x = (x + Math.imul(_e, He)) | 0), - (b = (b + Math.imul(de, Xe)) | 0), - (f = (f + Math.imul(de, Ze)) | 0), - (f = (f + Math.imul(ve, Xe)) | 0), - (x = (x + Math.imul(ve, Ze)) | 0), - (b = (b + Math.imul(ae, $e)) | 0), - (f = (f + Math.imul(ae, tt)) | 0), - (f = (f + Math.imul(le, $e)) | 0), - (x = (x + Math.imul(le, tt)) | 0), - (b = (b + Math.imul(fe, ie)) | 0), - (f = (f + Math.imul(fe, re)) | 0), - (f = (f + Math.imul(V, ie)) | 0), - (x = (x + Math.imul(V, re)) | 0), - (b = (b + Math.imul(L, se)) | 0), - (f = (f + Math.imul(L, be)) | 0), - (f = (f + Math.imul(ee, se)) | 0), - (x = (x + Math.imul(ee, be)) | 0), - (b = (b + Math.imul(E, Ae)) | 0), - (f = (f + Math.imul(E, ke)) | 0), - (f = (f + Math.imul(B, Ae)) | 0), - (x = (x + Math.imul(B, ke)) | 0); - var Ot = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ot >>> 26)) | 0), - (Ot &= 67108863), - (b = Math.imul(j, Ke)), - (f = Math.imul(j, pe)), - (f = (f + Math.imul(ce, Ke)) | 0), - (x = Math.imul(ce, pe)), - (b = (b + Math.imul(Ue, Se)) | 0), - (f = (f + Math.imul(Ue, Pe)) | 0), - (f = (f + Math.imul(Y, Se)) | 0), - (x = (x + Math.imul(Y, Pe)) | 0), - (b = (b + Math.imul(Ve, Ie)) | 0), - (f = (f + Math.imul(Ve, je)) | 0), - (f = (f + Math.imul(We, Ie)) | 0), - (x = (x + Math.imul(We, je)) | 0), - (b = (b + Math.imul(Ee, Fe)) | 0), - (f = (f + Math.imul(Ee, He)) | 0), - (f = (f + Math.imul(Be, Fe)) | 0), - (x = (x + Math.imul(Be, He)) | 0), - (b = (b + Math.imul(me, Xe)) | 0), - (f = (f + Math.imul(me, Ze)) | 0), - (f = (f + Math.imul(_e, Xe)) | 0), - (x = (x + Math.imul(_e, Ze)) | 0), - (b = (b + Math.imul(de, $e)) | 0), - (f = (f + Math.imul(de, tt)) | 0), - (f = (f + Math.imul(ve, $e)) | 0), - (x = (x + Math.imul(ve, tt)) | 0), - (b = (b + Math.imul(ae, ie)) | 0), - (f = (f + Math.imul(ae, re)) | 0), - (f = (f + Math.imul(le, ie)) | 0), - (x = (x + Math.imul(le, re)) | 0), - (b = (b + Math.imul(fe, se)) | 0), - (f = (f + Math.imul(fe, be)) | 0), - (f = (f + Math.imul(V, se)) | 0), - (x = (x + Math.imul(V, be)) | 0), - (b = (b + Math.imul(L, Ae)) | 0), - (f = (f + Math.imul(L, ke)) | 0), - (f = (f + Math.imul(ee, Ae)) | 0), - (x = (x + Math.imul(ee, ke)) | 0); - var Bt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Bt >>> 26)) | 0), - (Bt &= 67108863), - (b = Math.imul(j, Se)), - (f = Math.imul(j, Pe)), - (f = (f + Math.imul(ce, Se)) | 0), - (x = Math.imul(ce, Pe)), - (b = (b + Math.imul(Ue, Ie)) | 0), - (f = (f + Math.imul(Ue, je)) | 0), - (f = (f + Math.imul(Y, Ie)) | 0), - (x = (x + Math.imul(Y, je)) | 0), - (b = (b + Math.imul(Ve, Fe)) | 0), - (f = (f + Math.imul(Ve, He)) | 0), - (f = (f + Math.imul(We, Fe)) | 0), - (x = (x + Math.imul(We, He)) | 0), - (b = (b + Math.imul(Ee, Xe)) | 0), - (f = (f + Math.imul(Ee, Ze)) | 0), - (f = (f + Math.imul(Be, Xe)) | 0), - (x = (x + Math.imul(Be, Ze)) | 0), - (b = (b + Math.imul(me, $e)) | 0), - (f = (f + Math.imul(me, tt)) | 0), - (f = (f + Math.imul(_e, $e)) | 0), - (x = (x + Math.imul(_e, tt)) | 0), - (b = (b + Math.imul(de, ie)) | 0), - (f = (f + Math.imul(de, re)) | 0), - (f = (f + Math.imul(ve, ie)) | 0), - (x = (x + Math.imul(ve, re)) | 0), - (b = (b + Math.imul(ae, se)) | 0), - (f = (f + Math.imul(ae, be)) | 0), - (f = (f + Math.imul(le, se)) | 0), - (x = (x + Math.imul(le, be)) | 0), - (b = (b + Math.imul(fe, Ae)) | 0), - (f = (f + Math.imul(fe, ke)) | 0), - (f = (f + Math.imul(V, Ae)) | 0), - (x = (x + Math.imul(V, ke)) | 0); - var Et = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Et >>> 26)) | 0), - (Et &= 67108863), - (b = Math.imul(j, Ie)), - (f = Math.imul(j, je)), - (f = (f + Math.imul(ce, Ie)) | 0), - (x = Math.imul(ce, je)), - (b = (b + Math.imul(Ue, Fe)) | 0), - (f = (f + Math.imul(Ue, He)) | 0), - (f = (f + Math.imul(Y, Fe)) | 0), - (x = (x + Math.imul(Y, He)) | 0), - (b = (b + Math.imul(Ve, Xe)) | 0), - (f = (f + Math.imul(Ve, Ze)) | 0), - (f = (f + Math.imul(We, Xe)) | 0), - (x = (x + Math.imul(We, Ze)) | 0), - (b = (b + Math.imul(Ee, $e)) | 0), - (f = (f + Math.imul(Ee, tt)) | 0), - (f = (f + Math.imul(Be, $e)) | 0), - (x = (x + Math.imul(Be, tt)) | 0), - (b = (b + Math.imul(me, ie)) | 0), - (f = (f + Math.imul(me, re)) | 0), - (f = (f + Math.imul(_e, ie)) | 0), - (x = (x + Math.imul(_e, re)) | 0), - (b = (b + Math.imul(de, se)) | 0), - (f = (f + Math.imul(de, be)) | 0), - (f = (f + Math.imul(ve, se)) | 0), - (x = (x + Math.imul(ve, be)) | 0), - (b = (b + Math.imul(ae, Ae)) | 0), - (f = (f + Math.imul(ae, ke)) | 0), - (f = (f + Math.imul(le, Ae)) | 0), - (x = (x + Math.imul(le, ke)) | 0); - var Mt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Mt >>> 26)) | 0), - (Mt &= 67108863), - (b = Math.imul(j, Fe)), - (f = Math.imul(j, He)), - (f = (f + Math.imul(ce, Fe)) | 0), - (x = Math.imul(ce, He)), - (b = (b + Math.imul(Ue, Xe)) | 0), - (f = (f + Math.imul(Ue, Ze)) | 0), - (f = (f + Math.imul(Y, Xe)) | 0), - (x = (x + Math.imul(Y, Ze)) | 0), - (b = (b + Math.imul(Ve, $e)) | 0), - (f = (f + Math.imul(Ve, tt)) | 0), - (f = (f + Math.imul(We, $e)) | 0), - (x = (x + Math.imul(We, tt)) | 0), - (b = (b + Math.imul(Ee, ie)) | 0), - (f = (f + Math.imul(Ee, re)) | 0), - (f = (f + Math.imul(Be, ie)) | 0), - (x = (x + Math.imul(Be, re)) | 0), - (b = (b + Math.imul(me, se)) | 0), - (f = (f + Math.imul(me, be)) | 0), - (f = (f + Math.imul(_e, se)) | 0), - (x = (x + Math.imul(_e, be)) | 0), - (b = (b + Math.imul(de, Ae)) | 0), - (f = (f + Math.imul(de, ke)) | 0), - (f = (f + Math.imul(ve, Ae)) | 0), - (x = (x + Math.imul(ve, ke)) | 0); - var gt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (gt >>> 26)) | 0), - (gt &= 67108863), - (b = Math.imul(j, Xe)), - (f = Math.imul(j, Ze)), - (f = (f + Math.imul(ce, Xe)) | 0), - (x = Math.imul(ce, Ze)), - (b = (b + Math.imul(Ue, $e)) | 0), - (f = (f + Math.imul(Ue, tt)) | 0), - (f = (f + Math.imul(Y, $e)) | 0), - (x = (x + Math.imul(Y, tt)) | 0), - (b = (b + Math.imul(Ve, ie)) | 0), - (f = (f + Math.imul(Ve, re)) | 0), - (f = (f + Math.imul(We, ie)) | 0), - (x = (x + Math.imul(We, re)) | 0), - (b = (b + Math.imul(Ee, se)) | 0), - (f = (f + Math.imul(Ee, be)) | 0), - (f = (f + Math.imul(Be, se)) | 0), - (x = (x + Math.imul(Be, be)) | 0), - (b = (b + Math.imul(me, Ae)) | 0), - (f = (f + Math.imul(me, ke)) | 0), - (f = (f + Math.imul(_e, Ae)) | 0), - (x = (x + Math.imul(_e, ke)) | 0); - var Pt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Pt >>> 26)) | 0), - (Pt &= 67108863), - (b = Math.imul(j, $e)), - (f = Math.imul(j, tt)), - (f = (f + Math.imul(ce, $e)) | 0), - (x = Math.imul(ce, tt)), - (b = (b + Math.imul(Ue, ie)) | 0), - (f = (f + Math.imul(Ue, re)) | 0), - (f = (f + Math.imul(Y, ie)) | 0), - (x = (x + Math.imul(Y, re)) | 0), - (b = (b + Math.imul(Ve, se)) | 0), - (f = (f + Math.imul(Ve, be)) | 0), - (f = (f + Math.imul(We, se)) | 0), - (x = (x + Math.imul(We, be)) | 0), - (b = (b + Math.imul(Ee, Ae)) | 0), - (f = (f + Math.imul(Ee, ke)) | 0), - (f = (f + Math.imul(Be, Ae)) | 0), - (x = (x + Math.imul(Be, ke)) | 0); - var It = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (It >>> 26)) | 0), - (It &= 67108863), - (b = Math.imul(j, ie)), - (f = Math.imul(j, re)), - (f = (f + Math.imul(ce, ie)) | 0), - (x = Math.imul(ce, re)), - (b = (b + Math.imul(Ue, se)) | 0), - (f = (f + Math.imul(Ue, be)) | 0), - (f = (f + Math.imul(Y, se)) | 0), - (x = (x + Math.imul(Y, be)) | 0), - (b = (b + Math.imul(Ve, Ae)) | 0), - (f = (f + Math.imul(Ve, ke)) | 0), - (f = (f + Math.imul(We, Ae)) | 0), - (x = (x + Math.imul(We, ke)) | 0); - var yt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (yt >>> 26)) | 0), - (yt &= 67108863), - (b = Math.imul(j, se)), - (f = Math.imul(j, be)), - (f = (f + Math.imul(ce, se)) | 0), - (x = Math.imul(ce, be)), - (b = (b + Math.imul(Ue, Ae)) | 0), - (f = (f + Math.imul(Ue, ke)) | 0), - (f = (f + Math.imul(Y, Ae)) | 0), - (x = (x + Math.imul(Y, ke)) | 0); - var nt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (nt >>> 26)) | 0), - (nt &= 67108863), - (b = Math.imul(j, Ae)), - (f = Math.imul(j, ke)), - (f = (f + Math.imul(ce, Ae)) | 0), - (x = Math.imul(ce, ke)); - var it = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - return ( - (S = (((x + (f >>> 13)) | 0) + (it >>> 26)) | 0), - (it &= 67108863), - (_[0] = Ct), - (_[1] = ut), - (_[2] = St), - (_[3] = wt), - (_[4] = zt), - (_[5] = jt), - (_[6] = Ht), - (_[7] = Ut), - (_[8] = Kt), - (_[9] = Ot), - (_[10] = Bt), - (_[11] = Et), - (_[12] = Mt), - (_[13] = gt), - (_[14] = Pt), - (_[15] = It), - (_[16] = yt), - (_[17] = nt), - (_[18] = it), - S !== 0 && ((_[19] = S), y.length++), - y - ); - }; - Math.imul || (O = k); - function D(A, l, p) { - (p.negative = l.negative ^ A.negative), - (p.length = A.length + l.length); - for (var y = 0, d = 0, v = 0; v < p.length - 1; v++) { - var _ = d; - d = 0; - for ( - var S = y & 67108863, - b = Math.min(v, l.length - 1), - f = Math.max(0, v - A.length + 1); - f <= b; - f++ - ) { - var x = v - f, - C = A.words[x] | 0, - E = l.words[f] | 0, - B = C * E, - G = B & 67108863; - (_ = (_ + ((B / 67108864) | 0)) | 0), - (G = (G + S) | 0), - (S = G & 67108863), - (_ = (_ + (G >>> 26)) | 0), - (d += _ >>> 26), - (_ &= 67108863); - } - (p.words[v] = S), (y = _), (_ = d); - } - return y !== 0 ? (p.words[v] = y) : p.length--, p.strip(); - } - function F(A, l, p) { - var y = new N(); - return y.mulp(A, l, p); - } - i.prototype.mulTo = function (l, p) { - var y, - d = this.length + l.length; - return ( - this.length === 10 && l.length === 10 - ? (y = O(this, l, p)) - : d < 63 - ? (y = k(this, l, p)) - : d < 1024 - ? (y = D(this, l, p)) - : (y = F(this, l, p)), - y - ); - }; - function N(A, l) { - (this.x = A), (this.y = l); - } - (N.prototype.makeRBT = function (l) { - for ( - var p = new Array(l), y = i.prototype._countBits(l) - 1, d = 0; - d < l; - d++ - ) - p[d] = this.revBin(d, y, l); - return p; - }), - (N.prototype.revBin = function (l, p, y) { - if (l === 0 || l === y - 1) return l; - for (var d = 0, v = 0; v < p; v++) - (d |= (l & 1) << (p - v - 1)), (l >>= 1); - return d; - }), - (N.prototype.permute = function (l, p, y, d, v, _) { - for (var S = 0; S < _; S++) (d[S] = p[l[S]]), (v[S] = y[l[S]]); - }), - (N.prototype.transform = function (l, p, y, d, v, _) { - this.permute(_, l, p, y, d, v); - for (var S = 1; S < v; S <<= 1) - for ( - var b = S << 1, - f = Math.cos((2 * Math.PI) / b), - x = Math.sin((2 * Math.PI) / b), - C = 0; - C < v; - C += b - ) - for (var E = f, B = x, G = 0; G < S; G++) { - var L = y[C + G], - ee = d[C + G], - ge = y[C + G + S], - fe = d[C + G + S], - V = E * ge - B * fe; - (fe = E * fe + B * ge), - (ge = V), - (y[C + G] = L + ge), - (d[C + G] = ee + fe), - (y[C + G + S] = L - ge), - (d[C + G + S] = ee - fe), - G !== b && - ((V = f * E - x * B), (B = f * B + x * E), (E = V)); - } - }), - (N.prototype.guessLen13b = function (l, p) { - var y = Math.max(p, l) | 1, - d = y & 1, - v = 0; - for (y = (y / 2) | 0; y; y = y >>> 1) v++; - return 1 << (v + 1 + d); - }), - (N.prototype.conjugate = function (l, p, y) { - if (!(y <= 1)) - for (var d = 0; d < y / 2; d++) { - var v = l[d]; - (l[d] = l[y - d - 1]), - (l[y - d - 1] = v), - (v = p[d]), - (p[d] = -p[y - d - 1]), - (p[y - d - 1] = -v); - } - }), - (N.prototype.normalize13b = function (l, p) { - for (var y = 0, d = 0; d < p / 2; d++) { - var v = - Math.round(l[2 * d + 1] / p) * 8192 + - Math.round(l[2 * d] / p) + - y; - (l[d] = v & 67108863), - v < 67108864 ? (y = 0) : (y = (v / 67108864) | 0); - } - return l; - }), - (N.prototype.convert13b = function (l, p, y, d) { - for (var v = 0, _ = 0; _ < p; _++) - (v = v + (l[_] | 0)), - (y[2 * _] = v & 8191), - (v = v >>> 13), - (y[2 * _ + 1] = v & 8191), - (v = v >>> 13); - for (_ = 2 * p; _ < d; ++_) y[_] = 0; - r(v === 0), r((v & -8192) === 0); - }), - (N.prototype.stub = function (l) { - for (var p = new Array(l), y = 0; y < l; y++) p[y] = 0; - return p; - }), - (N.prototype.mulp = function (l, p, y) { - var d = 2 * this.guessLen13b(l.length, p.length), - v = this.makeRBT(d), - _ = this.stub(d), - S = new Array(d), - b = new Array(d), - f = new Array(d), - x = new Array(d), - C = new Array(d), - E = new Array(d), - B = y.words; - (B.length = d), - this.convert13b(l.words, l.length, S, d), - this.convert13b(p.words, p.length, x, d), - this.transform(S, _, b, f, d, v), - this.transform(x, _, C, E, d, v); - for (var G = 0; G < d; G++) { - var L = b[G] * C[G] - f[G] * E[G]; - (f[G] = b[G] * E[G] + f[G] * C[G]), (b[G] = L); - } - return ( - this.conjugate(b, f, d), - this.transform(b, f, B, _, d, v), - this.conjugate(B, _, d), - this.normalize13b(B, d), - (y.negative = l.negative ^ p.negative), - (y.length = l.length + p.length), - y.strip() - ); - }), - (i.prototype.mul = function (l) { - var p = new i(null); - return ( - (p.words = new Array(this.length + l.length)), this.mulTo(l, p) - ); - }), - (i.prototype.mulf = function (l) { - var p = new i(null); - return (p.words = new Array(this.length + l.length)), F(this, l, p); - }), - (i.prototype.imul = function (l) { - return this.clone().mulTo(l, this); - }), - (i.prototype.imuln = function (l) { - r(typeof l == "number"), r(l < 67108864); - for (var p = 0, y = 0; y < this.length; y++) { - var d = (this.words[y] | 0) * l, - v = (d & 67108863) + (p & 67108863); - (p >>= 26), - (p += (d / 67108864) | 0), - (p += v >>> 26), - (this.words[y] = v & 67108863); - } - return p !== 0 && ((this.words[y] = p), this.length++), this; - }), - (i.prototype.muln = function (l) { - return this.clone().imuln(l); - }), - (i.prototype.sqr = function () { - return this.mul(this); - }), - (i.prototype.isqr = function () { - return this.imul(this.clone()); - }), - (i.prototype.pow = function (l) { - var p = M(l); - if (p.length === 0) return new i(1); - for ( - var y = this, d = 0; - d < p.length && p[d] === 0; - d++, y = y.sqr() - ); - if (++d < p.length) - for (var v = y.sqr(); d < p.length; d++, v = v.sqr()) - p[d] !== 0 && (y = y.mul(v)); - return y; - }), - (i.prototype.iushln = function (l) { - r(typeof l == "number" && l >= 0); - var p = l % 26, - y = (l - p) / 26, - d = (67108863 >>> (26 - p)) << (26 - p), - v; - if (p !== 0) { - var _ = 0; - for (v = 0; v < this.length; v++) { - var S = this.words[v] & d, - b = ((this.words[v] | 0) - S) << p; - (this.words[v] = b | _), (_ = S >>> (26 - p)); - } - _ && ((this.words[v] = _), this.length++); - } - if (y !== 0) { - for (v = this.length - 1; v >= 0; v--) - this.words[v + y] = this.words[v]; - for (v = 0; v < y; v++) this.words[v] = 0; - this.length += y; - } - return this.strip(); - }), - (i.prototype.ishln = function (l) { - return r(this.negative === 0), this.iushln(l); - }), - (i.prototype.iushrn = function (l, p, y) { - r(typeof l == "number" && l >= 0); - var d; - p ? (d = (p - (p % 26)) / 26) : (d = 0); - var v = l % 26, - _ = Math.min((l - v) / 26, this.length), - S = 67108863 ^ ((67108863 >>> v) << v), - b = y; - if (((d -= _), (d = Math.max(0, d)), b)) { - for (var f = 0; f < _; f++) b.words[f] = this.words[f]; - b.length = _; - } - if (_ !== 0) - if (this.length > _) - for (this.length -= _, f = 0; f < this.length; f++) - this.words[f] = this.words[f + _]; - else (this.words[0] = 0), (this.length = 1); - var x = 0; - for (f = this.length - 1; f >= 0 && (x !== 0 || f >= d); f--) { - var C = this.words[f] | 0; - (this.words[f] = (x << (26 - v)) | (C >>> v)), (x = C & S); - } - return ( - b && x !== 0 && (b.words[b.length++] = x), - this.length === 0 && ((this.words[0] = 0), (this.length = 1)), - this.strip() - ); - }), - (i.prototype.ishrn = function (l, p, y) { - return r(this.negative === 0), this.iushrn(l, p, y); - }), - (i.prototype.shln = function (l) { - return this.clone().ishln(l); - }), - (i.prototype.ushln = function (l) { - return this.clone().iushln(l); - }), - (i.prototype.shrn = function (l) { - return this.clone().ishrn(l); - }), - (i.prototype.ushrn = function (l) { - return this.clone().iushrn(l); - }), - (i.prototype.testn = function (l) { - r(typeof l == "number" && l >= 0); - var p = l % 26, - y = (l - p) / 26, - d = 1 << p; - if (this.length <= y) return !1; - var v = this.words[y]; - return !!(v & d); - }), - (i.prototype.imaskn = function (l) { - r(typeof l == "number" && l >= 0); - var p = l % 26, - y = (l - p) / 26; - if ( - (r(this.negative === 0, "imaskn works only with positive numbers"), - this.length <= y) - ) - return this; - if ( - (p !== 0 && y++, (this.length = Math.min(y, this.length)), p !== 0) - ) { - var d = 67108863 ^ ((67108863 >>> p) << p); - this.words[this.length - 1] &= d; - } - return this.strip(); - }), - (i.prototype.maskn = function (l) { - return this.clone().imaskn(l); - }), - (i.prototype.iaddn = function (l) { - return ( - r(typeof l == "number"), - r(l < 67108864), - l < 0 - ? this.isubn(-l) - : this.negative !== 0 - ? this.length === 1 && (this.words[0] | 0) < l - ? ((this.words[0] = l - (this.words[0] | 0)), - (this.negative = 0), - this) - : ((this.negative = 0), - this.isubn(l), - (this.negative = 1), - this) - : this._iaddn(l) - ); - }), - (i.prototype._iaddn = function (l) { - this.words[0] += l; - for (var p = 0; p < this.length && this.words[p] >= 67108864; p++) - (this.words[p] -= 67108864), - p === this.length - 1 - ? (this.words[p + 1] = 1) - : this.words[p + 1]++; - return (this.length = Math.max(this.length, p + 1)), this; - }), - (i.prototype.isubn = function (l) { - if ((r(typeof l == "number"), r(l < 67108864), l < 0)) - return this.iaddn(-l); - if (this.negative !== 0) - return ( - (this.negative = 0), this.iaddn(l), (this.negative = 1), this - ); - if (((this.words[0] -= l), this.length === 1 && this.words[0] < 0)) - (this.words[0] = -this.words[0]), (this.negative = 1); - else - for (var p = 0; p < this.length && this.words[p] < 0; p++) - (this.words[p] += 67108864), (this.words[p + 1] -= 1); - return this.strip(); - }), - (i.prototype.addn = function (l) { - return this.clone().iaddn(l); - }), - (i.prototype.subn = function (l) { - return this.clone().isubn(l); - }), - (i.prototype.iabs = function () { - return (this.negative = 0), this; - }), - (i.prototype.abs = function () { - return this.clone().iabs(); - }), - (i.prototype._ishlnsubmul = function (l, p, y) { - var d = l.length + y, - v; - this._expand(d); - var _, - S = 0; - for (v = 0; v < l.length; v++) { - _ = (this.words[v + y] | 0) + S; - var b = (l.words[v] | 0) * p; - (_ -= b & 67108863), - (S = (_ >> 26) - ((b / 67108864) | 0)), - (this.words[v + y] = _ & 67108863); - } - for (; v < this.length - y; v++) - (_ = (this.words[v + y] | 0) + S), - (S = _ >> 26), - (this.words[v + y] = _ & 67108863); - if (S === 0) return this.strip(); - for (r(S === -1), S = 0, v = 0; v < this.length; v++) - (_ = -(this.words[v] | 0) + S), - (S = _ >> 26), - (this.words[v] = _ & 67108863); - return (this.negative = 1), this.strip(); - }), - (i.prototype._wordDiv = function (l, p) { - var y = this.length - l.length, - d = this.clone(), - v = l, - _ = v.words[v.length - 1] | 0, - S = this._countBits(_); - (y = 26 - S), - y !== 0 && - ((v = v.ushln(y)), d.iushln(y), (_ = v.words[v.length - 1] | 0)); - var b = d.length - v.length, - f; - if (p !== "mod") { - (f = new i(null)), - (f.length = b + 1), - (f.words = new Array(f.length)); - for (var x = 0; x < f.length; x++) f.words[x] = 0; - } - var C = d.clone()._ishlnsubmul(v, 1, b); - C.negative === 0 && ((d = C), f && (f.words[b] = 1)); - for (var E = b - 1; E >= 0; E--) { - var B = - (d.words[v.length + E] | 0) * 67108864 + - (d.words[v.length + E - 1] | 0); - for ( - B = Math.min((B / _) | 0, 67108863), d._ishlnsubmul(v, B, E); - d.negative !== 0; - - ) - B--, - (d.negative = 0), - d._ishlnsubmul(v, 1, E), - d.isZero() || (d.negative ^= 1); - f && (f.words[E] = B); - } - return ( - f && f.strip(), - d.strip(), - p !== "div" && y !== 0 && d.iushrn(y), - { div: f || null, mod: d } - ); - }), - (i.prototype.divmod = function (l, p, y) { - if ((r(!l.isZero()), this.isZero())) - return { div: new i(0), mod: new i(0) }; - var d, v, _; - return this.negative !== 0 && l.negative === 0 - ? ((_ = this.neg().divmod(l, p)), - p !== "mod" && (d = _.div.neg()), - p !== "div" && - ((v = _.mod.neg()), y && v.negative !== 0 && v.iadd(l)), - { div: d, mod: v }) - : this.negative === 0 && l.negative !== 0 - ? ((_ = this.divmod(l.neg(), p)), - p !== "mod" && (d = _.div.neg()), - { div: d, mod: _.mod }) - : (this.negative & l.negative) !== 0 - ? ((_ = this.neg().divmod(l.neg(), p)), - p !== "div" && - ((v = _.mod.neg()), y && v.negative !== 0 && v.isub(l)), - { div: _.div, mod: v }) - : l.length > this.length || this.cmp(l) < 0 - ? { div: new i(0), mod: this } - : l.length === 1 - ? p === "div" - ? { div: this.divn(l.words[0]), mod: null } - : p === "mod" - ? { div: null, mod: new i(this.modn(l.words[0])) } - : { - div: this.divn(l.words[0]), - mod: new i(this.modn(l.words[0])), - } - : this._wordDiv(l, p); - }), - (i.prototype.div = function (l) { - return this.divmod(l, "div", !1).div; - }), - (i.prototype.mod = function (l) { - return this.divmod(l, "mod", !1).mod; - }), - (i.prototype.umod = function (l) { - return this.divmod(l, "mod", !0).mod; - }), - (i.prototype.divRound = function (l) { - var p = this.divmod(l); - if (p.mod.isZero()) return p.div; - var y = p.div.negative !== 0 ? p.mod.isub(l) : p.mod, - d = l.ushrn(1), - v = l.andln(1), - _ = y.cmp(d); - return _ < 0 || (v === 1 && _ === 0) - ? p.div - : p.div.negative !== 0 - ? p.div.isubn(1) - : p.div.iaddn(1); - }), - (i.prototype.modn = function (l) { - r(l <= 67108863); - for (var p = (1 << 26) % l, y = 0, d = this.length - 1; d >= 0; d--) - y = (p * y + (this.words[d] | 0)) % l; - return y; - }), - (i.prototype.idivn = function (l) { - r(l <= 67108863); - for (var p = 0, y = this.length - 1; y >= 0; y--) { - var d = (this.words[y] | 0) + p * 67108864; - (this.words[y] = (d / l) | 0), (p = d % l); - } - return this.strip(); - }), - (i.prototype.divn = function (l) { - return this.clone().idivn(l); - }), - (i.prototype.egcd = function (l) { - r(l.negative === 0), r(!l.isZero()); - var p = this, - y = l.clone(); - p.negative !== 0 ? (p = p.umod(l)) : (p = p.clone()); - for ( - var d = new i(1), v = new i(0), _ = new i(0), S = new i(1), b = 0; - p.isEven() && y.isEven(); - - ) - p.iushrn(1), y.iushrn(1), ++b; - for (var f = y.clone(), x = p.clone(); !p.isZero(); ) { - for ( - var C = 0, E = 1; - (p.words[0] & E) === 0 && C < 26; - ++C, E <<= 1 - ); - if (C > 0) - for (p.iushrn(C); C-- > 0; ) - (d.isOdd() || v.isOdd()) && (d.iadd(f), v.isub(x)), - d.iushrn(1), - v.iushrn(1); - for ( - var B = 0, G = 1; - (y.words[0] & G) === 0 && B < 26; - ++B, G <<= 1 - ); - if (B > 0) - for (y.iushrn(B); B-- > 0; ) - (_.isOdd() || S.isOdd()) && (_.iadd(f), S.isub(x)), - _.iushrn(1), - S.iushrn(1); - p.cmp(y) >= 0 - ? (p.isub(y), d.isub(_), v.isub(S)) - : (y.isub(p), _.isub(d), S.isub(v)); - } - return { a: _, b: S, gcd: y.iushln(b) }; - }), - (i.prototype._invmp = function (l) { - r(l.negative === 0), r(!l.isZero()); - var p = this, - y = l.clone(); - p.negative !== 0 ? (p = p.umod(l)) : (p = p.clone()); - for ( - var d = new i(1), v = new i(0), _ = y.clone(); - p.cmpn(1) > 0 && y.cmpn(1) > 0; - - ) { - for ( - var S = 0, b = 1; - (p.words[0] & b) === 0 && S < 26; - ++S, b <<= 1 - ); - if (S > 0) - for (p.iushrn(S); S-- > 0; ) d.isOdd() && d.iadd(_), d.iushrn(1); - for ( - var f = 0, x = 1; - (y.words[0] & x) === 0 && f < 26; - ++f, x <<= 1 - ); - if (f > 0) - for (y.iushrn(f); f-- > 0; ) v.isOdd() && v.iadd(_), v.iushrn(1); - p.cmp(y) >= 0 ? (p.isub(y), d.isub(v)) : (y.isub(p), v.isub(d)); - } - var C; - return ( - p.cmpn(1) === 0 ? (C = d) : (C = v), C.cmpn(0) < 0 && C.iadd(l), C - ); - }), - (i.prototype.gcd = function (l) { - if (this.isZero()) return l.abs(); - if (l.isZero()) return this.abs(); - var p = this.clone(), - y = l.clone(); - (p.negative = 0), (y.negative = 0); - for (var d = 0; p.isEven() && y.isEven(); d++) - p.iushrn(1), y.iushrn(1); - do { - for (; p.isEven(); ) p.iushrn(1); - for (; y.isEven(); ) y.iushrn(1); - var v = p.cmp(y); - if (v < 0) { - var _ = p; - (p = y), (y = _); - } else if (v === 0 || y.cmpn(1) === 0) break; - p.isub(y); - } while (!0); - return y.iushln(d); - }), - (i.prototype.invm = function (l) { - return this.egcd(l).a.umod(l); - }), - (i.prototype.isEven = function () { - return (this.words[0] & 1) === 0; - }), - (i.prototype.isOdd = function () { - return (this.words[0] & 1) === 1; - }), - (i.prototype.andln = function (l) { - return this.words[0] & l; - }), - (i.prototype.bincn = function (l) { - r(typeof l == "number"); - var p = l % 26, - y = (l - p) / 26, - d = 1 << p; - if (this.length <= y) - return this._expand(y + 1), (this.words[y] |= d), this; - for (var v = d, _ = y; v !== 0 && _ < this.length; _++) { - var S = this.words[_] | 0; - (S += v), (v = S >>> 26), (S &= 67108863), (this.words[_] = S); - } - return v !== 0 && ((this.words[_] = v), this.length++), this; - }), - (i.prototype.isZero = function () { - return this.length === 1 && this.words[0] === 0; - }), - (i.prototype.cmpn = function (l) { - var p = l < 0; - if (this.negative !== 0 && !p) return -1; - if (this.negative === 0 && p) return 1; - this.strip(); - var y; - if (this.length > 1) y = 1; - else { - p && (l = -l), r(l <= 67108863, "Number is too big"); - var d = this.words[0] | 0; - y = d === l ? 0 : d < l ? -1 : 1; - } - return this.negative !== 0 ? -y | 0 : y; - }), - (i.prototype.cmp = function (l) { - if (this.negative !== 0 && l.negative === 0) return -1; - if (this.negative === 0 && l.negative !== 0) return 1; - var p = this.ucmp(l); - return this.negative !== 0 ? -p | 0 : p; - }), - (i.prototype.ucmp = function (l) { - if (this.length > l.length) return 1; - if (this.length < l.length) return -1; - for (var p = 0, y = this.length - 1; y >= 0; y--) { - var d = this.words[y] | 0, - v = l.words[y] | 0; - if (d !== v) { - d < v ? (p = -1) : d > v && (p = 1); - break; - } - } - return p; - }), - (i.prototype.gtn = function (l) { - return this.cmpn(l) === 1; - }), - (i.prototype.gt = function (l) { - return this.cmp(l) === 1; - }), - (i.prototype.gten = function (l) { - return this.cmpn(l) >= 0; - }), - (i.prototype.gte = function (l) { - return this.cmp(l) >= 0; - }), - (i.prototype.ltn = function (l) { - return this.cmpn(l) === -1; - }), - (i.prototype.lt = function (l) { - return this.cmp(l) === -1; - }), - (i.prototype.lten = function (l) { - return this.cmpn(l) <= 0; - }), - (i.prototype.lte = function (l) { - return this.cmp(l) <= 0; - }), - (i.prototype.eqn = function (l) { - return this.cmpn(l) === 0; - }), - (i.prototype.eq = function (l) { - return this.cmp(l) === 0; - }), - (i.red = function (l) { - return new te(l); - }), - (i.prototype.toRed = function (l) { - return ( - r(!this.red, "Already a number in reduction context"), - r(this.negative === 0, "red works only with positives"), - l.convertTo(this)._forceRed(l) - ); - }), - (i.prototype.fromRed = function () { - return ( - r(this.red, "fromRed works only with numbers in reduction context"), - this.red.convertFrom(this) - ); - }), - (i.prototype._forceRed = function (l) { - return (this.red = l), this; - }), - (i.prototype.forceRed = function (l) { - return ( - r(!this.red, "Already a number in reduction context"), - this._forceRed(l) - ); - }), - (i.prototype.redAdd = function (l) { - return ( - r(this.red, "redAdd works only with red numbers"), - this.red.add(this, l) - ); - }), - (i.prototype.redIAdd = function (l) { - return ( - r(this.red, "redIAdd works only with red numbers"), - this.red.iadd(this, l) - ); - }), - (i.prototype.redSub = function (l) { - return ( - r(this.red, "redSub works only with red numbers"), - this.red.sub(this, l) - ); - }), - (i.prototype.redISub = function (l) { - return ( - r(this.red, "redISub works only with red numbers"), - this.red.isub(this, l) - ); - }), - (i.prototype.redShl = function (l) { - return ( - r(this.red, "redShl works only with red numbers"), - this.red.shl(this, l) - ); - }), - (i.prototype.redMul = function (l) { - return ( - r(this.red, "redMul works only with red numbers"), - this.red._verify2(this, l), - this.red.mul(this, l) - ); - }), - (i.prototype.redIMul = function (l) { - return ( - r(this.red, "redMul works only with red numbers"), - this.red._verify2(this, l), - this.red.imul(this, l) - ); - }), - (i.prototype.redSqr = function () { - return ( - r(this.red, "redSqr works only with red numbers"), - this.red._verify1(this), - this.red.sqr(this) - ); - }), - (i.prototype.redISqr = function () { - return ( - r(this.red, "redISqr works only with red numbers"), - this.red._verify1(this), - this.red.isqr(this) - ); - }), - (i.prototype.redSqrt = function () { - return ( - r(this.red, "redSqrt works only with red numbers"), - this.red._verify1(this), - this.red.sqrt(this) - ); - }), - (i.prototype.redInvm = function () { - return ( - r(this.red, "redInvm works only with red numbers"), - this.red._verify1(this), - this.red.invm(this) - ); - }), - (i.prototype.redNeg = function () { - return ( - r(this.red, "redNeg works only with red numbers"), - this.red._verify1(this), - this.red.neg(this) - ); - }), - (i.prototype.redPow = function (l) { - return ( - r(this.red && !l.red, "redPow(normalNum)"), - this.red._verify1(this), - this.red.pow(this, l) - ); - }); - var q = { k256: null, p224: null, p192: null, p25519: null }; - function z(A, l) { - (this.name = A), - (this.p = new i(l, 16)), - (this.n = this.p.bitLength()), - (this.k = new i(1).iushln(this.n).isub(this.p)), - (this.tmp = this._tmp()); - } - (z.prototype._tmp = function () { - var l = new i(null); - return (l.words = new Array(Math.ceil(this.n / 13))), l; - }), - (z.prototype.ireduce = function (l) { - var p = l, - y; - do - this.split(p, this.tmp), - (p = this.imulK(p)), - (p = p.iadd(this.tmp)), - (y = p.bitLength()); - while (y > this.n); - var d = y < this.n ? -1 : p.ucmp(this.p); - return ( - d === 0 - ? ((p.words[0] = 0), (p.length = 1)) - : d > 0 - ? p.isub(this.p) - : p.strip !== void 0 - ? p.strip() - : p._strip(), - p - ); - }), - (z.prototype.split = function (l, p) { - l.iushrn(this.n, 0, p); - }), - (z.prototype.imulK = function (l) { - return l.imul(this.k); - }); - function H() { - z.call( - this, - "k256", - "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f" - ); - } - n(H, z), - (H.prototype.split = function (l, p) { - for (var y = 4194303, d = Math.min(l.length, 9), v = 0; v < d; v++) - p.words[v] = l.words[v]; - if (((p.length = d), l.length <= 9)) { - (l.words[0] = 0), (l.length = 1); - return; - } - var _ = l.words[9]; - for (p.words[p.length++] = _ & y, v = 10; v < l.length; v++) { - var S = l.words[v] | 0; - (l.words[v - 10] = ((S & y) << 4) | (_ >>> 22)), (_ = S); - } - (_ >>>= 22), - (l.words[v - 10] = _), - _ === 0 && l.length > 10 ? (l.length -= 10) : (l.length -= 9); - }), - (H.prototype.imulK = function (l) { - (l.words[l.length] = 0), (l.words[l.length + 1] = 0), (l.length += 2); - for (var p = 0, y = 0; y < l.length; y++) { - var d = l.words[y] | 0; - (p += d * 977), - (l.words[y] = p & 67108863), - (p = d * 64 + ((p / 67108864) | 0)); - } - return ( - l.words[l.length - 1] === 0 && - (l.length--, l.words[l.length - 1] === 0 && l.length--), - l - ); - }); - function Z() { - z.call( - this, - "p224", - "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001" - ); - } - n(Z, z); - function $() { - z.call( - this, - "p192", - "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff" - ); - } - n($, z); - function ue() { - z.call( - this, - "25519", - "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed" - ); - } - n(ue, z), - (ue.prototype.imulK = function (l) { - for (var p = 0, y = 0; y < l.length; y++) { - var d = (l.words[y] | 0) * 19 + p, - v = d & 67108863; - (d >>>= 26), (l.words[y] = v), (p = d); - } - return p !== 0 && (l.words[l.length++] = p), l; - }), - (i._prime = function (l) { - if (q[l]) return q[l]; - var p; - if (l === "k256") p = new H(); - else if (l === "p224") p = new Z(); - else if (l === "p192") p = new $(); - else if (l === "p25519") p = new ue(); - else throw new Error("Unknown prime " + l); - return (q[l] = p), p; - }); - function te(A) { - if (typeof A == "string") { - var l = i._prime(A); - (this.m = l.p), (this.prime = l); - } else - r(A.gtn(1), "modulus must be greater than 1"), - (this.m = A), - (this.prime = null); - } - (te.prototype._verify1 = function (l) { - r(l.negative === 0, "red works only with positives"), - r(l.red, "red works only with red numbers"); - }), - (te.prototype._verify2 = function (l, p) { - r((l.negative | p.negative) === 0, "red works only with positives"), - r(l.red && l.red === p.red, "red works only with red numbers"); - }), - (te.prototype.imod = function (l) { - return this.prime - ? this.prime.ireduce(l)._forceRed(this) - : l.umod(this.m)._forceRed(this); - }), - (te.prototype.neg = function (l) { - return l.isZero() ? l.clone() : this.m.sub(l)._forceRed(this); - }), - (te.prototype.add = function (l, p) { - this._verify2(l, p); - var y = l.add(p); - return y.cmp(this.m) >= 0 && y.isub(this.m), y._forceRed(this); - }), - (te.prototype.iadd = function (l, p) { - this._verify2(l, p); - var y = l.iadd(p); - return y.cmp(this.m) >= 0 && y.isub(this.m), y; - }), - (te.prototype.sub = function (l, p) { - this._verify2(l, p); - var y = l.sub(p); - return y.cmpn(0) < 0 && y.iadd(this.m), y._forceRed(this); - }), - (te.prototype.isub = function (l, p) { - this._verify2(l, p); - var y = l.isub(p); - return y.cmpn(0) < 0 && y.iadd(this.m), y; - }), - (te.prototype.shl = function (l, p) { - return this._verify1(l), this.imod(l.ushln(p)); - }), - (te.prototype.imul = function (l, p) { - return this._verify2(l, p), this.imod(l.imul(p)); - }), - (te.prototype.mul = function (l, p) { - return this._verify2(l, p), this.imod(l.mul(p)); - }), - (te.prototype.isqr = function (l) { - return this.imul(l, l.clone()); - }), - (te.prototype.sqr = function (l) { - return this.mul(l, l); - }), - (te.prototype.sqrt = function (l) { - if (l.isZero()) return l.clone(); - var p = this.m.andln(3); - if ((r(p % 2 === 1), p === 3)) { - var y = this.m.add(new i(1)).iushrn(2); - return this.pow(l, y); - } - for (var d = this.m.subn(1), v = 0; !d.isZero() && d.andln(1) === 0; ) - v++, d.iushrn(1); - r(!d.isZero()); - var _ = new i(1).toRed(this), - S = _.redNeg(), - b = this.m.subn(1).iushrn(1), - f = this.m.bitLength(); - for (f = new i(2 * f * f).toRed(this); this.pow(f, b).cmp(S) !== 0; ) - f.redIAdd(S); - for ( - var x = this.pow(f, d), - C = this.pow(l, d.addn(1).iushrn(1)), - E = this.pow(l, d), - B = v; - E.cmp(_) !== 0; - - ) { - for (var G = E, L = 0; G.cmp(_) !== 0; L++) G = G.redSqr(); - r(L < B); - var ee = this.pow(x, new i(1).iushln(B - L - 1)); - (C = C.redMul(ee)), (x = ee.redSqr()), (E = E.redMul(x)), (B = L); - } - return C; - }), - (te.prototype.invm = function (l) { - var p = l._invmp(this.m); - return p.negative !== 0 - ? ((p.negative = 0), this.imod(p).redNeg()) - : this.imod(p); - }), - (te.prototype.pow = function (l, p) { - if (p.isZero()) return new i(1).toRed(this); - if (p.cmpn(1) === 0) return l.clone(); - var y = 4, - d = new Array(1 << y); - (d[0] = new i(1).toRed(this)), (d[1] = l); - for (var v = 2; v < d.length; v++) d[v] = this.mul(d[v - 1], l); - var _ = d[0], - S = 0, - b = 0, - f = p.bitLength() % 26; - for (f === 0 && (f = 26), v = p.length - 1; v >= 0; v--) { - for (var x = p.words[v], C = f - 1; C >= 0; C--) { - var E = (x >> C) & 1; - if ((_ !== d[0] && (_ = this.sqr(_)), E === 0 && S === 0)) { - b = 0; - continue; - } - (S <<= 1), - (S |= E), - b++, - !(b !== y && (v !== 0 || C !== 0)) && - ((_ = this.mul(_, d[S])), (b = 0), (S = 0)); - } - f = 26; - } - return _; - }), - (te.prototype.convertTo = function (l) { - var p = l.umod(this.m); - return p === l ? p.clone() : p; - }), - (te.prototype.convertFrom = function (l) { - var p = l.clone(); - return (p.red = null), p; - }), - (i.mont = function (l) { - return new ne(l); - }); - function ne(A) { - te.call(this, A), - (this.shift = this.m.bitLength()), - this.shift % 26 !== 0 && (this.shift += 26 - (this.shift % 26)), - (this.r = new i(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)); - } - n(ne, te), - (ne.prototype.convertTo = function (l) { - return this.imod(l.ushln(this.shift)); - }), - (ne.prototype.convertFrom = function (l) { - var p = this.imod(l.mul(this.rinv)); - return (p.red = null), p; - }), - (ne.prototype.imul = function (l, p) { - if (l.isZero() || p.isZero()) - return (l.words[0] = 0), (l.length = 1), l; - var y = l.imul(p), - d = y - .maskn(this.shift) - .mul(this.minv) - .imaskn(this.shift) - .mul(this.m), - v = y.isub(d).iushrn(this.shift), - _ = v; - return ( - v.cmp(this.m) >= 0 - ? (_ = v.isub(this.m)) - : v.cmpn(0) < 0 && (_ = v.iadd(this.m)), - _._forceRed(this) - ); - }), - (ne.prototype.mul = function (l, p) { - if (l.isZero() || p.isZero()) return new i(0)._forceRed(this); - var y = l.mul(p), - d = y - .maskn(this.shift) - .mul(this.minv) - .imaskn(this.shift) - .mul(this.m), - v = y.isub(d).iushrn(this.shift), - _ = v; - return ( - v.cmp(this.m) >= 0 - ? (_ = v.isub(this.m)) - : v.cmpn(0) < 0 && (_ = v.iadd(this.m)), - _._forceRed(this) - ); - }), - (ne.prototype.invm = function (l) { - var p = this.imod(l._invmp(this.m).mul(this.r2)); - return p._forceRed(this); - }); - })(typeof Pbe > "u" || Pbe, cGe); - }); - var yX = I((kfn, lGe) => { - "use strict"; - m(); - g(); - var pX = Qr(), - L5 = pX.Buffer, - cy = {}, - ly; - for (ly in pX) - !pX.hasOwnProperty(ly) || - ly === "SlowBuffer" || - ly === "Buffer" || - (cy[ly] = pX[ly]); - var q5 = (cy.Buffer = {}); - for (ly in L5) - !L5.hasOwnProperty(ly) || - ly === "allocUnsafe" || - ly === "allocUnsafeSlow" || - (q5[ly] = L5[ly]); - cy.Buffer.prototype = L5.prototype; - (!q5.from || q5.from === Uint8Array.from) && - (q5.from = function (t, e, r) { - if (typeof t == "number") - throw new TypeError( - 'The "value" argument must not be of type number. Received type ' + - typeof t - ); - if (t && typeof t.length > "u") - throw new TypeError( - "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + - typeof t - ); - return L5(t, e, r); - }); - q5.alloc || - (q5.alloc = function (t, e, r) { - if (typeof t != "number") - throw new TypeError( - 'The "size" argument must be of type number. Received type ' + - typeof t - ); - if (t < 0 || t >= 2 * (1 << 30)) - throw new RangeError( - 'The value "' + t + '" is invalid for option "size"' - ); - var n = L5(t); - return ( - !e || e.length === 0 - ? n.fill(0) - : typeof r == "string" - ? n.fill(e, r) - : n.fill(e), - n - ); - }); - if (!cy.kStringMaxLength) - try { - cy.kStringMaxLength = process.binding("buffer").kStringMaxLength; - } catch {} - cy.constants || - ((cy.constants = { MAX_LENGTH: cy.kMaxLength }), - cy.kStringMaxLength && - (cy.constants.MAX_STRING_LENGTH = cy.kStringMaxLength)); - lGe.exports = cy; - }); - var mX = I((fGe) => { - "use strict"; - m(); - g(); - var CQt = dn(); - function fy(t) { - this._reporterState = { - obj: null, - path: [], - options: t || {}, - errors: [], - }; - } - fGe.Reporter = fy; - fy.prototype.isError = function (e) { - return e instanceof z5; - }; - fy.prototype.save = function () { - let e = this._reporterState; - return { obj: e.obj, pathLen: e.path.length }; - }; - fy.prototype.restore = function (e) { - let r = this._reporterState; - (r.obj = e.obj), (r.path = r.path.slice(0, e.pathLen)); - }; - fy.prototype.enterKey = function (e) { - return this._reporterState.path.push(e); - }; - fy.prototype.exitKey = function (e) { - let r = this._reporterState; - r.path = r.path.slice(0, e - 1); - }; - fy.prototype.leaveKey = function (e, r, n) { - let i = this._reporterState; - this.exitKey(e), i.obj !== null && (i.obj[r] = n); - }; - fy.prototype.path = function () { - return this._reporterState.path.join("/"); - }; - fy.prototype.enterObject = function () { - let e = this._reporterState, - r = e.obj; - return (e.obj = {}), r; - }; - fy.prototype.leaveObject = function (e) { - let r = this._reporterState, - n = r.obj; - return (r.obj = e), n; - }; - fy.prototype.error = function (e) { - let r, - n = this._reporterState, - i = e instanceof z5; - if ( - (i - ? (r = e) - : (r = new z5( - n.path - .map(function (o) { - return "[" + JSON.stringify(o) + "]"; - }) - .join(""), - e.message || e, - e.stack - )), - !n.options.partial) - ) - throw r; - return i || n.errors.push(r), r; - }; - fy.prototype.wrapResult = function (e) { - let r = this._reporterState; - return r.options.partial - ? { result: this.isError(e) ? null : e, errors: r.errors } - : e; - }; - function z5(t, e) { - (this.path = t), this.rethrow(e); - } - CQt(z5, Error); - z5.prototype.rethrow = function (e) { - if ( - ((this.message = e + " at: " + (this.path || "(shallow)")), - Error.captureStackTrace && Error.captureStackTrace(this, z5), - !this.stack) - ) - try { - throw new Error(this.message); - } catch (r) { - this.stack = r.stack; - } - return this; - }; - }); - var K5 = I((Bbe) => { - "use strict"; - m(); - g(); - var RQt = dn(), - gX = mX().Reporter, - j5 = yX().Buffer; - function dy(t, e) { - if ((gX.call(this, e), !j5.isBuffer(t))) { - this.error("Input not Buffer"); - return; - } - (this.base = t), (this.offset = 0), (this.length = t.length); - } - RQt(dy, gX); - Bbe.DecoderBuffer = dy; - dy.isDecoderBuffer = function (e) { - return e instanceof dy - ? !0 - : typeof e == "object" && - j5.isBuffer(e.base) && - e.constructor.name === "DecoderBuffer" && - typeof e.offset == "number" && - typeof e.length == "number" && - typeof e.save == "function" && - typeof e.restore == "function" && - typeof e.isEmpty == "function" && - typeof e.readUInt8 == "function" && - typeof e.skip == "function" && - typeof e.raw == "function"; - }; - dy.prototype.save = function () { - return { offset: this.offset, reporter: gX.prototype.save.call(this) }; - }; - dy.prototype.restore = function (e) { - let r = new dy(this.base); - return ( - (r.offset = e.offset), - (r.length = this.offset), - (this.offset = e.offset), - gX.prototype.restore.call(this, e.reporter), - r - ); - }; - dy.prototype.isEmpty = function () { - return this.offset === this.length; - }; - dy.prototype.readUInt8 = function (e) { - return this.offset + 1 <= this.length - ? this.base.readUInt8(this.offset++, !0) - : this.error(e || "DecoderBuffer overrun"); - }; - dy.prototype.skip = function (e, r) { - if (!(this.offset + e <= this.length)) - return this.error(r || "DecoderBuffer overrun"); - let n = new dy(this.base); - return ( - (n._reporterState = this._reporterState), - (n.offset = this.offset), - (n.length = this.offset + e), - (this.offset += e), - n - ); - }; - dy.prototype.raw = function (e) { - return this.base.slice(e ? e.offset : this.offset, this.length); - }; - function U5(t, e) { - if (Array.isArray(t)) - (this.length = 0), - (this.value = t.map(function (r) { - return ( - U5.isEncoderBuffer(r) || (r = new U5(r, e)), - (this.length += r.length), - r - ); - }, this)); - else if (typeof t == "number") { - if (!(0 <= t && t <= 255)) - return e.error("non-byte EncoderBuffer value"); - (this.value = t), (this.length = 1); - } else if (typeof t == "string") - (this.value = t), (this.length = j5.byteLength(t)); - else if (j5.isBuffer(t)) (this.value = t), (this.length = t.length); - else return e.error("Unsupported type: " + typeof t); - } - Bbe.EncoderBuffer = U5; - U5.isEncoderBuffer = function (e) { - return e instanceof U5 - ? !0 - : typeof e == "object" && - e.constructor.name === "EncoderBuffer" && - typeof e.length == "number" && - typeof e.join == "function"; - }; - U5.prototype.join = function (e, r) { - return ( - e || (e = j5.alloc(this.length)), - r || (r = 0), - this.length === 0 || - (Array.isArray(this.value) - ? this.value.forEach(function (n) { - n.join(e, r), (r += n.length); - }) - : (typeof this.value == "number" - ? (e[r] = this.value) - : typeof this.value == "string" - ? e.write(this.value, r) - : j5.isBuffer(this.value) && this.value.copy(e, r), - (r += this.length))), - e - ); - }; - }); - var vX = I((Bfn, hGe) => { - "use strict"; - m(); - g(); - var NQt = mX().Reporter, - DQt = K5().EncoderBuffer, - FQt = K5().DecoderBuffer, - jd = Cp(), - dGe = [ - "seq", - "seqof", - "set", - "setof", - "objid", - "bool", - "gentime", - "utctime", - "null_", - "enum", - "int", - "objDesc", - "bitstr", - "bmpstr", - "charstr", - "genstr", - "graphstr", - "ia5str", - "iso646str", - "numstr", - "octstr", - "printstr", - "t61str", - "unistr", - "utf8str", - "videostr", - ], - LQt = [ - "key", - "obj", - "use", - "optional", - "explicit", - "implicit", - "def", - "choice", - "any", - "contains", - ].concat(dGe), - qQt = [ - "_peekTag", - "_decodeTag", - "_use", - "_decodeStr", - "_decodeObjid", - "_decodeTime", - "_decodeNull", - "_decodeInt", - "_decodeBool", - "_decodeList", - "_encodeComposite", - "_encodeStr", - "_encodeObjid", - "_encodeTime", - "_encodeNull", - "_encodeInt", - "_encodeBool", - ]; - function ao(t, e, r) { - let n = {}; - (this._baseState = n), - (n.name = r), - (n.enc = t), - (n.parent = e || null), - (n.children = null), - (n.tag = null), - (n.args = null), - (n.reverseArgs = null), - (n.choice = null), - (n.optional = !1), - (n.any = !1), - (n.obj = !1), - (n.use = null), - (n.useDecoder = null), - (n.key = null), - (n.default = null), - (n.explicit = null), - (n.implicit = null), - (n.contains = null), - n.parent || ((n.children = []), this._wrap()); - } - hGe.exports = ao; - var zQt = [ - "enc", - "parent", - "children", - "tag", - "args", - "reverseArgs", - "choice", - "optional", - "any", - "obj", - "use", - "alteredUse", - "key", - "default", - "explicit", - "implicit", - "contains", - ]; - ao.prototype.clone = function () { - let e = this._baseState, - r = {}; - zQt.forEach(function (i) { - r[i] = e[i]; - }); - let n = new this.constructor(r.parent); - return (n._baseState = r), n; - }; - ao.prototype._wrap = function () { - let e = this._baseState; - LQt.forEach(function (r) { - this[r] = function () { - let i = new this.constructor(this); - return e.children.push(i), i[r].apply(i, arguments); - }; - }, this); - }; - ao.prototype._init = function (e) { - let r = this._baseState; - jd(r.parent === null), - e.call(this), - (r.children = r.children.filter(function (n) { - return n._baseState.parent === this; - }, this)), - jd.equal(r.children.length, 1, "Root node can have only one child"); - }; - ao.prototype._useArgs = function (e) { - let r = this._baseState, - n = e.filter(function (i) { - return i instanceof this.constructor; - }, this); - (e = e.filter(function (i) { - return !(i instanceof this.constructor); - }, this)), - n.length !== 0 && - (jd(r.children === null), - (r.children = n), - n.forEach(function (i) { - i._baseState.parent = this; - }, this)), - e.length !== 0 && - (jd(r.args === null), - (r.args = e), - (r.reverseArgs = e.map(function (i) { - if (typeof i != "object" || i.constructor !== Object) return i; - let o = {}; - return ( - Object.keys(i).forEach(function (a) { - a == (a | 0) && (a |= 0); - let s = i[a]; - o[s] = a; - }), - o - ); - }))); - }; - qQt.forEach(function (t) { - ao.prototype[t] = function () { - let r = this._baseState; - throw new Error(t + " not implemented for encoding: " + r.enc); - }; - }); - dGe.forEach(function (t) { - ao.prototype[t] = function () { - let r = this._baseState, - n = Array.prototype.slice.call(arguments); - return jd(r.tag === null), (r.tag = t), this._useArgs(n), this; - }; - }); - ao.prototype.use = function (e) { - jd(e); - let r = this._baseState; - return jd(r.use === null), (r.use = e), this; - }; - ao.prototype.optional = function () { - let e = this._baseState; - return (e.optional = !0), this; - }; - ao.prototype.def = function (e) { - let r = this._baseState; - return jd(r.default === null), (r.default = e), (r.optional = !0), this; - }; - ao.prototype.explicit = function (e) { - let r = this._baseState; - return ( - jd(r.explicit === null && r.implicit === null), (r.explicit = e), this - ); - }; - ao.prototype.implicit = function (e) { - let r = this._baseState; - return ( - jd(r.explicit === null && r.implicit === null), (r.implicit = e), this - ); - }; - ao.prototype.obj = function () { - let e = this._baseState, - r = Array.prototype.slice.call(arguments); - return (e.obj = !0), r.length !== 0 && this._useArgs(r), this; - }; - ao.prototype.key = function (e) { - let r = this._baseState; - return jd(r.key === null), (r.key = e), this; - }; - ao.prototype.any = function () { - let e = this._baseState; - return (e.any = !0), this; - }; - ao.prototype.choice = function (e) { - let r = this._baseState; - return ( - jd(r.choice === null), - (r.choice = e), - this._useArgs( - Object.keys(e).map(function (n) { - return e[n]; - }) - ), - this - ); - }; - ao.prototype.contains = function (e) { - let r = this._baseState; - return jd(r.use === null), (r.contains = e), this; - }; - ao.prototype._decode = function (e, r) { - let n = this._baseState; - if (n.parent === null) return e.wrapResult(n.children[0]._decode(e, r)); - let i = n.default, - o = !0, - a = null; - if ((n.key !== null && (a = e.enterKey(n.key)), n.optional)) { - let c = null; - if ( - (n.explicit !== null - ? (c = n.explicit) - : n.implicit !== null - ? (c = n.implicit) - : n.tag !== null && (c = n.tag), - c === null && !n.any) - ) { - let u = e.save(); - try { - n.choice === null - ? this._decodeGeneric(n.tag, e, r) - : this._decodeChoice(e, r), - (o = !0); - } catch { - o = !1; - } - e.restore(u); - } else if (((o = this._peekTag(e, c, n.any)), e.isError(o))) return o; - } - let s; - if ((n.obj && o && (s = e.enterObject()), o)) { - if (n.explicit !== null) { - let u = this._decodeTag(e, n.explicit); - if (e.isError(u)) return u; - e = u; - } - let c = e.offset; - if (n.use === null && n.choice === null) { - let u; - n.any && (u = e.save()); - let h = this._decodeTag( - e, - n.implicit !== null ? n.implicit : n.tag, - n.any - ); - if (e.isError(h)) return h; - n.any ? (i = e.raw(u)) : (e = h); - } - if ( - (r && - r.track && - n.tag !== null && - r.track(e.path(), c, e.length, "tagged"), - r && - r.track && - n.tag !== null && - r.track(e.path(), e.offset, e.length, "content"), - n.any || - (n.choice === null - ? (i = this._decodeGeneric(n.tag, e, r)) - : (i = this._decodeChoice(e, r))), - e.isError(i)) - ) - return i; - if ( - (!n.any && - n.choice === null && - n.children !== null && - n.children.forEach(function (h) { - h._decode(e, r); - }), - n.contains && (n.tag === "octstr" || n.tag === "bitstr")) - ) { - let u = new FQt(i); - i = this._getUse(n.contains, e._reporterState.obj)._decode(u, r); - } - } - return ( - n.obj && o && (i = e.leaveObject(s)), - n.key !== null && (i !== null || o === !0) - ? e.leaveKey(a, n.key, i) - : a !== null && e.exitKey(a), - i - ); - }; - ao.prototype._decodeGeneric = function (e, r, n) { - let i = this._baseState; - return e === "seq" || e === "set" - ? null - : e === "seqof" || e === "setof" - ? this._decodeList(r, e, i.args[0], n) - : /str$/.test(e) - ? this._decodeStr(r, e, n) - : e === "objid" && i.args - ? this._decodeObjid(r, i.args[0], i.args[1], n) - : e === "objid" - ? this._decodeObjid(r, null, null, n) - : e === "gentime" || e === "utctime" - ? this._decodeTime(r, e, n) - : e === "null_" - ? this._decodeNull(r, n) - : e === "bool" - ? this._decodeBool(r, n) - : e === "objDesc" - ? this._decodeStr(r, e, n) - : e === "int" || e === "enum" - ? this._decodeInt(r, i.args && i.args[0], n) - : i.use !== null - ? this._getUse(i.use, r._reporterState.obj)._decode(r, n) - : r.error("unknown tag: " + e); - }; - ao.prototype._getUse = function (e, r) { - let n = this._baseState; - return ( - (n.useDecoder = this._use(e, r)), - jd(n.useDecoder._baseState.parent === null), - (n.useDecoder = n.useDecoder._baseState.children[0]), - n.implicit !== n.useDecoder._baseState.implicit && - ((n.useDecoder = n.useDecoder.clone()), - (n.useDecoder._baseState.implicit = n.implicit)), - n.useDecoder - ); - }; - ao.prototype._decodeChoice = function (e, r) { - let n = this._baseState, - i = null, - o = !1; - return ( - Object.keys(n.choice).some(function (a) { - let s = e.save(), - c = n.choice[a]; - try { - let u = c._decode(e, r); - if (e.isError(u)) return !1; - (i = { type: a, value: u }), (o = !0); - } catch { - return e.restore(s), !1; - } - return !0; - }, this), - o ? i : e.error("Choice not matched") - ); - }; - ao.prototype._createEncoderBuffer = function (e) { - return new DQt(e, this.reporter); - }; - ao.prototype._encode = function (e, r, n) { - let i = this._baseState; - if (i.default !== null && i.default === e) return; - let o = this._encodeValue(e, r, n); - if (o !== void 0 && !this._skipDefault(o, r, n)) return o; - }; - ao.prototype._encodeValue = function (e, r, n) { - let i = this._baseState; - if (i.parent === null) return i.children[0]._encode(e, r || new NQt()); - let o = null; - if (((this.reporter = r), i.optional && e === void 0)) - if (i.default !== null) e = i.default; - else return; - let a = null, - s = !1; - if (i.any) o = this._createEncoderBuffer(e); - else if (i.choice) o = this._encodeChoice(e, r); - else if (i.contains) - (a = this._getUse(i.contains, n)._encode(e, r)), (s = !0); - else if (i.children) - (a = i.children - .map(function (c) { - if (c._baseState.tag === "null_") return c._encode(null, r, e); - if (c._baseState.key === null) - return r.error("Child should have a key"); - let u = r.enterKey(c._baseState.key); - if (typeof e != "object") - return r.error("Child expected, but input is not object"); - let h = c._encode(e[c._baseState.key], r, e); - return r.leaveKey(u), h; - }, this) - .filter(function (c) { - return c; - })), - (a = this._createEncoderBuffer(a)); - else if (i.tag === "seqof" || i.tag === "setof") { - if (!(i.args && i.args.length === 1)) - return r.error("Too many args for : " + i.tag); - if (!Array.isArray(e)) - return r.error("seqof/setof, but data is not Array"); - let c = this.clone(); - (c._baseState.implicit = null), - (a = this._createEncoderBuffer( - e.map(function (u) { - let h = this._baseState; - return this._getUse(h.args[0], e)._encode(u, r); - }, c) - )); - } else - i.use !== null - ? (o = this._getUse(i.use, n)._encode(e, r)) - : ((a = this._encodePrimitive(i.tag, e)), (s = !0)); - if (!i.any && i.choice === null) { - let c = i.implicit !== null ? i.implicit : i.tag, - u = i.implicit === null ? "universal" : "context"; - c === null - ? i.use === null && r.error("Tag could be omitted only for .use()") - : i.use === null && (o = this._encodeComposite(c, s, u, a)); - } - return ( - i.explicit !== null && - (o = this._encodeComposite(i.explicit, !1, "context", o)), - o - ); - }; - ao.prototype._encodeChoice = function (e, r) { - let n = this._baseState, - i = n.choice[e.type]; - return ( - i || - jd( - !1, - e.type + " not found in " + JSON.stringify(Object.keys(n.choice)) - ), - i._encode(e.value, r) - ); - }; - ao.prototype._encodePrimitive = function (e, r) { - let n = this._baseState; - if (/str$/.test(e)) return this._encodeStr(r, e); - if (e === "objid" && n.args) - return this._encodeObjid(r, n.reverseArgs[0], n.args[1]); - if (e === "objid") return this._encodeObjid(r, null, null); - if (e === "gentime" || e === "utctime") return this._encodeTime(r, e); - if (e === "null_") return this._encodeNull(); - if (e === "int" || e === "enum") - return this._encodeInt(r, n.args && n.reverseArgs[0]); - if (e === "bool") return this._encodeBool(r); - if (e === "objDesc") return this._encodeStr(r, e); - throw new Error("Unsupported tag: " + e); - }; - ao.prototype._isNumstr = function (e) { - return /^[0-9 ]*$/.test(e); - }; - ao.prototype._isPrintstr = function (e) { - return /^[A-Za-z0-9 '()+,-./:=?]*$/.test(e); - }; - }); - var bX = I((RM) => { - "use strict"; - m(); - g(); - function pGe(t) { - let e = {}; - return ( - Object.keys(t).forEach(function (r) { - (r | 0) == r && (r = r | 0); - let n = t[r]; - e[n] = r; - }), - e - ); - } - RM.tagClass = { - 0: "universal", - 1: "application", - 2: "context", - 3: "private", - }; - RM.tagClassByName = pGe(RM.tagClass); - RM.tag = { - 0: "end", - 1: "bool", - 2: "int", - 3: "bitstr", - 4: "octstr", - 5: "null_", - 6: "objid", - 7: "objDesc", - 8: "external", - 9: "real", - 10: "enum", - 11: "embed", - 12: "utf8str", - 13: "relativeOid", - 16: "seq", - 17: "set", - 18: "numstr", - 19: "printstr", - 20: "t61str", - 21: "videostr", - 22: "ia5str", - 23: "utctime", - 24: "gentime", - 25: "graphstr", - 26: "iso646str", - 27: "genstr", - 28: "unistr", - 29: "charstr", - 30: "bmpstr", - }; - RM.tagByName = pGe(RM.tag); - }); - var Cbe = I((Cfn, gGe) => { - "use strict"; - m(); - g(); - var jQt = dn(), - F_ = yX().Buffer, - yGe = vX(), - Ibe = bX(); - function mGe(t) { - (this.enc = "der"), - (this.name = t.name), - (this.entity = t), - (this.tree = new zm()), - this.tree._init(t.body); - } - gGe.exports = mGe; - mGe.prototype.encode = function (e, r) { - return this.tree._encode(e, r).join(); - }; - function zm(t) { - yGe.call(this, "der", t); - } - jQt(zm, yGe); - zm.prototype._encodeComposite = function (e, r, n, i) { - let o = UQt(e, r, n, this.reporter); - if (i.length < 128) { - let c = F_.alloc(2); - return (c[0] = o), (c[1] = i.length), this._createEncoderBuffer([c, i]); - } - let a = 1; - for (let c = i.length; c >= 256; c >>= 8) a++; - let s = F_.alloc(1 + 1 + a); - (s[0] = o), (s[1] = 128 | a); - for (let c = 1 + a, u = i.length; u > 0; c--, u >>= 8) s[c] = u & 255; - return this._createEncoderBuffer([s, i]); - }; - zm.prototype._encodeStr = function (e, r) { - if (r === "bitstr") - return this._createEncoderBuffer([e.unused | 0, e.data]); - if (r === "bmpstr") { - let n = F_.alloc(e.length * 2); - for (let i = 0; i < e.length; i++) - n.writeUInt16BE(e.charCodeAt(i), i * 2); - return this._createEncoderBuffer(n); - } else - return r === "numstr" - ? this._isNumstr(e) - ? this._createEncoderBuffer(e) - : this.reporter.error( - "Encoding of string type: numstr supports only digits and space" - ) - : r === "printstr" - ? this._isPrintstr(e) - ? this._createEncoderBuffer(e) - : this.reporter.error( - "Encoding of string type: printstr supports only latin upper and lower case letters, digits, space, apostrophe, left and rigth parenthesis, plus sign, comma, hyphen, dot, slash, colon, equal sign, question mark" - ) - : /str$/.test(r) - ? this._createEncoderBuffer(e) - : r === "objDesc" - ? this._createEncoderBuffer(e) - : this.reporter.error( - "Encoding of string type: " + r + " unsupported" - ); - }; - zm.prototype._encodeObjid = function (e, r, n) { - if (typeof e == "string") { - if (!r) - return this.reporter.error( - "string objid given, but no values map found" - ); - if (!r.hasOwnProperty(e)) - return this.reporter.error("objid not found in values map"); - e = r[e].split(/[\s.]+/g); - for (let s = 0; s < e.length; s++) e[s] |= 0; - } else if (Array.isArray(e)) { - e = e.slice(); - for (let s = 0; s < e.length; s++) e[s] |= 0; - } - if (!Array.isArray(e)) - return this.reporter.error( - "objid() should be either array or string, got: " + JSON.stringify(e) - ); - if (!n) { - if (e[1] >= 40) - return this.reporter.error("Second objid identifier OOB"); - e.splice(0, 2, e[0] * 40 + e[1]); - } - let i = 0; - for (let s = 0; s < e.length; s++) { - let c = e[s]; - for (i++; c >= 128; c >>= 7) i++; - } - let o = F_.alloc(i), - a = o.length - 1; - for (let s = e.length - 1; s >= 0; s--) { - let c = e[s]; - for (o[a--] = c & 127; (c >>= 7) > 0; ) o[a--] = 128 | (c & 127); - } - return this._createEncoderBuffer(o); - }; - function hy(t) { - return t < 10 ? "0" + t : t; - } - zm.prototype._encodeTime = function (e, r) { - let n, - i = new Date(e); - return ( - r === "gentime" - ? (n = [ - hy(i.getUTCFullYear()), - hy(i.getUTCMonth() + 1), - hy(i.getUTCDate()), - hy(i.getUTCHours()), - hy(i.getUTCMinutes()), - hy(i.getUTCSeconds()), - "Z", - ].join("")) - : r === "utctime" - ? (n = [ - hy(i.getUTCFullYear() % 100), - hy(i.getUTCMonth() + 1), - hy(i.getUTCDate()), - hy(i.getUTCHours()), - hy(i.getUTCMinutes()), - hy(i.getUTCSeconds()), - "Z", - ].join("")) - : this.reporter.error("Encoding " + r + " time is not supported yet"), - this._encodeStr(n, "octstr") - ); - }; - zm.prototype._encodeNull = function () { - return this._createEncoderBuffer(""); - }; - zm.prototype._encodeInt = function (e, r) { - if (typeof e == "string") { - if (!r) - return this.reporter.error( - "String int or enum given, but no values map" - ); - if (!r.hasOwnProperty(e)) - return this.reporter.error( - "Values map doesn't contain: " + JSON.stringify(e) - ); - e = r[e]; - } - if (typeof e != "number" && !F_.isBuffer(e)) { - let o = e.toArray(); - !e.sign && o[0] & 128 && o.unshift(0), (e = F_.from(o)); - } - if (F_.isBuffer(e)) { - let o = e.length; - e.length === 0 && o++; - let a = F_.alloc(o); - return ( - e.copy(a), e.length === 0 && (a[0] = 0), this._createEncoderBuffer(a) - ); - } - if (e < 128) return this._createEncoderBuffer(e); - if (e < 256) return this._createEncoderBuffer([0, e]); - let n = 1; - for (let o = e; o >= 256; o >>= 8) n++; - let i = new Array(n); - for (let o = i.length - 1; o >= 0; o--) (i[o] = e & 255), (e >>= 8); - return i[0] & 128 && i.unshift(0), this._createEncoderBuffer(F_.from(i)); - }; - zm.prototype._encodeBool = function (e) { - return this._createEncoderBuffer(e ? 255 : 0); - }; - zm.prototype._use = function (e, r) { - return typeof e == "function" && (e = e(r)), e._getEncoder("der").tree; - }; - zm.prototype._skipDefault = function (e, r, n) { - let i = this._baseState, - o; - if (i.default === null) return !1; - let a = e.join(); - if ( - (i.defaultBuffer === void 0 && - (i.defaultBuffer = this._encodeValue(i.default, r, n).join()), - a.length !== i.defaultBuffer.length) - ) - return !1; - for (o = 0; o < a.length; o++) if (a[o] !== i.defaultBuffer[o]) return !1; - return !0; - }; - function UQt(t, e, r, n) { - let i; - if ( - (t === "seqof" ? (t = "seq") : t === "setof" && (t = "set"), - Ibe.tagByName.hasOwnProperty(t)) - ) - i = Ibe.tagByName[t]; - else if (typeof t == "number" && (t | 0) === t) i = t; - else return n.error("Unknown tag: " + t); - return i >= 31 - ? n.error("Multi-octet tag encoding unsupported") - : (e || (i |= 32), (i |= Ibe.tagClassByName[r || "universal"] << 6), i); - } - }); - var bGe = I((Rfn, vGe) => { - "use strict"; - m(); - g(); - var KQt = dn(), - Rbe = Cbe(); - function Nbe(t) { - Rbe.call(this, t), (this.enc = "pem"); - } - KQt(Nbe, Rbe); - vGe.exports = Nbe; - Nbe.prototype.encode = function (e, r) { - let i = Rbe.prototype.encode.call(this, e).toString("base64"), - o = ["-----BEGIN " + r.label + "-----"]; - for (let a = 0; a < i.length; a += 64) o.push(i.slice(a, a + 64)); - return ( - o.push("-----END " + r.label + "-----"), - o.join(` -`) - ); - }; - }); - var Dbe = I((_Ge) => { - "use strict"; - m(); - g(); - var wGe = _Ge; - wGe.der = Cbe(); - wGe.pem = bGe(); - }); - var Lbe = I((Dfn, TGe) => { - "use strict"; - m(); - g(); - var HQt = dn(), - VQt = Obe(), - xGe = K5().DecoderBuffer, - AGe = vX(), - SGe = bX(); - function EGe(t) { - (this.enc = "der"), - (this.name = t.name), - (this.entity = t), - (this.tree = new Dp()), - this.tree._init(t.body); - } - TGe.exports = EGe; - EGe.prototype.decode = function (e, r) { - return ( - xGe.isDecoderBuffer(e) || (e = new xGe(e, r)), this.tree._decode(e, r) - ); - }; - function Dp(t) { - AGe.call(this, "der", t); - } - HQt(Dp, AGe); - Dp.prototype._peekTag = function (e, r, n) { - if (e.isEmpty()) return !1; - let i = e.save(), - o = Fbe(e, 'Failed to peek tag: "' + r + '"'); - return e.isError(o) - ? o - : (e.restore(i), - o.tag === r || o.tagStr === r || o.tagStr + "of" === r || n); - }; - Dp.prototype._decodeTag = function (e, r, n) { - let i = Fbe(e, 'Failed to decode tag of "' + r + '"'); - if (e.isError(i)) return i; - let o = MGe(e, i.primitive, 'Failed to get length of "' + r + '"'); - if (e.isError(o)) return o; - if (!n && i.tag !== r && i.tagStr !== r && i.tagStr + "of" !== r) - return e.error('Failed to match tag: "' + r + '"'); - if (i.primitive || o !== null) - return e.skip(o, 'Failed to match body of: "' + r + '"'); - let a = e.save(), - s = this._skipUntilEnd( - e, - 'Failed to skip indefinite length body: "' + this.tag + '"' - ); - return e.isError(s) - ? s - : ((o = e.offset - a.offset), - e.restore(a), - e.skip(o, 'Failed to match body of: "' + r + '"')); - }; - Dp.prototype._skipUntilEnd = function (e, r) { - for (;;) { - let n = Fbe(e, r); - if (e.isError(n)) return n; - let i = MGe(e, n.primitive, r); - if (e.isError(i)) return i; - let o; - if ( - (n.primitive || i !== null - ? (o = e.skip(i)) - : (o = this._skipUntilEnd(e, r)), - e.isError(o)) - ) - return o; - if (n.tagStr === "end") break; - } - }; - Dp.prototype._decodeList = function (e, r, n, i) { - let o = []; - for (; !e.isEmpty(); ) { - let a = this._peekTag(e, "end"); - if (e.isError(a)) return a; - let s = n.decode(e, "der", i); - if (e.isError(s) && a) break; - o.push(s); - } - return o; - }; - Dp.prototype._decodeStr = function (e, r) { - if (r === "bitstr") { - let n = e.readUInt8(); - return e.isError(n) ? n : { unused: n, data: e.raw() }; - } else if (r === "bmpstr") { - let n = e.raw(); - if (n.length % 2 === 1) - return e.error("Decoding of string type: bmpstr length mismatch"); - let i = ""; - for (let o = 0; o < n.length / 2; o++) - i += String.fromCharCode(n.readUInt16BE(o * 2)); - return i; - } else if (r === "numstr") { - let n = e.raw().toString("ascii"); - return this._isNumstr(n) - ? n - : e.error("Decoding of string type: numstr unsupported characters"); - } else { - if (r === "octstr") return e.raw(); - if (r === "objDesc") return e.raw(); - if (r === "printstr") { - let n = e.raw().toString("ascii"); - return this._isPrintstr(n) - ? n - : e.error( - "Decoding of string type: printstr unsupported characters" - ); - } else - return /str$/.test(r) - ? e.raw().toString() - : e.error("Decoding of string type: " + r + " unsupported"); - } - }; - Dp.prototype._decodeObjid = function (e, r, n) { - let i, - o = [], - a = 0, - s = 0; - for (; !e.isEmpty(); ) - (s = e.readUInt8()), - (a <<= 7), - (a |= s & 127), - (s & 128) === 0 && (o.push(a), (a = 0)); - s & 128 && o.push(a); - let c = (o[0] / 40) | 0, - u = o[0] % 40; - if ((n ? (i = o) : (i = [c, u].concat(o.slice(1))), r)) { - let h = r[i.join(" ")]; - h === void 0 && (h = r[i.join(".")]), h !== void 0 && (i = h); - } - return i; - }; - Dp.prototype._decodeTime = function (e, r) { - let n = e.raw().toString(), - i, - o, - a, - s, - c, - u; - if (r === "gentime") - (i = n.slice(0, 4) | 0), - (o = n.slice(4, 6) | 0), - (a = n.slice(6, 8) | 0), - (s = n.slice(8, 10) | 0), - (c = n.slice(10, 12) | 0), - (u = n.slice(12, 14) | 0); - else if (r === "utctime") - (i = n.slice(0, 2) | 0), - (o = n.slice(2, 4) | 0), - (a = n.slice(4, 6) | 0), - (s = n.slice(6, 8) | 0), - (c = n.slice(8, 10) | 0), - (u = n.slice(10, 12) | 0), - i < 70 ? (i = 2e3 + i) : (i = 1900 + i); - else return e.error("Decoding " + r + " time is not supported yet"); - return Date.UTC(i, o - 1, a, s, c, u, 0); - }; - Dp.prototype._decodeNull = function () { - return null; - }; - Dp.prototype._decodeBool = function (e) { - let r = e.readUInt8(); - return e.isError(r) ? r : r !== 0; - }; - Dp.prototype._decodeInt = function (e, r) { - let n = e.raw(), - i = new VQt(n); - return r && (i = r[i.toString(10)] || i), i; - }; - Dp.prototype._use = function (e, r) { - return typeof e == "function" && (e = e(r)), e._getDecoder("der").tree; - }; - function Fbe(t, e) { - let r = t.readUInt8(e); - if (t.isError(r)) return r; - let n = SGe.tagClass[r >> 6], - i = (r & 32) === 0; - if ((r & 31) === 31) { - let a = r; - for (r = 0; (a & 128) === 128; ) { - if (((a = t.readUInt8(e)), t.isError(a))) return a; - (r <<= 7), (r |= a & 127); - } - } else r &= 31; - let o = SGe.tag[r]; - return { cls: n, primitive: i, tag: r, tagStr: o }; - } - function MGe(t, e, r) { - let n = t.readUInt8(r); - if (t.isError(n)) return n; - if (!e && n === 128) return null; - if ((n & 128) === 0) return n; - let i = n & 127; - if (i > 4) return t.error("length octect is too long"); - n = 0; - for (let o = 0; o < i; o++) { - n <<= 8; - let a = t.readUInt8(r); - if (t.isError(a)) return a; - n |= a; - } - return n; - } - }); - var PGe = I((Ffn, kGe) => { - "use strict"; - m(); - g(); - var WQt = dn(), - GQt = yX().Buffer, - qbe = Lbe(); - function zbe(t) { - qbe.call(this, t), (this.enc = "pem"); - } - WQt(zbe, qbe); - kGe.exports = zbe; - zbe.prototype.decode = function (e, r) { - let n = e.toString().split(/[\r\n]+/g), - i = r.label.toUpperCase(), - o = /^-----(BEGIN|END) ([^-]+)-----$/, - a = -1, - s = -1; - for (let h = 0; h < n.length; h++) { - let w = n[h].match(o); - if (w !== null && w[2] === i) - if (a === -1) { - if (w[1] !== "BEGIN") break; - a = h; - } else { - if (w[1] !== "END") break; - s = h; - break; - } - } - if (a === -1 || s === -1) - throw new Error("PEM section not found for: " + i); - let c = n.slice(a + 1, s).join(""); - c.replace(/[^a-z0-9+/=]+/gi, ""); - let u = GQt.from(c, "base64"); - return qbe.prototype.decode.call(this, u, r); - }; - }); - var jbe = I((BGe) => { - "use strict"; - m(); - g(); - var OGe = BGe; - OGe.der = Lbe(); - OGe.pem = PGe(); - }); - var CGe = I((IGe) => { - "use strict"; - m(); - g(); - var JQt = Dbe(), - $Qt = jbe(), - ZQt = dn(), - XQt = IGe; - XQt.define = function (e, r) { - return new H5(e, r); - }; - function H5(t, e) { - (this.name = t), - (this.body = e), - (this.decoders = {}), - (this.encoders = {}); - } - H5.prototype._createNamed = function (e) { - let r = this.name; - function n(i) { - this._initNamed(i, r); - } - return ( - ZQt(n, e), - (n.prototype._initNamed = function (o, a) { - e.call(this, o, a); - }), - new n(this) - ); - }; - H5.prototype._getDecoder = function (e) { - return ( - (e = e || "der"), - this.decoders.hasOwnProperty(e) || - (this.decoders[e] = this._createNamed($Qt[e])), - this.decoders[e] - ); - }; - H5.prototype.decode = function (e, r, n) { - return this._getDecoder(r).decode(e, n); - }; - H5.prototype._getEncoder = function (e) { - return ( - (e = e || "der"), - this.encoders.hasOwnProperty(e) || - (this.encoders[e] = this._createNamed(JQt[e])), - this.encoders[e] - ); - }; - H5.prototype.encode = function (e, r, n) { - return this._getEncoder(r).encode(e, n); - }; - }); - var NGe = I((RGe) => { - "use strict"; - m(); - g(); - var wX = RGe; - wX.Reporter = mX().Reporter; - wX.DecoderBuffer = K5().DecoderBuffer; - wX.EncoderBuffer = K5().EncoderBuffer; - wX.Node = vX(); - }); - var LGe = I((FGe) => { - "use strict"; - m(); - g(); - var DGe = FGe; - DGe._reverse = function (e) { - let r = {}; - return ( - Object.keys(e).forEach(function (n) { - (n | 0) == n && (n = n | 0); - let i = e[n]; - r[i] = n; - }), - r - ); - }; - DGe.der = bX(); - }); - var _X = I((qGe) => { - "use strict"; - m(); - g(); - var V5 = qGe; - V5.bignum = Obe(); - V5.define = CGe().define; - V5.base = NGe(); - V5.constants = LGe(); - V5.decoders = jbe(); - V5.encoders = Dbe(); - }); - var KGe = I((Kfn, UGe) => { - "use strict"; - m(); - g(); - var jm = _X(), - zGe = jm.define("Time", function () { - this.choice({ utcTime: this.utctime(), generalTime: this.gentime() }); - }), - YQt = jm.define("AttributeTypeValue", function () { - this.seq().obj(this.key("type").objid(), this.key("value").any()); - }), - Ube = jm.define("AlgorithmIdentifier", function () { - this.seq().obj( - this.key("algorithm").objid(), - this.key("parameters").optional(), - this.key("curve").objid().optional() - ); - }), - QQt = jm.define("SubjectPublicKeyInfo", function () { - this.seq().obj( - this.key("algorithm").use(Ube), - this.key("subjectPublicKey").bitstr() - ); - }), - eer = jm.define("RelativeDistinguishedName", function () { - this.setof(YQt); - }), - ter = jm.define("RDNSequence", function () { - this.seqof(eer); - }), - jGe = jm.define("Name", function () { - this.choice({ rdnSequence: this.use(ter) }); - }), - rer = jm.define("Validity", function () { - this.seq().obj( - this.key("notBefore").use(zGe), - this.key("notAfter").use(zGe) - ); - }), - ner = jm.define("Extension", function () { - this.seq().obj( - this.key("extnID").objid(), - this.key("critical").bool().def(!1), - this.key("extnValue").octstr() - ); - }), - ier = jm.define("TBSCertificate", function () { - this.seq().obj( - this.key("version").explicit(0).int().optional(), - this.key("serialNumber").int(), - this.key("signature").use(Ube), - this.key("issuer").use(jGe), - this.key("validity").use(rer), - this.key("subject").use(jGe), - this.key("subjectPublicKeyInfo").use(QQt), - this.key("issuerUniqueID").implicit(1).bitstr().optional(), - this.key("subjectUniqueID").implicit(2).bitstr().optional(), - this.key("extensions").explicit(3).seqof(ner).optional() - ); - }), - oer = jm.define("X509Certificate", function () { - this.seq().obj( - this.key("tbsCertificate").use(ier), - this.key("signatureAlgorithm").use(Ube), - this.key("signatureValue").bitstr() - ); - }); - UGe.exports = oer; - }); - var VGe = I((Km) => { - "use strict"; - m(); - g(); - var Um = _X(); - Km.certificate = KGe(); - var aer = Um.define("RSAPrivateKey", function () { - this.seq().obj( - this.key("version").int(), - this.key("modulus").int(), - this.key("publicExponent").int(), - this.key("privateExponent").int(), - this.key("prime1").int(), - this.key("prime2").int(), - this.key("exponent1").int(), - this.key("exponent2").int(), - this.key("coefficient").int() - ); - }); - Km.RSAPrivateKey = aer; - var ser = Um.define("RSAPublicKey", function () { - this.seq().obj( - this.key("modulus").int(), - this.key("publicExponent").int() - ); - }); - Km.RSAPublicKey = ser; - var uer = Um.define("SubjectPublicKeyInfo", function () { - this.seq().obj( - this.key("algorithm").use(HGe), - this.key("subjectPublicKey").bitstr() - ); - }); - Km.PublicKey = uer; - var HGe = Um.define("AlgorithmIdentifier", function () { - this.seq().obj( - this.key("algorithm").objid(), - this.key("none").null_().optional(), - this.key("curve").objid().optional(), - this.key("params") - .seq() - .obj(this.key("p").int(), this.key("q").int(), this.key("g").int()) - .optional() - ); - }), - cer = Um.define("PrivateKeyInfo", function () { - this.seq().obj( - this.key("version").int(), - this.key("algorithm").use(HGe), - this.key("subjectPrivateKey").octstr() - ); - }); - Km.PrivateKey = cer; - var ler = Um.define("EncryptedPrivateKeyInfo", function () { - this.seq().obj( - this.key("algorithm") - .seq() - .obj( - this.key("id").objid(), - this.key("decrypt") - .seq() - .obj( - this.key("kde") - .seq() - .obj( - this.key("id").objid(), - this.key("kdeparams") - .seq() - .obj(this.key("salt").octstr(), this.key("iters").int()) - ), - this.key("cipher") - .seq() - .obj(this.key("algo").objid(), this.key("iv").octstr()) - ) - ), - this.key("subjectPrivateKey").octstr() - ); - }); - Km.EncryptedPrivateKey = ler; - var fer = Um.define("DSAPrivateKey", function () { - this.seq().obj( - this.key("version").int(), - this.key("p").int(), - this.key("q").int(), - this.key("g").int(), - this.key("pub_key").int(), - this.key("priv_key").int() - ); - }); - Km.DSAPrivateKey = fer; - Km.DSAparam = Um.define("DSAparam", function () { - this.int(); - }); - var der = Um.define("ECPrivateKey", function () { - this.seq().obj( - this.key("version").int(), - this.key("privateKey").octstr(), - this.key("parameters").optional().explicit(0).use(her), - this.key("publicKey").optional().explicit(1).bitstr() - ); - }); - Km.ECPrivateKey = der; - var her = Um.define("ECParameters", function () { - this.choice({ namedCurve: this.objid() }); - }); - Km.signature = Um.define("signature", function () { - this.seq().obj(this.key("r").int(), this.key("s").int()); - }); - }); - var WGe = I((Vfn, per) => { - per.exports = { - "2.16.840.1.101.3.4.1.1": "aes-128-ecb", - "2.16.840.1.101.3.4.1.2": "aes-128-cbc", - "2.16.840.1.101.3.4.1.3": "aes-128-ofb", - "2.16.840.1.101.3.4.1.4": "aes-128-cfb", - "2.16.840.1.101.3.4.1.21": "aes-192-ecb", - "2.16.840.1.101.3.4.1.22": "aes-192-cbc", - "2.16.840.1.101.3.4.1.23": "aes-192-ofb", - "2.16.840.1.101.3.4.1.24": "aes-192-cfb", - "2.16.840.1.101.3.4.1.41": "aes-256-ecb", - "2.16.840.1.101.3.4.1.42": "aes-256-cbc", - "2.16.840.1.101.3.4.1.43": "aes-256-ofb", - "2.16.840.1.101.3.4.1.44": "aes-256-cfb", - }; - }); - var JGe = I((Wfn, GGe) => { - m(); - g(); - var yer = - /Proc-Type: 4,ENCRYPTED[\n\r]+DEK-Info: AES-((?:128)|(?:192)|(?:256))-CBC,([0-9A-H]+)[\n\r]+([0-9A-z\n\r+/=]+)[\n\r]+/m, - mer = /^-----BEGIN ((?:.*? KEY)|CERTIFICATE)-----/m, - ger = - /^-----BEGIN ((?:.*? KEY)|CERTIFICATE)-----([0-9A-z\n\r+/=]+)-----END \1-----$/m, - ver = Rq(), - ber = JZ(), - xX = vn().Buffer; - GGe.exports = function (t, e) { - var r = t.toString(), - n = r.match(yer), - i; - if (n) { - var a = "aes" + n[1], - s = xX.from(n[2], "hex"), - c = xX.from(n[3].replace(/[\r\n]/g, ""), "base64"), - u = ver(e, s.slice(0, 8), parseInt(n[1], 10)).key, - h = [], - w = ber.createDecipheriv(a, u, s); - h.push(w.update(c)), h.push(w.final()), (i = xX.concat(h)); - } else { - var o = r.match(ger); - i = xX.from(o[2].replace(/[\r\n]/g, ""), "base64"); - } - var M = r.match(mer)[1]; - return { tag: M, data: i }; - }; - }); - var Kq = I((Gfn, ZGe) => { - m(); - g(); - var Bh = VGe(), - wer = WGe(), - _er = JGe(), - xer = JZ(), - Ser = kve(), - Kbe = vn().Buffer; - ZGe.exports = $Ge; - function $Ge(t) { - var e; - typeof t == "object" && - !Kbe.isBuffer(t) && - ((e = t.passphrase), (t = t.key)), - typeof t == "string" && (t = Kbe.from(t)); - var r = _er(t, e), - n = r.tag, - i = r.data, - o, - a; - switch (n) { - case "CERTIFICATE": - a = Bh.certificate.decode(i, "der").tbsCertificate - .subjectPublicKeyInfo; - case "PUBLIC KEY": - switch ( - (a || (a = Bh.PublicKey.decode(i, "der")), - (o = a.algorithm.algorithm.join(".")), - o) - ) { - case "1.2.840.113549.1.1.1": - return Bh.RSAPublicKey.decode(a.subjectPublicKey.data, "der"); - case "1.2.840.10045.2.1": - return ( - (a.subjectPrivateKey = a.subjectPublicKey), - { type: "ec", data: a } - ); - case "1.2.840.10040.4.1": - return ( - (a.algorithm.params.pub_key = Bh.DSAparam.decode( - a.subjectPublicKey.data, - "der" - )), - { type: "dsa", data: a.algorithm.params } - ); - default: - throw new Error("unknown key id " + o); - } - case "ENCRYPTED PRIVATE KEY": - (i = Bh.EncryptedPrivateKey.decode(i, "der")), (i = Aer(i, e)); - case "PRIVATE KEY": - switch ( - ((a = Bh.PrivateKey.decode(i, "der")), - (o = a.algorithm.algorithm.join(".")), - o) - ) { - case "1.2.840.113549.1.1.1": - return Bh.RSAPrivateKey.decode(a.subjectPrivateKey, "der"); - case "1.2.840.10045.2.1": - return { - curve: a.algorithm.curve, - privateKey: Bh.ECPrivateKey.decode(a.subjectPrivateKey, "der") - .privateKey, - }; - case "1.2.840.10040.4.1": - return ( - (a.algorithm.params.priv_key = Bh.DSAparam.decode( - a.subjectPrivateKey, - "der" - )), - { type: "dsa", params: a.algorithm.params } - ); - default: - throw new Error("unknown key id " + o); - } - case "RSA PUBLIC KEY": - return Bh.RSAPublicKey.decode(i, "der"); - case "RSA PRIVATE KEY": - return Bh.RSAPrivateKey.decode(i, "der"); - case "DSA PRIVATE KEY": - return { type: "dsa", params: Bh.DSAPrivateKey.decode(i, "der") }; - case "EC PRIVATE KEY": - return ( - (i = Bh.ECPrivateKey.decode(i, "der")), - { curve: i.parameters.value, privateKey: i.privateKey } - ); - default: - throw new Error("unknown key type " + n); - } - } - $Ge.signature = Bh.signature; - function Aer(t, e) { - var r = t.algorithm.decrypt.kde.kdeparams.salt, - n = parseInt(t.algorithm.decrypt.kde.kdeparams.iters.toString(), 10), - i = wer[t.algorithm.decrypt.cipher.algo.join(".")], - o = t.algorithm.decrypt.cipher.iv, - a = t.subjectPrivateKey, - s = parseInt(i.split("-")[1], 10) / 8, - c = Ser.pbkdf2Sync(e, r, n, s, "sha1"), - u = xer.createDecipheriv(i, c, o), - h = []; - return h.push(u.update(a)), h.push(u.final()), Kbe.concat(h); - } - }); - var Hbe = I((Jfn, Eer) => { - Eer.exports = { - "1.3.132.0.10": "secp256k1", - "1.3.132.0.33": "p224", - "1.2.840.10045.3.1.1": "p192", - "1.2.840.10045.3.1.7": "p256", - "1.3.132.0.34": "p384", - "1.3.132.0.35": "p521", - }; - }); - var QGe = I(($fn, AX) => { - m(); - g(); - var zc = vn().Buffer, - NM = vve(), - Mer = YZ(), - Ter = F5().ec, - SX = Ho(), - ker = Kq(), - Per = Hbe(); - function Oer(t, e, r, n, i) { - var o = ker(e); - if (o.curve) { - if (n !== "ecdsa" && n !== "ecdsa/rsa") - throw new Error("wrong private key type"); - return Ber(t, o); - } else if (o.type === "dsa") { - if (n !== "dsa") throw new Error("wrong private key type"); - return Ier(t, o, r); - } else if (n !== "rsa" && n !== "ecdsa/rsa") - throw new Error("wrong private key type"); - t = zc.concat([i, t]); - for ( - var a = o.modulus.byteLength(), s = [0, 1]; - t.length + s.length + 1 < a; - - ) - s.push(255); - s.push(0); - for (var c = -1; ++c < t.length; ) s.push(t[c]); - var u = Mer(s, o); - return u; - } - function Ber(t, e) { - var r = Per[e.curve.join(".")]; - if (!r) throw new Error("unknown curve " + e.curve.join(".")); - var n = new Ter(r), - i = n.keyFromPrivate(e.privateKey), - o = i.sign(t); - return zc.from(o.toDER()); - } - function Ier(t, e, r) { - for ( - var n = e.params.priv_key, - i = e.params.p, - o = e.params.q, - a = e.params.g, - s = new SX(0), - c, - u = Vbe(t, o).mod(o), - h = !1, - w = XGe(n, o, t, r); - h === !1; - - ) - (c = YGe(o, w, r)), - (s = Ner(a, c, i, o)), - (h = c - .invm(o) - .imul(u.add(n.mul(s))) - .mod(o)), - h.cmpn(0) === 0 && ((h = !1), (s = new SX(0))); - return Cer(s, h); - } - function Cer(t, e) { - (t = t.toArray()), - (e = e.toArray()), - t[0] & 128 && (t = [0].concat(t)), - e[0] & 128 && (e = [0].concat(e)); - var r = t.length + e.length + 4, - n = [48, r, 2, t.length]; - return (n = n.concat(t, [2, e.length], e)), zc.from(n); - } - function XGe(t, e, r, n) { - if (((t = zc.from(t.toArray())), t.length < e.byteLength())) { - var i = zc.alloc(e.byteLength() - t.length); - t = zc.concat([i, t]); - } - var o = r.length, - a = Rer(r, e), - s = zc.alloc(o); - s.fill(1); - var c = zc.alloc(o); - return ( - (c = NM(n, c) - .update(s) - .update(zc.from([0])) - .update(t) - .update(a) - .digest()), - (s = NM(n, c).update(s).digest()), - (c = NM(n, c) - .update(s) - .update(zc.from([1])) - .update(t) - .update(a) - .digest()), - (s = NM(n, c).update(s).digest()), - { k: c, v: s } - ); - } - function Vbe(t, e) { - var r = new SX(t), - n = (t.length << 3) - e.bitLength(); - return n > 0 && r.ishrn(n), r; - } - function Rer(t, e) { - (t = Vbe(t, e)), (t = t.mod(e)); - var r = zc.from(t.toArray()); - if (r.length < e.byteLength()) { - var n = zc.alloc(e.byteLength() - r.length); - r = zc.concat([n, r]); - } - return r; - } - function YGe(t, e, r) { - var n, i; - do { - for (n = zc.alloc(0); n.length * 8 < t.bitLength(); ) - (e.v = NM(r, e.k).update(e.v).digest()), (n = zc.concat([n, e.v])); - (i = Vbe(n, t)), - (e.k = NM(r, e.k) - .update(e.v) - .update(zc.from([0])) - .digest()), - (e.v = NM(r, e.k).update(e.v).digest()); - } while (i.cmp(t) !== -1); - return i; - } - function Ner(t, e, r, n) { - return t.toRed(SX.mont(r)).redPow(e).fromRed().mod(n); - } - AX.exports = Oer; - AX.exports.getKey = XGe; - AX.exports.makeKey = YGe; - }); - var nJe = I((Zfn, rJe) => { - m(); - g(); - var Wbe = vn().Buffer, - Hq = Ho(), - Der = F5().ec, - tJe = Kq(), - Fer = Hbe(); - function Ler(t, e, r, n, i) { - var o = tJe(r); - if (o.type === "ec") { - if (n !== "ecdsa" && n !== "ecdsa/rsa") - throw new Error("wrong public key type"); - return qer(t, e, o); - } else if (o.type === "dsa") { - if (n !== "dsa") throw new Error("wrong public key type"); - return zer(t, e, o); - } else if (n !== "rsa" && n !== "ecdsa/rsa") - throw new Error("wrong public key type"); - e = Wbe.concat([i, e]); - for ( - var a = o.modulus.byteLength(), s = [1], c = 0; - e.length + s.length + 2 < a; - - ) - s.push(255), c++; - s.push(0); - for (var u = -1; ++u < e.length; ) s.push(e[u]); - s = Wbe.from(s); - var h = Hq.mont(o.modulus); - (t = new Hq(t).toRed(h)), - (t = t.redPow(new Hq(o.publicExponent))), - (t = Wbe.from(t.fromRed().toArray())); - var w = c < 8 ? 1 : 0; - for ( - a = Math.min(t.length, s.length), - t.length !== s.length && (w = 1), - u = -1; - ++u < a; - - ) - w |= t[u] ^ s[u]; - return w === 0; - } - function qer(t, e, r) { - var n = Fer[r.data.algorithm.curve.join(".")]; - if (!n) - throw new Error("unknown curve " + r.data.algorithm.curve.join(".")); - var i = new Der(n), - o = r.data.subjectPrivateKey.data; - return i.verify(e, t, o); - } - function zer(t, e, r) { - var n = r.data.p, - i = r.data.q, - o = r.data.g, - a = r.data.pub_key, - s = tJe.signature.decode(t, "der"), - c = s.s, - u = s.r; - eJe(c, i), eJe(u, i); - var h = Hq.mont(n), - w = c.invm(i), - M = o - .toRed(h) - .redPow(new Hq(e).mul(w).mod(i)) - .fromRed() - .mul(a.toRed(h).redPow(u.mul(w).mod(i)).fromRed()) - .mod(n) - .mod(i); - return M.cmp(u) === 0; - } - function eJe(t, e) { - if (t.cmpn(0) <= 0) throw new Error("invalid sig"); - if (t.cmp(e) >= e) throw new Error("invalid sig"); - } - rJe.exports = Ler; - }); - var cJe = I((Xfn, uJe) => { - m(); - g(); - var EX = vn().Buffer, - aJe = v5(), - MX = mq(), - sJe = dn(), - jer = QGe(), - Uer = nJe(), - DM = bve(); - Object.keys(DM).forEach(function (t) { - (DM[t].id = EX.from(DM[t].id, "hex")), (DM[t.toLowerCase()] = DM[t]); - }); - function Vq(t) { - MX.Writable.call(this); - var e = DM[t]; - if (!e) throw new Error("Unknown message digest"); - (this._hashType = e.hash), - (this._hash = aJe(e.hash)), - (this._tag = e.id), - (this._signType = e.sign); - } - sJe(Vq, MX.Writable); - Vq.prototype._write = function (e, r, n) { - this._hash.update(e), n(); - }; - Vq.prototype.update = function (e, r) { - return ( - typeof e == "string" && (e = EX.from(e, r)), this._hash.update(e), this - ); - }; - Vq.prototype.sign = function (e, r) { - this.end(); - var n = this._hash.digest(), - i = jer(n, e, this._hashType, this._signType, this._tag); - return r ? i.toString(r) : i; - }; - function Wq(t) { - MX.Writable.call(this); - var e = DM[t]; - if (!e) throw new Error("Unknown message digest"); - (this._hash = aJe(e.hash)), (this._tag = e.id), (this._signType = e.sign); - } - sJe(Wq, MX.Writable); - Wq.prototype._write = function (e, r, n) { - this._hash.update(e), n(); - }; - Wq.prototype.update = function (e, r) { - return ( - typeof e == "string" && (e = EX.from(e, r)), this._hash.update(e), this - ); - }; - Wq.prototype.verify = function (e, r, n) { - typeof r == "string" && (r = EX.from(r, n)), this.end(); - var i = this._hash.digest(); - return Uer(r, i, e, this._signType, this._tag); - }; - function iJe(t) { - return new Vq(t); - } - function oJe(t) { - return new Wq(t); - } - uJe.exports = { - Sign: iJe, - Verify: oJe, - createSign: iJe, - createVerify: oJe, - }; - }); - var fJe = I((lJe, Gbe) => { - m(); - g(); - (function (t, e) { - "use strict"; - function r(A, l) { - if (!A) throw new Error(l || "Assertion failed"); - } - function n(A, l) { - A.super_ = l; - var p = function () {}; - (p.prototype = l.prototype), - (A.prototype = new p()), - (A.prototype.constructor = A); - } - function i(A, l, p) { - if (i.isBN(A)) return A; - (this.negative = 0), - (this.words = null), - (this.length = 0), - (this.red = null), - A !== null && - ((l === "le" || l === "be") && ((p = l), (l = 10)), - this._init(A || 0, l || 10, p || "be")); - } - typeof t == "object" ? (t.exports = i) : (e.BN = i), - (i.BN = i), - (i.wordSize = 26); - var o; - try { - typeof window < "u" && typeof window.Buffer < "u" - ? (o = window.Buffer) - : (o = Qr().Buffer); - } catch {} - (i.isBN = function (l) { - return l instanceof i - ? !0 - : l !== null && - typeof l == "object" && - l.constructor.wordSize === i.wordSize && - Array.isArray(l.words); - }), - (i.max = function (l, p) { - return l.cmp(p) > 0 ? l : p; - }), - (i.min = function (l, p) { - return l.cmp(p) < 0 ? l : p; - }), - (i.prototype._init = function (l, p, y) { - if (typeof l == "number") return this._initNumber(l, p, y); - if (typeof l == "object") return this._initArray(l, p, y); - p === "hex" && (p = 16), - r(p === (p | 0) && p >= 2 && p <= 36), - (l = l.toString().replace(/\s+/g, "")); - var d = 0; - l[0] === "-" && (d++, (this.negative = 1)), - d < l.length && - (p === 16 - ? this._parseHex(l, d, y) - : (this._parseBase(l, p, d), - y === "le" && this._initArray(this.toArray(), p, y))); - }), - (i.prototype._initNumber = function (l, p, y) { - l < 0 && ((this.negative = 1), (l = -l)), - l < 67108864 - ? ((this.words = [l & 67108863]), (this.length = 1)) - : l < 4503599627370496 - ? ((this.words = [l & 67108863, (l / 67108864) & 67108863]), - (this.length = 2)) - : (r(l < 9007199254740992), - (this.words = [l & 67108863, (l / 67108864) & 67108863, 1]), - (this.length = 3)), - y === "le" && this._initArray(this.toArray(), p, y); - }), - (i.prototype._initArray = function (l, p, y) { - if ((r(typeof l.length == "number"), l.length <= 0)) - return (this.words = [0]), (this.length = 1), this; - (this.length = Math.ceil(l.length / 3)), - (this.words = new Array(this.length)); - for (var d = 0; d < this.length; d++) this.words[d] = 0; - var v, - _, - S = 0; - if (y === "be") - for (d = l.length - 1, v = 0; d >= 0; d -= 3) - (_ = l[d] | (l[d - 1] << 8) | (l[d - 2] << 16)), - (this.words[v] |= (_ << S) & 67108863), - (this.words[v + 1] = (_ >>> (26 - S)) & 67108863), - (S += 24), - S >= 26 && ((S -= 26), v++); - else if (y === "le") - for (d = 0, v = 0; d < l.length; d += 3) - (_ = l[d] | (l[d + 1] << 8) | (l[d + 2] << 16)), - (this.words[v] |= (_ << S) & 67108863), - (this.words[v + 1] = (_ >>> (26 - S)) & 67108863), - (S += 24), - S >= 26 && ((S -= 26), v++); - return this.strip(); - }); - function a(A, l) { - var p = A.charCodeAt(l); - return p >= 65 && p <= 70 - ? p - 55 - : p >= 97 && p <= 102 - ? p - 87 - : (p - 48) & 15; - } - function s(A, l, p) { - var y = a(A, p); - return p - 1 >= l && (y |= a(A, p - 1) << 4), y; - } - i.prototype._parseHex = function (l, p, y) { - (this.length = Math.ceil((l.length - p) / 6)), - (this.words = new Array(this.length)); - for (var d = 0; d < this.length; d++) this.words[d] = 0; - var v = 0, - _ = 0, - S; - if (y === "be") - for (d = l.length - 1; d >= p; d -= 2) - (S = s(l, p, d) << v), - (this.words[_] |= S & 67108863), - v >= 18 - ? ((v -= 18), (_ += 1), (this.words[_] |= S >>> 26)) - : (v += 8); - else { - var b = l.length - p; - for (d = b % 2 === 0 ? p + 1 : p; d < l.length; d += 2) - (S = s(l, p, d) << v), - (this.words[_] |= S & 67108863), - v >= 18 - ? ((v -= 18), (_ += 1), (this.words[_] |= S >>> 26)) - : (v += 8); - } - this.strip(); - }; - function c(A, l, p, y) { - for (var d = 0, v = Math.min(A.length, p), _ = l; _ < v; _++) { - var S = A.charCodeAt(_) - 48; - (d *= y), - S >= 49 - ? (d += S - 49 + 10) - : S >= 17 - ? (d += S - 17 + 10) - : (d += S); - } - return d; - } - (i.prototype._parseBase = function (l, p, y) { - (this.words = [0]), (this.length = 1); - for (var d = 0, v = 1; v <= 67108863; v *= p) d++; - d--, (v = (v / p) | 0); - for ( - var _ = l.length - y, - S = _ % d, - b = Math.min(_, _ - S) + y, - f = 0, - x = y; - x < b; - x += d - ) - (f = c(l, x, x + d, p)), - this.imuln(v), - this.words[0] + f < 67108864 - ? (this.words[0] += f) - : this._iaddn(f); - if (S !== 0) { - var C = 1; - for (f = c(l, x, l.length, p), x = 0; x < S; x++) C *= p; - this.imuln(C), - this.words[0] + f < 67108864 - ? (this.words[0] += f) - : this._iaddn(f); - } - this.strip(); - }), - (i.prototype.copy = function (l) { - l.words = new Array(this.length); - for (var p = 0; p < this.length; p++) l.words[p] = this.words[p]; - (l.length = this.length), - (l.negative = this.negative), - (l.red = this.red); - }), - (i.prototype.clone = function () { - var l = new i(null); - return this.copy(l), l; - }), - (i.prototype._expand = function (l) { - for (; this.length < l; ) this.words[this.length++] = 0; - return this; - }), - (i.prototype.strip = function () { - for (; this.length > 1 && this.words[this.length - 1] === 0; ) - this.length--; - return this._normSign(); - }), - (i.prototype._normSign = function () { - return ( - this.length === 1 && this.words[0] === 0 && (this.negative = 0), - this - ); - }), - (i.prototype.inspect = function () { - return (this.red ? ""; - }); - var u = [ - "", - "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", - ], - h = [ - 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, - ], - w = [ - 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, - ]; - (i.prototype.toString = function (l, p) { - (l = l || 10), (p = p | 0 || 1); - var y; - if (l === 16 || l === "hex") { - y = ""; - for (var d = 0, v = 0, _ = 0; _ < this.length; _++) { - var S = this.words[_], - b = (((S << d) | v) & 16777215).toString(16); - (v = (S >>> (24 - d)) & 16777215), - v !== 0 || _ !== this.length - 1 - ? (y = u[6 - b.length] + b + y) - : (y = b + y), - (d += 2), - d >= 26 && ((d -= 26), _--); - } - for (v !== 0 && (y = v.toString(16) + y); y.length % p !== 0; ) - y = "0" + y; - return this.negative !== 0 && (y = "-" + y), y; - } - if (l === (l | 0) && l >= 2 && l <= 36) { - var f = h[l], - x = w[l]; - y = ""; - var C = this.clone(); - for (C.negative = 0; !C.isZero(); ) { - var E = C.modn(x).toString(l); - (C = C.idivn(x)), - C.isZero() ? (y = E + y) : (y = u[f - E.length] + E + y); - } - for (this.isZero() && (y = "0" + y); y.length % p !== 0; ) - y = "0" + y; - return this.negative !== 0 && (y = "-" + y), y; - } - r(!1, "Base should be between 2 and 36"); - }), - (i.prototype.toNumber = function () { - var l = this.words[0]; - return ( - this.length === 2 - ? (l += this.words[1] * 67108864) - : this.length === 3 && this.words[2] === 1 - ? (l += 4503599627370496 + this.words[1] * 67108864) - : this.length > 2 && - r(!1, "Number can only safely store up to 53 bits"), - this.negative !== 0 ? -l : l - ); - }), - (i.prototype.toJSON = function () { - return this.toString(16); - }), - (i.prototype.toBuffer = function (l, p) { - return r(typeof o < "u"), this.toArrayLike(o, l, p); - }), - (i.prototype.toArray = function (l, p) { - return this.toArrayLike(Array, l, p); - }), - (i.prototype.toArrayLike = function (l, p, y) { - var d = this.byteLength(), - v = y || Math.max(1, d); - r(d <= v, "byte array longer than desired length"), - r(v > 0, "Requested array length <= 0"), - this.strip(); - var _ = p === "le", - S = new l(v), - b, - f, - x = this.clone(); - if (_) { - for (f = 0; !x.isZero(); f++) - (b = x.andln(255)), x.iushrn(8), (S[f] = b); - for (; f < v; f++) S[f] = 0; - } else { - for (f = 0; f < v - d; f++) S[f] = 0; - for (f = 0; !x.isZero(); f++) - (b = x.andln(255)), x.iushrn(8), (S[v - f - 1] = b); - } - return S; - }), - Math.clz32 - ? (i.prototype._countBits = function (l) { - return 32 - Math.clz32(l); - }) - : (i.prototype._countBits = function (l) { - var p = l, - y = 0; - return ( - p >= 4096 && ((y += 13), (p >>>= 13)), - p >= 64 && ((y += 7), (p >>>= 7)), - p >= 8 && ((y += 4), (p >>>= 4)), - p >= 2 && ((y += 2), (p >>>= 2)), - y + p - ); - }), - (i.prototype._zeroBits = function (l) { - if (l === 0) return 26; - var p = l, - y = 0; - return ( - (p & 8191) === 0 && ((y += 13), (p >>>= 13)), - (p & 127) === 0 && ((y += 7), (p >>>= 7)), - (p & 15) === 0 && ((y += 4), (p >>>= 4)), - (p & 3) === 0 && ((y += 2), (p >>>= 2)), - (p & 1) === 0 && y++, - y - ); - }), - (i.prototype.bitLength = function () { - var l = this.words[this.length - 1], - p = this._countBits(l); - return (this.length - 1) * 26 + p; - }); - function M(A) { - for (var l = new Array(A.bitLength()), p = 0; p < l.length; p++) { - var y = (p / 26) | 0, - d = p % 26; - l[p] = (A.words[y] & (1 << d)) >>> d; - } - return l; - } - (i.prototype.zeroBits = function () { - if (this.isZero()) return 0; - for (var l = 0, p = 0; p < this.length; p++) { - var y = this._zeroBits(this.words[p]); - if (((l += y), y !== 26)) break; - } - return l; - }), - (i.prototype.byteLength = function () { - return Math.ceil(this.bitLength() / 8); - }), - (i.prototype.toTwos = function (l) { - return this.negative !== 0 - ? this.abs().inotn(l).iaddn(1) - : this.clone(); - }), - (i.prototype.fromTwos = function (l) { - return this.testn(l - 1) - ? this.notn(l).iaddn(1).ineg() - : this.clone(); - }), - (i.prototype.isNeg = function () { - return this.negative !== 0; - }), - (i.prototype.neg = function () { - return this.clone().ineg(); - }), - (i.prototype.ineg = function () { - return this.isZero() || (this.negative ^= 1), this; - }), - (i.prototype.iuor = function (l) { - for (; this.length < l.length; ) this.words[this.length++] = 0; - for (var p = 0; p < l.length; p++) - this.words[p] = this.words[p] | l.words[p]; - return this.strip(); - }), - (i.prototype.ior = function (l) { - return r((this.negative | l.negative) === 0), this.iuor(l); - }), - (i.prototype.or = function (l) { - return this.length > l.length - ? this.clone().ior(l) - : l.clone().ior(this); - }), - (i.prototype.uor = function (l) { - return this.length > l.length - ? this.clone().iuor(l) - : l.clone().iuor(this); - }), - (i.prototype.iuand = function (l) { - var p; - this.length > l.length ? (p = l) : (p = this); - for (var y = 0; y < p.length; y++) - this.words[y] = this.words[y] & l.words[y]; - return (this.length = p.length), this.strip(); - }), - (i.prototype.iand = function (l) { - return r((this.negative | l.negative) === 0), this.iuand(l); - }), - (i.prototype.and = function (l) { - return this.length > l.length - ? this.clone().iand(l) - : l.clone().iand(this); - }), - (i.prototype.uand = function (l) { - return this.length > l.length - ? this.clone().iuand(l) - : l.clone().iuand(this); - }), - (i.prototype.iuxor = function (l) { - var p, y; - this.length > l.length - ? ((p = this), (y = l)) - : ((p = l), (y = this)); - for (var d = 0; d < y.length; d++) - this.words[d] = p.words[d] ^ y.words[d]; - if (this !== p) for (; d < p.length; d++) this.words[d] = p.words[d]; - return (this.length = p.length), this.strip(); - }), - (i.prototype.ixor = function (l) { - return r((this.negative | l.negative) === 0), this.iuxor(l); - }), - (i.prototype.xor = function (l) { - return this.length > l.length - ? this.clone().ixor(l) - : l.clone().ixor(this); - }), - (i.prototype.uxor = function (l) { - return this.length > l.length - ? this.clone().iuxor(l) - : l.clone().iuxor(this); - }), - (i.prototype.inotn = function (l) { - r(typeof l == "number" && l >= 0); - var p = Math.ceil(l / 26) | 0, - y = l % 26; - this._expand(p), y > 0 && p--; - for (var d = 0; d < p; d++) this.words[d] = ~this.words[d] & 67108863; - return ( - y > 0 && (this.words[d] = ~this.words[d] & (67108863 >> (26 - y))), - this.strip() - ); - }), - (i.prototype.notn = function (l) { - return this.clone().inotn(l); - }), - (i.prototype.setn = function (l, p) { - r(typeof l == "number" && l >= 0); - var y = (l / 26) | 0, - d = l % 26; - return ( - this._expand(y + 1), - p - ? (this.words[y] = this.words[y] | (1 << d)) - : (this.words[y] = this.words[y] & ~(1 << d)), - this.strip() - ); - }), - (i.prototype.iadd = function (l) { - var p; - if (this.negative !== 0 && l.negative === 0) - return ( - (this.negative = 0), - (p = this.isub(l)), - (this.negative ^= 1), - this._normSign() - ); - if (this.negative === 0 && l.negative !== 0) - return ( - (l.negative = 0), - (p = this.isub(l)), - (l.negative = 1), - p._normSign() - ); - var y, d; - this.length > l.length - ? ((y = this), (d = l)) - : ((y = l), (d = this)); - for (var v = 0, _ = 0; _ < d.length; _++) - (p = (y.words[_] | 0) + (d.words[_] | 0) + v), - (this.words[_] = p & 67108863), - (v = p >>> 26); - for (; v !== 0 && _ < y.length; _++) - (p = (y.words[_] | 0) + v), - (this.words[_] = p & 67108863), - (v = p >>> 26); - if (((this.length = y.length), v !== 0)) - (this.words[this.length] = v), this.length++; - else if (y !== this) - for (; _ < y.length; _++) this.words[_] = y.words[_]; - return this; - }), - (i.prototype.add = function (l) { - var p; - return l.negative !== 0 && this.negative === 0 - ? ((l.negative = 0), (p = this.sub(l)), (l.negative ^= 1), p) - : l.negative === 0 && this.negative !== 0 - ? ((this.negative = 0), (p = l.sub(this)), (this.negative = 1), p) - : this.length > l.length - ? this.clone().iadd(l) - : l.clone().iadd(this); - }), - (i.prototype.isub = function (l) { - if (l.negative !== 0) { - l.negative = 0; - var p = this.iadd(l); - return (l.negative = 1), p._normSign(); - } else if (this.negative !== 0) - return ( - (this.negative = 0), - this.iadd(l), - (this.negative = 1), - this._normSign() - ); - var y = this.cmp(l); - if (y === 0) - return ( - (this.negative = 0), (this.length = 1), (this.words[0] = 0), this - ); - var d, v; - y > 0 ? ((d = this), (v = l)) : ((d = l), (v = this)); - for (var _ = 0, S = 0; S < v.length; S++) - (p = (d.words[S] | 0) - (v.words[S] | 0) + _), - (_ = p >> 26), - (this.words[S] = p & 67108863); - for (; _ !== 0 && S < d.length; S++) - (p = (d.words[S] | 0) + _), - (_ = p >> 26), - (this.words[S] = p & 67108863); - if (_ === 0 && S < d.length && d !== this) - for (; S < d.length; S++) this.words[S] = d.words[S]; - return ( - (this.length = Math.max(this.length, S)), - d !== this && (this.negative = 1), - this.strip() - ); - }), - (i.prototype.sub = function (l) { - return this.clone().isub(l); - }); - function k(A, l, p) { - p.negative = l.negative ^ A.negative; - var y = (A.length + l.length) | 0; - (p.length = y), (y = (y - 1) | 0); - var d = A.words[0] | 0, - v = l.words[0] | 0, - _ = d * v, - S = _ & 67108863, - b = (_ / 67108864) | 0; - p.words[0] = S; - for (var f = 1; f < y; f++) { - for ( - var x = b >>> 26, - C = b & 67108863, - E = Math.min(f, l.length - 1), - B = Math.max(0, f - A.length + 1); - B <= E; - B++ - ) { - var G = (f - B) | 0; - (d = A.words[G] | 0), - (v = l.words[B] | 0), - (_ = d * v + C), - (x += (_ / 67108864) | 0), - (C = _ & 67108863); - } - (p.words[f] = C | 0), (b = x | 0); - } - return b !== 0 ? (p.words[f] = b | 0) : p.length--, p.strip(); - } - var O = function (l, p, y) { - var d = l.words, - v = p.words, - _ = y.words, - S = 0, - b, - f, - x, - C = d[0] | 0, - E = C & 8191, - B = C >>> 13, - G = d[1] | 0, - L = G & 8191, - ee = G >>> 13, - ge = d[2] | 0, - fe = ge & 8191, - V = ge >>> 13, - ye = d[3] | 0, - ae = ye & 8191, - le = ye >>> 13, - Me = d[4] | 0, - de = Me & 8191, - ve = Me >>> 13, - De = d[5] | 0, - me = De & 8191, - _e = De >>> 13, - Ye = d[6] | 0, - Ee = Ye & 8191, - Be = Ye >>> 13, - kt = d[7] | 0, - Ve = kt & 8191, - We = kt >>> 13, - er = d[8] | 0, - Ue = er & 8191, - Y = er >>> 13, - W = d[9] | 0, - j = W & 8191, - ce = W >>> 13, - ze = v[0] | 0, - we = ze & 8191, - xe = ze >>> 13, - Ft = v[1] | 0, - Ke = Ft & 8191, - pe = Ft >>> 13, - Re = v[2] | 0, - Se = Re & 8191, - Pe = Re >>> 13, - At = v[3] | 0, - Ie = At & 8191, - je = At >>> 13, - qt = v[4] | 0, - Fe = qt & 8191, - He = qt >>> 13, - lr = v[5] | 0, - Xe = lr & 8191, - Ze = lr >>> 13, - Ir = v[6] | 0, - $e = Ir & 8191, - tt = Ir >>> 13, - oe = v[7] | 0, - ie = oe & 8191, - re = oe >>> 13, - U = v[8] | 0, - se = U & 8191, - be = U >>> 13, - Qe = v[9] | 0, - Ae = Qe & 8191, - ke = Qe >>> 13; - (y.negative = l.negative ^ p.negative), - (y.length = 19), - (b = Math.imul(E, we)), - (f = Math.imul(E, xe)), - (f = (f + Math.imul(B, we)) | 0), - (x = Math.imul(B, xe)); - var Ct = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ct >>> 26)) | 0), - (Ct &= 67108863), - (b = Math.imul(L, we)), - (f = Math.imul(L, xe)), - (f = (f + Math.imul(ee, we)) | 0), - (x = Math.imul(ee, xe)), - (b = (b + Math.imul(E, Ke)) | 0), - (f = (f + Math.imul(E, pe)) | 0), - (f = (f + Math.imul(B, Ke)) | 0), - (x = (x + Math.imul(B, pe)) | 0); - var ut = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (ut >>> 26)) | 0), - (ut &= 67108863), - (b = Math.imul(fe, we)), - (f = Math.imul(fe, xe)), - (f = (f + Math.imul(V, we)) | 0), - (x = Math.imul(V, xe)), - (b = (b + Math.imul(L, Ke)) | 0), - (f = (f + Math.imul(L, pe)) | 0), - (f = (f + Math.imul(ee, Ke)) | 0), - (x = (x + Math.imul(ee, pe)) | 0), - (b = (b + Math.imul(E, Se)) | 0), - (f = (f + Math.imul(E, Pe)) | 0), - (f = (f + Math.imul(B, Se)) | 0), - (x = (x + Math.imul(B, Pe)) | 0); - var St = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (St >>> 26)) | 0), - (St &= 67108863), - (b = Math.imul(ae, we)), - (f = Math.imul(ae, xe)), - (f = (f + Math.imul(le, we)) | 0), - (x = Math.imul(le, xe)), - (b = (b + Math.imul(fe, Ke)) | 0), - (f = (f + Math.imul(fe, pe)) | 0), - (f = (f + Math.imul(V, Ke)) | 0), - (x = (x + Math.imul(V, pe)) | 0), - (b = (b + Math.imul(L, Se)) | 0), - (f = (f + Math.imul(L, Pe)) | 0), - (f = (f + Math.imul(ee, Se)) | 0), - (x = (x + Math.imul(ee, Pe)) | 0), - (b = (b + Math.imul(E, Ie)) | 0), - (f = (f + Math.imul(E, je)) | 0), - (f = (f + Math.imul(B, Ie)) | 0), - (x = (x + Math.imul(B, je)) | 0); - var wt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (wt >>> 26)) | 0), - (wt &= 67108863), - (b = Math.imul(de, we)), - (f = Math.imul(de, xe)), - (f = (f + Math.imul(ve, we)) | 0), - (x = Math.imul(ve, xe)), - (b = (b + Math.imul(ae, Ke)) | 0), - (f = (f + Math.imul(ae, pe)) | 0), - (f = (f + Math.imul(le, Ke)) | 0), - (x = (x + Math.imul(le, pe)) | 0), - (b = (b + Math.imul(fe, Se)) | 0), - (f = (f + Math.imul(fe, Pe)) | 0), - (f = (f + Math.imul(V, Se)) | 0), - (x = (x + Math.imul(V, Pe)) | 0), - (b = (b + Math.imul(L, Ie)) | 0), - (f = (f + Math.imul(L, je)) | 0), - (f = (f + Math.imul(ee, Ie)) | 0), - (x = (x + Math.imul(ee, je)) | 0), - (b = (b + Math.imul(E, Fe)) | 0), - (f = (f + Math.imul(E, He)) | 0), - (f = (f + Math.imul(B, Fe)) | 0), - (x = (x + Math.imul(B, He)) | 0); - var zt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (zt >>> 26)) | 0), - (zt &= 67108863), - (b = Math.imul(me, we)), - (f = Math.imul(me, xe)), - (f = (f + Math.imul(_e, we)) | 0), - (x = Math.imul(_e, xe)), - (b = (b + Math.imul(de, Ke)) | 0), - (f = (f + Math.imul(de, pe)) | 0), - (f = (f + Math.imul(ve, Ke)) | 0), - (x = (x + Math.imul(ve, pe)) | 0), - (b = (b + Math.imul(ae, Se)) | 0), - (f = (f + Math.imul(ae, Pe)) | 0), - (f = (f + Math.imul(le, Se)) | 0), - (x = (x + Math.imul(le, Pe)) | 0), - (b = (b + Math.imul(fe, Ie)) | 0), - (f = (f + Math.imul(fe, je)) | 0), - (f = (f + Math.imul(V, Ie)) | 0), - (x = (x + Math.imul(V, je)) | 0), - (b = (b + Math.imul(L, Fe)) | 0), - (f = (f + Math.imul(L, He)) | 0), - (f = (f + Math.imul(ee, Fe)) | 0), - (x = (x + Math.imul(ee, He)) | 0), - (b = (b + Math.imul(E, Xe)) | 0), - (f = (f + Math.imul(E, Ze)) | 0), - (f = (f + Math.imul(B, Xe)) | 0), - (x = (x + Math.imul(B, Ze)) | 0); - var jt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (jt >>> 26)) | 0), - (jt &= 67108863), - (b = Math.imul(Ee, we)), - (f = Math.imul(Ee, xe)), - (f = (f + Math.imul(Be, we)) | 0), - (x = Math.imul(Be, xe)), - (b = (b + Math.imul(me, Ke)) | 0), - (f = (f + Math.imul(me, pe)) | 0), - (f = (f + Math.imul(_e, Ke)) | 0), - (x = (x + Math.imul(_e, pe)) | 0), - (b = (b + Math.imul(de, Se)) | 0), - (f = (f + Math.imul(de, Pe)) | 0), - (f = (f + Math.imul(ve, Se)) | 0), - (x = (x + Math.imul(ve, Pe)) | 0), - (b = (b + Math.imul(ae, Ie)) | 0), - (f = (f + Math.imul(ae, je)) | 0), - (f = (f + Math.imul(le, Ie)) | 0), - (x = (x + Math.imul(le, je)) | 0), - (b = (b + Math.imul(fe, Fe)) | 0), - (f = (f + Math.imul(fe, He)) | 0), - (f = (f + Math.imul(V, Fe)) | 0), - (x = (x + Math.imul(V, He)) | 0), - (b = (b + Math.imul(L, Xe)) | 0), - (f = (f + Math.imul(L, Ze)) | 0), - (f = (f + Math.imul(ee, Xe)) | 0), - (x = (x + Math.imul(ee, Ze)) | 0), - (b = (b + Math.imul(E, $e)) | 0), - (f = (f + Math.imul(E, tt)) | 0), - (f = (f + Math.imul(B, $e)) | 0), - (x = (x + Math.imul(B, tt)) | 0); - var Ht = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ht >>> 26)) | 0), - (Ht &= 67108863), - (b = Math.imul(Ve, we)), - (f = Math.imul(Ve, xe)), - (f = (f + Math.imul(We, we)) | 0), - (x = Math.imul(We, xe)), - (b = (b + Math.imul(Ee, Ke)) | 0), - (f = (f + Math.imul(Ee, pe)) | 0), - (f = (f + Math.imul(Be, Ke)) | 0), - (x = (x + Math.imul(Be, pe)) | 0), - (b = (b + Math.imul(me, Se)) | 0), - (f = (f + Math.imul(me, Pe)) | 0), - (f = (f + Math.imul(_e, Se)) | 0), - (x = (x + Math.imul(_e, Pe)) | 0), - (b = (b + Math.imul(de, Ie)) | 0), - (f = (f + Math.imul(de, je)) | 0), - (f = (f + Math.imul(ve, Ie)) | 0), - (x = (x + Math.imul(ve, je)) | 0), - (b = (b + Math.imul(ae, Fe)) | 0), - (f = (f + Math.imul(ae, He)) | 0), - (f = (f + Math.imul(le, Fe)) | 0), - (x = (x + Math.imul(le, He)) | 0), - (b = (b + Math.imul(fe, Xe)) | 0), - (f = (f + Math.imul(fe, Ze)) | 0), - (f = (f + Math.imul(V, Xe)) | 0), - (x = (x + Math.imul(V, Ze)) | 0), - (b = (b + Math.imul(L, $e)) | 0), - (f = (f + Math.imul(L, tt)) | 0), - (f = (f + Math.imul(ee, $e)) | 0), - (x = (x + Math.imul(ee, tt)) | 0), - (b = (b + Math.imul(E, ie)) | 0), - (f = (f + Math.imul(E, re)) | 0), - (f = (f + Math.imul(B, ie)) | 0), - (x = (x + Math.imul(B, re)) | 0); - var Ut = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ut >>> 26)) | 0), - (Ut &= 67108863), - (b = Math.imul(Ue, we)), - (f = Math.imul(Ue, xe)), - (f = (f + Math.imul(Y, we)) | 0), - (x = Math.imul(Y, xe)), - (b = (b + Math.imul(Ve, Ke)) | 0), - (f = (f + Math.imul(Ve, pe)) | 0), - (f = (f + Math.imul(We, Ke)) | 0), - (x = (x + Math.imul(We, pe)) | 0), - (b = (b + Math.imul(Ee, Se)) | 0), - (f = (f + Math.imul(Ee, Pe)) | 0), - (f = (f + Math.imul(Be, Se)) | 0), - (x = (x + Math.imul(Be, Pe)) | 0), - (b = (b + Math.imul(me, Ie)) | 0), - (f = (f + Math.imul(me, je)) | 0), - (f = (f + Math.imul(_e, Ie)) | 0), - (x = (x + Math.imul(_e, je)) | 0), - (b = (b + Math.imul(de, Fe)) | 0), - (f = (f + Math.imul(de, He)) | 0), - (f = (f + Math.imul(ve, Fe)) | 0), - (x = (x + Math.imul(ve, He)) | 0), - (b = (b + Math.imul(ae, Xe)) | 0), - (f = (f + Math.imul(ae, Ze)) | 0), - (f = (f + Math.imul(le, Xe)) | 0), - (x = (x + Math.imul(le, Ze)) | 0), - (b = (b + Math.imul(fe, $e)) | 0), - (f = (f + Math.imul(fe, tt)) | 0), - (f = (f + Math.imul(V, $e)) | 0), - (x = (x + Math.imul(V, tt)) | 0), - (b = (b + Math.imul(L, ie)) | 0), - (f = (f + Math.imul(L, re)) | 0), - (f = (f + Math.imul(ee, ie)) | 0), - (x = (x + Math.imul(ee, re)) | 0), - (b = (b + Math.imul(E, se)) | 0), - (f = (f + Math.imul(E, be)) | 0), - (f = (f + Math.imul(B, se)) | 0), - (x = (x + Math.imul(B, be)) | 0); - var Kt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Kt >>> 26)) | 0), - (Kt &= 67108863), - (b = Math.imul(j, we)), - (f = Math.imul(j, xe)), - (f = (f + Math.imul(ce, we)) | 0), - (x = Math.imul(ce, xe)), - (b = (b + Math.imul(Ue, Ke)) | 0), - (f = (f + Math.imul(Ue, pe)) | 0), - (f = (f + Math.imul(Y, Ke)) | 0), - (x = (x + Math.imul(Y, pe)) | 0), - (b = (b + Math.imul(Ve, Se)) | 0), - (f = (f + Math.imul(Ve, Pe)) | 0), - (f = (f + Math.imul(We, Se)) | 0), - (x = (x + Math.imul(We, Pe)) | 0), - (b = (b + Math.imul(Ee, Ie)) | 0), - (f = (f + Math.imul(Ee, je)) | 0), - (f = (f + Math.imul(Be, Ie)) | 0), - (x = (x + Math.imul(Be, je)) | 0), - (b = (b + Math.imul(me, Fe)) | 0), - (f = (f + Math.imul(me, He)) | 0), - (f = (f + Math.imul(_e, Fe)) | 0), - (x = (x + Math.imul(_e, He)) | 0), - (b = (b + Math.imul(de, Xe)) | 0), - (f = (f + Math.imul(de, Ze)) | 0), - (f = (f + Math.imul(ve, Xe)) | 0), - (x = (x + Math.imul(ve, Ze)) | 0), - (b = (b + Math.imul(ae, $e)) | 0), - (f = (f + Math.imul(ae, tt)) | 0), - (f = (f + Math.imul(le, $e)) | 0), - (x = (x + Math.imul(le, tt)) | 0), - (b = (b + Math.imul(fe, ie)) | 0), - (f = (f + Math.imul(fe, re)) | 0), - (f = (f + Math.imul(V, ie)) | 0), - (x = (x + Math.imul(V, re)) | 0), - (b = (b + Math.imul(L, se)) | 0), - (f = (f + Math.imul(L, be)) | 0), - (f = (f + Math.imul(ee, se)) | 0), - (x = (x + Math.imul(ee, be)) | 0), - (b = (b + Math.imul(E, Ae)) | 0), - (f = (f + Math.imul(E, ke)) | 0), - (f = (f + Math.imul(B, Ae)) | 0), - (x = (x + Math.imul(B, ke)) | 0); - var Ot = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ot >>> 26)) | 0), - (Ot &= 67108863), - (b = Math.imul(j, Ke)), - (f = Math.imul(j, pe)), - (f = (f + Math.imul(ce, Ke)) | 0), - (x = Math.imul(ce, pe)), - (b = (b + Math.imul(Ue, Se)) | 0), - (f = (f + Math.imul(Ue, Pe)) | 0), - (f = (f + Math.imul(Y, Se)) | 0), - (x = (x + Math.imul(Y, Pe)) | 0), - (b = (b + Math.imul(Ve, Ie)) | 0), - (f = (f + Math.imul(Ve, je)) | 0), - (f = (f + Math.imul(We, Ie)) | 0), - (x = (x + Math.imul(We, je)) | 0), - (b = (b + Math.imul(Ee, Fe)) | 0), - (f = (f + Math.imul(Ee, He)) | 0), - (f = (f + Math.imul(Be, Fe)) | 0), - (x = (x + Math.imul(Be, He)) | 0), - (b = (b + Math.imul(me, Xe)) | 0), - (f = (f + Math.imul(me, Ze)) | 0), - (f = (f + Math.imul(_e, Xe)) | 0), - (x = (x + Math.imul(_e, Ze)) | 0), - (b = (b + Math.imul(de, $e)) | 0), - (f = (f + Math.imul(de, tt)) | 0), - (f = (f + Math.imul(ve, $e)) | 0), - (x = (x + Math.imul(ve, tt)) | 0), - (b = (b + Math.imul(ae, ie)) | 0), - (f = (f + Math.imul(ae, re)) | 0), - (f = (f + Math.imul(le, ie)) | 0), - (x = (x + Math.imul(le, re)) | 0), - (b = (b + Math.imul(fe, se)) | 0), - (f = (f + Math.imul(fe, be)) | 0), - (f = (f + Math.imul(V, se)) | 0), - (x = (x + Math.imul(V, be)) | 0), - (b = (b + Math.imul(L, Ae)) | 0), - (f = (f + Math.imul(L, ke)) | 0), - (f = (f + Math.imul(ee, Ae)) | 0), - (x = (x + Math.imul(ee, ke)) | 0); - var Bt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Bt >>> 26)) | 0), - (Bt &= 67108863), - (b = Math.imul(j, Se)), - (f = Math.imul(j, Pe)), - (f = (f + Math.imul(ce, Se)) | 0), - (x = Math.imul(ce, Pe)), - (b = (b + Math.imul(Ue, Ie)) | 0), - (f = (f + Math.imul(Ue, je)) | 0), - (f = (f + Math.imul(Y, Ie)) | 0), - (x = (x + Math.imul(Y, je)) | 0), - (b = (b + Math.imul(Ve, Fe)) | 0), - (f = (f + Math.imul(Ve, He)) | 0), - (f = (f + Math.imul(We, Fe)) | 0), - (x = (x + Math.imul(We, He)) | 0), - (b = (b + Math.imul(Ee, Xe)) | 0), - (f = (f + Math.imul(Ee, Ze)) | 0), - (f = (f + Math.imul(Be, Xe)) | 0), - (x = (x + Math.imul(Be, Ze)) | 0), - (b = (b + Math.imul(me, $e)) | 0), - (f = (f + Math.imul(me, tt)) | 0), - (f = (f + Math.imul(_e, $e)) | 0), - (x = (x + Math.imul(_e, tt)) | 0), - (b = (b + Math.imul(de, ie)) | 0), - (f = (f + Math.imul(de, re)) | 0), - (f = (f + Math.imul(ve, ie)) | 0), - (x = (x + Math.imul(ve, re)) | 0), - (b = (b + Math.imul(ae, se)) | 0), - (f = (f + Math.imul(ae, be)) | 0), - (f = (f + Math.imul(le, se)) | 0), - (x = (x + Math.imul(le, be)) | 0), - (b = (b + Math.imul(fe, Ae)) | 0), - (f = (f + Math.imul(fe, ke)) | 0), - (f = (f + Math.imul(V, Ae)) | 0), - (x = (x + Math.imul(V, ke)) | 0); - var Et = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Et >>> 26)) | 0), - (Et &= 67108863), - (b = Math.imul(j, Ie)), - (f = Math.imul(j, je)), - (f = (f + Math.imul(ce, Ie)) | 0), - (x = Math.imul(ce, je)), - (b = (b + Math.imul(Ue, Fe)) | 0), - (f = (f + Math.imul(Ue, He)) | 0), - (f = (f + Math.imul(Y, Fe)) | 0), - (x = (x + Math.imul(Y, He)) | 0), - (b = (b + Math.imul(Ve, Xe)) | 0), - (f = (f + Math.imul(Ve, Ze)) | 0), - (f = (f + Math.imul(We, Xe)) | 0), - (x = (x + Math.imul(We, Ze)) | 0), - (b = (b + Math.imul(Ee, $e)) | 0), - (f = (f + Math.imul(Ee, tt)) | 0), - (f = (f + Math.imul(Be, $e)) | 0), - (x = (x + Math.imul(Be, tt)) | 0), - (b = (b + Math.imul(me, ie)) | 0), - (f = (f + Math.imul(me, re)) | 0), - (f = (f + Math.imul(_e, ie)) | 0), - (x = (x + Math.imul(_e, re)) | 0), - (b = (b + Math.imul(de, se)) | 0), - (f = (f + Math.imul(de, be)) | 0), - (f = (f + Math.imul(ve, se)) | 0), - (x = (x + Math.imul(ve, be)) | 0), - (b = (b + Math.imul(ae, Ae)) | 0), - (f = (f + Math.imul(ae, ke)) | 0), - (f = (f + Math.imul(le, Ae)) | 0), - (x = (x + Math.imul(le, ke)) | 0); - var Mt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Mt >>> 26)) | 0), - (Mt &= 67108863), - (b = Math.imul(j, Fe)), - (f = Math.imul(j, He)), - (f = (f + Math.imul(ce, Fe)) | 0), - (x = Math.imul(ce, He)), - (b = (b + Math.imul(Ue, Xe)) | 0), - (f = (f + Math.imul(Ue, Ze)) | 0), - (f = (f + Math.imul(Y, Xe)) | 0), - (x = (x + Math.imul(Y, Ze)) | 0), - (b = (b + Math.imul(Ve, $e)) | 0), - (f = (f + Math.imul(Ve, tt)) | 0), - (f = (f + Math.imul(We, $e)) | 0), - (x = (x + Math.imul(We, tt)) | 0), - (b = (b + Math.imul(Ee, ie)) | 0), - (f = (f + Math.imul(Ee, re)) | 0), - (f = (f + Math.imul(Be, ie)) | 0), - (x = (x + Math.imul(Be, re)) | 0), - (b = (b + Math.imul(me, se)) | 0), - (f = (f + Math.imul(me, be)) | 0), - (f = (f + Math.imul(_e, se)) | 0), - (x = (x + Math.imul(_e, be)) | 0), - (b = (b + Math.imul(de, Ae)) | 0), - (f = (f + Math.imul(de, ke)) | 0), - (f = (f + Math.imul(ve, Ae)) | 0), - (x = (x + Math.imul(ve, ke)) | 0); - var gt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (gt >>> 26)) | 0), - (gt &= 67108863), - (b = Math.imul(j, Xe)), - (f = Math.imul(j, Ze)), - (f = (f + Math.imul(ce, Xe)) | 0), - (x = Math.imul(ce, Ze)), - (b = (b + Math.imul(Ue, $e)) | 0), - (f = (f + Math.imul(Ue, tt)) | 0), - (f = (f + Math.imul(Y, $e)) | 0), - (x = (x + Math.imul(Y, tt)) | 0), - (b = (b + Math.imul(Ve, ie)) | 0), - (f = (f + Math.imul(Ve, re)) | 0), - (f = (f + Math.imul(We, ie)) | 0), - (x = (x + Math.imul(We, re)) | 0), - (b = (b + Math.imul(Ee, se)) | 0), - (f = (f + Math.imul(Ee, be)) | 0), - (f = (f + Math.imul(Be, se)) | 0), - (x = (x + Math.imul(Be, be)) | 0), - (b = (b + Math.imul(me, Ae)) | 0), - (f = (f + Math.imul(me, ke)) | 0), - (f = (f + Math.imul(_e, Ae)) | 0), - (x = (x + Math.imul(_e, ke)) | 0); - var Pt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Pt >>> 26)) | 0), - (Pt &= 67108863), - (b = Math.imul(j, $e)), - (f = Math.imul(j, tt)), - (f = (f + Math.imul(ce, $e)) | 0), - (x = Math.imul(ce, tt)), - (b = (b + Math.imul(Ue, ie)) | 0), - (f = (f + Math.imul(Ue, re)) | 0), - (f = (f + Math.imul(Y, ie)) | 0), - (x = (x + Math.imul(Y, re)) | 0), - (b = (b + Math.imul(Ve, se)) | 0), - (f = (f + Math.imul(Ve, be)) | 0), - (f = (f + Math.imul(We, se)) | 0), - (x = (x + Math.imul(We, be)) | 0), - (b = (b + Math.imul(Ee, Ae)) | 0), - (f = (f + Math.imul(Ee, ke)) | 0), - (f = (f + Math.imul(Be, Ae)) | 0), - (x = (x + Math.imul(Be, ke)) | 0); - var It = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (It >>> 26)) | 0), - (It &= 67108863), - (b = Math.imul(j, ie)), - (f = Math.imul(j, re)), - (f = (f + Math.imul(ce, ie)) | 0), - (x = Math.imul(ce, re)), - (b = (b + Math.imul(Ue, se)) | 0), - (f = (f + Math.imul(Ue, be)) | 0), - (f = (f + Math.imul(Y, se)) | 0), - (x = (x + Math.imul(Y, be)) | 0), - (b = (b + Math.imul(Ve, Ae)) | 0), - (f = (f + Math.imul(Ve, ke)) | 0), - (f = (f + Math.imul(We, Ae)) | 0), - (x = (x + Math.imul(We, ke)) | 0); - var yt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (yt >>> 26)) | 0), - (yt &= 67108863), - (b = Math.imul(j, se)), - (f = Math.imul(j, be)), - (f = (f + Math.imul(ce, se)) | 0), - (x = Math.imul(ce, be)), - (b = (b + Math.imul(Ue, Ae)) | 0), - (f = (f + Math.imul(Ue, ke)) | 0), - (f = (f + Math.imul(Y, Ae)) | 0), - (x = (x + Math.imul(Y, ke)) | 0); - var nt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (nt >>> 26)) | 0), - (nt &= 67108863), - (b = Math.imul(j, Ae)), - (f = Math.imul(j, ke)), - (f = (f + Math.imul(ce, Ae)) | 0), - (x = Math.imul(ce, ke)); - var it = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - return ( - (S = (((x + (f >>> 13)) | 0) + (it >>> 26)) | 0), - (it &= 67108863), - (_[0] = Ct), - (_[1] = ut), - (_[2] = St), - (_[3] = wt), - (_[4] = zt), - (_[5] = jt), - (_[6] = Ht), - (_[7] = Ut), - (_[8] = Kt), - (_[9] = Ot), - (_[10] = Bt), - (_[11] = Et), - (_[12] = Mt), - (_[13] = gt), - (_[14] = Pt), - (_[15] = It), - (_[16] = yt), - (_[17] = nt), - (_[18] = it), - S !== 0 && ((_[19] = S), y.length++), - y - ); - }; - Math.imul || (O = k); - function D(A, l, p) { - (p.negative = l.negative ^ A.negative), - (p.length = A.length + l.length); - for (var y = 0, d = 0, v = 0; v < p.length - 1; v++) { - var _ = d; - d = 0; - for ( - var S = y & 67108863, - b = Math.min(v, l.length - 1), - f = Math.max(0, v - A.length + 1); - f <= b; - f++ - ) { - var x = v - f, - C = A.words[x] | 0, - E = l.words[f] | 0, - B = C * E, - G = B & 67108863; - (_ = (_ + ((B / 67108864) | 0)) | 0), - (G = (G + S) | 0), - (S = G & 67108863), - (_ = (_ + (G >>> 26)) | 0), - (d += _ >>> 26), - (_ &= 67108863); - } - (p.words[v] = S), (y = _), (_ = d); - } - return y !== 0 ? (p.words[v] = y) : p.length--, p.strip(); - } - function F(A, l, p) { - var y = new N(); - return y.mulp(A, l, p); - } - i.prototype.mulTo = function (l, p) { - var y, - d = this.length + l.length; - return ( - this.length === 10 && l.length === 10 - ? (y = O(this, l, p)) - : d < 63 - ? (y = k(this, l, p)) - : d < 1024 - ? (y = D(this, l, p)) - : (y = F(this, l, p)), - y - ); - }; - function N(A, l) { - (this.x = A), (this.y = l); - } - (N.prototype.makeRBT = function (l) { - for ( - var p = new Array(l), y = i.prototype._countBits(l) - 1, d = 0; - d < l; - d++ - ) - p[d] = this.revBin(d, y, l); - return p; - }), - (N.prototype.revBin = function (l, p, y) { - if (l === 0 || l === y - 1) return l; - for (var d = 0, v = 0; v < p; v++) - (d |= (l & 1) << (p - v - 1)), (l >>= 1); - return d; - }), - (N.prototype.permute = function (l, p, y, d, v, _) { - for (var S = 0; S < _; S++) (d[S] = p[l[S]]), (v[S] = y[l[S]]); - }), - (N.prototype.transform = function (l, p, y, d, v, _) { - this.permute(_, l, p, y, d, v); - for (var S = 1; S < v; S <<= 1) - for ( - var b = S << 1, - f = Math.cos((2 * Math.PI) / b), - x = Math.sin((2 * Math.PI) / b), - C = 0; - C < v; - C += b - ) - for (var E = f, B = x, G = 0; G < S; G++) { - var L = y[C + G], - ee = d[C + G], - ge = y[C + G + S], - fe = d[C + G + S], - V = E * ge - B * fe; - (fe = E * fe + B * ge), - (ge = V), - (y[C + G] = L + ge), - (d[C + G] = ee + fe), - (y[C + G + S] = L - ge), - (d[C + G + S] = ee - fe), - G !== b && - ((V = f * E - x * B), (B = f * B + x * E), (E = V)); - } - }), - (N.prototype.guessLen13b = function (l, p) { - var y = Math.max(p, l) | 1, - d = y & 1, - v = 0; - for (y = (y / 2) | 0; y; y = y >>> 1) v++; - return 1 << (v + 1 + d); - }), - (N.prototype.conjugate = function (l, p, y) { - if (!(y <= 1)) - for (var d = 0; d < y / 2; d++) { - var v = l[d]; - (l[d] = l[y - d - 1]), - (l[y - d - 1] = v), - (v = p[d]), - (p[d] = -p[y - d - 1]), - (p[y - d - 1] = -v); - } - }), - (N.prototype.normalize13b = function (l, p) { - for (var y = 0, d = 0; d < p / 2; d++) { - var v = - Math.round(l[2 * d + 1] / p) * 8192 + - Math.round(l[2 * d] / p) + - y; - (l[d] = v & 67108863), - v < 67108864 ? (y = 0) : (y = (v / 67108864) | 0); - } - return l; - }), - (N.prototype.convert13b = function (l, p, y, d) { - for (var v = 0, _ = 0; _ < p; _++) - (v = v + (l[_] | 0)), - (y[2 * _] = v & 8191), - (v = v >>> 13), - (y[2 * _ + 1] = v & 8191), - (v = v >>> 13); - for (_ = 2 * p; _ < d; ++_) y[_] = 0; - r(v === 0), r((v & -8192) === 0); - }), - (N.prototype.stub = function (l) { - for (var p = new Array(l), y = 0; y < l; y++) p[y] = 0; - return p; - }), - (N.prototype.mulp = function (l, p, y) { - var d = 2 * this.guessLen13b(l.length, p.length), - v = this.makeRBT(d), - _ = this.stub(d), - S = new Array(d), - b = new Array(d), - f = new Array(d), - x = new Array(d), - C = new Array(d), - E = new Array(d), - B = y.words; - (B.length = d), - this.convert13b(l.words, l.length, S, d), - this.convert13b(p.words, p.length, x, d), - this.transform(S, _, b, f, d, v), - this.transform(x, _, C, E, d, v); - for (var G = 0; G < d; G++) { - var L = b[G] * C[G] - f[G] * E[G]; - (f[G] = b[G] * E[G] + f[G] * C[G]), (b[G] = L); - } - return ( - this.conjugate(b, f, d), - this.transform(b, f, B, _, d, v), - this.conjugate(B, _, d), - this.normalize13b(B, d), - (y.negative = l.negative ^ p.negative), - (y.length = l.length + p.length), - y.strip() - ); - }), - (i.prototype.mul = function (l) { - var p = new i(null); - return ( - (p.words = new Array(this.length + l.length)), this.mulTo(l, p) - ); - }), - (i.prototype.mulf = function (l) { - var p = new i(null); - return (p.words = new Array(this.length + l.length)), F(this, l, p); - }), - (i.prototype.imul = function (l) { - return this.clone().mulTo(l, this); - }), - (i.prototype.imuln = function (l) { - r(typeof l == "number"), r(l < 67108864); - for (var p = 0, y = 0; y < this.length; y++) { - var d = (this.words[y] | 0) * l, - v = (d & 67108863) + (p & 67108863); - (p >>= 26), - (p += (d / 67108864) | 0), - (p += v >>> 26), - (this.words[y] = v & 67108863); - } - return p !== 0 && ((this.words[y] = p), this.length++), this; - }), - (i.prototype.muln = function (l) { - return this.clone().imuln(l); - }), - (i.prototype.sqr = function () { - return this.mul(this); - }), - (i.prototype.isqr = function () { - return this.imul(this.clone()); - }), - (i.prototype.pow = function (l) { - var p = M(l); - if (p.length === 0) return new i(1); - for ( - var y = this, d = 0; - d < p.length && p[d] === 0; - d++, y = y.sqr() - ); - if (++d < p.length) - for (var v = y.sqr(); d < p.length; d++, v = v.sqr()) - p[d] !== 0 && (y = y.mul(v)); - return y; - }), - (i.prototype.iushln = function (l) { - r(typeof l == "number" && l >= 0); - var p = l % 26, - y = (l - p) / 26, - d = (67108863 >>> (26 - p)) << (26 - p), - v; - if (p !== 0) { - var _ = 0; - for (v = 0; v < this.length; v++) { - var S = this.words[v] & d, - b = ((this.words[v] | 0) - S) << p; - (this.words[v] = b | _), (_ = S >>> (26 - p)); - } - _ && ((this.words[v] = _), this.length++); - } - if (y !== 0) { - for (v = this.length - 1; v >= 0; v--) - this.words[v + y] = this.words[v]; - for (v = 0; v < y; v++) this.words[v] = 0; - this.length += y; - } - return this.strip(); - }), - (i.prototype.ishln = function (l) { - return r(this.negative === 0), this.iushln(l); - }), - (i.prototype.iushrn = function (l, p, y) { - r(typeof l == "number" && l >= 0); - var d; - p ? (d = (p - (p % 26)) / 26) : (d = 0); - var v = l % 26, - _ = Math.min((l - v) / 26, this.length), - S = 67108863 ^ ((67108863 >>> v) << v), - b = y; - if (((d -= _), (d = Math.max(0, d)), b)) { - for (var f = 0; f < _; f++) b.words[f] = this.words[f]; - b.length = _; - } - if (_ !== 0) - if (this.length > _) - for (this.length -= _, f = 0; f < this.length; f++) - this.words[f] = this.words[f + _]; - else (this.words[0] = 0), (this.length = 1); - var x = 0; - for (f = this.length - 1; f >= 0 && (x !== 0 || f >= d); f--) { - var C = this.words[f] | 0; - (this.words[f] = (x << (26 - v)) | (C >>> v)), (x = C & S); - } - return ( - b && x !== 0 && (b.words[b.length++] = x), - this.length === 0 && ((this.words[0] = 0), (this.length = 1)), - this.strip() - ); - }), - (i.prototype.ishrn = function (l, p, y) { - return r(this.negative === 0), this.iushrn(l, p, y); - }), - (i.prototype.shln = function (l) { - return this.clone().ishln(l); - }), - (i.prototype.ushln = function (l) { - return this.clone().iushln(l); - }), - (i.prototype.shrn = function (l) { - return this.clone().ishrn(l); - }), - (i.prototype.ushrn = function (l) { - return this.clone().iushrn(l); - }), - (i.prototype.testn = function (l) { - r(typeof l == "number" && l >= 0); - var p = l % 26, - y = (l - p) / 26, - d = 1 << p; - if (this.length <= y) return !1; - var v = this.words[y]; - return !!(v & d); - }), - (i.prototype.imaskn = function (l) { - r(typeof l == "number" && l >= 0); - var p = l % 26, - y = (l - p) / 26; - if ( - (r(this.negative === 0, "imaskn works only with positive numbers"), - this.length <= y) - ) - return this; - if ( - (p !== 0 && y++, (this.length = Math.min(y, this.length)), p !== 0) - ) { - var d = 67108863 ^ ((67108863 >>> p) << p); - this.words[this.length - 1] &= d; - } - return this.strip(); - }), - (i.prototype.maskn = function (l) { - return this.clone().imaskn(l); - }), - (i.prototype.iaddn = function (l) { - return ( - r(typeof l == "number"), - r(l < 67108864), - l < 0 - ? this.isubn(-l) - : this.negative !== 0 - ? this.length === 1 && (this.words[0] | 0) < l - ? ((this.words[0] = l - (this.words[0] | 0)), - (this.negative = 0), - this) - : ((this.negative = 0), - this.isubn(l), - (this.negative = 1), - this) - : this._iaddn(l) - ); - }), - (i.prototype._iaddn = function (l) { - this.words[0] += l; - for (var p = 0; p < this.length && this.words[p] >= 67108864; p++) - (this.words[p] -= 67108864), - p === this.length - 1 - ? (this.words[p + 1] = 1) - : this.words[p + 1]++; - return (this.length = Math.max(this.length, p + 1)), this; - }), - (i.prototype.isubn = function (l) { - if ((r(typeof l == "number"), r(l < 67108864), l < 0)) - return this.iaddn(-l); - if (this.negative !== 0) - return ( - (this.negative = 0), this.iaddn(l), (this.negative = 1), this - ); - if (((this.words[0] -= l), this.length === 1 && this.words[0] < 0)) - (this.words[0] = -this.words[0]), (this.negative = 1); - else - for (var p = 0; p < this.length && this.words[p] < 0; p++) - (this.words[p] += 67108864), (this.words[p + 1] -= 1); - return this.strip(); - }), - (i.prototype.addn = function (l) { - return this.clone().iaddn(l); - }), - (i.prototype.subn = function (l) { - return this.clone().isubn(l); - }), - (i.prototype.iabs = function () { - return (this.negative = 0), this; - }), - (i.prototype.abs = function () { - return this.clone().iabs(); - }), - (i.prototype._ishlnsubmul = function (l, p, y) { - var d = l.length + y, - v; - this._expand(d); - var _, - S = 0; - for (v = 0; v < l.length; v++) { - _ = (this.words[v + y] | 0) + S; - var b = (l.words[v] | 0) * p; - (_ -= b & 67108863), - (S = (_ >> 26) - ((b / 67108864) | 0)), - (this.words[v + y] = _ & 67108863); - } - for (; v < this.length - y; v++) - (_ = (this.words[v + y] | 0) + S), - (S = _ >> 26), - (this.words[v + y] = _ & 67108863); - if (S === 0) return this.strip(); - for (r(S === -1), S = 0, v = 0; v < this.length; v++) - (_ = -(this.words[v] | 0) + S), - (S = _ >> 26), - (this.words[v] = _ & 67108863); - return (this.negative = 1), this.strip(); - }), - (i.prototype._wordDiv = function (l, p) { - var y = this.length - l.length, - d = this.clone(), - v = l, - _ = v.words[v.length - 1] | 0, - S = this._countBits(_); - (y = 26 - S), - y !== 0 && - ((v = v.ushln(y)), d.iushln(y), (_ = v.words[v.length - 1] | 0)); - var b = d.length - v.length, - f; - if (p !== "mod") { - (f = new i(null)), - (f.length = b + 1), - (f.words = new Array(f.length)); - for (var x = 0; x < f.length; x++) f.words[x] = 0; - } - var C = d.clone()._ishlnsubmul(v, 1, b); - C.negative === 0 && ((d = C), f && (f.words[b] = 1)); - for (var E = b - 1; E >= 0; E--) { - var B = - (d.words[v.length + E] | 0) * 67108864 + - (d.words[v.length + E - 1] | 0); - for ( - B = Math.min((B / _) | 0, 67108863), d._ishlnsubmul(v, B, E); - d.negative !== 0; - - ) - B--, - (d.negative = 0), - d._ishlnsubmul(v, 1, E), - d.isZero() || (d.negative ^= 1); - f && (f.words[E] = B); - } - return ( - f && f.strip(), - d.strip(), - p !== "div" && y !== 0 && d.iushrn(y), - { div: f || null, mod: d } - ); - }), - (i.prototype.divmod = function (l, p, y) { - if ((r(!l.isZero()), this.isZero())) - return { div: new i(0), mod: new i(0) }; - var d, v, _; - return this.negative !== 0 && l.negative === 0 - ? ((_ = this.neg().divmod(l, p)), - p !== "mod" && (d = _.div.neg()), - p !== "div" && - ((v = _.mod.neg()), y && v.negative !== 0 && v.iadd(l)), - { div: d, mod: v }) - : this.negative === 0 && l.negative !== 0 - ? ((_ = this.divmod(l.neg(), p)), - p !== "mod" && (d = _.div.neg()), - { div: d, mod: _.mod }) - : (this.negative & l.negative) !== 0 - ? ((_ = this.neg().divmod(l.neg(), p)), - p !== "div" && - ((v = _.mod.neg()), y && v.negative !== 0 && v.isub(l)), - { div: _.div, mod: v }) - : l.length > this.length || this.cmp(l) < 0 - ? { div: new i(0), mod: this } - : l.length === 1 - ? p === "div" - ? { div: this.divn(l.words[0]), mod: null } - : p === "mod" - ? { div: null, mod: new i(this.modn(l.words[0])) } - : { - div: this.divn(l.words[0]), - mod: new i(this.modn(l.words[0])), - } - : this._wordDiv(l, p); - }), - (i.prototype.div = function (l) { - return this.divmod(l, "div", !1).div; - }), - (i.prototype.mod = function (l) { - return this.divmod(l, "mod", !1).mod; - }), - (i.prototype.umod = function (l) { - return this.divmod(l, "mod", !0).mod; - }), - (i.prototype.divRound = function (l) { - var p = this.divmod(l); - if (p.mod.isZero()) return p.div; - var y = p.div.negative !== 0 ? p.mod.isub(l) : p.mod, - d = l.ushrn(1), - v = l.andln(1), - _ = y.cmp(d); - return _ < 0 || (v === 1 && _ === 0) - ? p.div - : p.div.negative !== 0 - ? p.div.isubn(1) - : p.div.iaddn(1); - }), - (i.prototype.modn = function (l) { - r(l <= 67108863); - for (var p = (1 << 26) % l, y = 0, d = this.length - 1; d >= 0; d--) - y = (p * y + (this.words[d] | 0)) % l; - return y; - }), - (i.prototype.idivn = function (l) { - r(l <= 67108863); - for (var p = 0, y = this.length - 1; y >= 0; y--) { - var d = (this.words[y] | 0) + p * 67108864; - (this.words[y] = (d / l) | 0), (p = d % l); - } - return this.strip(); - }), - (i.prototype.divn = function (l) { - return this.clone().idivn(l); - }), - (i.prototype.egcd = function (l) { - r(l.negative === 0), r(!l.isZero()); - var p = this, - y = l.clone(); - p.negative !== 0 ? (p = p.umod(l)) : (p = p.clone()); - for ( - var d = new i(1), v = new i(0), _ = new i(0), S = new i(1), b = 0; - p.isEven() && y.isEven(); - - ) - p.iushrn(1), y.iushrn(1), ++b; - for (var f = y.clone(), x = p.clone(); !p.isZero(); ) { - for ( - var C = 0, E = 1; - (p.words[0] & E) === 0 && C < 26; - ++C, E <<= 1 - ); - if (C > 0) - for (p.iushrn(C); C-- > 0; ) - (d.isOdd() || v.isOdd()) && (d.iadd(f), v.isub(x)), - d.iushrn(1), - v.iushrn(1); - for ( - var B = 0, G = 1; - (y.words[0] & G) === 0 && B < 26; - ++B, G <<= 1 - ); - if (B > 0) - for (y.iushrn(B); B-- > 0; ) - (_.isOdd() || S.isOdd()) && (_.iadd(f), S.isub(x)), - _.iushrn(1), - S.iushrn(1); - p.cmp(y) >= 0 - ? (p.isub(y), d.isub(_), v.isub(S)) - : (y.isub(p), _.isub(d), S.isub(v)); - } - return { a: _, b: S, gcd: y.iushln(b) }; - }), - (i.prototype._invmp = function (l) { - r(l.negative === 0), r(!l.isZero()); - var p = this, - y = l.clone(); - p.negative !== 0 ? (p = p.umod(l)) : (p = p.clone()); - for ( - var d = new i(1), v = new i(0), _ = y.clone(); - p.cmpn(1) > 0 && y.cmpn(1) > 0; - - ) { - for ( - var S = 0, b = 1; - (p.words[0] & b) === 0 && S < 26; - ++S, b <<= 1 - ); - if (S > 0) - for (p.iushrn(S); S-- > 0; ) d.isOdd() && d.iadd(_), d.iushrn(1); - for ( - var f = 0, x = 1; - (y.words[0] & x) === 0 && f < 26; - ++f, x <<= 1 - ); - if (f > 0) - for (y.iushrn(f); f-- > 0; ) v.isOdd() && v.iadd(_), v.iushrn(1); - p.cmp(y) >= 0 ? (p.isub(y), d.isub(v)) : (y.isub(p), v.isub(d)); - } - var C; - return ( - p.cmpn(1) === 0 ? (C = d) : (C = v), C.cmpn(0) < 0 && C.iadd(l), C - ); - }), - (i.prototype.gcd = function (l) { - if (this.isZero()) return l.abs(); - if (l.isZero()) return this.abs(); - var p = this.clone(), - y = l.clone(); - (p.negative = 0), (y.negative = 0); - for (var d = 0; p.isEven() && y.isEven(); d++) - p.iushrn(1), y.iushrn(1); - do { - for (; p.isEven(); ) p.iushrn(1); - for (; y.isEven(); ) y.iushrn(1); - var v = p.cmp(y); - if (v < 0) { - var _ = p; - (p = y), (y = _); - } else if (v === 0 || y.cmpn(1) === 0) break; - p.isub(y); - } while (!0); - return y.iushln(d); - }), - (i.prototype.invm = function (l) { - return this.egcd(l).a.umod(l); - }), - (i.prototype.isEven = function () { - return (this.words[0] & 1) === 0; - }), - (i.prototype.isOdd = function () { - return (this.words[0] & 1) === 1; - }), - (i.prototype.andln = function (l) { - return this.words[0] & l; - }), - (i.prototype.bincn = function (l) { - r(typeof l == "number"); - var p = l % 26, - y = (l - p) / 26, - d = 1 << p; - if (this.length <= y) - return this._expand(y + 1), (this.words[y] |= d), this; - for (var v = d, _ = y; v !== 0 && _ < this.length; _++) { - var S = this.words[_] | 0; - (S += v), (v = S >>> 26), (S &= 67108863), (this.words[_] = S); - } - return v !== 0 && ((this.words[_] = v), this.length++), this; - }), - (i.prototype.isZero = function () { - return this.length === 1 && this.words[0] === 0; - }), - (i.prototype.cmpn = function (l) { - var p = l < 0; - if (this.negative !== 0 && !p) return -1; - if (this.negative === 0 && p) return 1; - this.strip(); - var y; - if (this.length > 1) y = 1; - else { - p && (l = -l), r(l <= 67108863, "Number is too big"); - var d = this.words[0] | 0; - y = d === l ? 0 : d < l ? -1 : 1; - } - return this.negative !== 0 ? -y | 0 : y; - }), - (i.prototype.cmp = function (l) { - if (this.negative !== 0 && l.negative === 0) return -1; - if (this.negative === 0 && l.negative !== 0) return 1; - var p = this.ucmp(l); - return this.negative !== 0 ? -p | 0 : p; - }), - (i.prototype.ucmp = function (l) { - if (this.length > l.length) return 1; - if (this.length < l.length) return -1; - for (var p = 0, y = this.length - 1; y >= 0; y--) { - var d = this.words[y] | 0, - v = l.words[y] | 0; - if (d !== v) { - d < v ? (p = -1) : d > v && (p = 1); - break; - } - } - return p; - }), - (i.prototype.gtn = function (l) { - return this.cmpn(l) === 1; - }), - (i.prototype.gt = function (l) { - return this.cmp(l) === 1; - }), - (i.prototype.gten = function (l) { - return this.cmpn(l) >= 0; - }), - (i.prototype.gte = function (l) { - return this.cmp(l) >= 0; - }), - (i.prototype.ltn = function (l) { - return this.cmpn(l) === -1; - }), - (i.prototype.lt = function (l) { - return this.cmp(l) === -1; - }), - (i.prototype.lten = function (l) { - return this.cmpn(l) <= 0; - }), - (i.prototype.lte = function (l) { - return this.cmp(l) <= 0; - }), - (i.prototype.eqn = function (l) { - return this.cmpn(l) === 0; - }), - (i.prototype.eq = function (l) { - return this.cmp(l) === 0; - }), - (i.red = function (l) { - return new te(l); - }), - (i.prototype.toRed = function (l) { - return ( - r(!this.red, "Already a number in reduction context"), - r(this.negative === 0, "red works only with positives"), - l.convertTo(this)._forceRed(l) - ); - }), - (i.prototype.fromRed = function () { - return ( - r(this.red, "fromRed works only with numbers in reduction context"), - this.red.convertFrom(this) - ); - }), - (i.prototype._forceRed = function (l) { - return (this.red = l), this; - }), - (i.prototype.forceRed = function (l) { - return ( - r(!this.red, "Already a number in reduction context"), - this._forceRed(l) - ); - }), - (i.prototype.redAdd = function (l) { - return ( - r(this.red, "redAdd works only with red numbers"), - this.red.add(this, l) - ); - }), - (i.prototype.redIAdd = function (l) { - return ( - r(this.red, "redIAdd works only with red numbers"), - this.red.iadd(this, l) - ); - }), - (i.prototype.redSub = function (l) { - return ( - r(this.red, "redSub works only with red numbers"), - this.red.sub(this, l) - ); - }), - (i.prototype.redISub = function (l) { - return ( - r(this.red, "redISub works only with red numbers"), - this.red.isub(this, l) - ); - }), - (i.prototype.redShl = function (l) { - return ( - r(this.red, "redShl works only with red numbers"), - this.red.shl(this, l) - ); - }), - (i.prototype.redMul = function (l) { - return ( - r(this.red, "redMul works only with red numbers"), - this.red._verify2(this, l), - this.red.mul(this, l) - ); - }), - (i.prototype.redIMul = function (l) { - return ( - r(this.red, "redMul works only with red numbers"), - this.red._verify2(this, l), - this.red.imul(this, l) - ); - }), - (i.prototype.redSqr = function () { - return ( - r(this.red, "redSqr works only with red numbers"), - this.red._verify1(this), - this.red.sqr(this) - ); - }), - (i.prototype.redISqr = function () { - return ( - r(this.red, "redISqr works only with red numbers"), - this.red._verify1(this), - this.red.isqr(this) - ); - }), - (i.prototype.redSqrt = function () { - return ( - r(this.red, "redSqrt works only with red numbers"), - this.red._verify1(this), - this.red.sqrt(this) - ); - }), - (i.prototype.redInvm = function () { - return ( - r(this.red, "redInvm works only with red numbers"), - this.red._verify1(this), - this.red.invm(this) - ); - }), - (i.prototype.redNeg = function () { - return ( - r(this.red, "redNeg works only with red numbers"), - this.red._verify1(this), - this.red.neg(this) - ); - }), - (i.prototype.redPow = function (l) { - return ( - r(this.red && !l.red, "redPow(normalNum)"), - this.red._verify1(this), - this.red.pow(this, l) - ); - }); - var q = { k256: null, p224: null, p192: null, p25519: null }; - function z(A, l) { - (this.name = A), - (this.p = new i(l, 16)), - (this.n = this.p.bitLength()), - (this.k = new i(1).iushln(this.n).isub(this.p)), - (this.tmp = this._tmp()); - } - (z.prototype._tmp = function () { - var l = new i(null); - return (l.words = new Array(Math.ceil(this.n / 13))), l; - }), - (z.prototype.ireduce = function (l) { - var p = l, - y; - do - this.split(p, this.tmp), - (p = this.imulK(p)), - (p = p.iadd(this.tmp)), - (y = p.bitLength()); - while (y > this.n); - var d = y < this.n ? -1 : p.ucmp(this.p); - return ( - d === 0 - ? ((p.words[0] = 0), (p.length = 1)) - : d > 0 - ? p.isub(this.p) - : p.strip !== void 0 - ? p.strip() - : p._strip(), - p - ); - }), - (z.prototype.split = function (l, p) { - l.iushrn(this.n, 0, p); - }), - (z.prototype.imulK = function (l) { - return l.imul(this.k); - }); - function H() { - z.call( - this, - "k256", - "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f" - ); - } - n(H, z), - (H.prototype.split = function (l, p) { - for (var y = 4194303, d = Math.min(l.length, 9), v = 0; v < d; v++) - p.words[v] = l.words[v]; - if (((p.length = d), l.length <= 9)) { - (l.words[0] = 0), (l.length = 1); - return; - } - var _ = l.words[9]; - for (p.words[p.length++] = _ & y, v = 10; v < l.length; v++) { - var S = l.words[v] | 0; - (l.words[v - 10] = ((S & y) << 4) | (_ >>> 22)), (_ = S); - } - (_ >>>= 22), - (l.words[v - 10] = _), - _ === 0 && l.length > 10 ? (l.length -= 10) : (l.length -= 9); - }), - (H.prototype.imulK = function (l) { - (l.words[l.length] = 0), (l.words[l.length + 1] = 0), (l.length += 2); - for (var p = 0, y = 0; y < l.length; y++) { - var d = l.words[y] | 0; - (p += d * 977), - (l.words[y] = p & 67108863), - (p = d * 64 + ((p / 67108864) | 0)); - } - return ( - l.words[l.length - 1] === 0 && - (l.length--, l.words[l.length - 1] === 0 && l.length--), - l - ); - }); - function Z() { - z.call( - this, - "p224", - "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001" - ); - } - n(Z, z); - function $() { - z.call( - this, - "p192", - "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff" - ); - } - n($, z); - function ue() { - z.call( - this, - "25519", - "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed" - ); - } - n(ue, z), - (ue.prototype.imulK = function (l) { - for (var p = 0, y = 0; y < l.length; y++) { - var d = (l.words[y] | 0) * 19 + p, - v = d & 67108863; - (d >>>= 26), (l.words[y] = v), (p = d); - } - return p !== 0 && (l.words[l.length++] = p), l; - }), - (i._prime = function (l) { - if (q[l]) return q[l]; - var p; - if (l === "k256") p = new H(); - else if (l === "p224") p = new Z(); - else if (l === "p192") p = new $(); - else if (l === "p25519") p = new ue(); - else throw new Error("Unknown prime " + l); - return (q[l] = p), p; - }); - function te(A) { - if (typeof A == "string") { - var l = i._prime(A); - (this.m = l.p), (this.prime = l); - } else - r(A.gtn(1), "modulus must be greater than 1"), - (this.m = A), - (this.prime = null); - } - (te.prototype._verify1 = function (l) { - r(l.negative === 0, "red works only with positives"), - r(l.red, "red works only with red numbers"); - }), - (te.prototype._verify2 = function (l, p) { - r((l.negative | p.negative) === 0, "red works only with positives"), - r(l.red && l.red === p.red, "red works only with red numbers"); - }), - (te.prototype.imod = function (l) { - return this.prime - ? this.prime.ireduce(l)._forceRed(this) - : l.umod(this.m)._forceRed(this); - }), - (te.prototype.neg = function (l) { - return l.isZero() ? l.clone() : this.m.sub(l)._forceRed(this); - }), - (te.prototype.add = function (l, p) { - this._verify2(l, p); - var y = l.add(p); - return y.cmp(this.m) >= 0 && y.isub(this.m), y._forceRed(this); - }), - (te.prototype.iadd = function (l, p) { - this._verify2(l, p); - var y = l.iadd(p); - return y.cmp(this.m) >= 0 && y.isub(this.m), y; - }), - (te.prototype.sub = function (l, p) { - this._verify2(l, p); - var y = l.sub(p); - return y.cmpn(0) < 0 && y.iadd(this.m), y._forceRed(this); - }), - (te.prototype.isub = function (l, p) { - this._verify2(l, p); - var y = l.isub(p); - return y.cmpn(0) < 0 && y.iadd(this.m), y; - }), - (te.prototype.shl = function (l, p) { - return this._verify1(l), this.imod(l.ushln(p)); - }), - (te.prototype.imul = function (l, p) { - return this._verify2(l, p), this.imod(l.imul(p)); - }), - (te.prototype.mul = function (l, p) { - return this._verify2(l, p), this.imod(l.mul(p)); - }), - (te.prototype.isqr = function (l) { - return this.imul(l, l.clone()); - }), - (te.prototype.sqr = function (l) { - return this.mul(l, l); - }), - (te.prototype.sqrt = function (l) { - if (l.isZero()) return l.clone(); - var p = this.m.andln(3); - if ((r(p % 2 === 1), p === 3)) { - var y = this.m.add(new i(1)).iushrn(2); - return this.pow(l, y); - } - for (var d = this.m.subn(1), v = 0; !d.isZero() && d.andln(1) === 0; ) - v++, d.iushrn(1); - r(!d.isZero()); - var _ = new i(1).toRed(this), - S = _.redNeg(), - b = this.m.subn(1).iushrn(1), - f = this.m.bitLength(); - for (f = new i(2 * f * f).toRed(this); this.pow(f, b).cmp(S) !== 0; ) - f.redIAdd(S); - for ( - var x = this.pow(f, d), - C = this.pow(l, d.addn(1).iushrn(1)), - E = this.pow(l, d), - B = v; - E.cmp(_) !== 0; - - ) { - for (var G = E, L = 0; G.cmp(_) !== 0; L++) G = G.redSqr(); - r(L < B); - var ee = this.pow(x, new i(1).iushln(B - L - 1)); - (C = C.redMul(ee)), (x = ee.redSqr()), (E = E.redMul(x)), (B = L); - } - return C; - }), - (te.prototype.invm = function (l) { - var p = l._invmp(this.m); - return p.negative !== 0 - ? ((p.negative = 0), this.imod(p).redNeg()) - : this.imod(p); - }), - (te.prototype.pow = function (l, p) { - if (p.isZero()) return new i(1).toRed(this); - if (p.cmpn(1) === 0) return l.clone(); - var y = 4, - d = new Array(1 << y); - (d[0] = new i(1).toRed(this)), (d[1] = l); - for (var v = 2; v < d.length; v++) d[v] = this.mul(d[v - 1], l); - var _ = d[0], - S = 0, - b = 0, - f = p.bitLength() % 26; - for (f === 0 && (f = 26), v = p.length - 1; v >= 0; v--) { - for (var x = p.words[v], C = f - 1; C >= 0; C--) { - var E = (x >> C) & 1; - if ((_ !== d[0] && (_ = this.sqr(_)), E === 0 && S === 0)) { - b = 0; - continue; - } - (S <<= 1), - (S |= E), - b++, - !(b !== y && (v !== 0 || C !== 0)) && - ((_ = this.mul(_, d[S])), (b = 0), (S = 0)); - } - f = 26; - } - return _; - }), - (te.prototype.convertTo = function (l) { - var p = l.umod(this.m); - return p === l ? p.clone() : p; - }), - (te.prototype.convertFrom = function (l) { - var p = l.clone(); - return (p.red = null), p; - }), - (i.mont = function (l) { - return new ne(l); - }); - function ne(A) { - te.call(this, A), - (this.shift = this.m.bitLength()), - this.shift % 26 !== 0 && (this.shift += 26 - (this.shift % 26)), - (this.r = new i(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)); - } - n(ne, te), - (ne.prototype.convertTo = function (l) { - return this.imod(l.ushln(this.shift)); - }), - (ne.prototype.convertFrom = function (l) { - var p = this.imod(l.mul(this.rinv)); - return (p.red = null), p; - }), - (ne.prototype.imul = function (l, p) { - if (l.isZero() || p.isZero()) - return (l.words[0] = 0), (l.length = 1), l; - var y = l.imul(p), - d = y - .maskn(this.shift) - .mul(this.minv) - .imaskn(this.shift) - .mul(this.m), - v = y.isub(d).iushrn(this.shift), - _ = v; - return ( - v.cmp(this.m) >= 0 - ? (_ = v.isub(this.m)) - : v.cmpn(0) < 0 && (_ = v.iadd(this.m)), - _._forceRed(this) - ); - }), - (ne.prototype.mul = function (l, p) { - if (l.isZero() || p.isZero()) return new i(0)._forceRed(this); - var y = l.mul(p), - d = y - .maskn(this.shift) - .mul(this.minv) - .imaskn(this.shift) - .mul(this.m), - v = y.isub(d).iushrn(this.shift), - _ = v; - return ( - v.cmp(this.m) >= 0 - ? (_ = v.isub(this.m)) - : v.cmpn(0) < 0 && (_ = v.iadd(this.m)), - _._forceRed(this) - ); - }), - (ne.prototype.invm = function (l) { - var p = this.imod(l._invmp(this.m).mul(this.r2)); - return p._forceRed(this); - }); - })(typeof Gbe > "u" || Gbe, lJe); - }); - var hJe = I((Yfn, dJe) => { - m(); - g(); - var Ker = F5(), - Her = fJe(); - dJe.exports = function (e) { - return new FM(e); - }; - var Fp = { - secp256k1: { name: "secp256k1", byteLength: 32 }, - secp224r1: { name: "p224", byteLength: 28 }, - prime256v1: { name: "p256", byteLength: 32 }, - prime192v1: { name: "p192", byteLength: 24 }, - ed25519: { name: "ed25519", byteLength: 32 }, - secp384r1: { name: "p384", byteLength: 48 }, - secp521r1: { name: "p521", byteLength: 66 }, - }; - Fp.p224 = Fp.secp224r1; - Fp.p256 = Fp.secp256r1 = Fp.prime256v1; - Fp.p192 = Fp.secp192r1 = Fp.prime192v1; - Fp.p384 = Fp.secp384r1; - Fp.p521 = Fp.secp521r1; - function FM(t) { - (this.curveType = Fp[t]), - this.curveType || (this.curveType = { name: t }), - (this.curve = new Ker.ec(this.curveType.name)), - (this.keys = void 0); - } - FM.prototype.generateKeys = function (t, e) { - return (this.keys = this.curve.genKeyPair()), this.getPublicKey(t, e); - }; - FM.prototype.computeSecret = function (t, e, r) { - (e = e || "utf8"), Buffer.isBuffer(t) || (t = new Buffer(t, e)); - var n = this.curve.keyFromPublic(t).getPublic(), - i = n.mul(this.keys.getPrivate()).getX(); - return Jbe(i, r, this.curveType.byteLength); - }; - FM.prototype.getPublicKey = function (t, e) { - var r = this.keys.getPublic(e === "compressed", !0); - return ( - e === "hybrid" && (r[r.length - 1] % 2 ? (r[0] = 7) : (r[0] = 6)), - Jbe(r, t) - ); - }; - FM.prototype.getPrivateKey = function (t) { - return Jbe(this.keys.getPrivate(), t); - }; - FM.prototype.setPublicKey = function (t, e) { - return ( - (e = e || "utf8"), - Buffer.isBuffer(t) || (t = new Buffer(t, e)), - this.keys._importPublic(t), - this - ); - }; - FM.prototype.setPrivateKey = function (t, e) { - (e = e || "utf8"), Buffer.isBuffer(t) || (t = new Buffer(t, e)); - var r = new Her(t); - return ( - (r = r.toString(16)), - (this.keys = this.curve.genKeyPair()), - this.keys._importPrivate(r), - this - ); - }; - function Jbe(t, e, r) { - Array.isArray(t) || (t = t.toArray()); - var n = new Buffer(t); - if (r && n.length < r) { - var i = new Buffer(r - n.length); - i.fill(0), (n = Buffer.concat([i, n])); - } - return e ? n.toString(e) : n; - } - }); - var Zbe = I((Qfn, pJe) => { - m(); - g(); - var Ver = v5(), - $be = vn().Buffer; - pJe.exports = function (t, e) { - for (var r = $be.alloc(0), n = 0, i; r.length < e; ) - (i = Wer(n++)), - (r = $be.concat([r, Ver("sha1").update(t).update(i).digest()])); - return r.slice(0, e); - }; - function Wer(t) { - var e = $be.allocUnsafe(4); - return e.writeUInt32BE(t, 0), e; - } - }); - var Xbe = I((edn, yJe) => { - m(); - g(); - yJe.exports = function (e, r) { - for (var n = e.length, i = -1; ++i < n; ) e[i] ^= r[i]; - return e; - }; - }); - var TX = I((mJe, Ybe) => { - m(); - g(); - (function (t, e) { - "use strict"; - function r(A, l) { - if (!A) throw new Error(l || "Assertion failed"); - } - function n(A, l) { - A.super_ = l; - var p = function () {}; - (p.prototype = l.prototype), - (A.prototype = new p()), - (A.prototype.constructor = A); - } - function i(A, l, p) { - if (i.isBN(A)) return A; - (this.negative = 0), - (this.words = null), - (this.length = 0), - (this.red = null), - A !== null && - ((l === "le" || l === "be") && ((p = l), (l = 10)), - this._init(A || 0, l || 10, p || "be")); - } - typeof t == "object" ? (t.exports = i) : (e.BN = i), - (i.BN = i), - (i.wordSize = 26); - var o; - try { - typeof window < "u" && typeof window.Buffer < "u" - ? (o = window.Buffer) - : (o = Qr().Buffer); - } catch {} - (i.isBN = function (l) { - return l instanceof i - ? !0 - : l !== null && - typeof l == "object" && - l.constructor.wordSize === i.wordSize && - Array.isArray(l.words); - }), - (i.max = function (l, p) { - return l.cmp(p) > 0 ? l : p; - }), - (i.min = function (l, p) { - return l.cmp(p) < 0 ? l : p; - }), - (i.prototype._init = function (l, p, y) { - if (typeof l == "number") return this._initNumber(l, p, y); - if (typeof l == "object") return this._initArray(l, p, y); - p === "hex" && (p = 16), - r(p === (p | 0) && p >= 2 && p <= 36), - (l = l.toString().replace(/\s+/g, "")); - var d = 0; - l[0] === "-" && (d++, (this.negative = 1)), - d < l.length && - (p === 16 - ? this._parseHex(l, d, y) - : (this._parseBase(l, p, d), - y === "le" && this._initArray(this.toArray(), p, y))); - }), - (i.prototype._initNumber = function (l, p, y) { - l < 0 && ((this.negative = 1), (l = -l)), - l < 67108864 - ? ((this.words = [l & 67108863]), (this.length = 1)) - : l < 4503599627370496 - ? ((this.words = [l & 67108863, (l / 67108864) & 67108863]), - (this.length = 2)) - : (r(l < 9007199254740992), - (this.words = [l & 67108863, (l / 67108864) & 67108863, 1]), - (this.length = 3)), - y === "le" && this._initArray(this.toArray(), p, y); - }), - (i.prototype._initArray = function (l, p, y) { - if ((r(typeof l.length == "number"), l.length <= 0)) - return (this.words = [0]), (this.length = 1), this; - (this.length = Math.ceil(l.length / 3)), - (this.words = new Array(this.length)); - for (var d = 0; d < this.length; d++) this.words[d] = 0; - var v, - _, - S = 0; - if (y === "be") - for (d = l.length - 1, v = 0; d >= 0; d -= 3) - (_ = l[d] | (l[d - 1] << 8) | (l[d - 2] << 16)), - (this.words[v] |= (_ << S) & 67108863), - (this.words[v + 1] = (_ >>> (26 - S)) & 67108863), - (S += 24), - S >= 26 && ((S -= 26), v++); - else if (y === "le") - for (d = 0, v = 0; d < l.length; d += 3) - (_ = l[d] | (l[d + 1] << 8) | (l[d + 2] << 16)), - (this.words[v] |= (_ << S) & 67108863), - (this.words[v + 1] = (_ >>> (26 - S)) & 67108863), - (S += 24), - S >= 26 && ((S -= 26), v++); - return this.strip(); - }); - function a(A, l) { - var p = A.charCodeAt(l); - return p >= 65 && p <= 70 - ? p - 55 - : p >= 97 && p <= 102 - ? p - 87 - : (p - 48) & 15; - } - function s(A, l, p) { - var y = a(A, p); - return p - 1 >= l && (y |= a(A, p - 1) << 4), y; - } - i.prototype._parseHex = function (l, p, y) { - (this.length = Math.ceil((l.length - p) / 6)), - (this.words = new Array(this.length)); - for (var d = 0; d < this.length; d++) this.words[d] = 0; - var v = 0, - _ = 0, - S; - if (y === "be") - for (d = l.length - 1; d >= p; d -= 2) - (S = s(l, p, d) << v), - (this.words[_] |= S & 67108863), - v >= 18 - ? ((v -= 18), (_ += 1), (this.words[_] |= S >>> 26)) - : (v += 8); - else { - var b = l.length - p; - for (d = b % 2 === 0 ? p + 1 : p; d < l.length; d += 2) - (S = s(l, p, d) << v), - (this.words[_] |= S & 67108863), - v >= 18 - ? ((v -= 18), (_ += 1), (this.words[_] |= S >>> 26)) - : (v += 8); - } - this.strip(); - }; - function c(A, l, p, y) { - for (var d = 0, v = Math.min(A.length, p), _ = l; _ < v; _++) { - var S = A.charCodeAt(_) - 48; - (d *= y), - S >= 49 - ? (d += S - 49 + 10) - : S >= 17 - ? (d += S - 17 + 10) - : (d += S); - } - return d; - } - (i.prototype._parseBase = function (l, p, y) { - (this.words = [0]), (this.length = 1); - for (var d = 0, v = 1; v <= 67108863; v *= p) d++; - d--, (v = (v / p) | 0); - for ( - var _ = l.length - y, - S = _ % d, - b = Math.min(_, _ - S) + y, - f = 0, - x = y; - x < b; - x += d - ) - (f = c(l, x, x + d, p)), - this.imuln(v), - this.words[0] + f < 67108864 - ? (this.words[0] += f) - : this._iaddn(f); - if (S !== 0) { - var C = 1; - for (f = c(l, x, l.length, p), x = 0; x < S; x++) C *= p; - this.imuln(C), - this.words[0] + f < 67108864 - ? (this.words[0] += f) - : this._iaddn(f); - } - this.strip(); - }), - (i.prototype.copy = function (l) { - l.words = new Array(this.length); - for (var p = 0; p < this.length; p++) l.words[p] = this.words[p]; - (l.length = this.length), - (l.negative = this.negative), - (l.red = this.red); - }), - (i.prototype.clone = function () { - var l = new i(null); - return this.copy(l), l; - }), - (i.prototype._expand = function (l) { - for (; this.length < l; ) this.words[this.length++] = 0; - return this; - }), - (i.prototype.strip = function () { - for (; this.length > 1 && this.words[this.length - 1] === 0; ) - this.length--; - return this._normSign(); - }), - (i.prototype._normSign = function () { - return ( - this.length === 1 && this.words[0] === 0 && (this.negative = 0), - this - ); - }), - (i.prototype.inspect = function () { - return (this.red ? ""; - }); - var u = [ - "", - "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", - ], - h = [ - 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, - ], - w = [ - 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, - ]; - (i.prototype.toString = function (l, p) { - (l = l || 10), (p = p | 0 || 1); - var y; - if (l === 16 || l === "hex") { - y = ""; - for (var d = 0, v = 0, _ = 0; _ < this.length; _++) { - var S = this.words[_], - b = (((S << d) | v) & 16777215).toString(16); - (v = (S >>> (24 - d)) & 16777215), - v !== 0 || _ !== this.length - 1 - ? (y = u[6 - b.length] + b + y) - : (y = b + y), - (d += 2), - d >= 26 && ((d -= 26), _--); - } - for (v !== 0 && (y = v.toString(16) + y); y.length % p !== 0; ) - y = "0" + y; - return this.negative !== 0 && (y = "-" + y), y; - } - if (l === (l | 0) && l >= 2 && l <= 36) { - var f = h[l], - x = w[l]; - y = ""; - var C = this.clone(); - for (C.negative = 0; !C.isZero(); ) { - var E = C.modn(x).toString(l); - (C = C.idivn(x)), - C.isZero() ? (y = E + y) : (y = u[f - E.length] + E + y); - } - for (this.isZero() && (y = "0" + y); y.length % p !== 0; ) - y = "0" + y; - return this.negative !== 0 && (y = "-" + y), y; - } - r(!1, "Base should be between 2 and 36"); - }), - (i.prototype.toNumber = function () { - var l = this.words[0]; - return ( - this.length === 2 - ? (l += this.words[1] * 67108864) - : this.length === 3 && this.words[2] === 1 - ? (l += 4503599627370496 + this.words[1] * 67108864) - : this.length > 2 && - r(!1, "Number can only safely store up to 53 bits"), - this.negative !== 0 ? -l : l - ); - }), - (i.prototype.toJSON = function () { - return this.toString(16); - }), - (i.prototype.toBuffer = function (l, p) { - return r(typeof o < "u"), this.toArrayLike(o, l, p); - }), - (i.prototype.toArray = function (l, p) { - return this.toArrayLike(Array, l, p); - }), - (i.prototype.toArrayLike = function (l, p, y) { - var d = this.byteLength(), - v = y || Math.max(1, d); - r(d <= v, "byte array longer than desired length"), - r(v > 0, "Requested array length <= 0"), - this.strip(); - var _ = p === "le", - S = new l(v), - b, - f, - x = this.clone(); - if (_) { - for (f = 0; !x.isZero(); f++) - (b = x.andln(255)), x.iushrn(8), (S[f] = b); - for (; f < v; f++) S[f] = 0; - } else { - for (f = 0; f < v - d; f++) S[f] = 0; - for (f = 0; !x.isZero(); f++) - (b = x.andln(255)), x.iushrn(8), (S[v - f - 1] = b); - } - return S; - }), - Math.clz32 - ? (i.prototype._countBits = function (l) { - return 32 - Math.clz32(l); - }) - : (i.prototype._countBits = function (l) { - var p = l, - y = 0; - return ( - p >= 4096 && ((y += 13), (p >>>= 13)), - p >= 64 && ((y += 7), (p >>>= 7)), - p >= 8 && ((y += 4), (p >>>= 4)), - p >= 2 && ((y += 2), (p >>>= 2)), - y + p - ); - }), - (i.prototype._zeroBits = function (l) { - if (l === 0) return 26; - var p = l, - y = 0; - return ( - (p & 8191) === 0 && ((y += 13), (p >>>= 13)), - (p & 127) === 0 && ((y += 7), (p >>>= 7)), - (p & 15) === 0 && ((y += 4), (p >>>= 4)), - (p & 3) === 0 && ((y += 2), (p >>>= 2)), - (p & 1) === 0 && y++, - y - ); - }), - (i.prototype.bitLength = function () { - var l = this.words[this.length - 1], - p = this._countBits(l); - return (this.length - 1) * 26 + p; - }); - function M(A) { - for (var l = new Array(A.bitLength()), p = 0; p < l.length; p++) { - var y = (p / 26) | 0, - d = p % 26; - l[p] = (A.words[y] & (1 << d)) >>> d; - } - return l; - } - (i.prototype.zeroBits = function () { - if (this.isZero()) return 0; - for (var l = 0, p = 0; p < this.length; p++) { - var y = this._zeroBits(this.words[p]); - if (((l += y), y !== 26)) break; - } - return l; - }), - (i.prototype.byteLength = function () { - return Math.ceil(this.bitLength() / 8); - }), - (i.prototype.toTwos = function (l) { - return this.negative !== 0 - ? this.abs().inotn(l).iaddn(1) - : this.clone(); - }), - (i.prototype.fromTwos = function (l) { - return this.testn(l - 1) - ? this.notn(l).iaddn(1).ineg() - : this.clone(); - }), - (i.prototype.isNeg = function () { - return this.negative !== 0; - }), - (i.prototype.neg = function () { - return this.clone().ineg(); - }), - (i.prototype.ineg = function () { - return this.isZero() || (this.negative ^= 1), this; - }), - (i.prototype.iuor = function (l) { - for (; this.length < l.length; ) this.words[this.length++] = 0; - for (var p = 0; p < l.length; p++) - this.words[p] = this.words[p] | l.words[p]; - return this.strip(); - }), - (i.prototype.ior = function (l) { - return r((this.negative | l.negative) === 0), this.iuor(l); - }), - (i.prototype.or = function (l) { - return this.length > l.length - ? this.clone().ior(l) - : l.clone().ior(this); - }), - (i.prototype.uor = function (l) { - return this.length > l.length - ? this.clone().iuor(l) - : l.clone().iuor(this); - }), - (i.prototype.iuand = function (l) { - var p; - this.length > l.length ? (p = l) : (p = this); - for (var y = 0; y < p.length; y++) - this.words[y] = this.words[y] & l.words[y]; - return (this.length = p.length), this.strip(); - }), - (i.prototype.iand = function (l) { - return r((this.negative | l.negative) === 0), this.iuand(l); - }), - (i.prototype.and = function (l) { - return this.length > l.length - ? this.clone().iand(l) - : l.clone().iand(this); - }), - (i.prototype.uand = function (l) { - return this.length > l.length - ? this.clone().iuand(l) - : l.clone().iuand(this); - }), - (i.prototype.iuxor = function (l) { - var p, y; - this.length > l.length - ? ((p = this), (y = l)) - : ((p = l), (y = this)); - for (var d = 0; d < y.length; d++) - this.words[d] = p.words[d] ^ y.words[d]; - if (this !== p) for (; d < p.length; d++) this.words[d] = p.words[d]; - return (this.length = p.length), this.strip(); - }), - (i.prototype.ixor = function (l) { - return r((this.negative | l.negative) === 0), this.iuxor(l); - }), - (i.prototype.xor = function (l) { - return this.length > l.length - ? this.clone().ixor(l) - : l.clone().ixor(this); - }), - (i.prototype.uxor = function (l) { - return this.length > l.length - ? this.clone().iuxor(l) - : l.clone().iuxor(this); - }), - (i.prototype.inotn = function (l) { - r(typeof l == "number" && l >= 0); - var p = Math.ceil(l / 26) | 0, - y = l % 26; - this._expand(p), y > 0 && p--; - for (var d = 0; d < p; d++) this.words[d] = ~this.words[d] & 67108863; - return ( - y > 0 && (this.words[d] = ~this.words[d] & (67108863 >> (26 - y))), - this.strip() - ); - }), - (i.prototype.notn = function (l) { - return this.clone().inotn(l); - }), - (i.prototype.setn = function (l, p) { - r(typeof l == "number" && l >= 0); - var y = (l / 26) | 0, - d = l % 26; - return ( - this._expand(y + 1), - p - ? (this.words[y] = this.words[y] | (1 << d)) - : (this.words[y] = this.words[y] & ~(1 << d)), - this.strip() - ); - }), - (i.prototype.iadd = function (l) { - var p; - if (this.negative !== 0 && l.negative === 0) - return ( - (this.negative = 0), - (p = this.isub(l)), - (this.negative ^= 1), - this._normSign() - ); - if (this.negative === 0 && l.negative !== 0) - return ( - (l.negative = 0), - (p = this.isub(l)), - (l.negative = 1), - p._normSign() - ); - var y, d; - this.length > l.length - ? ((y = this), (d = l)) - : ((y = l), (d = this)); - for (var v = 0, _ = 0; _ < d.length; _++) - (p = (y.words[_] | 0) + (d.words[_] | 0) + v), - (this.words[_] = p & 67108863), - (v = p >>> 26); - for (; v !== 0 && _ < y.length; _++) - (p = (y.words[_] | 0) + v), - (this.words[_] = p & 67108863), - (v = p >>> 26); - if (((this.length = y.length), v !== 0)) - (this.words[this.length] = v), this.length++; - else if (y !== this) - for (; _ < y.length; _++) this.words[_] = y.words[_]; - return this; - }), - (i.prototype.add = function (l) { - var p; - return l.negative !== 0 && this.negative === 0 - ? ((l.negative = 0), (p = this.sub(l)), (l.negative ^= 1), p) - : l.negative === 0 && this.negative !== 0 - ? ((this.negative = 0), (p = l.sub(this)), (this.negative = 1), p) - : this.length > l.length - ? this.clone().iadd(l) - : l.clone().iadd(this); - }), - (i.prototype.isub = function (l) { - if (l.negative !== 0) { - l.negative = 0; - var p = this.iadd(l); - return (l.negative = 1), p._normSign(); - } else if (this.negative !== 0) - return ( - (this.negative = 0), - this.iadd(l), - (this.negative = 1), - this._normSign() - ); - var y = this.cmp(l); - if (y === 0) - return ( - (this.negative = 0), (this.length = 1), (this.words[0] = 0), this - ); - var d, v; - y > 0 ? ((d = this), (v = l)) : ((d = l), (v = this)); - for (var _ = 0, S = 0; S < v.length; S++) - (p = (d.words[S] | 0) - (v.words[S] | 0) + _), - (_ = p >> 26), - (this.words[S] = p & 67108863); - for (; _ !== 0 && S < d.length; S++) - (p = (d.words[S] | 0) + _), - (_ = p >> 26), - (this.words[S] = p & 67108863); - if (_ === 0 && S < d.length && d !== this) - for (; S < d.length; S++) this.words[S] = d.words[S]; - return ( - (this.length = Math.max(this.length, S)), - d !== this && (this.negative = 1), - this.strip() - ); - }), - (i.prototype.sub = function (l) { - return this.clone().isub(l); - }); - function k(A, l, p) { - p.negative = l.negative ^ A.negative; - var y = (A.length + l.length) | 0; - (p.length = y), (y = (y - 1) | 0); - var d = A.words[0] | 0, - v = l.words[0] | 0, - _ = d * v, - S = _ & 67108863, - b = (_ / 67108864) | 0; - p.words[0] = S; - for (var f = 1; f < y; f++) { - for ( - var x = b >>> 26, - C = b & 67108863, - E = Math.min(f, l.length - 1), - B = Math.max(0, f - A.length + 1); - B <= E; - B++ - ) { - var G = (f - B) | 0; - (d = A.words[G] | 0), - (v = l.words[B] | 0), - (_ = d * v + C), - (x += (_ / 67108864) | 0), - (C = _ & 67108863); - } - (p.words[f] = C | 0), (b = x | 0); - } - return b !== 0 ? (p.words[f] = b | 0) : p.length--, p.strip(); - } - var O = function (l, p, y) { - var d = l.words, - v = p.words, - _ = y.words, - S = 0, - b, - f, - x, - C = d[0] | 0, - E = C & 8191, - B = C >>> 13, - G = d[1] | 0, - L = G & 8191, - ee = G >>> 13, - ge = d[2] | 0, - fe = ge & 8191, - V = ge >>> 13, - ye = d[3] | 0, - ae = ye & 8191, - le = ye >>> 13, - Me = d[4] | 0, - de = Me & 8191, - ve = Me >>> 13, - De = d[5] | 0, - me = De & 8191, - _e = De >>> 13, - Ye = d[6] | 0, - Ee = Ye & 8191, - Be = Ye >>> 13, - kt = d[7] | 0, - Ve = kt & 8191, - We = kt >>> 13, - er = d[8] | 0, - Ue = er & 8191, - Y = er >>> 13, - W = d[9] | 0, - j = W & 8191, - ce = W >>> 13, - ze = v[0] | 0, - we = ze & 8191, - xe = ze >>> 13, - Ft = v[1] | 0, - Ke = Ft & 8191, - pe = Ft >>> 13, - Re = v[2] | 0, - Se = Re & 8191, - Pe = Re >>> 13, - At = v[3] | 0, - Ie = At & 8191, - je = At >>> 13, - qt = v[4] | 0, - Fe = qt & 8191, - He = qt >>> 13, - lr = v[5] | 0, - Xe = lr & 8191, - Ze = lr >>> 13, - Ir = v[6] | 0, - $e = Ir & 8191, - tt = Ir >>> 13, - oe = v[7] | 0, - ie = oe & 8191, - re = oe >>> 13, - U = v[8] | 0, - se = U & 8191, - be = U >>> 13, - Qe = v[9] | 0, - Ae = Qe & 8191, - ke = Qe >>> 13; - (y.negative = l.negative ^ p.negative), - (y.length = 19), - (b = Math.imul(E, we)), - (f = Math.imul(E, xe)), - (f = (f + Math.imul(B, we)) | 0), - (x = Math.imul(B, xe)); - var Ct = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ct >>> 26)) | 0), - (Ct &= 67108863), - (b = Math.imul(L, we)), - (f = Math.imul(L, xe)), - (f = (f + Math.imul(ee, we)) | 0), - (x = Math.imul(ee, xe)), - (b = (b + Math.imul(E, Ke)) | 0), - (f = (f + Math.imul(E, pe)) | 0), - (f = (f + Math.imul(B, Ke)) | 0), - (x = (x + Math.imul(B, pe)) | 0); - var ut = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (ut >>> 26)) | 0), - (ut &= 67108863), - (b = Math.imul(fe, we)), - (f = Math.imul(fe, xe)), - (f = (f + Math.imul(V, we)) | 0), - (x = Math.imul(V, xe)), - (b = (b + Math.imul(L, Ke)) | 0), - (f = (f + Math.imul(L, pe)) | 0), - (f = (f + Math.imul(ee, Ke)) | 0), - (x = (x + Math.imul(ee, pe)) | 0), - (b = (b + Math.imul(E, Se)) | 0), - (f = (f + Math.imul(E, Pe)) | 0), - (f = (f + Math.imul(B, Se)) | 0), - (x = (x + Math.imul(B, Pe)) | 0); - var St = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (St >>> 26)) | 0), - (St &= 67108863), - (b = Math.imul(ae, we)), - (f = Math.imul(ae, xe)), - (f = (f + Math.imul(le, we)) | 0), - (x = Math.imul(le, xe)), - (b = (b + Math.imul(fe, Ke)) | 0), - (f = (f + Math.imul(fe, pe)) | 0), - (f = (f + Math.imul(V, Ke)) | 0), - (x = (x + Math.imul(V, pe)) | 0), - (b = (b + Math.imul(L, Se)) | 0), - (f = (f + Math.imul(L, Pe)) | 0), - (f = (f + Math.imul(ee, Se)) | 0), - (x = (x + Math.imul(ee, Pe)) | 0), - (b = (b + Math.imul(E, Ie)) | 0), - (f = (f + Math.imul(E, je)) | 0), - (f = (f + Math.imul(B, Ie)) | 0), - (x = (x + Math.imul(B, je)) | 0); - var wt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (wt >>> 26)) | 0), - (wt &= 67108863), - (b = Math.imul(de, we)), - (f = Math.imul(de, xe)), - (f = (f + Math.imul(ve, we)) | 0), - (x = Math.imul(ve, xe)), - (b = (b + Math.imul(ae, Ke)) | 0), - (f = (f + Math.imul(ae, pe)) | 0), - (f = (f + Math.imul(le, Ke)) | 0), - (x = (x + Math.imul(le, pe)) | 0), - (b = (b + Math.imul(fe, Se)) | 0), - (f = (f + Math.imul(fe, Pe)) | 0), - (f = (f + Math.imul(V, Se)) | 0), - (x = (x + Math.imul(V, Pe)) | 0), - (b = (b + Math.imul(L, Ie)) | 0), - (f = (f + Math.imul(L, je)) | 0), - (f = (f + Math.imul(ee, Ie)) | 0), - (x = (x + Math.imul(ee, je)) | 0), - (b = (b + Math.imul(E, Fe)) | 0), - (f = (f + Math.imul(E, He)) | 0), - (f = (f + Math.imul(B, Fe)) | 0), - (x = (x + Math.imul(B, He)) | 0); - var zt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (zt >>> 26)) | 0), - (zt &= 67108863), - (b = Math.imul(me, we)), - (f = Math.imul(me, xe)), - (f = (f + Math.imul(_e, we)) | 0), - (x = Math.imul(_e, xe)), - (b = (b + Math.imul(de, Ke)) | 0), - (f = (f + Math.imul(de, pe)) | 0), - (f = (f + Math.imul(ve, Ke)) | 0), - (x = (x + Math.imul(ve, pe)) | 0), - (b = (b + Math.imul(ae, Se)) | 0), - (f = (f + Math.imul(ae, Pe)) | 0), - (f = (f + Math.imul(le, Se)) | 0), - (x = (x + Math.imul(le, Pe)) | 0), - (b = (b + Math.imul(fe, Ie)) | 0), - (f = (f + Math.imul(fe, je)) | 0), - (f = (f + Math.imul(V, Ie)) | 0), - (x = (x + Math.imul(V, je)) | 0), - (b = (b + Math.imul(L, Fe)) | 0), - (f = (f + Math.imul(L, He)) | 0), - (f = (f + Math.imul(ee, Fe)) | 0), - (x = (x + Math.imul(ee, He)) | 0), - (b = (b + Math.imul(E, Xe)) | 0), - (f = (f + Math.imul(E, Ze)) | 0), - (f = (f + Math.imul(B, Xe)) | 0), - (x = (x + Math.imul(B, Ze)) | 0); - var jt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (jt >>> 26)) | 0), - (jt &= 67108863), - (b = Math.imul(Ee, we)), - (f = Math.imul(Ee, xe)), - (f = (f + Math.imul(Be, we)) | 0), - (x = Math.imul(Be, xe)), - (b = (b + Math.imul(me, Ke)) | 0), - (f = (f + Math.imul(me, pe)) | 0), - (f = (f + Math.imul(_e, Ke)) | 0), - (x = (x + Math.imul(_e, pe)) | 0), - (b = (b + Math.imul(de, Se)) | 0), - (f = (f + Math.imul(de, Pe)) | 0), - (f = (f + Math.imul(ve, Se)) | 0), - (x = (x + Math.imul(ve, Pe)) | 0), - (b = (b + Math.imul(ae, Ie)) | 0), - (f = (f + Math.imul(ae, je)) | 0), - (f = (f + Math.imul(le, Ie)) | 0), - (x = (x + Math.imul(le, je)) | 0), - (b = (b + Math.imul(fe, Fe)) | 0), - (f = (f + Math.imul(fe, He)) | 0), - (f = (f + Math.imul(V, Fe)) | 0), - (x = (x + Math.imul(V, He)) | 0), - (b = (b + Math.imul(L, Xe)) | 0), - (f = (f + Math.imul(L, Ze)) | 0), - (f = (f + Math.imul(ee, Xe)) | 0), - (x = (x + Math.imul(ee, Ze)) | 0), - (b = (b + Math.imul(E, $e)) | 0), - (f = (f + Math.imul(E, tt)) | 0), - (f = (f + Math.imul(B, $e)) | 0), - (x = (x + Math.imul(B, tt)) | 0); - var Ht = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ht >>> 26)) | 0), - (Ht &= 67108863), - (b = Math.imul(Ve, we)), - (f = Math.imul(Ve, xe)), - (f = (f + Math.imul(We, we)) | 0), - (x = Math.imul(We, xe)), - (b = (b + Math.imul(Ee, Ke)) | 0), - (f = (f + Math.imul(Ee, pe)) | 0), - (f = (f + Math.imul(Be, Ke)) | 0), - (x = (x + Math.imul(Be, pe)) | 0), - (b = (b + Math.imul(me, Se)) | 0), - (f = (f + Math.imul(me, Pe)) | 0), - (f = (f + Math.imul(_e, Se)) | 0), - (x = (x + Math.imul(_e, Pe)) | 0), - (b = (b + Math.imul(de, Ie)) | 0), - (f = (f + Math.imul(de, je)) | 0), - (f = (f + Math.imul(ve, Ie)) | 0), - (x = (x + Math.imul(ve, je)) | 0), - (b = (b + Math.imul(ae, Fe)) | 0), - (f = (f + Math.imul(ae, He)) | 0), - (f = (f + Math.imul(le, Fe)) | 0), - (x = (x + Math.imul(le, He)) | 0), - (b = (b + Math.imul(fe, Xe)) | 0), - (f = (f + Math.imul(fe, Ze)) | 0), - (f = (f + Math.imul(V, Xe)) | 0), - (x = (x + Math.imul(V, Ze)) | 0), - (b = (b + Math.imul(L, $e)) | 0), - (f = (f + Math.imul(L, tt)) | 0), - (f = (f + Math.imul(ee, $e)) | 0), - (x = (x + Math.imul(ee, tt)) | 0), - (b = (b + Math.imul(E, ie)) | 0), - (f = (f + Math.imul(E, re)) | 0), - (f = (f + Math.imul(B, ie)) | 0), - (x = (x + Math.imul(B, re)) | 0); - var Ut = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ut >>> 26)) | 0), - (Ut &= 67108863), - (b = Math.imul(Ue, we)), - (f = Math.imul(Ue, xe)), - (f = (f + Math.imul(Y, we)) | 0), - (x = Math.imul(Y, xe)), - (b = (b + Math.imul(Ve, Ke)) | 0), - (f = (f + Math.imul(Ve, pe)) | 0), - (f = (f + Math.imul(We, Ke)) | 0), - (x = (x + Math.imul(We, pe)) | 0), - (b = (b + Math.imul(Ee, Se)) | 0), - (f = (f + Math.imul(Ee, Pe)) | 0), - (f = (f + Math.imul(Be, Se)) | 0), - (x = (x + Math.imul(Be, Pe)) | 0), - (b = (b + Math.imul(me, Ie)) | 0), - (f = (f + Math.imul(me, je)) | 0), - (f = (f + Math.imul(_e, Ie)) | 0), - (x = (x + Math.imul(_e, je)) | 0), - (b = (b + Math.imul(de, Fe)) | 0), - (f = (f + Math.imul(de, He)) | 0), - (f = (f + Math.imul(ve, Fe)) | 0), - (x = (x + Math.imul(ve, He)) | 0), - (b = (b + Math.imul(ae, Xe)) | 0), - (f = (f + Math.imul(ae, Ze)) | 0), - (f = (f + Math.imul(le, Xe)) | 0), - (x = (x + Math.imul(le, Ze)) | 0), - (b = (b + Math.imul(fe, $e)) | 0), - (f = (f + Math.imul(fe, tt)) | 0), - (f = (f + Math.imul(V, $e)) | 0), - (x = (x + Math.imul(V, tt)) | 0), - (b = (b + Math.imul(L, ie)) | 0), - (f = (f + Math.imul(L, re)) | 0), - (f = (f + Math.imul(ee, ie)) | 0), - (x = (x + Math.imul(ee, re)) | 0), - (b = (b + Math.imul(E, se)) | 0), - (f = (f + Math.imul(E, be)) | 0), - (f = (f + Math.imul(B, se)) | 0), - (x = (x + Math.imul(B, be)) | 0); - var Kt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Kt >>> 26)) | 0), - (Kt &= 67108863), - (b = Math.imul(j, we)), - (f = Math.imul(j, xe)), - (f = (f + Math.imul(ce, we)) | 0), - (x = Math.imul(ce, xe)), - (b = (b + Math.imul(Ue, Ke)) | 0), - (f = (f + Math.imul(Ue, pe)) | 0), - (f = (f + Math.imul(Y, Ke)) | 0), - (x = (x + Math.imul(Y, pe)) | 0), - (b = (b + Math.imul(Ve, Se)) | 0), - (f = (f + Math.imul(Ve, Pe)) | 0), - (f = (f + Math.imul(We, Se)) | 0), - (x = (x + Math.imul(We, Pe)) | 0), - (b = (b + Math.imul(Ee, Ie)) | 0), - (f = (f + Math.imul(Ee, je)) | 0), - (f = (f + Math.imul(Be, Ie)) | 0), - (x = (x + Math.imul(Be, je)) | 0), - (b = (b + Math.imul(me, Fe)) | 0), - (f = (f + Math.imul(me, He)) | 0), - (f = (f + Math.imul(_e, Fe)) | 0), - (x = (x + Math.imul(_e, He)) | 0), - (b = (b + Math.imul(de, Xe)) | 0), - (f = (f + Math.imul(de, Ze)) | 0), - (f = (f + Math.imul(ve, Xe)) | 0), - (x = (x + Math.imul(ve, Ze)) | 0), - (b = (b + Math.imul(ae, $e)) | 0), - (f = (f + Math.imul(ae, tt)) | 0), - (f = (f + Math.imul(le, $e)) | 0), - (x = (x + Math.imul(le, tt)) | 0), - (b = (b + Math.imul(fe, ie)) | 0), - (f = (f + Math.imul(fe, re)) | 0), - (f = (f + Math.imul(V, ie)) | 0), - (x = (x + Math.imul(V, re)) | 0), - (b = (b + Math.imul(L, se)) | 0), - (f = (f + Math.imul(L, be)) | 0), - (f = (f + Math.imul(ee, se)) | 0), - (x = (x + Math.imul(ee, be)) | 0), - (b = (b + Math.imul(E, Ae)) | 0), - (f = (f + Math.imul(E, ke)) | 0), - (f = (f + Math.imul(B, Ae)) | 0), - (x = (x + Math.imul(B, ke)) | 0); - var Ot = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Ot >>> 26)) | 0), - (Ot &= 67108863), - (b = Math.imul(j, Ke)), - (f = Math.imul(j, pe)), - (f = (f + Math.imul(ce, Ke)) | 0), - (x = Math.imul(ce, pe)), - (b = (b + Math.imul(Ue, Se)) | 0), - (f = (f + Math.imul(Ue, Pe)) | 0), - (f = (f + Math.imul(Y, Se)) | 0), - (x = (x + Math.imul(Y, Pe)) | 0), - (b = (b + Math.imul(Ve, Ie)) | 0), - (f = (f + Math.imul(Ve, je)) | 0), - (f = (f + Math.imul(We, Ie)) | 0), - (x = (x + Math.imul(We, je)) | 0), - (b = (b + Math.imul(Ee, Fe)) | 0), - (f = (f + Math.imul(Ee, He)) | 0), - (f = (f + Math.imul(Be, Fe)) | 0), - (x = (x + Math.imul(Be, He)) | 0), - (b = (b + Math.imul(me, Xe)) | 0), - (f = (f + Math.imul(me, Ze)) | 0), - (f = (f + Math.imul(_e, Xe)) | 0), - (x = (x + Math.imul(_e, Ze)) | 0), - (b = (b + Math.imul(de, $e)) | 0), - (f = (f + Math.imul(de, tt)) | 0), - (f = (f + Math.imul(ve, $e)) | 0), - (x = (x + Math.imul(ve, tt)) | 0), - (b = (b + Math.imul(ae, ie)) | 0), - (f = (f + Math.imul(ae, re)) | 0), - (f = (f + Math.imul(le, ie)) | 0), - (x = (x + Math.imul(le, re)) | 0), - (b = (b + Math.imul(fe, se)) | 0), - (f = (f + Math.imul(fe, be)) | 0), - (f = (f + Math.imul(V, se)) | 0), - (x = (x + Math.imul(V, be)) | 0), - (b = (b + Math.imul(L, Ae)) | 0), - (f = (f + Math.imul(L, ke)) | 0), - (f = (f + Math.imul(ee, Ae)) | 0), - (x = (x + Math.imul(ee, ke)) | 0); - var Bt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Bt >>> 26)) | 0), - (Bt &= 67108863), - (b = Math.imul(j, Se)), - (f = Math.imul(j, Pe)), - (f = (f + Math.imul(ce, Se)) | 0), - (x = Math.imul(ce, Pe)), - (b = (b + Math.imul(Ue, Ie)) | 0), - (f = (f + Math.imul(Ue, je)) | 0), - (f = (f + Math.imul(Y, Ie)) | 0), - (x = (x + Math.imul(Y, je)) | 0), - (b = (b + Math.imul(Ve, Fe)) | 0), - (f = (f + Math.imul(Ve, He)) | 0), - (f = (f + Math.imul(We, Fe)) | 0), - (x = (x + Math.imul(We, He)) | 0), - (b = (b + Math.imul(Ee, Xe)) | 0), - (f = (f + Math.imul(Ee, Ze)) | 0), - (f = (f + Math.imul(Be, Xe)) | 0), - (x = (x + Math.imul(Be, Ze)) | 0), - (b = (b + Math.imul(me, $e)) | 0), - (f = (f + Math.imul(me, tt)) | 0), - (f = (f + Math.imul(_e, $e)) | 0), - (x = (x + Math.imul(_e, tt)) | 0), - (b = (b + Math.imul(de, ie)) | 0), - (f = (f + Math.imul(de, re)) | 0), - (f = (f + Math.imul(ve, ie)) | 0), - (x = (x + Math.imul(ve, re)) | 0), - (b = (b + Math.imul(ae, se)) | 0), - (f = (f + Math.imul(ae, be)) | 0), - (f = (f + Math.imul(le, se)) | 0), - (x = (x + Math.imul(le, be)) | 0), - (b = (b + Math.imul(fe, Ae)) | 0), - (f = (f + Math.imul(fe, ke)) | 0), - (f = (f + Math.imul(V, Ae)) | 0), - (x = (x + Math.imul(V, ke)) | 0); - var Et = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Et >>> 26)) | 0), - (Et &= 67108863), - (b = Math.imul(j, Ie)), - (f = Math.imul(j, je)), - (f = (f + Math.imul(ce, Ie)) | 0), - (x = Math.imul(ce, je)), - (b = (b + Math.imul(Ue, Fe)) | 0), - (f = (f + Math.imul(Ue, He)) | 0), - (f = (f + Math.imul(Y, Fe)) | 0), - (x = (x + Math.imul(Y, He)) | 0), - (b = (b + Math.imul(Ve, Xe)) | 0), - (f = (f + Math.imul(Ve, Ze)) | 0), - (f = (f + Math.imul(We, Xe)) | 0), - (x = (x + Math.imul(We, Ze)) | 0), - (b = (b + Math.imul(Ee, $e)) | 0), - (f = (f + Math.imul(Ee, tt)) | 0), - (f = (f + Math.imul(Be, $e)) | 0), - (x = (x + Math.imul(Be, tt)) | 0), - (b = (b + Math.imul(me, ie)) | 0), - (f = (f + Math.imul(me, re)) | 0), - (f = (f + Math.imul(_e, ie)) | 0), - (x = (x + Math.imul(_e, re)) | 0), - (b = (b + Math.imul(de, se)) | 0), - (f = (f + Math.imul(de, be)) | 0), - (f = (f + Math.imul(ve, se)) | 0), - (x = (x + Math.imul(ve, be)) | 0), - (b = (b + Math.imul(ae, Ae)) | 0), - (f = (f + Math.imul(ae, ke)) | 0), - (f = (f + Math.imul(le, Ae)) | 0), - (x = (x + Math.imul(le, ke)) | 0); - var Mt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Mt >>> 26)) | 0), - (Mt &= 67108863), - (b = Math.imul(j, Fe)), - (f = Math.imul(j, He)), - (f = (f + Math.imul(ce, Fe)) | 0), - (x = Math.imul(ce, He)), - (b = (b + Math.imul(Ue, Xe)) | 0), - (f = (f + Math.imul(Ue, Ze)) | 0), - (f = (f + Math.imul(Y, Xe)) | 0), - (x = (x + Math.imul(Y, Ze)) | 0), - (b = (b + Math.imul(Ve, $e)) | 0), - (f = (f + Math.imul(Ve, tt)) | 0), - (f = (f + Math.imul(We, $e)) | 0), - (x = (x + Math.imul(We, tt)) | 0), - (b = (b + Math.imul(Ee, ie)) | 0), - (f = (f + Math.imul(Ee, re)) | 0), - (f = (f + Math.imul(Be, ie)) | 0), - (x = (x + Math.imul(Be, re)) | 0), - (b = (b + Math.imul(me, se)) | 0), - (f = (f + Math.imul(me, be)) | 0), - (f = (f + Math.imul(_e, se)) | 0), - (x = (x + Math.imul(_e, be)) | 0), - (b = (b + Math.imul(de, Ae)) | 0), - (f = (f + Math.imul(de, ke)) | 0), - (f = (f + Math.imul(ve, Ae)) | 0), - (x = (x + Math.imul(ve, ke)) | 0); - var gt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (gt >>> 26)) | 0), - (gt &= 67108863), - (b = Math.imul(j, Xe)), - (f = Math.imul(j, Ze)), - (f = (f + Math.imul(ce, Xe)) | 0), - (x = Math.imul(ce, Ze)), - (b = (b + Math.imul(Ue, $e)) | 0), - (f = (f + Math.imul(Ue, tt)) | 0), - (f = (f + Math.imul(Y, $e)) | 0), - (x = (x + Math.imul(Y, tt)) | 0), - (b = (b + Math.imul(Ve, ie)) | 0), - (f = (f + Math.imul(Ve, re)) | 0), - (f = (f + Math.imul(We, ie)) | 0), - (x = (x + Math.imul(We, re)) | 0), - (b = (b + Math.imul(Ee, se)) | 0), - (f = (f + Math.imul(Ee, be)) | 0), - (f = (f + Math.imul(Be, se)) | 0), - (x = (x + Math.imul(Be, be)) | 0), - (b = (b + Math.imul(me, Ae)) | 0), - (f = (f + Math.imul(me, ke)) | 0), - (f = (f + Math.imul(_e, Ae)) | 0), - (x = (x + Math.imul(_e, ke)) | 0); - var Pt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (Pt >>> 26)) | 0), - (Pt &= 67108863), - (b = Math.imul(j, $e)), - (f = Math.imul(j, tt)), - (f = (f + Math.imul(ce, $e)) | 0), - (x = Math.imul(ce, tt)), - (b = (b + Math.imul(Ue, ie)) | 0), - (f = (f + Math.imul(Ue, re)) | 0), - (f = (f + Math.imul(Y, ie)) | 0), - (x = (x + Math.imul(Y, re)) | 0), - (b = (b + Math.imul(Ve, se)) | 0), - (f = (f + Math.imul(Ve, be)) | 0), - (f = (f + Math.imul(We, se)) | 0), - (x = (x + Math.imul(We, be)) | 0), - (b = (b + Math.imul(Ee, Ae)) | 0), - (f = (f + Math.imul(Ee, ke)) | 0), - (f = (f + Math.imul(Be, Ae)) | 0), - (x = (x + Math.imul(Be, ke)) | 0); - var It = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (It >>> 26)) | 0), - (It &= 67108863), - (b = Math.imul(j, ie)), - (f = Math.imul(j, re)), - (f = (f + Math.imul(ce, ie)) | 0), - (x = Math.imul(ce, re)), - (b = (b + Math.imul(Ue, se)) | 0), - (f = (f + Math.imul(Ue, be)) | 0), - (f = (f + Math.imul(Y, se)) | 0), - (x = (x + Math.imul(Y, be)) | 0), - (b = (b + Math.imul(Ve, Ae)) | 0), - (f = (f + Math.imul(Ve, ke)) | 0), - (f = (f + Math.imul(We, Ae)) | 0), - (x = (x + Math.imul(We, ke)) | 0); - var yt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (yt >>> 26)) | 0), - (yt &= 67108863), - (b = Math.imul(j, se)), - (f = Math.imul(j, be)), - (f = (f + Math.imul(ce, se)) | 0), - (x = Math.imul(ce, be)), - (b = (b + Math.imul(Ue, Ae)) | 0), - (f = (f + Math.imul(Ue, ke)) | 0), - (f = (f + Math.imul(Y, Ae)) | 0), - (x = (x + Math.imul(Y, ke)) | 0); - var nt = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - (S = (((x + (f >>> 13)) | 0) + (nt >>> 26)) | 0), - (nt &= 67108863), - (b = Math.imul(j, Ae)), - (f = Math.imul(j, ke)), - (f = (f + Math.imul(ce, Ae)) | 0), - (x = Math.imul(ce, ke)); - var it = (((S + b) | 0) + ((f & 8191) << 13)) | 0; - return ( - (S = (((x + (f >>> 13)) | 0) + (it >>> 26)) | 0), - (it &= 67108863), - (_[0] = Ct), - (_[1] = ut), - (_[2] = St), - (_[3] = wt), - (_[4] = zt), - (_[5] = jt), - (_[6] = Ht), - (_[7] = Ut), - (_[8] = Kt), - (_[9] = Ot), - (_[10] = Bt), - (_[11] = Et), - (_[12] = Mt), - (_[13] = gt), - (_[14] = Pt), - (_[15] = It), - (_[16] = yt), - (_[17] = nt), - (_[18] = it), - S !== 0 && ((_[19] = S), y.length++), - y - ); - }; - Math.imul || (O = k); - function D(A, l, p) { - (p.negative = l.negative ^ A.negative), - (p.length = A.length + l.length); - for (var y = 0, d = 0, v = 0; v < p.length - 1; v++) { - var _ = d; - d = 0; - for ( - var S = y & 67108863, - b = Math.min(v, l.length - 1), - f = Math.max(0, v - A.length + 1); - f <= b; - f++ - ) { - var x = v - f, - C = A.words[x] | 0, - E = l.words[f] | 0, - B = C * E, - G = B & 67108863; - (_ = (_ + ((B / 67108864) | 0)) | 0), - (G = (G + S) | 0), - (S = G & 67108863), - (_ = (_ + (G >>> 26)) | 0), - (d += _ >>> 26), - (_ &= 67108863); - } - (p.words[v] = S), (y = _), (_ = d); - } - return y !== 0 ? (p.words[v] = y) : p.length--, p.strip(); - } - function F(A, l, p) { - var y = new N(); - return y.mulp(A, l, p); - } - i.prototype.mulTo = function (l, p) { - var y, - d = this.length + l.length; - return ( - this.length === 10 && l.length === 10 - ? (y = O(this, l, p)) - : d < 63 - ? (y = k(this, l, p)) - : d < 1024 - ? (y = D(this, l, p)) - : (y = F(this, l, p)), - y - ); - }; - function N(A, l) { - (this.x = A), (this.y = l); - } - (N.prototype.makeRBT = function (l) { - for ( - var p = new Array(l), y = i.prototype._countBits(l) - 1, d = 0; - d < l; - d++ - ) - p[d] = this.revBin(d, y, l); - return p; - }), - (N.prototype.revBin = function (l, p, y) { - if (l === 0 || l === y - 1) return l; - for (var d = 0, v = 0; v < p; v++) - (d |= (l & 1) << (p - v - 1)), (l >>= 1); - return d; - }), - (N.prototype.permute = function (l, p, y, d, v, _) { - for (var S = 0; S < _; S++) (d[S] = p[l[S]]), (v[S] = y[l[S]]); - }), - (N.prototype.transform = function (l, p, y, d, v, _) { - this.permute(_, l, p, y, d, v); - for (var S = 1; S < v; S <<= 1) - for ( - var b = S << 1, - f = Math.cos((2 * Math.PI) / b), - x = Math.sin((2 * Math.PI) / b), - C = 0; - C < v; - C += b - ) - for (var E = f, B = x, G = 0; G < S; G++) { - var L = y[C + G], - ee = d[C + G], - ge = y[C + G + S], - fe = d[C + G + S], - V = E * ge - B * fe; - (fe = E * fe + B * ge), - (ge = V), - (y[C + G] = L + ge), - (d[C + G] = ee + fe), - (y[C + G + S] = L - ge), - (d[C + G + S] = ee - fe), - G !== b && - ((V = f * E - x * B), (B = f * B + x * E), (E = V)); - } - }), - (N.prototype.guessLen13b = function (l, p) { - var y = Math.max(p, l) | 1, - d = y & 1, - v = 0; - for (y = (y / 2) | 0; y; y = y >>> 1) v++; - return 1 << (v + 1 + d); - }), - (N.prototype.conjugate = function (l, p, y) { - if (!(y <= 1)) - for (var d = 0; d < y / 2; d++) { - var v = l[d]; - (l[d] = l[y - d - 1]), - (l[y - d - 1] = v), - (v = p[d]), - (p[d] = -p[y - d - 1]), - (p[y - d - 1] = -v); - } - }), - (N.prototype.normalize13b = function (l, p) { - for (var y = 0, d = 0; d < p / 2; d++) { - var v = - Math.round(l[2 * d + 1] / p) * 8192 + - Math.round(l[2 * d] / p) + - y; - (l[d] = v & 67108863), - v < 67108864 ? (y = 0) : (y = (v / 67108864) | 0); - } - return l; - }), - (N.prototype.convert13b = function (l, p, y, d) { - for (var v = 0, _ = 0; _ < p; _++) - (v = v + (l[_] | 0)), - (y[2 * _] = v & 8191), - (v = v >>> 13), - (y[2 * _ + 1] = v & 8191), - (v = v >>> 13); - for (_ = 2 * p; _ < d; ++_) y[_] = 0; - r(v === 0), r((v & -8192) === 0); - }), - (N.prototype.stub = function (l) { - for (var p = new Array(l), y = 0; y < l; y++) p[y] = 0; - return p; - }), - (N.prototype.mulp = function (l, p, y) { - var d = 2 * this.guessLen13b(l.length, p.length), - v = this.makeRBT(d), - _ = this.stub(d), - S = new Array(d), - b = new Array(d), - f = new Array(d), - x = new Array(d), - C = new Array(d), - E = new Array(d), - B = y.words; - (B.length = d), - this.convert13b(l.words, l.length, S, d), - this.convert13b(p.words, p.length, x, d), - this.transform(S, _, b, f, d, v), - this.transform(x, _, C, E, d, v); - for (var G = 0; G < d; G++) { - var L = b[G] * C[G] - f[G] * E[G]; - (f[G] = b[G] * E[G] + f[G] * C[G]), (b[G] = L); - } - return ( - this.conjugate(b, f, d), - this.transform(b, f, B, _, d, v), - this.conjugate(B, _, d), - this.normalize13b(B, d), - (y.negative = l.negative ^ p.negative), - (y.length = l.length + p.length), - y.strip() - ); - }), - (i.prototype.mul = function (l) { - var p = new i(null); - return ( - (p.words = new Array(this.length + l.length)), this.mulTo(l, p) - ); - }), - (i.prototype.mulf = function (l) { - var p = new i(null); - return (p.words = new Array(this.length + l.length)), F(this, l, p); - }), - (i.prototype.imul = function (l) { - return this.clone().mulTo(l, this); - }), - (i.prototype.imuln = function (l) { - r(typeof l == "number"), r(l < 67108864); - for (var p = 0, y = 0; y < this.length; y++) { - var d = (this.words[y] | 0) * l, - v = (d & 67108863) + (p & 67108863); - (p >>= 26), - (p += (d / 67108864) | 0), - (p += v >>> 26), - (this.words[y] = v & 67108863); - } - return p !== 0 && ((this.words[y] = p), this.length++), this; - }), - (i.prototype.muln = function (l) { - return this.clone().imuln(l); - }), - (i.prototype.sqr = function () { - return this.mul(this); - }), - (i.prototype.isqr = function () { - return this.imul(this.clone()); - }), - (i.prototype.pow = function (l) { - var p = M(l); - if (p.length === 0) return new i(1); - for ( - var y = this, d = 0; - d < p.length && p[d] === 0; - d++, y = y.sqr() - ); - if (++d < p.length) - for (var v = y.sqr(); d < p.length; d++, v = v.sqr()) - p[d] !== 0 && (y = y.mul(v)); - return y; - }), - (i.prototype.iushln = function (l) { - r(typeof l == "number" && l >= 0); - var p = l % 26, - y = (l - p) / 26, - d = (67108863 >>> (26 - p)) << (26 - p), - v; - if (p !== 0) { - var _ = 0; - for (v = 0; v < this.length; v++) { - var S = this.words[v] & d, - b = ((this.words[v] | 0) - S) << p; - (this.words[v] = b | _), (_ = S >>> (26 - p)); - } - _ && ((this.words[v] = _), this.length++); - } - if (y !== 0) { - for (v = this.length - 1; v >= 0; v--) - this.words[v + y] = this.words[v]; - for (v = 0; v < y; v++) this.words[v] = 0; - this.length += y; - } - return this.strip(); - }), - (i.prototype.ishln = function (l) { - return r(this.negative === 0), this.iushln(l); - }), - (i.prototype.iushrn = function (l, p, y) { - r(typeof l == "number" && l >= 0); - var d; - p ? (d = (p - (p % 26)) / 26) : (d = 0); - var v = l % 26, - _ = Math.min((l - v) / 26, this.length), - S = 67108863 ^ ((67108863 >>> v) << v), - b = y; - if (((d -= _), (d = Math.max(0, d)), b)) { - for (var f = 0; f < _; f++) b.words[f] = this.words[f]; - b.length = _; - } - if (_ !== 0) - if (this.length > _) - for (this.length -= _, f = 0; f < this.length; f++) - this.words[f] = this.words[f + _]; - else (this.words[0] = 0), (this.length = 1); - var x = 0; - for (f = this.length - 1; f >= 0 && (x !== 0 || f >= d); f--) { - var C = this.words[f] | 0; - (this.words[f] = (x << (26 - v)) | (C >>> v)), (x = C & S); - } - return ( - b && x !== 0 && (b.words[b.length++] = x), - this.length === 0 && ((this.words[0] = 0), (this.length = 1)), - this.strip() - ); - }), - (i.prototype.ishrn = function (l, p, y) { - return r(this.negative === 0), this.iushrn(l, p, y); - }), - (i.prototype.shln = function (l) { - return this.clone().ishln(l); - }), - (i.prototype.ushln = function (l) { - return this.clone().iushln(l); - }), - (i.prototype.shrn = function (l) { - return this.clone().ishrn(l); - }), - (i.prototype.ushrn = function (l) { - return this.clone().iushrn(l); - }), - (i.prototype.testn = function (l) { - r(typeof l == "number" && l >= 0); - var p = l % 26, - y = (l - p) / 26, - d = 1 << p; - if (this.length <= y) return !1; - var v = this.words[y]; - return !!(v & d); - }), - (i.prototype.imaskn = function (l) { - r(typeof l == "number" && l >= 0); - var p = l % 26, - y = (l - p) / 26; - if ( - (r(this.negative === 0, "imaskn works only with positive numbers"), - this.length <= y) - ) - return this; - if ( - (p !== 0 && y++, (this.length = Math.min(y, this.length)), p !== 0) - ) { - var d = 67108863 ^ ((67108863 >>> p) << p); - this.words[this.length - 1] &= d; - } - return this.strip(); - }), - (i.prototype.maskn = function (l) { - return this.clone().imaskn(l); - }), - (i.prototype.iaddn = function (l) { - return ( - r(typeof l == "number"), - r(l < 67108864), - l < 0 - ? this.isubn(-l) - : this.negative !== 0 - ? this.length === 1 && (this.words[0] | 0) < l - ? ((this.words[0] = l - (this.words[0] | 0)), - (this.negative = 0), - this) - : ((this.negative = 0), - this.isubn(l), - (this.negative = 1), - this) - : this._iaddn(l) - ); - }), - (i.prototype._iaddn = function (l) { - this.words[0] += l; - for (var p = 0; p < this.length && this.words[p] >= 67108864; p++) - (this.words[p] -= 67108864), - p === this.length - 1 - ? (this.words[p + 1] = 1) - : this.words[p + 1]++; - return (this.length = Math.max(this.length, p + 1)), this; - }), - (i.prototype.isubn = function (l) { - if ((r(typeof l == "number"), r(l < 67108864), l < 0)) - return this.iaddn(-l); - if (this.negative !== 0) - return ( - (this.negative = 0), this.iaddn(l), (this.negative = 1), this - ); - if (((this.words[0] -= l), this.length === 1 && this.words[0] < 0)) - (this.words[0] = -this.words[0]), (this.negative = 1); - else - for (var p = 0; p < this.length && this.words[p] < 0; p++) - (this.words[p] += 67108864), (this.words[p + 1] -= 1); - return this.strip(); - }), - (i.prototype.addn = function (l) { - return this.clone().iaddn(l); - }), - (i.prototype.subn = function (l) { - return this.clone().isubn(l); - }), - (i.prototype.iabs = function () { - return (this.negative = 0), this; - }), - (i.prototype.abs = function () { - return this.clone().iabs(); - }), - (i.prototype._ishlnsubmul = function (l, p, y) { - var d = l.length + y, - v; - this._expand(d); - var _, - S = 0; - for (v = 0; v < l.length; v++) { - _ = (this.words[v + y] | 0) + S; - var b = (l.words[v] | 0) * p; - (_ -= b & 67108863), - (S = (_ >> 26) - ((b / 67108864) | 0)), - (this.words[v + y] = _ & 67108863); - } - for (; v < this.length - y; v++) - (_ = (this.words[v + y] | 0) + S), - (S = _ >> 26), - (this.words[v + y] = _ & 67108863); - if (S === 0) return this.strip(); - for (r(S === -1), S = 0, v = 0; v < this.length; v++) - (_ = -(this.words[v] | 0) + S), - (S = _ >> 26), - (this.words[v] = _ & 67108863); - return (this.negative = 1), this.strip(); - }), - (i.prototype._wordDiv = function (l, p) { - var y = this.length - l.length, - d = this.clone(), - v = l, - _ = v.words[v.length - 1] | 0, - S = this._countBits(_); - (y = 26 - S), - y !== 0 && - ((v = v.ushln(y)), d.iushln(y), (_ = v.words[v.length - 1] | 0)); - var b = d.length - v.length, - f; - if (p !== "mod") { - (f = new i(null)), - (f.length = b + 1), - (f.words = new Array(f.length)); - for (var x = 0; x < f.length; x++) f.words[x] = 0; - } - var C = d.clone()._ishlnsubmul(v, 1, b); - C.negative === 0 && ((d = C), f && (f.words[b] = 1)); - for (var E = b - 1; E >= 0; E--) { - var B = - (d.words[v.length + E] | 0) * 67108864 + - (d.words[v.length + E - 1] | 0); - for ( - B = Math.min((B / _) | 0, 67108863), d._ishlnsubmul(v, B, E); - d.negative !== 0; - - ) - B--, - (d.negative = 0), - d._ishlnsubmul(v, 1, E), - d.isZero() || (d.negative ^= 1); - f && (f.words[E] = B); - } - return ( - f && f.strip(), - d.strip(), - p !== "div" && y !== 0 && d.iushrn(y), - { div: f || null, mod: d } - ); - }), - (i.prototype.divmod = function (l, p, y) { - if ((r(!l.isZero()), this.isZero())) - return { div: new i(0), mod: new i(0) }; - var d, v, _; - return this.negative !== 0 && l.negative === 0 - ? ((_ = this.neg().divmod(l, p)), - p !== "mod" && (d = _.div.neg()), - p !== "div" && - ((v = _.mod.neg()), y && v.negative !== 0 && v.iadd(l)), - { div: d, mod: v }) - : this.negative === 0 && l.negative !== 0 - ? ((_ = this.divmod(l.neg(), p)), - p !== "mod" && (d = _.div.neg()), - { div: d, mod: _.mod }) - : (this.negative & l.negative) !== 0 - ? ((_ = this.neg().divmod(l.neg(), p)), - p !== "div" && - ((v = _.mod.neg()), y && v.negative !== 0 && v.isub(l)), - { div: _.div, mod: v }) - : l.length > this.length || this.cmp(l) < 0 - ? { div: new i(0), mod: this } - : l.length === 1 - ? p === "div" - ? { div: this.divn(l.words[0]), mod: null } - : p === "mod" - ? { div: null, mod: new i(this.modn(l.words[0])) } - : { - div: this.divn(l.words[0]), - mod: new i(this.modn(l.words[0])), - } - : this._wordDiv(l, p); - }), - (i.prototype.div = function (l) { - return this.divmod(l, "div", !1).div; - }), - (i.prototype.mod = function (l) { - return this.divmod(l, "mod", !1).mod; - }), - (i.prototype.umod = function (l) { - return this.divmod(l, "mod", !0).mod; - }), - (i.prototype.divRound = function (l) { - var p = this.divmod(l); - if (p.mod.isZero()) return p.div; - var y = p.div.negative !== 0 ? p.mod.isub(l) : p.mod, - d = l.ushrn(1), - v = l.andln(1), - _ = y.cmp(d); - return _ < 0 || (v === 1 && _ === 0) - ? p.div - : p.div.negative !== 0 - ? p.div.isubn(1) - : p.div.iaddn(1); - }), - (i.prototype.modn = function (l) { - r(l <= 67108863); - for (var p = (1 << 26) % l, y = 0, d = this.length - 1; d >= 0; d--) - y = (p * y + (this.words[d] | 0)) % l; - return y; - }), - (i.prototype.idivn = function (l) { - r(l <= 67108863); - for (var p = 0, y = this.length - 1; y >= 0; y--) { - var d = (this.words[y] | 0) + p * 67108864; - (this.words[y] = (d / l) | 0), (p = d % l); - } - return this.strip(); - }), - (i.prototype.divn = function (l) { - return this.clone().idivn(l); - }), - (i.prototype.egcd = function (l) { - r(l.negative === 0), r(!l.isZero()); - var p = this, - y = l.clone(); - p.negative !== 0 ? (p = p.umod(l)) : (p = p.clone()); - for ( - var d = new i(1), v = new i(0), _ = new i(0), S = new i(1), b = 0; - p.isEven() && y.isEven(); - - ) - p.iushrn(1), y.iushrn(1), ++b; - for (var f = y.clone(), x = p.clone(); !p.isZero(); ) { - for ( - var C = 0, E = 1; - (p.words[0] & E) === 0 && C < 26; - ++C, E <<= 1 - ); - if (C > 0) - for (p.iushrn(C); C-- > 0; ) - (d.isOdd() || v.isOdd()) && (d.iadd(f), v.isub(x)), - d.iushrn(1), - v.iushrn(1); - for ( - var B = 0, G = 1; - (y.words[0] & G) === 0 && B < 26; - ++B, G <<= 1 - ); - if (B > 0) - for (y.iushrn(B); B-- > 0; ) - (_.isOdd() || S.isOdd()) && (_.iadd(f), S.isub(x)), - _.iushrn(1), - S.iushrn(1); - p.cmp(y) >= 0 - ? (p.isub(y), d.isub(_), v.isub(S)) - : (y.isub(p), _.isub(d), S.isub(v)); - } - return { a: _, b: S, gcd: y.iushln(b) }; - }), - (i.prototype._invmp = function (l) { - r(l.negative === 0), r(!l.isZero()); - var p = this, - y = l.clone(); - p.negative !== 0 ? (p = p.umod(l)) : (p = p.clone()); - for ( - var d = new i(1), v = new i(0), _ = y.clone(); - p.cmpn(1) > 0 && y.cmpn(1) > 0; - - ) { - for ( - var S = 0, b = 1; - (p.words[0] & b) === 0 && S < 26; - ++S, b <<= 1 - ); - if (S > 0) - for (p.iushrn(S); S-- > 0; ) d.isOdd() && d.iadd(_), d.iushrn(1); - for ( - var f = 0, x = 1; - (y.words[0] & x) === 0 && f < 26; - ++f, x <<= 1 - ); - if (f > 0) - for (y.iushrn(f); f-- > 0; ) v.isOdd() && v.iadd(_), v.iushrn(1); - p.cmp(y) >= 0 ? (p.isub(y), d.isub(v)) : (y.isub(p), v.isub(d)); - } - var C; - return ( - p.cmpn(1) === 0 ? (C = d) : (C = v), C.cmpn(0) < 0 && C.iadd(l), C - ); - }), - (i.prototype.gcd = function (l) { - if (this.isZero()) return l.abs(); - if (l.isZero()) return this.abs(); - var p = this.clone(), - y = l.clone(); - (p.negative = 0), (y.negative = 0); - for (var d = 0; p.isEven() && y.isEven(); d++) - p.iushrn(1), y.iushrn(1); - do { - for (; p.isEven(); ) p.iushrn(1); - for (; y.isEven(); ) y.iushrn(1); - var v = p.cmp(y); - if (v < 0) { - var _ = p; - (p = y), (y = _); - } else if (v === 0 || y.cmpn(1) === 0) break; - p.isub(y); - } while (!0); - return y.iushln(d); - }), - (i.prototype.invm = function (l) { - return this.egcd(l).a.umod(l); - }), - (i.prototype.isEven = function () { - return (this.words[0] & 1) === 0; - }), - (i.prototype.isOdd = function () { - return (this.words[0] & 1) === 1; - }), - (i.prototype.andln = function (l) { - return this.words[0] & l; - }), - (i.prototype.bincn = function (l) { - r(typeof l == "number"); - var p = l % 26, - y = (l - p) / 26, - d = 1 << p; - if (this.length <= y) - return this._expand(y + 1), (this.words[y] |= d), this; - for (var v = d, _ = y; v !== 0 && _ < this.length; _++) { - var S = this.words[_] | 0; - (S += v), (v = S >>> 26), (S &= 67108863), (this.words[_] = S); - } - return v !== 0 && ((this.words[_] = v), this.length++), this; - }), - (i.prototype.isZero = function () { - return this.length === 1 && this.words[0] === 0; - }), - (i.prototype.cmpn = function (l) { - var p = l < 0; - if (this.negative !== 0 && !p) return -1; - if (this.negative === 0 && p) return 1; - this.strip(); - var y; - if (this.length > 1) y = 1; - else { - p && (l = -l), r(l <= 67108863, "Number is too big"); - var d = this.words[0] | 0; - y = d === l ? 0 : d < l ? -1 : 1; - } - return this.negative !== 0 ? -y | 0 : y; - }), - (i.prototype.cmp = function (l) { - if (this.negative !== 0 && l.negative === 0) return -1; - if (this.negative === 0 && l.negative !== 0) return 1; - var p = this.ucmp(l); - return this.negative !== 0 ? -p | 0 : p; - }), - (i.prototype.ucmp = function (l) { - if (this.length > l.length) return 1; - if (this.length < l.length) return -1; - for (var p = 0, y = this.length - 1; y >= 0; y--) { - var d = this.words[y] | 0, - v = l.words[y] | 0; - if (d !== v) { - d < v ? (p = -1) : d > v && (p = 1); - break; - } - } - return p; - }), - (i.prototype.gtn = function (l) { - return this.cmpn(l) === 1; - }), - (i.prototype.gt = function (l) { - return this.cmp(l) === 1; - }), - (i.prototype.gten = function (l) { - return this.cmpn(l) >= 0; - }), - (i.prototype.gte = function (l) { - return this.cmp(l) >= 0; - }), - (i.prototype.ltn = function (l) { - return this.cmpn(l) === -1; - }), - (i.prototype.lt = function (l) { - return this.cmp(l) === -1; - }), - (i.prototype.lten = function (l) { - return this.cmpn(l) <= 0; - }), - (i.prototype.lte = function (l) { - return this.cmp(l) <= 0; - }), - (i.prototype.eqn = function (l) { - return this.cmpn(l) === 0; - }), - (i.prototype.eq = function (l) { - return this.cmp(l) === 0; - }), - (i.red = function (l) { - return new te(l); - }), - (i.prototype.toRed = function (l) { - return ( - r(!this.red, "Already a number in reduction context"), - r(this.negative === 0, "red works only with positives"), - l.convertTo(this)._forceRed(l) - ); - }), - (i.prototype.fromRed = function () { - return ( - r(this.red, "fromRed works only with numbers in reduction context"), - this.red.convertFrom(this) - ); - }), - (i.prototype._forceRed = function (l) { - return (this.red = l), this; - }), - (i.prototype.forceRed = function (l) { - return ( - r(!this.red, "Already a number in reduction context"), - this._forceRed(l) - ); - }), - (i.prototype.redAdd = function (l) { - return ( - r(this.red, "redAdd works only with red numbers"), - this.red.add(this, l) - ); - }), - (i.prototype.redIAdd = function (l) { - return ( - r(this.red, "redIAdd works only with red numbers"), - this.red.iadd(this, l) - ); - }), - (i.prototype.redSub = function (l) { - return ( - r(this.red, "redSub works only with red numbers"), - this.red.sub(this, l) - ); - }), - (i.prototype.redISub = function (l) { - return ( - r(this.red, "redISub works only with red numbers"), - this.red.isub(this, l) - ); - }), - (i.prototype.redShl = function (l) { - return ( - r(this.red, "redShl works only with red numbers"), - this.red.shl(this, l) - ); - }), - (i.prototype.redMul = function (l) { - return ( - r(this.red, "redMul works only with red numbers"), - this.red._verify2(this, l), - this.red.mul(this, l) - ); - }), - (i.prototype.redIMul = function (l) { - return ( - r(this.red, "redMul works only with red numbers"), - this.red._verify2(this, l), - this.red.imul(this, l) - ); - }), - (i.prototype.redSqr = function () { - return ( - r(this.red, "redSqr works only with red numbers"), - this.red._verify1(this), - this.red.sqr(this) - ); - }), - (i.prototype.redISqr = function () { - return ( - r(this.red, "redISqr works only with red numbers"), - this.red._verify1(this), - this.red.isqr(this) - ); - }), - (i.prototype.redSqrt = function () { - return ( - r(this.red, "redSqrt works only with red numbers"), - this.red._verify1(this), - this.red.sqrt(this) - ); - }), - (i.prototype.redInvm = function () { - return ( - r(this.red, "redInvm works only with red numbers"), - this.red._verify1(this), - this.red.invm(this) - ); - }), - (i.prototype.redNeg = function () { - return ( - r(this.red, "redNeg works only with red numbers"), - this.red._verify1(this), - this.red.neg(this) - ); - }), - (i.prototype.redPow = function (l) { - return ( - r(this.red && !l.red, "redPow(normalNum)"), - this.red._verify1(this), - this.red.pow(this, l) - ); - }); - var q = { k256: null, p224: null, p192: null, p25519: null }; - function z(A, l) { - (this.name = A), - (this.p = new i(l, 16)), - (this.n = this.p.bitLength()), - (this.k = new i(1).iushln(this.n).isub(this.p)), - (this.tmp = this._tmp()); - } - (z.prototype._tmp = function () { - var l = new i(null); - return (l.words = new Array(Math.ceil(this.n / 13))), l; - }), - (z.prototype.ireduce = function (l) { - var p = l, - y; - do - this.split(p, this.tmp), - (p = this.imulK(p)), - (p = p.iadd(this.tmp)), - (y = p.bitLength()); - while (y > this.n); - var d = y < this.n ? -1 : p.ucmp(this.p); - return ( - d === 0 - ? ((p.words[0] = 0), (p.length = 1)) - : d > 0 - ? p.isub(this.p) - : p.strip !== void 0 - ? p.strip() - : p._strip(), - p - ); - }), - (z.prototype.split = function (l, p) { - l.iushrn(this.n, 0, p); - }), - (z.prototype.imulK = function (l) { - return l.imul(this.k); - }); - function H() { - z.call( - this, - "k256", - "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f" - ); - } - n(H, z), - (H.prototype.split = function (l, p) { - for (var y = 4194303, d = Math.min(l.length, 9), v = 0; v < d; v++) - p.words[v] = l.words[v]; - if (((p.length = d), l.length <= 9)) { - (l.words[0] = 0), (l.length = 1); - return; - } - var _ = l.words[9]; - for (p.words[p.length++] = _ & y, v = 10; v < l.length; v++) { - var S = l.words[v] | 0; - (l.words[v - 10] = ((S & y) << 4) | (_ >>> 22)), (_ = S); - } - (_ >>>= 22), - (l.words[v - 10] = _), - _ === 0 && l.length > 10 ? (l.length -= 10) : (l.length -= 9); - }), - (H.prototype.imulK = function (l) { - (l.words[l.length] = 0), (l.words[l.length + 1] = 0), (l.length += 2); - for (var p = 0, y = 0; y < l.length; y++) { - var d = l.words[y] | 0; - (p += d * 977), - (l.words[y] = p & 67108863), - (p = d * 64 + ((p / 67108864) | 0)); - } - return ( - l.words[l.length - 1] === 0 && - (l.length--, l.words[l.length - 1] === 0 && l.length--), - l - ); - }); - function Z() { - z.call( - this, - "p224", - "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001" - ); - } - n(Z, z); - function $() { - z.call( - this, - "p192", - "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff" - ); - } - n($, z); - function ue() { - z.call( - this, - "25519", - "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed" - ); - } - n(ue, z), - (ue.prototype.imulK = function (l) { - for (var p = 0, y = 0; y < l.length; y++) { - var d = (l.words[y] | 0) * 19 + p, - v = d & 67108863; - (d >>>= 26), (l.words[y] = v), (p = d); - } - return p !== 0 && (l.words[l.length++] = p), l; - }), - (i._prime = function (l) { - if (q[l]) return q[l]; - var p; - if (l === "k256") p = new H(); - else if (l === "p224") p = new Z(); - else if (l === "p192") p = new $(); - else if (l === "p25519") p = new ue(); - else throw new Error("Unknown prime " + l); - return (q[l] = p), p; - }); - function te(A) { - if (typeof A == "string") { - var l = i._prime(A); - (this.m = l.p), (this.prime = l); - } else - r(A.gtn(1), "modulus must be greater than 1"), - (this.m = A), - (this.prime = null); - } - (te.prototype._verify1 = function (l) { - r(l.negative === 0, "red works only with positives"), - r(l.red, "red works only with red numbers"); - }), - (te.prototype._verify2 = function (l, p) { - r((l.negative | p.negative) === 0, "red works only with positives"), - r(l.red && l.red === p.red, "red works only with red numbers"); - }), - (te.prototype.imod = function (l) { - return this.prime - ? this.prime.ireduce(l)._forceRed(this) - : l.umod(this.m)._forceRed(this); - }), - (te.prototype.neg = function (l) { - return l.isZero() ? l.clone() : this.m.sub(l)._forceRed(this); - }), - (te.prototype.add = function (l, p) { - this._verify2(l, p); - var y = l.add(p); - return y.cmp(this.m) >= 0 && y.isub(this.m), y._forceRed(this); - }), - (te.prototype.iadd = function (l, p) { - this._verify2(l, p); - var y = l.iadd(p); - return y.cmp(this.m) >= 0 && y.isub(this.m), y; - }), - (te.prototype.sub = function (l, p) { - this._verify2(l, p); - var y = l.sub(p); - return y.cmpn(0) < 0 && y.iadd(this.m), y._forceRed(this); - }), - (te.prototype.isub = function (l, p) { - this._verify2(l, p); - var y = l.isub(p); - return y.cmpn(0) < 0 && y.iadd(this.m), y; - }), - (te.prototype.shl = function (l, p) { - return this._verify1(l), this.imod(l.ushln(p)); - }), - (te.prototype.imul = function (l, p) { - return this._verify2(l, p), this.imod(l.imul(p)); - }), - (te.prototype.mul = function (l, p) { - return this._verify2(l, p), this.imod(l.mul(p)); - }), - (te.prototype.isqr = function (l) { - return this.imul(l, l.clone()); - }), - (te.prototype.sqr = function (l) { - return this.mul(l, l); - }), - (te.prototype.sqrt = function (l) { - if (l.isZero()) return l.clone(); - var p = this.m.andln(3); - if ((r(p % 2 === 1), p === 3)) { - var y = this.m.add(new i(1)).iushrn(2); - return this.pow(l, y); - } - for (var d = this.m.subn(1), v = 0; !d.isZero() && d.andln(1) === 0; ) - v++, d.iushrn(1); - r(!d.isZero()); - var _ = new i(1).toRed(this), - S = _.redNeg(), - b = this.m.subn(1).iushrn(1), - f = this.m.bitLength(); - for (f = new i(2 * f * f).toRed(this); this.pow(f, b).cmp(S) !== 0; ) - f.redIAdd(S); - for ( - var x = this.pow(f, d), - C = this.pow(l, d.addn(1).iushrn(1)), - E = this.pow(l, d), - B = v; - E.cmp(_) !== 0; - - ) { - for (var G = E, L = 0; G.cmp(_) !== 0; L++) G = G.redSqr(); - r(L < B); - var ee = this.pow(x, new i(1).iushln(B - L - 1)); - (C = C.redMul(ee)), (x = ee.redSqr()), (E = E.redMul(x)), (B = L); - } - return C; - }), - (te.prototype.invm = function (l) { - var p = l._invmp(this.m); - return p.negative !== 0 - ? ((p.negative = 0), this.imod(p).redNeg()) - : this.imod(p); - }), - (te.prototype.pow = function (l, p) { - if (p.isZero()) return new i(1).toRed(this); - if (p.cmpn(1) === 0) return l.clone(); - var y = 4, - d = new Array(1 << y); - (d[0] = new i(1).toRed(this)), (d[1] = l); - for (var v = 2; v < d.length; v++) d[v] = this.mul(d[v - 1], l); - var _ = d[0], - S = 0, - b = 0, - f = p.bitLength() % 26; - for (f === 0 && (f = 26), v = p.length - 1; v >= 0; v--) { - for (var x = p.words[v], C = f - 1; C >= 0; C--) { - var E = (x >> C) & 1; - if ((_ !== d[0] && (_ = this.sqr(_)), E === 0 && S === 0)) { - b = 0; - continue; - } - (S <<= 1), - (S |= E), - b++, - !(b !== y && (v !== 0 || C !== 0)) && - ((_ = this.mul(_, d[S])), (b = 0), (S = 0)); - } - f = 26; - } - return _; - }), - (te.prototype.convertTo = function (l) { - var p = l.umod(this.m); - return p === l ? p.clone() : p; - }), - (te.prototype.convertFrom = function (l) { - var p = l.clone(); - return (p.red = null), p; - }), - (i.mont = function (l) { - return new ne(l); - }); - function ne(A) { - te.call(this, A), - (this.shift = this.m.bitLength()), - this.shift % 26 !== 0 && (this.shift += 26 - (this.shift % 26)), - (this.r = new i(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)); - } - n(ne, te), - (ne.prototype.convertTo = function (l) { - return this.imod(l.ushln(this.shift)); - }), - (ne.prototype.convertFrom = function (l) { - var p = this.imod(l.mul(this.rinv)); - return (p.red = null), p; - }), - (ne.prototype.imul = function (l, p) { - if (l.isZero() || p.isZero()) - return (l.words[0] = 0), (l.length = 1), l; - var y = l.imul(p), - d = y - .maskn(this.shift) - .mul(this.minv) - .imaskn(this.shift) - .mul(this.m), - v = y.isub(d).iushrn(this.shift), - _ = v; - return ( - v.cmp(this.m) >= 0 - ? (_ = v.isub(this.m)) - : v.cmpn(0) < 0 && (_ = v.iadd(this.m)), - _._forceRed(this) - ); - }), - (ne.prototype.mul = function (l, p) { - if (l.isZero() || p.isZero()) return new i(0)._forceRed(this); - var y = l.mul(p), - d = y - .maskn(this.shift) - .mul(this.minv) - .imaskn(this.shift) - .mul(this.m), - v = y.isub(d).iushrn(this.shift), - _ = v; - return ( - v.cmp(this.m) >= 0 - ? (_ = v.isub(this.m)) - : v.cmpn(0) < 0 && (_ = v.iadd(this.m)), - _._forceRed(this) - ); - }), - (ne.prototype.invm = function (l) { - var p = this.imod(l._invmp(this.m).mul(this.r2)); - return p._forceRed(this); - }); - })(typeof Ybe > "u" || Ybe, mJe); - }); - var Qbe = I((tdn, vJe) => { - m(); - g(); - var gJe = TX(), - Ger = vn().Buffer; - function Jer(t, e) { - return Ger.from( - t - .toRed(gJe.mont(e.modulus)) - .redPow(new gJe(e.publicExponent)) - .fromRed() - .toArray() - ); - } - vJe.exports = Jer; - }); - var xJe = I((rdn, _Je) => { - m(); - g(); - var $er = Kq(), - e1e = sM(), - Zer = v5(), - bJe = Zbe(), - wJe = Xbe(), - t1e = TX(), - Xer = Qbe(), - Yer = YZ(), - Hm = vn().Buffer; - _Je.exports = function (e, r, n) { - var i; - e.padding ? (i = e.padding) : n ? (i = 1) : (i = 4); - var o = $er(e), - a; - if (i === 4) a = Qer(o, r); - else if (i === 1) a = etr(o, r, n); - else if (i === 3) { - if (((a = new t1e(r)), a.cmp(o.modulus) >= 0)) - throw new Error("data too long for modulus"); - } else throw new Error("unknown padding"); - return n ? Yer(a, o) : Xer(a, o); - }; - function Qer(t, e) { - var r = t.modulus.byteLength(), - n = e.length, - i = Zer("sha1").update(Hm.alloc(0)).digest(), - o = i.length, - a = 2 * o; - if (n > r - a - 2) throw new Error("message too long"); - var s = Hm.alloc(r - n - a - 2), - c = r - o - 1, - u = e1e(o), - h = wJe(Hm.concat([i, s, Hm.alloc(1, 1), e], c), bJe(u, c)), - w = wJe(u, bJe(h, o)); - return new t1e(Hm.concat([Hm.alloc(1), w, h], r)); - } - function etr(t, e, r) { - var n = e.length, - i = t.modulus.byteLength(); - if (n > i - 11) throw new Error("message too long"); - var o; - return ( - r ? (o = Hm.alloc(i - n - 3, 255)) : (o = ttr(i - n - 3)), - new t1e(Hm.concat([Hm.from([0, r ? 1 : 2]), o, Hm.alloc(1), e], i)) - ); - } - function ttr(t) { - for (var e = Hm.allocUnsafe(t), r = 0, n = e1e(t * 2), i = 0, o; r < t; ) - i === n.length && ((n = e1e(t * 2)), (i = 0)), - (o = n[i++]), - o && (e[r++] = o); - return e; - } - }); - var TJe = I((ndn, MJe) => { - m(); - g(); - var rtr = Kq(), - SJe = Zbe(), - AJe = Xbe(), - EJe = TX(), - ntr = YZ(), - itr = v5(), - otr = Qbe(), - Gq = vn().Buffer; - MJe.exports = function (e, r, n) { - var i; - e.padding ? (i = e.padding) : n ? (i = 1) : (i = 4); - var o = rtr(e), - a = o.modulus.byteLength(); - if (r.length > a || new EJe(r).cmp(o.modulus) >= 0) - throw new Error("decryption error"); - var s; - n ? (s = otr(new EJe(r), o)) : (s = ntr(r, o)); - var c = Gq.alloc(a - s.length); - if (((s = Gq.concat([c, s], a)), i === 4)) return atr(o, s); - if (i === 1) return str(o, s, n); - if (i === 3) return s; - throw new Error("unknown padding"); - }; - function atr(t, e) { - var r = t.modulus.byteLength(), - n = itr("sha1").update(Gq.alloc(0)).digest(), - i = n.length; - if (e[0] !== 0) throw new Error("decryption error"); - var o = e.slice(1, i + 1), - a = e.slice(i + 1), - s = AJe(o, SJe(a, i)), - c = AJe(a, SJe(s, r - i - 1)); - if (utr(n, c.slice(0, i))) throw new Error("decryption error"); - for (var u = i; c[u] === 0; ) u++; - if (c[u++] !== 1) throw new Error("decryption error"); - return c.slice(u); - } - function str(t, e, r) { - for (var n = e.slice(0, 2), i = 2, o = 0; e[i++] !== 0; ) - if (i >= e.length) { - o++; - break; - } - var a = e.slice(2, i - 1); - if ( - (((n.toString("hex") !== "0002" && !r) || - (n.toString("hex") !== "0001" && r)) && - o++, - a.length < 8 && o++, - o) - ) - throw new Error("decryption error"); - return e.slice(i); - } - function utr(t, e) { - (t = Gq.from(t)), (e = Gq.from(e)); - var r = 0, - n = t.length; - t.length !== e.length && (r++, (n = Math.min(t.length, e.length))); - for (var i = -1; ++i < n; ) r += t[i] ^ e[i]; - return r; - } - }); - var kJe = I((LM) => { - m(); - g(); - LM.publicEncrypt = xJe(); - LM.privateDecrypt = TJe(); - LM.privateEncrypt = function (e, r) { - return LM.publicEncrypt(e, r, !0); - }; - LM.publicDecrypt = function (e, r) { - return LM.privateDecrypt(e, r, !0); - }; - }); - var LJe = I((Jq) => { - "use strict"; - m(); - g(); - function PJe() { - throw new Error(`secure random number generation not supported by this browser -use chrome, FireFox or Internet Explorer 11`); - } - var BJe = vn(), - OJe = sM(), - IJe = BJe.Buffer, - CJe = BJe.kMaxLength, - r1e = window.crypto || window.msCrypto, - RJe = Math.pow(2, 32) - 1; - function NJe(t, e) { - if (typeof t != "number" || t !== t) - throw new TypeError("offset must be a number"); - if (t > RJe || t < 0) throw new TypeError("offset must be a uint32"); - if (t > CJe || t > e) throw new RangeError("offset out of range"); - } - function DJe(t, e, r) { - if (typeof t != "number" || t !== t) - throw new TypeError("size must be a number"); - if (t > RJe || t < 0) throw new TypeError("size must be a uint32"); - if (t + e > r || t > CJe) throw new RangeError("buffer too small"); - } - (r1e && r1e.getRandomValues) || !process.browser - ? ((Jq.randomFill = ctr), (Jq.randomFillSync = ltr)) - : ((Jq.randomFill = PJe), (Jq.randomFillSync = PJe)); - function ctr(t, e, r, n) { - if (!IJe.isBuffer(t) && !(t instanceof window.Uint8Array)) - throw new TypeError('"buf" argument must be a Buffer or Uint8Array'); - if (typeof e == "function") (n = e), (e = 0), (r = t.length); - else if (typeof r == "function") (n = r), (r = t.length - e); - else if (typeof n != "function") - throw new TypeError('"cb" argument must be a function'); - return NJe(e, t.length), DJe(r, e, t.length), FJe(t, e, r, n); - } - function FJe(t, e, r, n) { - if (process.browser) { - var i = t.buffer, - o = new Uint8Array(i, e, r); - if ((r1e.getRandomValues(o), n)) { - process.nextTick(function () { - n(null, t); - }); - return; - } - return t; - } - if (n) { - OJe(r, function (s, c) { - if (s) return n(s); - c.copy(t, e), n(null, t); - }); - return; - } - var a = OJe(r); - return a.copy(t, e), t; - } - function ltr(t, e, r) { - if ( - (typeof e > "u" && (e = 0), - !IJe.isBuffer(t) && !(t instanceof window.Uint8Array)) - ) - throw new TypeError('"buf" argument must be a Buffer or Uint8Array'); - return ( - NJe(e, t.length), - r === void 0 && (r = t.length - e), - DJe(r, e, t.length), - FJe(t, e, r) - ); - } - }); - var Rp = I((xn) => { - "use strict"; - m(); - g(); - xn.randomBytes = xn.rng = xn.pseudoRandomBytes = xn.prng = sM(); - xn.createHash = xn.Hash = v5(); - xn.createHmac = xn.Hmac = vve(); - var ftr = XKe(), - dtr = Object.keys(ftr), - htr = [ - "sha1", - "sha224", - "sha256", - "sha384", - "sha512", - "md5", - "rmd160", - ].concat(dtr); - xn.getHashes = function () { - return htr; - }; - var qJe = kve(); - xn.pbkdf2 = qJe.pbkdf2; - xn.pbkdf2Sync = qJe.pbkdf2Sync; - var _v = bVe(); - xn.Cipher = _v.Cipher; - xn.createCipher = _v.createCipher; - xn.Cipheriv = _v.Cipheriv; - xn.createCipheriv = _v.createCipheriv; - xn.Decipher = _v.Decipher; - xn.createDecipher = _v.createDecipher; - xn.Decipheriv = _v.Decipheriv; - xn.createDecipheriv = _v.createDecipheriv; - xn.getCiphers = _v.getCiphers; - xn.listCiphers = _v.listCiphers; - var $q = RVe(); - xn.DiffieHellmanGroup = $q.DiffieHellmanGroup; - xn.createDiffieHellmanGroup = $q.createDiffieHellmanGroup; - xn.getDiffieHellman = $q.getDiffieHellman; - xn.createDiffieHellman = $q.createDiffieHellman; - xn.DiffieHellman = $q.DiffieHellman; - var kX = cJe(); - xn.createSign = kX.createSign; - xn.Sign = kX.Sign; - xn.createVerify = kX.createVerify; - xn.Verify = kX.Verify; - xn.createECDH = hJe(); - var PX = kJe(); - xn.publicEncrypt = PX.publicEncrypt; - xn.privateEncrypt = PX.privateEncrypt; - xn.publicDecrypt = PX.publicDecrypt; - xn.privateDecrypt = PX.privateDecrypt; - var zJe = LJe(); - xn.randomFill = zJe.randomFill; - xn.randomFillSync = zJe.randomFillSync; - xn.createCredentials = function () { - throw new Error( - [ - "sorry, createCredentials is not implemented yet", - "we accept pull requests", - "https://github.com/crypto-browserify/crypto-browserify", - ].join(` -`) - ); - }; - xn.constants = { - DH_CHECK_P_NOT_SAFE_PRIME: 2, - DH_CHECK_P_NOT_PRIME: 1, - DH_UNABLE_TO_CHECK_GENERATOR: 4, - DH_NOT_SUITABLE_GENERATOR: 8, - NPN_ENABLED: 1, - ALPN_ENABLED: 1, - RSA_PKCS1_PADDING: 1, - RSA_SSLV23_PADDING: 2, - RSA_NO_PADDING: 3, - RSA_PKCS1_OAEP_PADDING: 4, - RSA_X931_PADDING: 5, - RSA_PKCS1_PSS_PADDING: 6, - POINT_CONVERSION_COMPRESSED: 2, - POINT_CONVERSION_UNCOMPRESSED: 4, - POINT_CONVERSION_HYBRID: 6, - }; - }); - var CX = I((ai) => { - "use strict"; - m(); - g(); - Object.defineProperty(ai, "__esModule", { value: !0 }); - ai.utils = - ai.curve25519 = - ai.getSharedSecret = - ai.sync = - ai.verify = - ai.sign = - ai.getPublicKey = - ai.Signature = - ai.Point = - ai.RistrettoPoint = - ai.ExtendedPoint = - ai.CURVE = - void 0; - var ptr = Rp(), - Na = BigInt(0), - Zn = BigInt(1), - W5 = BigInt(2), - jJe = BigInt( - "7237005577332262213973186563042994240857116359379907606001950938285454250989" - ), - so = Object.freeze({ - a: BigInt(-1), - d: BigInt( - "37095705934669439343138083508754565189542113879843219016388785533085940283555" - ), - P: BigInt( - "57896044618658097711785492504343953926634992332820282019728792003956564819949" - ), - l: jJe, - n: jJe, - h: BigInt(8), - Gx: BigInt( - "15112221349535400772501151409588531511454012693041857206046113283949847762202" - ), - Gy: BigInt( - "46316835694926478169428394003475163141307993866256225615783033603165251855960" - ), - }); - ai.CURVE = so; - var VJe = BigInt( - "0x10000000000000000000000000000000000000000000000000000000000000000" - ), - Zq = BigInt( - "19681161376707505956807079304988542015446066515923890162744021073123829784752" - ), - sdn = BigInt( - "6853475219497561581579357271197624642482790079785650197046958215289687604742" - ), - ytr = BigInt( - "25063068953384623474111414158702152701244531502492656460079210482610430750235" - ), - mtr = BigInt( - "54469307008909316920995813868745141605393597292927456921205312896311721017578" - ), - gtr = BigInt( - "1159843021668779879193775521855586647937357759715417654439879720876111806838" - ), - vtr = BigInt( - "40440834346308536858101042469323190826248399146238708352240133220865137265952" - ), - oi = class { - constructor(e, r, n, i) { - (this.x = e), (this.y = r), (this.z = n), (this.t = i); - } - static fromAffine(e) { - if (!(e instanceof Bo)) - throw new TypeError("ExtendedPoint#fromAffine: expected Point"); - return e.equals(Bo.ZERO) - ? oi.ZERO - : new oi(e.x, e.y, Zn, vt(e.x * e.y)); - } - static toAffineBatch(e) { - let r = _tr(e.map((n) => n.z)); - return e.map((n, i) => n.toAffine(r[i])); - } - static normalizeZ(e) { - return this.toAffineBatch(e).map(this.fromAffine); - } - equals(e) { - UJe(e); - let { x: r, y: n, z: i } = this, - { x: o, y: a, z: s } = e, - c = vt(r * s), - u = vt(o * i), - h = vt(n * s), - w = vt(a * i); - return c === u && h === w; - } - negate() { - return new oi(vt(-this.x), this.y, this.z, vt(-this.t)); - } - double() { - let { x: e, y: r, z: n } = this, - { a: i } = so, - o = vt(e * e), - a = vt(r * r), - s = vt(W5 * vt(n * n)), - c = vt(i * o), - u = e + r, - h = vt(vt(u * u) - o - a), - w = c + a, - M = w - s, - k = c - a, - O = vt(h * M), - D = vt(w * k), - F = vt(h * k), - N = vt(M * w); - return new oi(O, D, N, F); - } - add(e) { - UJe(e); - let { x: r, y: n, z: i, t: o } = this, - { x: a, y: s, z: c, t: u } = e, - h = vt((n - r) * (s + a)), - w = vt((n + r) * (s - a)), - M = vt(w - h); - if (M === Na) return this.double(); - let k = vt(i * W5 * u), - O = vt(o * W5 * c), - D = O + k, - F = w + h, - N = O - k, - q = vt(D * M), - z = vt(F * N), - H = vt(D * N), - Z = vt(M * F); - return new oi(q, z, Z, H); - } - subtract(e) { - return this.add(e.negate()); - } - precomputeWindow(e) { - let r = 1 + 256 / e, - n = [], - i = this, - o = i; - for (let a = 0; a < r; a++) { - (o = i), n.push(o); - for (let s = 1; s < 2 ** (e - 1); s++) (o = o.add(i)), n.push(o); - i = o.double(); - } - return n; - } - wNAF(e, r) { - !r && this.equals(oi.BASE) && (r = Bo.BASE); - let n = (r && r._WINDOW_SIZE) || 1; - if (256 % n) - throw new Error( - "Point#wNAF: Invalid precomputation window, must be power of 2" - ); - let i = r && a1e.get(r); - i || - ((i = this.precomputeWindow(n)), - r && n !== 1 && ((i = oi.normalizeZ(i)), a1e.set(r, i))); - let o = oi.ZERO, - a = oi.ZERO, - s = 1 + 256 / n, - c = 2 ** (n - 1), - u = BigInt(2 ** n - 1), - h = 2 ** n, - w = BigInt(n); - for (let M = 0; M < s; M++) { - let k = M * c, - O = Number(e & u); - if (((e >>= w), O > c && ((O -= h), (e += Zn)), O === 0)) { - let D = i[k]; - M % 2 && (D = D.negate()), (a = a.add(D)); - } else { - let D = i[k + Math.abs(O) - 1]; - O < 0 && (D = D.negate()), (o = o.add(D)); - } - } - return oi.normalizeZ([o, a])[0]; - } - multiply(e, r) { - return this.wNAF($5(e, so.l), r); - } - multiplyUnsafe(e) { - let r = $5(e, so.l, !1), - n = oi.BASE, - i = oi.ZERO; - if (r === Na) return i; - if (this.equals(i) || r === Zn) return this; - if (this.equals(n)) return this.wNAF(r); - let o = i, - a = this; - for (; r > Na; ) - r & Zn && (o = o.add(a)), (a = a.double()), (r >>= Zn); - return o; - } - isSmallOrder() { - return this.multiplyUnsafe(so.h).equals(oi.ZERO); - } - isTorsionFree() { - return this.multiplyUnsafe(so.l).equals(oi.ZERO); - } - toAffine(e = IX(this.z)) { - let { x: r, y: n, z: i } = this, - o = vt(r * e), - a = vt(n * e); - if (vt(i * e) !== Zn) throw new Error("invZ was invalid"); - return new Bo(o, a); - } - fromRistrettoBytes() { - i1e(); - } - toRistrettoBytes() { - i1e(); - } - fromRistrettoHash() { - i1e(); - } - }; - ai.ExtendedPoint = oi; - oi.BASE = new oi(so.Gx, so.Gy, Zn, vt(so.Gx * so.Gy)); - oi.ZERO = new oi(Na, Zn, Zn, Na); - function UJe(t) { - if (!(t instanceof oi)) throw new TypeError("ExtendedPoint expected"); - } - function n1e(t) { - if (!(t instanceof Ud)) throw new TypeError("RistrettoPoint expected"); - } - function i1e() { - throw new Error("Legacy method: switch to RistrettoPoint"); - } - var Ud = class { - constructor(e) { - this.ep = e; - } - static calcElligatorRistrettoMap(e) { - let { d: r } = so, - n = vt(Zq * e * e), - i = vt((n + Zn) * gtr), - o = BigInt(-1), - a = vt((o - r * n) * vt(n + r)), - { isValid: s, value: c } = u1e(i, a), - u = vt(c * e); - w2(u) || (u = vt(-u)), s || (c = u), s || (o = n); - let h = vt(o * (n - Zn) * vtr - a), - w = c * c, - M = vt((c + c) * a), - k = vt(h * ytr), - O = vt(Zn - w), - D = vt(Zn + w); - return new oi(vt(M * D), vt(O * k), vt(k * D), vt(M * O)); - } - static hashToCurve(e) { - e = Wm(e, 64); - let r = o1e(e.slice(0, 32)), - n = this.calcElligatorRistrettoMap(r), - i = o1e(e.slice(32, 64)), - o = this.calcElligatorRistrettoMap(i); - return new Ud(n.add(o)); - } - static fromHex(e) { - e = Wm(e, 32); - let { a: r, d: n } = so, - i = - "RistrettoPoint.fromHex: the hex is not valid encoding of RistrettoPoint", - o = o1e(e); - if (!xtr(G5(o), e) || w2(o)) throw new Error(i); - let a = vt(o * o), - s = vt(Zn + r * a), - c = vt(Zn - r * a), - u = vt(s * s), - h = vt(c * c), - w = vt(r * n * u - h), - { isValid: M, value: k } = HJe(vt(w * h)), - O = vt(k * c), - D = vt(k * O * w), - F = vt((o + o) * O); - w2(F) && (F = vt(-F)); - let N = vt(s * D), - q = vt(F * N); - if (!M || w2(q) || N === Na) throw new Error(i); - return new Ud(new oi(F, N, Zn, q)); - } - toRawBytes() { - let { x: e, y: r, z: n, t: i } = this.ep, - o = vt(vt(n + r) * vt(n - r)), - a = vt(e * r), - s = vt(a * a), - { value: c } = HJe(vt(o * s)), - u = vt(c * o), - h = vt(c * a), - w = vt(u * h * i), - M; - if (w2(i * w)) { - let O = vt(r * Zq), - D = vt(e * Zq); - (e = O), (r = D), (M = vt(u * mtr)); - } else M = h; - w2(e * w) && (r = vt(-r)); - let k = vt((n - r) * M); - return w2(k) && (k = vt(-k)), G5(k); - } - toHex() { - return Yq(this.toRawBytes()); - } - toString() { - return this.toHex(); - } - equals(e) { - n1e(e); - let r = this.ep, - n = e.ep, - i = vt(r.x * n.y) === vt(r.y * n.x), - o = vt(r.y * n.y) === vt(r.x * n.x); - return i || o; - } - add(e) { - return n1e(e), new Ud(this.ep.add(e.ep)); - } - subtract(e) { - return n1e(e), new Ud(this.ep.subtract(e.ep)); - } - multiply(e) { - return new Ud(this.ep.multiply(e)); - } - multiplyUnsafe(e) { - return new Ud(this.ep.multiplyUnsafe(e)); - } - }; - ai.RistrettoPoint = Ud; - Ud.BASE = new Ud(oi.BASE); - Ud.ZERO = new Ud(oi.ZERO); - var a1e = new WeakMap(), - Bo = class { - constructor(e, r) { - (this.x = e), (this.y = r); - } - _setWindowSize(e) { - (this._WINDOW_SIZE = e), a1e.delete(this); - } - static fromHex(e, r = !0) { - let { d: n, P: i } = so; - e = Wm(e, 32); - let o = e.slice(); - o[31] = e[31] & -129; - let a = qM(o); - if (r && a >= i) throw new Error("Expected 0 < hex < P"); - if (!r && a >= VJe) throw new Error("Expected 0 < hex < 2**256"); - let s = vt(a * a), - c = vt(s - Zn), - u = vt(n * s + Zn), - { isValid: h, value: w } = u1e(c, u); - if (!h) throw new Error("Point.fromHex: invalid y coordinate"); - let M = (w & Zn) === Zn; - return ((e[31] & 128) !== 0) !== M && (w = vt(-w)), new Bo(w, a); - } - static async fromPrivateKey(e) { - return (await Qq(e)).point; - } - toRawBytes() { - let e = G5(this.y); - return (e[31] |= this.x & Zn ? 128 : 0), e; - } - toHex() { - return Yq(this.toRawBytes()); - } - toX25519() { - let { y: e } = this, - r = vt((Zn + e) * IX(Zn - e)); - return G5(r); - } - isTorsionFree() { - return oi.fromAffine(this).isTorsionFree(); - } - equals(e) { - return this.x === e.x && this.y === e.y; - } - negate() { - return new Bo(vt(-this.x), this.y); - } - add(e) { - return oi.fromAffine(this).add(oi.fromAffine(e)).toAffine(); - } - subtract(e) { - return this.add(e.negate()); - } - multiply(e) { - return oi.fromAffine(this).multiply(e, this).toAffine(); - } - }; - ai.Point = Bo; - Bo.BASE = new Bo(so.Gx, so.Gy); - Bo.ZERO = new Bo(Na, Zn); - var L_ = class { - constructor(e, r) { - (this.r = e), (this.s = r), this.assertValidity(); - } - static fromHex(e) { - let r = Wm(e, 64), - n = Bo.fromHex(r.slice(0, 32), !1), - i = qM(r.slice(32, 64)); - return new L_(n, i); - } - assertValidity() { - let { r: e, s: r } = this; - if (!(e instanceof Bo)) throw new Error("Expected Point instance"); - return $5(r, so.l, !1), this; - } - toRawBytes() { - let e = new Uint8Array(64); - return e.set(this.r.toRawBytes()), e.set(G5(this.s), 32), e; - } - toHex() { - return Yq(this.toRawBytes()); - } - }; - ai.Signature = L_; - function KJe(...t) { - if (!t.every((n) => n instanceof Uint8Array)) - throw new Error("Expected Uint8Array list"); - if (t.length === 1) return t[0]; - let e = t.reduce((n, i) => n + i.length, 0), - r = new Uint8Array(e); - for (let n = 0, i = 0; n < t.length; n++) { - let o = t[n]; - r.set(o, i), (i += o.length); - } - return r; - } - var btr = Array.from({ length: 256 }, (t, e) => - e.toString(16).padStart(2, "0") - ); - function Yq(t) { - if (!(t instanceof Uint8Array)) throw new Error("Uint8Array expected"); - let e = ""; - for (let r = 0; r < t.length; r++) e += btr[t[r]]; - return e; - } - function s1e(t) { - if (typeof t != "string") - throw new TypeError("hexToBytes: expected string, got " + typeof t); - if (t.length % 2) - throw new Error("hexToBytes: received invalid unpadded hex"); - let e = new Uint8Array(t.length / 2); - for (let r = 0; r < e.length; r++) { - let n = r * 2, - i = t.slice(n, n + 2), - o = Number.parseInt(i, 16); - if (Number.isNaN(o) || o < 0) throw new Error("Invalid byte sequence"); - e[r] = o; - } - return e; - } - function WJe(t) { - let r = t.toString(16).padStart(64, "0"); - return s1e(r); - } - function G5(t) { - return WJe(t).reverse(); - } - function w2(t) { - return (vt(t) & Zn) === Zn; - } - function qM(t) { - if (!(t instanceof Uint8Array)) throw new Error("Expected Uint8Array"); - return BigInt("0x" + Yq(Uint8Array.from(t).reverse())); - } - var wtr = BigInt( - "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - ); - function o1e(t) { - return vt(qM(t) & wtr); - } - function vt(t, e = so.P) { - let r = t % e; - return r >= Na ? r : e + r; - } - function IX(t, e = so.P) { - if (t === Na || e <= Na) - throw new Error( - `invert: expected positive integers, got n=${t} mod=${e}` - ); - let r = vt(t, e), - n = e, - i = Na, - o = Zn, - a = Zn, - s = Na; - for (; r !== Na; ) { - let u = n / r, - h = n % r, - w = i - a * u, - M = o - s * u; - (n = r), (r = h), (i = a), (o = s), (a = w), (s = M); - } - if (n !== Zn) throw new Error("invert: does not exist"); - return vt(i, e); - } - function _tr(t, e = so.P) { - let r = new Array(t.length), - n = t.reduce( - (o, a, s) => (a === Na ? o : ((r[s] = o), vt(o * a, e))), - Zn - ), - i = IX(n, e); - return ( - t.reduceRight( - (o, a, s) => - a === Na ? o : ((r[s] = vt(o * r[s], e)), vt(o * a, e)), - i - ), - r - ); - } - function Vm(t, e) { - let { P: r } = so, - n = t; - for (; e-- > Na; ) (n *= n), (n %= r); - return n; - } - function GJe(t) { - let { P: e } = so, - r = BigInt(5), - n = BigInt(10), - i = BigInt(20), - o = BigInt(40), - a = BigInt(80), - c = (((t * t) % e) * t) % e, - u = (Vm(c, W5) * c) % e, - h = (Vm(u, Zn) * t) % e, - w = (Vm(h, r) * h) % e, - M = (Vm(w, n) * w) % e, - k = (Vm(M, i) * M) % e, - O = (Vm(k, o) * k) % e, - D = (Vm(O, a) * O) % e, - F = (Vm(D, a) * O) % e, - N = (Vm(F, n) * w) % e; - return { pow_p_5_8: (Vm(N, W5) * t) % e, b2: c }; - } - function u1e(t, e) { - let r = vt(e * e * e), - n = vt(r * r * e), - i = GJe(t * n).pow_p_5_8, - o = vt(t * r * i), - a = vt(e * o * o), - s = o, - c = vt(o * Zq), - u = a === t, - h = a === vt(-t), - w = a === vt(-t * Zq); - return ( - u && (o = s), - (h || w) && (o = c), - w2(o) && (o = vt(-o)), - { isValid: u || h, value: o } - ); - } - function HJe(t) { - return u1e(Zn, t); - } - function J5(t) { - return vt(qM(t), so.l); - } - function xtr(t, e) { - if (t.length !== e.length) return !1; - for (let r = 0; r < t.length; r++) if (t[r] !== e[r]) return !1; - return !0; - } - function Wm(t, e) { - let r = t instanceof Uint8Array ? Uint8Array.from(t) : s1e(t); - if (typeof e == "number" && r.length !== e) - throw new Error(`Expected ${e} bytes`); - return r; - } - function $5(t, e, r = !0) { - if (!e) throw new TypeError("Specify max value"); - if ( - (typeof t == "number" && Number.isSafeInteger(t) && (t = BigInt(t)), - typeof t == "bigint" && t < e) - ) { - if (r) { - if (Na < t) return t; - } else if (Na <= t) return t; - } - throw new TypeError("Expected valid scalar: 0 < scalar < max"); - } - function JJe(t) { - return (t[0] &= 248), (t[31] &= 127), (t[31] |= 64), t; - } - function Str(t) { - return qM(JJe(Wm(t, 32))); - } - function $Je(t) { - if ( - ((t = - typeof t == "bigint" || typeof t == "number" - ? WJe($5(t, VJe)) - : Wm(t)), - t.length !== 32) - ) - throw new Error("Expected 32 bytes"); - return t; - } - function ZJe(t) { - let e = JJe(t.slice(0, 32)), - r = t.slice(32, 64), - n = J5(e), - i = Bo.BASE.multiply(n), - o = i.toRawBytes(); - return { head: e, prefix: r, scalar: n, point: i, pointBytes: o }; - } - var Xq; - function BX(...t) { - if (typeof Xq != "function") - throw new Error("utils.sha512Sync must be set to use sync methods"); - return Xq(...t); - } - async function Qq(t) { - return ZJe(await ai.utils.sha512($Je(t))); - } - function c1e(t) { - return ZJe(BX($Je(t))); - } - async function Atr(t) { - return (await Qq(t)).pointBytes; - } - ai.getPublicKey = Atr; - function Etr(t) { - return c1e(t).pointBytes; - } - async function Mtr(t, e) { - t = Wm(t); - let { prefix: r, scalar: n, pointBytes: i } = await Qq(e), - o = J5(await ai.utils.sha512(r, t)), - a = Bo.BASE.multiply(o), - s = J5(await ai.utils.sha512(a.toRawBytes(), i, t)), - c = vt(o + s * n, so.l); - return new L_(a, c).toRawBytes(); - } - ai.sign = Mtr; - function Ttr(t, e) { - t = Wm(t); - let { prefix: r, scalar: n, pointBytes: i } = c1e(e), - o = J5(BX(r, t)), - a = Bo.BASE.multiply(o), - s = J5(BX(a.toRawBytes(), i, t)), - c = vt(o + s * n, so.l); - return new L_(a, c).toRawBytes(); - } - function XJe(t, e, r) { - (e = Wm(e)), r instanceof Bo || (r = Bo.fromHex(r, !1)); - let { r: n, s: i } = t instanceof L_ ? t.assertValidity() : L_.fromHex(t), - o = oi.BASE.multiplyUnsafe(i); - return { r: n, s: i, SB: o, pub: r, msg: e }; - } - function YJe(t, e, r, n) { - let i = J5(n), - o = oi.fromAffine(t).multiplyUnsafe(i); - return oi - .fromAffine(e) - .add(o) - .subtract(r) - .multiplyUnsafe(so.h) - .equals(oi.ZERO); - } - async function ktr(t, e, r) { - let { r: n, SB: i, msg: o, pub: a } = XJe(t, e, r), - s = await ai.utils.sha512(n.toRawBytes(), a.toRawBytes(), o); - return YJe(a, n, i, s); - } - ai.verify = ktr; - function Ptr(t, e, r) { - let { r: n, SB: i, msg: o, pub: a } = XJe(t, e, r), - s = BX(n.toRawBytes(), a.toRawBytes(), o); - return YJe(a, n, i, s); - } - ai.sync = { - getExtendedPublicKey: c1e, - getPublicKey: Etr, - sign: Ttr, - verify: Ptr, - }; - async function Otr(t, e) { - let { head: r } = await Qq(t), - n = Bo.fromHex(e).toX25519(); - return ai.curve25519.scalarMult(r, n); - } - ai.getSharedSecret = Otr; - Bo.BASE._setWindowSize(8); - function OX(t, e, r) { - let n = vt(t * (e - r)); - return (e = vt(e - n)), (r = vt(r + n)), [e, r]; - } - function Btr(t, e) { - let { P: r } = so, - n = $5(t, r), - i = $5(e, r), - o = BigInt(121665), - a = n, - s = Zn, - c = Na, - u = n, - h = Zn, - w = Na, - M; - for (let F = BigInt(255 - 1); F >= Na; F--) { - let N = (i >> F) & Zn; - (w ^= N), - (M = OX(w, s, u)), - (s = M[0]), - (u = M[1]), - (M = OX(w, c, h)), - (c = M[0]), - (h = M[1]), - (w = N); - let q = s + c, - z = vt(q * q), - H = s - c, - Z = vt(H * H), - $ = z - Z, - ue = u + h, - te = u - h, - ne = vt(te * q), - A = vt(ue * H), - l = ne + A, - p = ne - A; - (u = vt(l * l)), - (h = vt(a * vt(p * p))), - (s = vt(z * Z)), - (c = vt($ * (z + vt(o * $)))); - } - (M = OX(w, s, u)), - (s = M[0]), - (u = M[1]), - (M = OX(w, c, h)), - (c = M[0]), - (h = M[1]); - let { pow_p_5_8: k, b2: O } = GJe(c), - D = vt(Vm(k, BigInt(3)) * O); - return vt(s * D); - } - function Itr(t) { - return G5(vt(t, so.P)); - } - function Ctr(t) { - let e = Wm(t, 32); - return (e[31] &= 127), qM(e); - } - ai.curve25519 = { - BASE_POINT_U: - "0900000000000000000000000000000000000000000000000000000000000000", - scalarMult(t, e) { - let r = Ctr(e), - n = Str(t), - i = Btr(r, n); - if (i === Na) throw new Error("Invalid private or public key received"); - return Itr(i); - }, - scalarMultBase(t) { - return ai.curve25519.scalarMult(t, ai.curve25519.BASE_POINT_U); - }, - }; - var b2 = { - node: ptr, - web: typeof self == "object" && "crypto" in self ? self.crypto : void 0, - }; - ai.utils = { - bytesToHex: Yq, - hexToBytes: s1e, - concatBytes: KJe, - getExtendedPublicKey: Qq, - mod: vt, - invert: IX, - TORSION_SUBGROUP: [ - "0100000000000000000000000000000000000000000000000000000000000000", - "c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac037a", - "0000000000000000000000000000000000000000000000000000000000000080", - "26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc05", - "ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f", - "26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc85", - "0000000000000000000000000000000000000000000000000000000000000000", - "c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac03fa", - ], - hashToPrivateScalar: (t) => { - if (((t = Wm(t)), t.length < 40 || t.length > 1024)) - throw new Error( - "Expected 40-1024 bytes of private key as per FIPS 186" - ); - return vt(qM(t), so.l - Zn) + Zn; - }, - randomBytes: (t = 32) => { - if (b2.web) return b2.web.getRandomValues(new Uint8Array(t)); - if (b2.node) { - let { randomBytes: e } = b2.node; - return new Uint8Array(e(t).buffer); - } else - throw new Error("The environment doesn't have randomBytes function"); - }, - randomPrivateKey: () => ai.utils.randomBytes(32), - sha512: async (...t) => { - let e = KJe(...t); - if (b2.web) { - let r = await b2.web.subtle.digest("SHA-512", e.buffer); - return new Uint8Array(r); - } else { - if (b2.node) - return Uint8Array.from( - b2.node.createHash("sha512").update(e).digest() - ); - throw new Error("The environment doesn't have sha512 function"); - } - }, - precompute(t = 8, e = Bo.BASE) { - let r = e.equals(Bo.BASE) ? e : new Bo(e.x, e.y); - return r._setWindowSize(t), r.multiply(W5), r; - }, - sha512Sync: void 0, - }; - Object.defineProperties(ai.utils, { - sha512Sync: { - configurable: !1, - get() { - return Xq; - }, - set(t) { - Xq || (Xq = t); - }, - }, - }); - }); - var e$e = I((cdn, QJe) => { - "use strict"; - m(); - g(); - var RX = vn().Buffer; - function Rtr(t) { - if (t.length >= 255) throw new TypeError("Alphabet too long"); - for (var e = new Uint8Array(256), r = 0; r < e.length; r++) e[r] = 255; - for (var n = 0; n < t.length; n++) { - var i = t.charAt(n), - o = i.charCodeAt(0); - if (e[o] !== 255) throw new TypeError(i + " is ambiguous"); - e[o] = n; - } - var a = t.length, - s = t.charAt(0), - c = Math.log(a) / Math.log(256), - u = Math.log(256) / Math.log(a); - function h(k) { - if ( - ((Array.isArray(k) || k instanceof Uint8Array) && (k = RX.from(k)), - !RX.isBuffer(k)) - ) - throw new TypeError("Expected Buffer"); - if (k.length === 0) return ""; - for (var O = 0, D = 0, F = 0, N = k.length; F !== N && k[F] === 0; ) - F++, O++; - for ( - var q = ((N - F) * u + 1) >>> 0, z = new Uint8Array(q); - F !== N; - - ) { - for ( - var H = k[F], Z = 0, $ = q - 1; - (H !== 0 || Z < D) && $ !== -1; - $--, Z++ - ) - (H += (256 * z[$]) >>> 0), - (z[$] = H % a >>> 0), - (H = (H / a) >>> 0); - if (H !== 0) throw new Error("Non-zero carry"); - (D = Z), F++; - } - for (var ue = q - D; ue !== q && z[ue] === 0; ) ue++; - for (var te = s.repeat(O); ue < q; ++ue) te += t.charAt(z[ue]); - return te; - } - function w(k) { - if (typeof k != "string") throw new TypeError("Expected String"); - if (k.length === 0) return RX.alloc(0); - for (var O = 0, D = 0, F = 0; k[O] === s; ) D++, O++; - for ( - var N = ((k.length - O) * c + 1) >>> 0, q = new Uint8Array(N); - k[O]; - - ) { - var z = e[k.charCodeAt(O)]; - if (z === 255) return; - for (var H = 0, Z = N - 1; (z !== 0 || H < F) && Z !== -1; Z--, H++) - (z += (a * q[Z]) >>> 0), - (q[Z] = z % 256 >>> 0), - (z = (z / 256) >>> 0); - if (z !== 0) throw new Error("Non-zero carry"); - (F = H), O++; - } - for (var $ = N - F; $ !== N && q[$] === 0; ) $++; - var ue = RX.allocUnsafe(D + (N - $)); - ue.fill(0, 0, D); - for (var te = D; $ !== N; ) ue[te++] = q[$++]; - return ue; - } - function M(k) { - var O = w(k); - if (O) return O; - throw new Error("Non-base" + a + " character"); - } - return { encode: h, decodeUnsafe: w, decode: M }; - } - QJe.exports = Rtr; - }); - var xv = I((ldn, t$e) => { - m(); - g(); - var Ntr = e$e(), - Dtr = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"; - t$e.exports = Ntr(Dtr); - }); - var r$e = I((NX) => { - "use strict"; - m(); - g(); - Object.defineProperty(NX, "__esModule", { value: !0 }); - NX.sha256 = void 0; - var Ftr = tge(), - Gm = r5(), - Ltr = (t, e, r) => (t & e) ^ (~t & r), - qtr = (t, e, r) => (t & e) ^ (t & r) ^ (e & r), - ztr = new Uint32Array([ - 1116352408, 1899447441, 3049323471, 3921009573, 961987163, 1508970993, - 2453635748, 2870763221, 3624381080, 310598401, 607225278, 1426881987, - 1925078388, 2162078206, 2614888103, 3248222580, 3835390401, 4022224774, - 264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986, - 2554220882, 2821834349, 2952996808, 3210313671, 3336571891, 3584528711, - 113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291, - 1695183700, 1986661051, 2177026350, 2456956037, 2730485921, 2820302411, - 3259730800, 3345764771, 3516065817, 3600352804, 4094571909, 275423344, - 430227734, 506948616, 659060556, 883997877, 958139571, 1322822218, - 1537002063, 1747873779, 1955562222, 2024104815, 2227730452, 2361852424, - 2428436474, 2756734187, 3204031479, 3329325298, - ]), - _2 = new Uint32Array([ - 1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, - 528734635, 1541459225, - ]), - x2 = new Uint32Array(64), - l1e = class extends Ftr.SHA2 { - constructor() { - super(64, 32, 8, !1), - (this.A = _2[0] | 0), - (this.B = _2[1] | 0), - (this.C = _2[2] | 0), - (this.D = _2[3] | 0), - (this.E = _2[4] | 0), - (this.F = _2[5] | 0), - (this.G = _2[6] | 0), - (this.H = _2[7] | 0); - } - get() { - let { A: e, B: r, C: n, D: i, E: o, F: a, G: s, H: c } = this; - return [e, r, n, i, o, a, s, c]; - } - set(e, r, n, i, o, a, s, c) { - (this.A = e | 0), - (this.B = r | 0), - (this.C = n | 0), - (this.D = i | 0), - (this.E = o | 0), - (this.F = a | 0), - (this.G = s | 0), - (this.H = c | 0); - } - process(e, r) { - for (let w = 0; w < 16; w++, r += 4) x2[w] = e.getUint32(r, !1); - for (let w = 16; w < 64; w++) { - let M = x2[w - 15], - k = x2[w - 2], - O = (0, Gm.rotr)(M, 7) ^ (0, Gm.rotr)(M, 18) ^ (M >>> 3), - D = (0, Gm.rotr)(k, 17) ^ (0, Gm.rotr)(k, 19) ^ (k >>> 10); - x2[w] = (D + x2[w - 7] + O + x2[w - 16]) | 0; - } - let { A: n, B: i, C: o, D: a, E: s, F: c, G: u, H: h } = this; - for (let w = 0; w < 64; w++) { - let M = - (0, Gm.rotr)(s, 6) ^ (0, Gm.rotr)(s, 11) ^ (0, Gm.rotr)(s, 25), - k = (h + M + Ltr(s, c, u) + ztr[w] + x2[w]) | 0, - D = - (((0, Gm.rotr)(n, 2) ^ - (0, Gm.rotr)(n, 13) ^ - (0, Gm.rotr)(n, 22)) + - qtr(n, i, o)) | - 0; - (h = u), - (u = c), - (c = s), - (s = (a + k) | 0), - (a = o), - (o = i), - (i = n), - (n = (k + D) | 0); - } - (n = (n + this.A) | 0), - (i = (i + this.B) | 0), - (o = (o + this.C) | 0), - (a = (a + this.D) | 0), - (s = (s + this.E) | 0), - (c = (c + this.F) | 0), - (u = (u + this.G) | 0), - (h = (h + this.H) | 0), - this.set(n, i, o, a, s, c, u, h); - } - roundClean() { - x2.fill(0); - } - destroy() { - this.set(0, 0, 0, 0, 0, 0, 0, 0), this.buffer.fill(0); - } - }; - NX.sha256 = (0, Gm.wrapConstructor)(() => new l1e()); - }); - var p1e = I((h1e) => { - "use strict"; - m(); - g(); - function q_(t, e, r) { - return e <= t && t <= r; - } - function zX(t) { - if (t === void 0) return {}; - if (t === Object(t)) return t; - throw TypeError("Could not convert argument to dictionary"); - } - function jtr(t) { - for (var e = String(t), r = e.length, n = 0, i = []; n < r; ) { - var o = e.charCodeAt(n); - if (o < 55296 || o > 57343) i.push(o); - else if (56320 <= o && o <= 57343) i.push(65533); - else if (55296 <= o && o <= 56319) - if (n === r - 1) i.push(65533); - else { - var a = t.charCodeAt(n + 1); - if (56320 <= a && a <= 57343) { - var s = o & 1023, - c = a & 1023; - i.push(65536 + (s << 10) + c), (n += 1); - } else i.push(65533); - } - n += 1; - } - return i; - } - function Utr(t) { - for (var e = "", r = 0; r < t.length; ++r) { - var n = t[r]; - n <= 65535 - ? (e += String.fromCharCode(n)) - : ((n -= 65536), - (e += String.fromCharCode((n >> 10) + 55296, (n & 1023) + 56320))); - } - return e; - } - var DX = -1; - function d1e(t) { - this.tokens = [].slice.call(t); - } - d1e.prototype = { - endOfStream: function () { - return !this.tokens.length; - }, - read: function () { - return this.tokens.length ? this.tokens.shift() : DX; - }, - prepend: function (t) { - if (Array.isArray(t)) - for (var e = t; e.length; ) this.tokens.unshift(e.pop()); - else this.tokens.unshift(t); - }, - push: function (t) { - if (Array.isArray(t)) - for (var e = t; e.length; ) this.tokens.push(e.shift()); - else this.tokens.push(t); - }, - }; - var Z5 = -1; - function f1e(t, e) { - if (t) throw TypeError("Decoder error"); - return e || 65533; - } - var FX = "utf-8"; - function LX(t, e) { - if (!(this instanceof LX)) return new LX(t, e); - if (((t = t !== void 0 ? String(t).toLowerCase() : FX), t !== FX)) - throw new Error("Encoding not supported. Only utf-8 is supported"); - (e = zX(e)), - (this._streaming = !1), - (this._BOMseen = !1), - (this._decoder = null), - (this._fatal = Boolean(e.fatal)), - (this._ignoreBOM = Boolean(e.ignoreBOM)), - Object.defineProperty(this, "encoding", { value: "utf-8" }), - Object.defineProperty(this, "fatal", { value: this._fatal }), - Object.defineProperty(this, "ignoreBOM", { value: this._ignoreBOM }); - } - LX.prototype = { - decode: function (e, r) { - var n; - typeof e == "object" && e instanceof ArrayBuffer - ? (n = new Uint8Array(e)) - : typeof e == "object" && - "buffer" in e && - e.buffer instanceof ArrayBuffer - ? (n = new Uint8Array(e.buffer, e.byteOffset, e.byteLength)) - : (n = new Uint8Array(0)), - (r = zX(r)), - this._streaming || - ((this._decoder = new Ktr({ fatal: this._fatal })), - (this._BOMseen = !1)), - (this._streaming = Boolean(r.stream)); - for ( - var i = new d1e(n), o = [], a; - !i.endOfStream() && - ((a = this._decoder.handler(i, i.read())), a !== Z5); - - ) - a !== null && (Array.isArray(a) ? o.push.apply(o, a) : o.push(a)); - if (!this._streaming) { - do { - if (((a = this._decoder.handler(i, i.read())), a === Z5)) break; - a !== null && (Array.isArray(a) ? o.push.apply(o, a) : o.push(a)); - } while (!i.endOfStream()); - this._decoder = null; - } - return ( - o.length && - ["utf-8"].indexOf(this.encoding) !== -1 && - !this._ignoreBOM && - !this._BOMseen && - (o[0] === 65279 - ? ((this._BOMseen = !0), o.shift()) - : (this._BOMseen = !0)), - Utr(o) - ); - }, - }; - function qX(t, e) { - if (!(this instanceof qX)) return new qX(t, e); - if (((t = t !== void 0 ? String(t).toLowerCase() : FX), t !== FX)) - throw new Error("Encoding not supported. Only utf-8 is supported"); - (e = zX(e)), - (this._streaming = !1), - (this._encoder = null), - (this._options = { fatal: Boolean(e.fatal) }), - Object.defineProperty(this, "encoding", { value: "utf-8" }); - } - qX.prototype = { - encode: function (e, r) { - (e = e ? String(e) : ""), - (r = zX(r)), - this._streaming || (this._encoder = new Htr(this._options)), - (this._streaming = Boolean(r.stream)); - for ( - var n = [], i = new d1e(jtr(e)), o; - !i.endOfStream() && - ((o = this._encoder.handler(i, i.read())), o !== Z5); - - ) - Array.isArray(o) ? n.push.apply(n, o) : n.push(o); - if (!this._streaming) { - for (; (o = this._encoder.handler(i, i.read())), o !== Z5; ) - Array.isArray(o) ? n.push.apply(n, o) : n.push(o); - this._encoder = null; - } - return new Uint8Array(n); - }, - }; - function Ktr(t) { - var e = t.fatal, - r = 0, - n = 0, - i = 0, - o = 128, - a = 191; - this.handler = function (s, c) { - if (c === DX && i !== 0) return (i = 0), f1e(e); - if (c === DX) return Z5; - if (i === 0) { - if (q_(c, 0, 127)) return c; - if (q_(c, 194, 223)) (i = 1), (r = c - 192); - else if (q_(c, 224, 239)) - c === 224 && (o = 160), - c === 237 && (a = 159), - (i = 2), - (r = c - 224); - else if (q_(c, 240, 244)) - c === 240 && (o = 144), - c === 244 && (a = 143), - (i = 3), - (r = c - 240); - else return f1e(e); - return (r = r << (6 * i)), null; - } - if (!q_(c, o, a)) - return (r = i = n = 0), (o = 128), (a = 191), s.prepend(c), f1e(e); - if ( - ((o = 128), - (a = 191), - (n += 1), - (r += (c - 128) << (6 * (i - n))), - n !== i) - ) - return null; - var u = r; - return (r = i = n = 0), u; - }; - } - function Htr(t) { - var e = t.fatal; - this.handler = function (r, n) { - if (n === DX) return Z5; - if (q_(n, 0, 127)) return n; - var i, o; - q_(n, 128, 2047) - ? ((i = 1), (o = 192)) - : q_(n, 2048, 65535) - ? ((i = 2), (o = 224)) - : q_(n, 65536, 1114111) && ((i = 3), (o = 240)); - for (var a = [(n >> (6 * i)) + o]; i > 0; ) { - var s = n >> (6 * (i - 1)); - a.push(128 | (s & 63)), (i -= 1); - } - return a; - }; - } - h1e.TextEncoder = qX; - h1e.TextDecoder = LX; - }); - var s$e = I((uo) => { - "use strict"; - m(); - g(); - var Vtr = - (uo && uo.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Wtr = - (uo && uo.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Sv = - (uo && uo.__decorate) || - function (t, e, r, n) { - var i = arguments.length, - o = - i < 3 - ? e - : n === null - ? (n = Object.getOwnPropertyDescriptor(e, r)) - : n, - a; - if ( - typeof Reflect == "object" && - typeof Reflect.decorate == "function" - ) - o = Reflect.decorate(t, e, r, n); - else - for (var s = t.length - 1; s >= 0; s--) - (a = t[s]) && - (o = (i < 3 ? a(o) : i > 3 ? a(e, r, o) : a(e, r)) || o); - return i > 3 && o && Object.defineProperty(e, r, o), o; - }, - Gtr = - (uo && uo.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.hasOwnProperty.call(t, r) && - Vtr(e, t, r); - return Wtr(e, t), e; - }, - n$e = - (uo && uo.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(uo, "__esModule", { value: !0 }); - uo.deserializeUnchecked = - uo.deserialize = - uo.serialize = - uo.BinaryReader = - uo.BinaryWriter = - uo.BorshError = - uo.baseDecode = - uo.baseEncode = - void 0; - var S2 = n$e(Ho()), - i$e = n$e(xv()), - Jtr = Gtr(p1e()), - $tr = typeof TextDecoder != "function" ? Jtr.TextDecoder : TextDecoder, - Ztr = new $tr("utf-8", { fatal: !0 }); - function Xtr(t) { - return ( - typeof t == "string" && (t = Buffer.from(t, "utf8")), - i$e.default.encode(Buffer.from(t)) - ); - } - uo.baseEncode = Xtr; - function Ytr(t) { - return Buffer.from(i$e.default.decode(t)); - } - uo.baseDecode = Ytr; - var y1e = 1024, - rc = class extends Error { - constructor(e) { - super(e), (this.fieldPath = []), (this.originalMessage = e); - } - addToFieldPath(e) { - this.fieldPath.splice(0, 0, e), - (this.message = - this.originalMessage + ": " + this.fieldPath.join(".")); - } - }; - uo.BorshError = rc; - var jX = class { - constructor() { - (this.buf = Buffer.alloc(y1e)), (this.length = 0); - } - maybeResize() { - this.buf.length < 16 + this.length && - (this.buf = Buffer.concat([this.buf, Buffer.alloc(y1e)])); - } - writeU8(e) { - this.maybeResize(), - this.buf.writeUInt8(e, this.length), - (this.length += 1); - } - writeU16(e) { - this.maybeResize(), - this.buf.writeUInt16LE(e, this.length), - (this.length += 2); - } - writeU32(e) { - this.maybeResize(), - this.buf.writeUInt32LE(e, this.length), - (this.length += 4); - } - writeU64(e) { - this.maybeResize(), - this.writeBuffer(Buffer.from(new S2.default(e).toArray("le", 8))); - } - writeU128(e) { - this.maybeResize(), - this.writeBuffer(Buffer.from(new S2.default(e).toArray("le", 16))); - } - writeU256(e) { - this.maybeResize(), - this.writeBuffer(Buffer.from(new S2.default(e).toArray("le", 32))); - } - writeU512(e) { - this.maybeResize(), - this.writeBuffer(Buffer.from(new S2.default(e).toArray("le", 64))); - } - writeBuffer(e) { - (this.buf = Buffer.concat([ - Buffer.from(this.buf.subarray(0, this.length)), - e, - Buffer.alloc(y1e), - ])), - (this.length += e.length); - } - writeString(e) { - this.maybeResize(); - let r = Buffer.from(e, "utf8"); - this.writeU32(r.length), this.writeBuffer(r); - } - writeFixedArray(e) { - this.writeBuffer(Buffer.from(e)); - } - writeArray(e, r) { - this.maybeResize(), this.writeU32(e.length); - for (let n of e) this.maybeResize(), r(n); - } - toArray() { - return this.buf.subarray(0, this.length); - } - }; - uo.BinaryWriter = jX; - function Av(t, e, r) { - let n = r.value; - r.value = function (...i) { - try { - return n.apply(this, i); - } catch (o) { - if (o instanceof RangeError) { - let a = o.code; - if ( - ["ERR_BUFFER_OUT_OF_BOUNDS", "ERR_OUT_OF_RANGE"].indexOf(a) >= 0 - ) - throw new rc("Reached the end of buffer when deserializing"); - } - throw o; - } - }; - } - var Kd = class { - constructor(e) { - (this.buf = e), (this.offset = 0); - } - readU8() { - let e = this.buf.readUInt8(this.offset); - return (this.offset += 1), e; - } - readU16() { - let e = this.buf.readUInt16LE(this.offset); - return (this.offset += 2), e; - } - readU32() { - let e = this.buf.readUInt32LE(this.offset); - return (this.offset += 4), e; - } - readU64() { - let e = this.readBuffer(8); - return new S2.default(e, "le"); - } - readU128() { - let e = this.readBuffer(16); - return new S2.default(e, "le"); - } - readU256() { - let e = this.readBuffer(32); - return new S2.default(e, "le"); - } - readU512() { - let e = this.readBuffer(64); - return new S2.default(e, "le"); - } - readBuffer(e) { - if (this.offset + e > this.buf.length) - throw new rc(`Expected buffer length ${e} isn't within bounds`); - let r = this.buf.slice(this.offset, this.offset + e); - return (this.offset += e), r; - } - readString() { - let e = this.readU32(), - r = this.readBuffer(e); - try { - return Ztr.decode(r); - } catch (n) { - throw new rc(`Error decoding UTF-8 string: ${n}`); - } - } - readFixedArray(e) { - return new Uint8Array(this.readBuffer(e)); - } - readArray(e) { - let r = this.readU32(), - n = Array(); - for (let i = 0; i < r; ++i) n.push(e()); - return n; - } - }; - Sv([Av], Kd.prototype, "readU8", null); - Sv([Av], Kd.prototype, "readU16", null); - Sv([Av], Kd.prototype, "readU32", null); - Sv([Av], Kd.prototype, "readU64", null); - Sv([Av], Kd.prototype, "readU128", null); - Sv([Av], Kd.prototype, "readU256", null); - Sv([Av], Kd.prototype, "readU512", null); - Sv([Av], Kd.prototype, "readString", null); - Sv([Av], Kd.prototype, "readFixedArray", null); - Sv([Av], Kd.prototype, "readArray", null); - uo.BinaryReader = Kd; - function o$e(t) { - return t.charAt(0).toUpperCase() + t.slice(1); - } - function zM(t, e, r, n, i) { - try { - if (typeof n == "string") i[`write${o$e(n)}`](r); - else if (n instanceof Array) - if (typeof n[0] == "number") { - if (r.length !== n[0]) - throw new rc( - `Expecting byte array of length ${n[0]}, but got ${r.length} bytes` - ); - i.writeFixedArray(r); - } else if (n.length === 2 && typeof n[1] == "number") { - if (r.length !== n[1]) - throw new rc( - `Expecting byte array of length ${n[1]}, but got ${r.length} bytes` - ); - for (let o = 0; o < n[1]; o++) zM(t, null, r[o], n[0], i); - } else - i.writeArray(r, (o) => { - zM(t, e, o, n[0], i); - }); - else if (n.kind !== void 0) - switch (n.kind) { - case "option": { - r == null ? i.writeU8(0) : (i.writeU8(1), zM(t, e, r, n.type, i)); - break; - } - case "map": { - i.writeU32(r.size), - r.forEach((o, a) => { - zM(t, e, a, n.key, i), zM(t, e, o, n.value, i); - }); - break; - } - default: - throw new rc(`FieldType ${n} unrecognized`); - } - else a$e(t, r, i); - } catch (o) { - throw (o instanceof rc && o.addToFieldPath(e), o); - } - } - function a$e(t, e, r) { - if (typeof e.borshSerialize == "function") { - e.borshSerialize(r); - return; - } - let n = t.get(e.constructor); - if (!n) throw new rc(`Class ${e.constructor.name} is missing in schema`); - if (n.kind === "struct") - n.fields.map(([i, o]) => { - zM(t, i, e[i], o, r); - }); - else if (n.kind === "enum") { - let i = e[n.field]; - for (let o = 0; o < n.values.length; ++o) { - let [a, s] = n.values[o]; - if (a === i) { - r.writeU8(o), zM(t, a, e[a], s, r); - break; - } - } - } else - throw new rc( - `Unexpected schema kind: ${n.kind} for ${e.constructor.name}` - ); - } - function Qtr(t, e, r = jX) { - let n = new r(); - return a$e(t, e, n), n.toArray(); - } - uo.serialize = Qtr; - function jM(t, e, r, n) { - try { - if (typeof r == "string") return n[`read${o$e(r)}`](); - if (r instanceof Array) { - if (typeof r[0] == "number") return n.readFixedArray(r[0]); - if (typeof r[1] == "number") { - let i = []; - for (let o = 0; o < r[1]; o++) i.push(jM(t, null, r[0], n)); - return i; - } else return n.readArray(() => jM(t, e, r[0], n)); - } - if (r.kind === "option") - return n.readU8() ? jM(t, e, r.type, n) : void 0; - if (r.kind === "map") { - let i = new Map(), - o = n.readU32(); - for (let a = 0; a < o; a++) { - let s = jM(t, e, r.key, n), - c = jM(t, e, r.value, n); - i.set(s, c); - } - return i; - } - return m1e(t, r, n); - } catch (i) { - throw (i instanceof rc && i.addToFieldPath(e), i); - } - } - function m1e(t, e, r) { - if (typeof e.borshDeserialize == "function") return e.borshDeserialize(r); - let n = t.get(e); - if (!n) throw new rc(`Class ${e.name} is missing in schema`); - if (n.kind === "struct") { - let i = {}; - for (let [o, a] of t.get(e).fields) i[o] = jM(t, o, a, r); - return new e(i); - } - if (n.kind === "enum") { - let i = r.readU8(); - if (i >= n.values.length) - throw new rc(`Enum index: ${i} is out of range`); - let [o, a] = n.values[i], - s = jM(t, o, a, r); - return new e({ [o]: s }); - } - throw new rc( - `Unexpected schema kind: ${n.kind} for ${e.constructor.name}` - ); - } - function err(t, e, r, n = Kd) { - let i = new n(r), - o = m1e(t, e, i); - if (i.offset < r.length) - throw new rc( - `Unexpected ${r.length - i.offset} bytes after deserialized data` - ); - return o; - } - uo.deserialize = err; - function trr(t, e, r, n = Kd) { - let i = new n(r); - return m1e(t, e, i); - } - uo.deserializeUnchecked = trr; - }); - var Sn = I((st) => { - "use strict"; - m(); - g(); - Object.defineProperty(st, "__esModule", { value: !0 }); - st.s16 = - st.s8 = - st.nu64be = - st.u48be = - st.u40be = - st.u32be = - st.u24be = - st.u16be = - st.nu64 = - st.u48 = - st.u40 = - st.u32 = - st.u24 = - st.u16 = - st.u8 = - st.offset = - st.greedy = - st.Constant = - st.UTF8 = - st.CString = - st.Blob = - st.Boolean = - st.BitField = - st.BitStructure = - st.VariantLayout = - st.Union = - st.UnionLayoutDiscriminator = - st.UnionDiscriminator = - st.Structure = - st.Sequence = - st.DoubleBE = - st.Double = - st.FloatBE = - st.Float = - st.NearInt64BE = - st.NearInt64 = - st.NearUInt64BE = - st.NearUInt64 = - st.IntBE = - st.Int = - st.UIntBE = - st.UInt = - st.OffsetLayout = - st.GreedyCount = - st.ExternalLayout = - st.bindConstructorLayout = - st.nameWithProperty = - st.Layout = - st.uint8ArrayToBuffer = - st.checkUint8Array = - void 0; - st.constant = - st.utf8 = - st.cstr = - st.blob = - st.unionLayoutDiscriminator = - st.union = - st.seq = - st.bits = - st.struct = - st.f64be = - st.f64 = - st.f32be = - st.f32 = - st.ns64be = - st.s48be = - st.s40be = - st.s32be = - st.s24be = - st.s16be = - st.ns64 = - st.s48 = - st.s40 = - st.s32 = - st.s24 = - void 0; - var v1e = Qr(); - function Q5(t) { - if (!(t instanceof Uint8Array)) - throw new TypeError("b must be a Uint8Array"); - } - st.checkUint8Array = Q5; - function Pi(t) { - return Q5(t), v1e.Buffer.from(t.buffer, t.byteOffset, t.length); - } - st.uint8ArrayToBuffer = Pi; - var zi = class { - constructor(e, r) { - if (!Number.isInteger(e)) - throw new TypeError("span must be an integer"); - (this.span = e), (this.property = r); - } - makeDestinationObject() { - return {}; - } - getSpan(e, r) { - if (0 > this.span) throw new RangeError("indeterminate span"); - return this.span; - } - replicate(e) { - let r = Object.create(this.constructor.prototype); - return Object.assign(r, this), (r.property = e), r; - } - fromArray(e) {} - }; - st.Layout = zi; - function b1e(t, e) { - return e.property ? t + "[" + e.property + "]" : t; - } - st.nameWithProperty = b1e; - function rrr(t, e) { - if (typeof t != "function") - throw new TypeError("Class must be constructor"); - if (Object.prototype.hasOwnProperty.call(t, "layout_")) - throw new Error("Class is already bound to a layout"); - if (!(e && e instanceof zi)) - throw new TypeError("layout must be a Layout"); - if (Object.prototype.hasOwnProperty.call(e, "boundConstructor_")) - throw new Error("layout is already bound to a constructor"); - (t.layout_ = e), - (e.boundConstructor_ = t), - (e.makeDestinationObject = () => new t()), - Object.defineProperty(t.prototype, "encode", { - value(r, n) { - return e.encode(this, r, n); - }, - writable: !0, - }), - Object.defineProperty(t, "decode", { - value(r, n) { - return e.decode(r, n); - }, - writable: !0, - }); - } - st.bindConstructorLayout = rrr; - var jc = class extends zi { - isCount() { - throw new Error("ExternalLayout is abstract"); - } - }; - st.ExternalLayout = jc; - var UX = class extends jc { - constructor(e = 1, r) { - if (!Number.isInteger(e) || 0 >= e) - throw new TypeError("elementSpan must be a (positive) integer"); - super(-1, r), (this.elementSpan = e); - } - isCount() { - return !0; - } - decode(e, r = 0) { - Q5(e); - let n = e.length - r; - return Math.floor(n / this.elementSpan); - } - encode(e, r, n) { - return 0; - } - }; - st.GreedyCount = UX; - var ez = class extends jc { - constructor(e, r = 0, n) { - if (!(e instanceof zi)) throw new TypeError("layout must be a Layout"); - if (!Number.isInteger(r)) - throw new TypeError("offset must be integer or undefined"); - super(e.span, n || e.property), (this.layout = e), (this.offset = r); - } - isCount() { - return this.layout instanceof Ih || this.layout instanceof Lp; - } - decode(e, r = 0) { - return this.layout.decode(e, r + this.offset); - } - encode(e, r, n = 0) { - return this.layout.encode(e, r, n + this.offset); - } - }; - st.OffsetLayout = ez; - var Ih = class extends zi { - constructor(e, r) { - if ((super(e, r), 6 < this.span)) - throw new RangeError("span must not exceed 6 bytes"); - } - decode(e, r = 0) { - return Pi(e).readUIntLE(r, this.span); - } - encode(e, r, n = 0) { - return Pi(r).writeUIntLE(e, n, this.span), this.span; - } - }; - st.UInt = Ih; - var Lp = class extends zi { - constructor(e, r) { - if ((super(e, r), 6 < this.span)) - throw new RangeError("span must not exceed 6 bytes"); - } - decode(e, r = 0) { - return Pi(e).readUIntBE(r, this.span); - } - encode(e, r, n = 0) { - return Pi(r).writeUIntBE(e, n, this.span), this.span; - } - }; - st.UIntBE = Lp; - var z_ = class extends zi { - constructor(e, r) { - if ((super(e, r), 6 < this.span)) - throw new RangeError("span must not exceed 6 bytes"); - } - decode(e, r = 0) { - return Pi(e).readIntLE(r, this.span); - } - encode(e, r, n = 0) { - return Pi(r).writeIntLE(e, n, this.span), this.span; - } - }; - st.Int = z_; - var A2 = class extends zi { - constructor(e, r) { - if ((super(e, r), 6 < this.span)) - throw new RangeError("span must not exceed 6 bytes"); - } - decode(e, r = 0) { - return Pi(e).readIntBE(r, this.span); - } - encode(e, r, n = 0) { - return Pi(r).writeIntBE(e, n, this.span), this.span; - } - }; - st.IntBE = A2; - var g1e = Math.pow(2, 32); - function oY(t) { - let e = Math.floor(t / g1e), - r = t - e * g1e; - return { hi32: e, lo32: r }; - } - function aY(t, e) { - return t * g1e + e; - } - var KX = class extends zi { - constructor(e) { - super(8, e); - } - decode(e, r = 0) { - let n = Pi(e), - i = n.readUInt32LE(r), - o = n.readUInt32LE(r + 4); - return aY(o, i); - } - encode(e, r, n = 0) { - let i = oY(e), - o = Pi(r); - return o.writeUInt32LE(i.lo32, n), o.writeUInt32LE(i.hi32, n + 4), 8; - } - }; - st.NearUInt64 = KX; - var HX = class extends zi { - constructor(e) { - super(8, e); - } - decode(e, r = 0) { - let n = Pi(e), - i = n.readUInt32BE(r), - o = n.readUInt32BE(r + 4); - return aY(i, o); - } - encode(e, r, n = 0) { - let i = oY(e), - o = Pi(r); - return o.writeUInt32BE(i.hi32, n), o.writeUInt32BE(i.lo32, n + 4), 8; - } - }; - st.NearUInt64BE = HX; - var VX = class extends zi { - constructor(e) { - super(8, e); - } - decode(e, r = 0) { - let n = Pi(e), - i = n.readUInt32LE(r), - o = n.readInt32LE(r + 4); - return aY(o, i); - } - encode(e, r, n = 0) { - let i = oY(e), - o = Pi(r); - return o.writeUInt32LE(i.lo32, n), o.writeInt32LE(i.hi32, n + 4), 8; - } - }; - st.NearInt64 = VX; - var WX = class extends zi { - constructor(e) { - super(8, e); - } - decode(e, r = 0) { - let n = Pi(e), - i = n.readInt32BE(r), - o = n.readUInt32BE(r + 4); - return aY(i, o); - } - encode(e, r, n = 0) { - let i = oY(e), - o = Pi(r); - return o.writeInt32BE(i.hi32, n), o.writeUInt32BE(i.lo32, n + 4), 8; - } - }; - st.NearInt64BE = WX; - var GX = class extends zi { - constructor(e) { - super(4, e); - } - decode(e, r = 0) { - return Pi(e).readFloatLE(r); - } - encode(e, r, n = 0) { - return Pi(r).writeFloatLE(e, n), 4; - } - }; - st.Float = GX; - var JX = class extends zi { - constructor(e) { - super(4, e); - } - decode(e, r = 0) { - return Pi(e).readFloatBE(r); - } - encode(e, r, n = 0) { - return Pi(r).writeFloatBE(e, n), 4; - } - }; - st.FloatBE = JX; - var $X = class extends zi { - constructor(e) { - super(8, e); - } - decode(e, r = 0) { - return Pi(e).readDoubleLE(r); - } - encode(e, r, n = 0) { - return Pi(r).writeDoubleLE(e, n), 8; - } - }; - st.Double = $X; - var ZX = class extends zi { - constructor(e) { - super(8, e); - } - decode(e, r = 0) { - return Pi(e).readDoubleBE(r); - } - encode(e, r, n = 0) { - return Pi(r).writeDoubleBE(e, n), 8; - } - }; - st.DoubleBE = ZX; - var XX = class extends zi { - constructor(e, r, n) { - if (!(e instanceof zi)) - throw new TypeError("elementLayout must be a Layout"); - if ( - !((r instanceof jc && r.isCount()) || (Number.isInteger(r) && 0 <= r)) - ) - throw new TypeError( - "count must be non-negative integer or an unsigned integer ExternalLayout" - ); - let i = -1; - !(r instanceof jc) && 0 < e.span && (i = r * e.span), - super(i, n), - (this.elementLayout = e), - (this.count = r); - } - getSpan(e, r = 0) { - if (0 <= this.span) return this.span; - let n = 0, - i = this.count; - if ( - (i instanceof jc && (i = i.decode(e, r)), 0 < this.elementLayout.span) - ) - n = i * this.elementLayout.span; - else { - let o = 0; - for (; o < i; ) (n += this.elementLayout.getSpan(e, r + n)), ++o; - } - return n; - } - decode(e, r = 0) { - let n = [], - i = 0, - o = this.count; - for (o instanceof jc && (o = o.decode(e, r)); i < o; ) - n.push(this.elementLayout.decode(e, r)), - (r += this.elementLayout.getSpan(e, r)), - (i += 1); - return n; - } - encode(e, r, n = 0) { - let i = this.elementLayout, - o = e.reduce((a, s) => a + i.encode(s, r, n + a), 0); - return this.count instanceof jc && this.count.encode(e.length, r, n), o; - } - }; - st.Sequence = XX; - var YX = class extends zi { - constructor(e, r, n) { - if (!(Array.isArray(e) && e.reduce((o, a) => o && a instanceof zi, !0))) - throw new TypeError("fields must be array of Layout instances"); - typeof r == "boolean" && n === void 0 && ((n = r), (r = void 0)); - for (let o of e) - if (0 > o.span && o.property === void 0) - throw new Error( - "fields cannot contain unnamed variable-length layout" - ); - let i = -1; - try { - i = e.reduce((o, a) => o + a.getSpan(), 0); - } catch {} - super(i, r), (this.fields = e), (this.decodePrefixes = !!n); - } - getSpan(e, r = 0) { - if (0 <= this.span) return this.span; - let n = 0; - try { - n = this.fields.reduce((i, o) => { - let a = o.getSpan(e, r); - return (r += a), i + a; - }, 0); - } catch { - throw new RangeError("indeterminate span"); - } - return n; - } - decode(e, r = 0) { - Q5(e); - let n = this.makeDestinationObject(); - for (let i of this.fields) - if ( - (i.property !== void 0 && (n[i.property] = i.decode(e, r)), - (r += i.getSpan(e, r)), - this.decodePrefixes && e.length === r) - ) - break; - return n; - } - encode(e, r, n = 0) { - let i = n, - o = 0, - a = 0; - for (let s of this.fields) { - let c = s.span; - if (((a = 0 < c ? c : 0), s.property !== void 0)) { - let u = e[s.property]; - u !== void 0 && - ((a = s.encode(u, r, n)), 0 > c && (c = s.getSpan(r, n))); - } - (o = n), (n += c); - } - return o + a - i; - } - fromArray(e) { - let r = this.makeDestinationObject(); - for (let n of this.fields) - n.property !== void 0 && 0 < e.length && (r[n.property] = e.shift()); - return r; - } - layoutFor(e) { - if (typeof e != "string") - throw new TypeError("property must be string"); - for (let r of this.fields) if (r.property === e) return r; - } - offsetOf(e) { - if (typeof e != "string") - throw new TypeError("property must be string"); - let r = 0; - for (let n of this.fields) { - if (n.property === e) return r; - 0 > n.span ? (r = -1) : 0 <= r && (r += n.span); - } - } - }; - st.Structure = YX; - var tz = class { - constructor(e) { - this.property = e; - } - decode(e, r) { - throw new Error("UnionDiscriminator is abstract"); - } - encode(e, r, n) { - throw new Error("UnionDiscriminator is abstract"); - } - }; - st.UnionDiscriminator = tz; - var Y5 = class extends tz { - constructor(e, r) { - if (!(e instanceof jc && e.isCount())) - throw new TypeError( - "layout must be an unsigned integer ExternalLayout" - ); - super(r || e.property || "variant"), (this.layout = e); - } - decode(e, r) { - return this.layout.decode(e, r); - } - encode(e, r, n) { - return this.layout.encode(e, r, n); - } - }; - st.UnionLayoutDiscriminator = Y5; - var rz = class extends zi { - constructor(e, r, n) { - let i; - if (e instanceof Ih || e instanceof Lp) i = new Y5(new ez(e)); - else if (e instanceof jc && e.isCount()) i = new Y5(e); - else if (e instanceof tz) i = e; - else - throw new TypeError( - "discr must be a UnionDiscriminator or an unsigned integer layout" - ); - if ((r === void 0 && (r = null), !(r === null || r instanceof zi))) - throw new TypeError("defaultLayout must be null or a Layout"); - if (r !== null) { - if (0 > r.span) - throw new Error("defaultLayout must have constant span"); - r.property === void 0 && (r = r.replicate("content")); - } - let o = -1; - r && - ((o = r.span), - 0 <= o && - (e instanceof Ih || e instanceof Lp) && - (o += i.layout.span)), - super(o, n), - (this.discriminator = i), - (this.usesPrefixDiscriminator = e instanceof Ih || e instanceof Lp), - (this.defaultLayout = r), - (this.registry = {}); - let a = this.defaultGetSourceVariant.bind(this); - (this.getSourceVariant = function (s) { - return a(s); - }), - (this.configGetSourceVariant = function (s) { - a = s.bind(this); - }); - } - getSpan(e, r = 0) { - if (0 <= this.span) return this.span; - let n = this.getVariant(e, r); - if (!n) - throw new Error("unable to determine span for unrecognized variant"); - return n.getSpan(e, r); - } - defaultGetSourceVariant(e) { - if ( - Object.prototype.hasOwnProperty.call(e, this.discriminator.property) - ) { - if ( - this.defaultLayout && - this.defaultLayout.property && - Object.prototype.hasOwnProperty.call(e, this.defaultLayout.property) - ) - return; - let r = this.registry[e[this.discriminator.property]]; - if ( - r && - (!r.layout || - (r.property && - Object.prototype.hasOwnProperty.call(e, r.property))) - ) - return r; - } else - for (let r in this.registry) { - let n = this.registry[r]; - if ( - n.property && - Object.prototype.hasOwnProperty.call(e, n.property) - ) - return n; - } - throw new Error("unable to infer src variant"); - } - decode(e, r = 0) { - let n, - i = this.discriminator, - o = i.decode(e, r), - a = this.registry[o]; - if (a === void 0) { - let s = this.defaultLayout, - c = 0; - this.usesPrefixDiscriminator && (c = i.layout.span), - (n = this.makeDestinationObject()), - (n[i.property] = o), - (n[s.property] = s.decode(e, r + c)); - } else n = a.decode(e, r); - return n; - } - encode(e, r, n = 0) { - let i = this.getSourceVariant(e); - if (i === void 0) { - let o = this.discriminator, - a = this.defaultLayout, - s = 0; - return ( - this.usesPrefixDiscriminator && (s = o.layout.span), - o.encode(e[o.property], r, n), - s + a.encode(e[a.property], r, n + s) - ); - } - return i.encode(e, r, n); - } - addVariant(e, r, n) { - let i = new QX(this, e, r, n); - return (this.registry[e] = i), i; - } - getVariant(e, r = 0) { - let n; - return ( - e instanceof Uint8Array - ? (n = this.discriminator.decode(e, r)) - : (n = e), - this.registry[n] - ); - } - }; - st.Union = rz; - var QX = class extends zi { - constructor(e, r, n, i) { - if (!(e instanceof rz)) throw new TypeError("union must be a Union"); - if (!Number.isInteger(r) || 0 > r) - throw new TypeError("variant must be a (non-negative) integer"); - if ( - (typeof n == "string" && i === void 0 && ((i = n), (n = null)), n) - ) { - if (!(n instanceof zi)) - throw new TypeError("layout must be a Layout"); - if ( - e.defaultLayout !== null && - 0 <= n.span && - n.span > e.defaultLayout.span - ) - throw new Error("variant span exceeds span of containing union"); - if (typeof i != "string") - throw new TypeError("variant must have a String property"); - } - let o = e.span; - 0 > e.span && - ((o = n ? n.span : 0), - 0 <= o && - e.usesPrefixDiscriminator && - (o += e.discriminator.layout.span)), - super(o, i), - (this.union = e), - (this.variant = r), - (this.layout = n || null); - } - getSpan(e, r = 0) { - if (0 <= this.span) return this.span; - let n = 0; - this.union.usesPrefixDiscriminator && - (n = this.union.discriminator.layout.span); - let i = 0; - return this.layout && (i = this.layout.getSpan(e, r + n)), n + i; - } - decode(e, r = 0) { - let n = this.makeDestinationObject(); - if (this !== this.union.getVariant(e, r)) - throw new Error("variant mismatch"); - let i = 0; - return ( - this.union.usesPrefixDiscriminator && - (i = this.union.discriminator.layout.span), - this.layout - ? (n[this.property] = this.layout.decode(e, r + i)) - : this.property - ? (n[this.property] = !0) - : this.union.usesPrefixDiscriminator && - (n[this.union.discriminator.property] = this.variant), - n - ); - } - encode(e, r, n = 0) { - let i = 0; - if ( - (this.union.usesPrefixDiscriminator && - (i = this.union.discriminator.layout.span), - this.layout && - !Object.prototype.hasOwnProperty.call(e, this.property)) - ) - throw new TypeError("variant lacks property " + this.property); - this.union.discriminator.encode(this.variant, r, n); - let o = i; - if ( - this.layout && - (this.layout.encode(e[this.property], r, n + i), - (o += this.layout.getSpan(r, n + i)), - 0 <= this.union.span && o > this.union.span) - ) - throw new Error("encoded variant overruns containing union"); - return o; - } - fromArray(e) { - if (this.layout) return this.layout.fromArray(e); - } - }; - st.VariantLayout = QX; - function X5(t) { - return 0 > t && (t += 4294967296), t; - } - var nz = class extends zi { - constructor(e, r, n) { - if (!(e instanceof Ih || e instanceof Lp)) - throw new TypeError("word must be a UInt or UIntBE layout"); - if ( - (typeof r == "string" && n === void 0 && ((n = r), (r = !1)), - 4 < e.span) - ) - throw new RangeError("word cannot exceed 32 bits"); - super(e.span, n), (this.word = e), (this.msb = !!r), (this.fields = []); - let i = 0; - (this._packedSetValue = function (o) { - return (i = X5(o)), this; - }), - (this._packedGetValue = function () { - return i; - }); - } - decode(e, r = 0) { - let n = this.makeDestinationObject(), - i = this.word.decode(e, r); - this._packedSetValue(i); - for (let o of this.fields) - o.property !== void 0 && (n[o.property] = o.decode(e)); - return n; - } - encode(e, r, n = 0) { - let i = this.word.decode(r, n); - this._packedSetValue(i); - for (let o of this.fields) - if (o.property !== void 0) { - let a = e[o.property]; - a !== void 0 && o.encode(a); - } - return this.word.encode(this._packedGetValue(), r, n); - } - addField(e, r) { - let n = new iz(this, e, r); - return this.fields.push(n), n; - } - addBoolean(e) { - let r = new eY(this, e); - return this.fields.push(r), r; - } - fieldFor(e) { - if (typeof e != "string") - throw new TypeError("property must be string"); - for (let r of this.fields) if (r.property === e) return r; - } - }; - st.BitStructure = nz; - var iz = class { - constructor(e, r, n) { - if (!(e instanceof nz)) - throw new TypeError("container must be a BitStructure"); - if (!Number.isInteger(r) || 0 >= r) - throw new TypeError("bits must be positive integer"); - let i = 8 * e.span, - o = e.fields.reduce((a, s) => a + s.bits, 0); - if (r + o > i) - throw new Error( - "bits too long for span remainder (" + - (i - o) + - " of " + - i + - " remain)" - ); - (this.container = e), - (this.bits = r), - (this.valueMask = (1 << r) - 1), - r === 32 && (this.valueMask = 4294967295), - (this.start = o), - this.container.msb && (this.start = i - o - r), - (this.wordMask = X5(this.valueMask << this.start)), - (this.property = n); - } - decode(e, r) { - let n = this.container._packedGetValue(); - return X5(n & this.wordMask) >>> this.start; - } - encode(e) { - if ( - typeof e != "number" || - !Number.isInteger(e) || - e !== X5(e & this.valueMask) - ) - throw new TypeError( - b1e("BitField.encode", this) + - " value must be integer not exceeding " + - this.valueMask - ); - let r = this.container._packedGetValue(), - n = X5(e << this.start); - this.container._packedSetValue(X5(r & ~this.wordMask) | n); - } - }; - st.BitField = iz; - var eY = class extends iz { - constructor(e, r) { - super(e, 1, r); - } - decode(e, r) { - return !!super.decode(e, r); - } - encode(e) { - typeof e == "boolean" && (e = +e), super.encode(e); - } - }; - st.Boolean = eY; - var tY = class extends zi { - constructor(e, r) { - if ( - !((e instanceof jc && e.isCount()) || (Number.isInteger(e) && 0 <= e)) - ) - throw new TypeError( - "length must be positive integer or an unsigned integer ExternalLayout" - ); - let n = -1; - e instanceof jc || (n = e), super(n, r), (this.length = e); - } - getSpan(e, r) { - let n = this.span; - return 0 > n && (n = this.length.decode(e, r)), n; - } - decode(e, r = 0) { - let n = this.span; - return 0 > n && (n = this.length.decode(e, r)), Pi(e).slice(r, r + n); - } - encode(e, r, n) { - let i = this.length; - if ( - (this.length instanceof jc && (i = e.length), - !(e instanceof Uint8Array && i === e.length)) - ) - throw new TypeError( - b1e("Blob.encode", this) + - " requires (length " + - i + - ") Uint8Array as src" - ); - if (n + i > r.length) - throw new RangeError("encoding overruns Uint8Array"); - let o = Pi(e); - return ( - Pi(r).write(o.toString("hex"), n, i, "hex"), - this.length instanceof jc && this.length.encode(i, r, n), - i - ); - } - }; - st.Blob = tY; - var rY = class extends zi { - constructor(e) { - super(-1, e); - } - getSpan(e, r = 0) { - Q5(e); - let n = r; - for (; n < e.length && e[n] !== 0; ) n += 1; - return 1 + n - r; - } - decode(e, r = 0) { - let n = this.getSpan(e, r); - return Pi(e) - .slice(r, r + n - 1) - .toString("utf-8"); - } - encode(e, r, n = 0) { - typeof e != "string" && (e = String(e)); - let i = v1e.Buffer.from(e, "utf8"), - o = i.length; - if (n + o > r.length) throw new RangeError("encoding overruns Buffer"); - let a = Pi(r); - return i.copy(a, n), (a[n + o] = 0), o + 1; - } - }; - st.CString = rY; - var nY = class extends zi { - constructor(e, r) { - if ( - (typeof e == "string" && r === void 0 && ((r = e), (e = void 0)), - e === void 0) - ) - e = -1; - else if (!Number.isInteger(e)) - throw new TypeError("maxSpan must be an integer"); - super(-1, r), (this.maxSpan = e); - } - getSpan(e, r = 0) { - return Q5(e), e.length - r; - } - decode(e, r = 0) { - let n = this.getSpan(e, r); - if (0 <= this.maxSpan && this.maxSpan < n) - throw new RangeError("text length exceeds maxSpan"); - return Pi(e) - .slice(r, r + n) - .toString("utf-8"); - } - encode(e, r, n = 0) { - typeof e != "string" && (e = String(e)); - let i = v1e.Buffer.from(e, "utf8"), - o = i.length; - if (0 <= this.maxSpan && this.maxSpan < o) - throw new RangeError("text length exceeds maxSpan"); - if (n + o > r.length) throw new RangeError("encoding overruns Buffer"); - return i.copy(Pi(r), n), o; - } - }; - st.UTF8 = nY; - var iY = class extends zi { - constructor(e, r) { - super(0, r), (this.value = e); - } - decode(e, r) { - return this.value; - } - encode(e, r, n) { - return 0; - } - }; - st.Constant = iY; - st.greedy = (t, e) => new UX(t, e); - st.offset = (t, e, r) => new ez(t, e, r); - st.u8 = (t) => new Ih(1, t); - st.u16 = (t) => new Ih(2, t); - st.u24 = (t) => new Ih(3, t); - st.u32 = (t) => new Ih(4, t); - st.u40 = (t) => new Ih(5, t); - st.u48 = (t) => new Ih(6, t); - st.nu64 = (t) => new KX(t); - st.u16be = (t) => new Lp(2, t); - st.u24be = (t) => new Lp(3, t); - st.u32be = (t) => new Lp(4, t); - st.u40be = (t) => new Lp(5, t); - st.u48be = (t) => new Lp(6, t); - st.nu64be = (t) => new HX(t); - st.s8 = (t) => new z_(1, t); - st.s16 = (t) => new z_(2, t); - st.s24 = (t) => new z_(3, t); - st.s32 = (t) => new z_(4, t); - st.s40 = (t) => new z_(5, t); - st.s48 = (t) => new z_(6, t); - st.ns64 = (t) => new VX(t); - st.s16be = (t) => new A2(2, t); - st.s24be = (t) => new A2(3, t); - st.s32be = (t) => new A2(4, t); - st.s40be = (t) => new A2(5, t); - st.s48be = (t) => new A2(6, t); - st.ns64be = (t) => new WX(t); - st.f32 = (t) => new GX(t); - st.f32be = (t) => new JX(t); - st.f64 = (t) => new $X(t); - st.f64be = (t) => new ZX(t); - st.struct = (t, e, r) => new YX(t, e, r); - st.bits = (t, e, r) => new nz(t, e, r); - st.seq = (t, e, r) => new XX(t, e, r); - st.union = (t, e, r) => new rz(t, e, r); - st.unionLayoutDiscriminator = (t, e) => new Y5(t, e); - st.blob = (t, e) => new tY(t, e); - st.cstr = (t) => new rY(t); - st.utf8 = (t, e) => new nY(t, e); - st.constant = (t, e) => new iY(t, e); - }); - var uY = I((eC) => { - "use strict"; - m(); - g(); - Object.defineProperty(eC, "__esModule", { value: !0 }); - var sY; - function nrr(t) { - { - let e = Buffer.from(t); - e.reverse(); - let r = e.toString("hex"); - return r.length === 0 ? BigInt(0) : BigInt(`0x${r}`); - } - return sY.toBigInt(t, !1); - } - eC.toBigIntLE = nrr; - function irr(t) { - { - let e = t.toString("hex"); - return e.length === 0 ? BigInt(0) : BigInt(`0x${e}`); - } - return sY.toBigInt(t, !0); - } - eC.toBigIntBE = irr; - function orr(t, e) { - { - let r = t.toString(16), - n = Buffer.from(r.padStart(e * 2, "0").slice(0, e * 2), "hex"); - return n.reverse(), n; - } - return sY.fromBigInt(t, Buffer.allocUnsafe(e), !1); - } - eC.toBufferLE = orr; - function arr(t, e) { - { - let r = t.toString(16); - return Buffer.from(r.padStart(e * 2, "0").slice(0, e * 2), "hex"); - } - return sY.fromBigInt(t, Buffer.allocUnsafe(e), !0); - } - eC.toBufferBE = arr; - }); - var y$e = I((Or) => { - "use strict"; - m(); - g(); - Object.defineProperty(Or, "__esModule", { value: !0 }); - var cY = class extends TypeError { - constructor(e, r) { - let n, - { message: i, ...o } = e, - { path: a } = e, - s = a.length === 0 ? i : "At path: " + a.join(".") + " -- " + i; - super(s), - Object.assign(this, o), - (this.name = this.constructor.name), - (this.failures = () => { - var c; - return (c = n) != null ? c : (n = [e, ...r()]); - }); - } - }; - function srr(t) { - return Jm(t) && typeof t[Symbol.iterator] == "function"; - } - function Jm(t) { - return typeof t == "object" && t != null; - } - function u$e(t) { - if (Object.prototype.toString.call(t) !== "[object Object]") return !1; - let e = Object.getPrototypeOf(t); - return e === null || e === Object.prototype; - } - function Ws(t) { - return typeof t == "string" ? JSON.stringify(t) : "" + t; - } - function urr(t) { - let { done: e, value: r } = t.next(); - return e ? void 0 : r; - } - function crr(t, e, r, n) { - if (t === !0) return; - t === !1 ? (t = {}) : typeof t == "string" && (t = { message: t }); - let { path: i, branch: o } = e, - { type: a } = r, - { - refinement: s, - message: c = "Expected a value of type `" + - a + - "`" + - (s ? " with refinement `" + s + "`" : "") + - ", but received: `" + - Ws(n) + - "`", - } = t; - return { - value: n, - type: a, - refinement: s, - key: i[i.length - 1], - path: i, - branch: o, - ...t, - message: c, - }; - } - function* w1e(t, e, r, n) { - srr(t) || (t = [t]); - for (let i of t) { - let o = crr(i, e, r, n); - o && (yield o); - } - } - function* _1e(t, e, r = {}) { - let { path: n = [], branch: i = [t], coerce: o = !1, mask: a = !1 } = r, - s = { path: n, branch: i }; - if ( - o && - ((t = e.coercer(t, s)), - a && e.type !== "type" && Jm(e.schema) && Jm(t) && !Array.isArray(t)) - ) - for (let u in t) e.schema[u] === void 0 && delete t[u]; - let c = !0; - for (let u of e.validator(t, s)) (c = !1), yield [u, void 0]; - for (let [u, h, w] of e.entries(t, s)) { - let M = _1e(h, w, { - path: u === void 0 ? n : [...n, u], - branch: u === void 0 ? i : [...i, h], - coerce: o, - mask: a, - }); - for (let k of M) - k[0] - ? ((c = !1), yield [k[0], void 0]) - : o && - ((h = k[1]), - u === void 0 - ? (t = h) - : t instanceof Map - ? t.set(u, h) - : t instanceof Set - ? t.add(h) - : Jm(t) && (t[u] = h)); - } - if (c) for (let u of e.refiner(t, s)) (c = !1), yield [u, void 0]; - c && (yield [void 0, t]); - } - var ma = class { - constructor(e) { - let { - type: r, - schema: n, - validator: i, - refiner: o, - coercer: a = (c) => c, - entries: s = function* () {}, - } = e; - (this.type = r), - (this.schema = n), - (this.entries = s), - (this.coercer = a), - i - ? (this.validator = (c, u) => { - let h = i(c, u); - return w1e(h, u, this, c); - }) - : (this.validator = () => []), - o - ? (this.refiner = (c, u) => { - let h = o(c, u); - return w1e(h, u, this, c); - }) - : (this.refiner = () => []); - } - assert(e) { - return c$e(e, this); - } - create(e) { - return l$e(e, this); - } - is(e) { - return x1e(e, this); - } - mask(e) { - return f$e(e, this); - } - validate(e, r = {}) { - return tC(e, this, r); - } - }; - function c$e(t, e) { - let r = tC(t, e); - if (r[0]) throw r[0]; - } - function l$e(t, e) { - let r = tC(t, e, { coerce: !0 }); - if (r[0]) throw r[0]; - return r[1]; - } - function f$e(t, e) { - let r = tC(t, e, { coerce: !0, mask: !0 }); - if (r[0]) throw r[0]; - return r[1]; - } - function x1e(t, e) { - return !tC(t, e)[0]; - } - function tC(t, e, r = {}) { - let n = _1e(t, e, r), - i = urr(n); - if (i[0]) - return [ - new cY(i[0], function* () { - for (let a of n) a[0] && (yield a[0]); - }), - void 0, - ]; - { - let o = i[1]; - return [void 0, o]; - } - } - function lrr(...t) { - let e = t.map((n) => n.schema), - r = Object.assign({}, ...e); - return oz(r); - } - function qp(t, e) { - return new ma({ type: t, schema: null, validator: e }); - } - function frr(t, e) { - return new ma({ - ...t, - refiner: (r, n) => r === void 0 || t.refiner(r, n), - validator(r, n) { - return r === void 0 ? !0 : (e(r, n), t.validator(r, n)); - }, - }); - } - function drr(t) { - return new ma({ - type: "dynamic", - schema: null, - *entries(e, r) { - yield* t(e, r).entries(e, r); - }, - validator(e, r) { - return t(e, r).validator(e, r); - }, - coercer(e, r) { - return t(e, r).coercer(e, r); - }, - }); - } - function hrr(t) { - let e; - return new ma({ - type: "lazy", - schema: null, - *entries(r, n) { - var i; - (i = e) != null || (e = t()), yield* e.entries(r, n); - }, - validator(r, n) { - var i; - return (i = e) != null || (e = t()), e.validator(r, n); - }, - coercer(r, n) { - var i; - return (i = e) != null || (e = t()), e.coercer(r, n); - }, - }); - } - function prr(t, e) { - let { schema: r } = t, - n = { ...r }; - for (let i of e) delete n[i]; - return oz(n); - } - function yrr(t) { - let e = t instanceof ma ? { ...t.schema } : { ...t }; - for (let r in e) e[r] = d$e(e[r]); - return oz(e); - } - function mrr(t, e) { - let { schema: r } = t, - n = {}; - for (let i of e) n[i] = r[i]; - return oz(n); - } - function grr(t, e) { - return ( - console.warn( - "superstruct@0.11 - The `struct` helper has been renamed to `define`." - ), - qp(t, e) - ); - } - function vrr() { - return qp("any", () => !0); - } - function brr(t) { - return new ma({ - type: "array", - schema: t, - *entries(e) { - if (t && Array.isArray(e)) - for (let [r, n] of e.entries()) yield [r, n, t]; - }, - coercer(e) { - return Array.isArray(e) ? e.slice() : e; - }, - validator(e) { - return ( - Array.isArray(e) || - "Expected an array value, but received: " + Ws(e) - ); - }, - }); - } - function wrr() { - return qp("boolean", (t) => typeof t == "boolean"); - } - function _rr() { - return qp( - "date", - (t) => - (t instanceof Date && !isNaN(t.getTime())) || - "Expected a valid `Date` object, but received: " + Ws(t) - ); - } - function xrr(t) { - let e = {}, - r = t.map((n) => Ws(n)).join(); - for (let n of t) e[n] = n; - return new ma({ - type: "enums", - schema: e, - validator(n) { - return ( - t.includes(n) || - "Expected one of `" + r + "`, but received: " + Ws(n) - ); - }, - }); - } - function Srr() { - return qp( - "func", - (t) => - typeof t == "function" || - "Expected a function, but received: " + Ws(t) - ); - } - function Arr(t) { - return qp( - "instance", - (e) => - e instanceof t || - "Expected a `" + t.name + "` instance, but received: " + Ws(e) - ); - } - function Err() { - return qp( - "integer", - (t) => - (typeof t == "number" && !isNaN(t) && Number.isInteger(t)) || - "Expected an integer, but received: " + Ws(t) - ); - } - function Mrr(t) { - return new ma({ - type: "intersection", - schema: null, - *entries(e, r) { - for (let n of t) yield* n.entries(e, r); - }, - *validator(e, r) { - for (let n of t) yield* n.validator(e, r); - }, - *refiner(e, r) { - for (let n of t) yield* n.refiner(e, r); - }, - }); - } - function Trr(t) { - let e = Ws(t), - r = typeof t; - return new ma({ - type: "literal", - schema: r === "string" || r === "number" || r === "boolean" ? t : null, - validator(n) { - return ( - n === t || - "Expected the literal `" + e + "`, but received: " + Ws(n) - ); - }, - }); - } - function krr(t, e) { - return new ma({ - type: "map", - schema: null, - *entries(r) { - if (t && e && r instanceof Map) - for (let [n, i] of r.entries()) yield [n, n, t], yield [n, i, e]; - }, - coercer(r) { - return r instanceof Map ? new Map(r) : r; - }, - validator(r) { - return ( - r instanceof Map || - "Expected a `Map` object, but received: " + Ws(r) - ); - }, - }); - } - function S1e() { - return qp("never", () => !1); - } - function Prr(t) { - return new ma({ - ...t, - validator: (e, r) => e === null || t.validator(e, r), - refiner: (e, r) => e === null || t.refiner(e, r), - }); - } - function Orr() { - return qp( - "number", - (t) => - (typeof t == "number" && !isNaN(t)) || - "Expected a number, but received: " + Ws(t) - ); - } - function oz(t) { - let e = t ? Object.keys(t) : [], - r = S1e(); - return new ma({ - type: "object", - schema: t || null, - *entries(n) { - if (t && Jm(n)) { - let i = new Set(Object.keys(n)); - for (let o of e) i.delete(o), yield [o, n[o], t[o]]; - for (let o of i) yield [o, n[o], r]; - } - }, - validator(n) { - return Jm(n) || "Expected an object, but received: " + Ws(n); - }, - coercer(n) { - return Jm(n) ? { ...n } : n; - }, - }); - } - function d$e(t) { - return new ma({ - ...t, - validator: (e, r) => e === void 0 || t.validator(e, r), - refiner: (e, r) => e === void 0 || t.refiner(e, r), - }); - } - function Brr(t, e) { - return new ma({ - type: "record", - schema: null, - *entries(r) { - if (Jm(r)) - for (let n in r) { - let i = r[n]; - yield [n, n, t], yield [n, i, e]; - } - }, - validator(r) { - return Jm(r) || "Expected an object, but received: " + Ws(r); - }, - }); - } - function Irr() { - return qp("regexp", (t) => t instanceof RegExp); - } - function Crr(t) { - return new ma({ - type: "set", - schema: null, - *entries(e) { - if (t && e instanceof Set) for (let r of e) yield [r, r, t]; - }, - coercer(e) { - return e instanceof Set ? new Set(e) : e; - }, - validator(e) { - return ( - e instanceof Set || - "Expected a `Set` object, but received: " + Ws(e) - ); - }, - }); - } - function h$e() { - return qp( - "string", - (t) => - typeof t == "string" || "Expected a string, but received: " + Ws(t) - ); - } - function Rrr(t) { - let e = S1e(); - return new ma({ - type: "tuple", - schema: null, - *entries(r) { - if (Array.isArray(r)) { - let n = Math.max(t.length, r.length); - for (let i = 0; i < n; i++) yield [i, r[i], t[i] || e]; - } - }, - validator(r) { - return ( - Array.isArray(r) || "Expected an array, but received: " + Ws(r) - ); - }, - }); - } - function Nrr(t) { - let e = Object.keys(t); - return new ma({ - type: "type", - schema: t, - *entries(r) { - if (Jm(r)) for (let n of e) yield [n, r[n], t[n]]; - }, - validator(r) { - return Jm(r) || "Expected an object, but received: " + Ws(r); - }, - }); - } - function Drr(t) { - let e = t.map((r) => r.type).join(" | "); - return new ma({ - type: "union", - schema: null, - validator(r, n) { - let i = []; - for (let o of t) { - let [...a] = _1e(r, o, n), - [s] = a; - if (s[0]) for (let [c] of a) c && i.push(c); - else return []; - } - return [ - "Expected the value to satisfy a union of `" + - e + - "`, but received: " + - Ws(r), - ...i, - ]; - }, - }); - } - function p$e() { - return qp("unknown", () => !0); - } - function A1e(t, e, r) { - return new ma({ - ...t, - coercer: (n, i) => - x1e(n, e) ? t.coercer(r(n, i), i) : t.coercer(n, i), - }); - } - function Frr(t, e, r = {}) { - return A1e(t, p$e(), (n) => { - let i = typeof e == "function" ? e() : e; - if (n === void 0) return i; - if (!r.strict && u$e(n) && u$e(i)) { - let o = { ...n }, - a = !1; - for (let s in i) o[s] === void 0 && ((o[s] = i[s]), (a = !0)); - if (a) return o; - } - return n; - }); - } - function Lrr(t) { - return A1e(t, h$e(), (e) => e.trim()); - } - function qrr(t) { - let e = "Expected an empty " + t.type; - return rC(t, "empty", (r) => { - if (r instanceof Map || r instanceof Set) { - let { size: n } = r; - return n === 0 || e + " but received one with a size of `" + n + "`"; - } else { - let { length: n } = r; - return ( - n === 0 || e + " but received one with a length of `" + n + "`" - ); - } - }); - } - function zrr(t, e, r = {}) { - let { exclusive: n } = r; - return rC(t, "max", (i) => - n - ? i < e - : i <= e || - "Expected a " + - t.type + - " greater than " + - (n ? "" : "or equal to ") + - e + - " but received `" + - i + - "`" - ); - } - function jrr(t, e, r = {}) { - let { exclusive: n } = r; - return rC(t, "min", (i) => - n - ? i > e - : i >= e || - "Expected a " + - t.type + - " greater than " + - (n ? "" : "or equal to ") + - e + - " but received `" + - i + - "`" - ); - } - function Urr(t, e) { - return rC( - t, - "pattern", - (r) => - e.test(r) || - "Expected a " + - t.type + - " matching `/" + - e.source + - '/` but received "' + - r + - '"' - ); - } - function Krr(t, e, r = e) { - let n = "Expected a " + t.type, - i = e === r ? "of `" + e + "`" : "between `" + e + "` and `" + r + "`"; - return rC(t, "size", (o) => { - if (typeof o == "number" || o instanceof Date) - return ( - (e <= o && o <= r) || n + " " + i + " but received `" + o + "`" - ); - if (o instanceof Map || o instanceof Set) { - let { size: a } = o; - return ( - (e <= a && a <= r) || - n + - " with a size " + - i + - " but received one with a size of `" + - a + - "`" - ); - } else { - let { length: a } = o; - return ( - (e <= a && a <= r) || - n + - " with a length " + - i + - " but received one with a length of `" + - a + - "`" - ); - } - }); - } - function rC(t, e, r) { - return new ma({ - ...t, - *refiner(n, i) { - yield* t.refiner(n, i); - let o = r(n, i), - a = w1e(o, i, t, n); - for (let s of a) yield { ...s, refinement: e }; - }, - }); - } - Or.Struct = ma; - Or.StructError = cY; - Or.any = vrr; - Or.array = brr; - Or.assert = c$e; - Or.assign = lrr; - Or.boolean = wrr; - Or.coerce = A1e; - Or.create = l$e; - Or.date = _rr; - Or.defaulted = Frr; - Or.define = qp; - Or.deprecated = frr; - Or.dynamic = drr; - Or.empty = qrr; - Or.enums = xrr; - Or.func = Srr; - Or.instance = Arr; - Or.integer = Err; - Or.intersection = Mrr; - Or.is = x1e; - Or.lazy = hrr; - Or.literal = Trr; - Or.map = krr; - Or.mask = f$e; - Or.max = zrr; - Or.min = jrr; - Or.never = S1e; - Or.nullable = Prr; - Or.number = Orr; - Or.object = oz; - Or.omit = prr; - Or.optional = d$e; - Or.partial = yrr; - Or.pattern = Urr; - Or.pick = mrr; - Or.record = Brr; - Or.refine = rC; - Or.regexp = Irr; - Or.set = Crr; - Or.size = Krr; - Or.string = h$e; - Or.struct = grr; - Or.trimmed = Lrr; - Or.tuple = Rrr; - Or.type = Nrr; - Or.union = Drr; - Or.unknown = p$e; - Or.validate = tC; - }); - var lY = I((gdn, az) => { - m(); - g(); - function Hrr(t) { - return t && t.__esModule ? t : { default: t }; - } - (az.exports = Hrr), - (az.exports.__esModule = !0), - (az.exports.default = az.exports); - }); - var fY = I((vdn, sz) => { - m(); - g(); - function m$e(t, e) { - for (var r = 0; r < e.length; r++) { - var n = e[r]; - (n.enumerable = n.enumerable || !1), - (n.configurable = !0), - "value" in n && (n.writable = !0), - Object.defineProperty(t, n.key, n); - } - } - function Vrr(t, e, r) { - return ( - e && m$e(t.prototype, e), - r && m$e(t, r), - Object.defineProperty(t, "prototype", { writable: !1 }), - t - ); - } - (sz.exports = Vrr), - (sz.exports.__esModule = !0), - (sz.exports.default = sz.exports); - }); - var dY = I((bdn, uz) => { - m(); - g(); - function Wrr(t, e) { - if (!(t instanceof e)) - throw new TypeError("Cannot call a class as a function"); - } - (uz.exports = Wrr), - (uz.exports.__esModule = !0), - (uz.exports.default = uz.exports); - }); - var g$e = I((wdn, j_) => { - m(); - g(); - function E1e(t, e) { - return ( - (j_.exports = E1e = - Object.setPrototypeOf - ? Object.setPrototypeOf.bind() - : function (n, i) { - return (n.__proto__ = i), n; - }), - (j_.exports.__esModule = !0), - (j_.exports.default = j_.exports), - E1e(t, e) - ); - } - (j_.exports = E1e), - (j_.exports.__esModule = !0), - (j_.exports.default = j_.exports); - }); - var hY = I((_dn, cz) => { - m(); - g(); - var Grr = g$e(); - function Jrr(t, e) { - if (typeof e != "function" && e !== null) - throw new TypeError( - "Super expression must either be null or a function" - ); - (t.prototype = Object.create(e && e.prototype, { - constructor: { value: t, writable: !0, configurable: !0 }, - })), - Object.defineProperty(t, "prototype", { writable: !1 }), - e && Grr(t, e); - } - (cz.exports = Jrr), - (cz.exports.__esModule = !0), - (cz.exports.default = cz.exports); - }); - var pY = I((xdn, U_) => { - m(); - g(); - function M1e(t) { - return ( - (U_.exports = M1e = - typeof Symbol == "function" && typeof Symbol.iterator == "symbol" - ? function (e) { - return typeof e; - } - : function (e) { - return e && - typeof Symbol == "function" && - e.constructor === Symbol && - e !== Symbol.prototype - ? "symbol" - : typeof e; - }), - (U_.exports.__esModule = !0), - (U_.exports.default = U_.exports), - M1e(t) - ); - } - (U_.exports = M1e), - (U_.exports.__esModule = !0), - (U_.exports.default = U_.exports); - }); - var v$e = I((Sdn, lz) => { - m(); - g(); - function $rr(t) { - if (t === void 0) - throw new ReferenceError( - "this hasn't been initialised - super() hasn't been called" - ); - return t; - } - (lz.exports = $rr), - (lz.exports.__esModule = !0), - (lz.exports.default = lz.exports); - }); - var yY = I((Adn, fz) => { - m(); - g(); - var Zrr = pY().default, - Xrr = v$e(); - function Yrr(t, e) { - if (e && (Zrr(e) === "object" || typeof e == "function")) return e; - if (e !== void 0) - throw new TypeError( - "Derived constructors may only return object or undefined" - ); - return Xrr(t); - } - (fz.exports = Yrr), - (fz.exports.__esModule = !0), - (fz.exports.default = fz.exports); - }); - var mY = I((Edn, K_) => { - m(); - g(); - function T1e(t) { - return ( - (K_.exports = T1e = - Object.setPrototypeOf - ? Object.getPrototypeOf.bind() - : function (r) { - return r.__proto__ || Object.getPrototypeOf(r); - }), - (K_.exports.__esModule = !0), - (K_.exports.default = K_.exports), - T1e(t) - ); - } - (K_.exports = T1e), - (K_.exports.__esModule = !0), - (K_.exports.default = K_.exports); - }); - var w$e = I((k1e) => { - "use strict"; - m(); - g(); - var dz = lY(); - Object.defineProperty(k1e, "__esModule", { value: !0 }); - k1e.default = snr; - var Qrr = dz(dY()), - enr = dz(fY()), - tnr = dz(hY()), - rnr = dz(yY()), - b$e = dz(mY()), - nnr = lI(); - function inr(t) { - var e = onr(); - return function () { - var n = (0, b$e.default)(t), - i; - if (e) { - var o = (0, b$e.default)(this).constructor; - i = Reflect.construct(n, arguments, o); - } else i = n.apply(this, arguments); - return (0, rnr.default)(this, i); - }; - } - function onr() { - if (typeof Reflect > "u" || !Reflect.construct || Reflect.construct.sham) - return !1; - if (typeof Proxy == "function") return !0; - try { - return ( - Boolean.prototype.valueOf.call( - Reflect.construct(Boolean, [], function () {}) - ), - !0 - ); - } catch { - return !1; - } - } - var anr = (function (t) { - (0, tnr.default)(r, t); - var e = inr(r); - function r(n, i, o) { - var a; - return ( - (0, Qrr.default)(this, r), - (a = e.call(this)), - (a.socket = new window.WebSocket(n, o)), - (a.socket.onopen = function () { - return a.emit("open"); - }), - (a.socket.onmessage = function (s) { - return a.emit("message", s.data); - }), - (a.socket.onerror = function (s) { - return a.emit("error", s); - }), - (a.socket.onclose = function (s) { - a.emit("close", s.code, s.reason); - }), - a - ); - } - return ( - (0, enr.default)(r, [ - { - key: "send", - value: function (i, o, a) { - var s = a || o; - try { - this.socket.send(i), s(); - } catch (c) { - s(c); - } - }, - }, - { - key: "close", - value: function (i, o) { - this.socket.close(i, o); - }, - }, - { - key: "addEventListener", - value: function (i, o, a) { - this.socket.addEventListener(i, o, a); - }, - }, - ]), - r - ); - })(nnr.EventEmitter); - function snr(t, e) { - return new anr(t, e); - } - }); - var x$e = I((Tdn, H_) => { - m(); - g(); - var unr = pY().default; - function _$e() { - "use strict"; - (H_.exports = _$e = - function () { - return t; - }), - (H_.exports.__esModule = !0), - (H_.exports.default = H_.exports); - var t = {}, - e = Object.prototype, - r = e.hasOwnProperty, - n = - Object.defineProperty || - function (p, y, d) { - p[y] = d.value; - }, - i = typeof Symbol == "function" ? Symbol : {}, - o = i.iterator || "@@iterator", - a = i.asyncIterator || "@@asyncIterator", - s = i.toStringTag || "@@toStringTag"; - function c(p, y, d) { - return ( - Object.defineProperty(p, y, { - value: d, - enumerable: !0, - configurable: !0, - writable: !0, - }), - p[y] - ); - } - try { - c({}, ""); - } catch { - c = function (d, v, _) { - return (d[v] = _); - }; - } - function u(p, y, d, v) { - var _ = y && y.prototype instanceof M ? y : M, - S = Object.create(_.prototype), - b = new ne(v || []); - return n(S, "_invoke", { value: Z(p, d, b) }), S; - } - function h(p, y, d) { - try { - return { type: "normal", arg: p.call(y, d) }; - } catch (v) { - return { type: "throw", arg: v }; - } - } - t.wrap = u; - var w = {}; - function M() {} - function k() {} - function O() {} - var D = {}; - c(D, o, function () { - return this; - }); - var F = Object.getPrototypeOf, - N = F && F(F(A([]))); - N && N !== e && r.call(N, o) && (D = N); - var q = (O.prototype = M.prototype = Object.create(D)); - function z(p) { - ["next", "throw", "return"].forEach(function (y) { - c(p, y, function (d) { - return this._invoke(y, d); - }); - }); - } - function H(p, y) { - function d(_, S, b, f) { - var x = h(p[_], p, S); - if (x.type !== "throw") { - var C = x.arg, - E = C.value; - return E && unr(E) == "object" && r.call(E, "__await") - ? y.resolve(E.__await).then( - function (B) { - d("next", B, b, f); - }, - function (B) { - d("throw", B, b, f); - } - ) - : y.resolve(E).then( - function (B) { - (C.value = B), b(C); - }, - function (B) { - return d("throw", B, b, f); - } - ); - } - f(x.arg); - } - var v; - n(this, "_invoke", { - value: function (S, b) { - function f() { - return new y(function (x, C) { - d(S, b, x, C); - }); - } - return (v = v ? v.then(f, f) : f()); - }, - }); - } - function Z(p, y, d) { - var v = "suspendedStart"; - return function (_, S) { - if (v === "executing") - throw new Error("Generator is already running"); - if (v === "completed") { - if (_ === "throw") throw S; - return l(); - } - for (d.method = _, d.arg = S; ; ) { - var b = d.delegate; - if (b) { - var f = $(b, d); - if (f) { - if (f === w) continue; - return f; - } - } - if (d.method === "next") d.sent = d._sent = d.arg; - else if (d.method === "throw") { - if (v === "suspendedStart") throw ((v = "completed"), d.arg); - d.dispatchException(d.arg); - } else d.method === "return" && d.abrupt("return", d.arg); - v = "executing"; - var x = h(p, y, d); - if (x.type === "normal") { - if (((v = d.done ? "completed" : "suspendedYield"), x.arg === w)) - continue; - return { value: x.arg, done: d.done }; - } - x.type === "throw" && - ((v = "completed"), (d.method = "throw"), (d.arg = x.arg)); - } - }; - } - function $(p, y) { - var d = p.iterator[y.method]; - if (d === void 0) { - if (((y.delegate = null), y.method === "throw")) { - if ( - p.iterator.return && - ((y.method = "return"), - (y.arg = void 0), - $(p, y), - y.method === "throw") - ) - return w; - (y.method = "throw"), - (y.arg = new TypeError( - "The iterator does not provide a 'throw' method" - )); - } - return w; - } - var v = h(d, p.iterator, y.arg); - if (v.type === "throw") - return (y.method = "throw"), (y.arg = v.arg), (y.delegate = null), w; - var _ = v.arg; - return _ - ? _.done - ? ((y[p.resultName] = _.value), - (y.next = p.nextLoc), - y.method !== "return" && ((y.method = "next"), (y.arg = void 0)), - (y.delegate = null), - w) - : _ - : ((y.method = "throw"), - (y.arg = new TypeError("iterator result is not an object")), - (y.delegate = null), - w); - } - function ue(p) { - var y = { tryLoc: p[0] }; - 1 in p && (y.catchLoc = p[1]), - 2 in p && ((y.finallyLoc = p[2]), (y.afterLoc = p[3])), - this.tryEntries.push(y); - } - function te(p) { - var y = p.completion || {}; - (y.type = "normal"), delete y.arg, (p.completion = y); - } - function ne(p) { - (this.tryEntries = [{ tryLoc: "root" }]), - p.forEach(ue, this), - this.reset(!0); - } - function A(p) { - if (p) { - var y = p[o]; - if (y) return y.call(p); - if (typeof p.next == "function") return p; - if (!isNaN(p.length)) { - var d = -1, - v = function _() { - for (; ++d < p.length; ) - if (r.call(p, d)) return (_.value = p[d]), (_.done = !1), _; - return (_.value = void 0), (_.done = !0), _; - }; - return (v.next = v); - } - } - return { next: l }; - } - function l() { - return { value: void 0, done: !0 }; - } - return ( - (k.prototype = O), - n(q, "constructor", { value: O, configurable: !0 }), - n(O, "constructor", { value: k, configurable: !0 }), - (k.displayName = c(O, s, "GeneratorFunction")), - (t.isGeneratorFunction = function (p) { - var y = typeof p == "function" && p.constructor; - return ( - !!y && - (y === k || (y.displayName || y.name) === "GeneratorFunction") - ); - }), - (t.mark = function (p) { - return ( - Object.setPrototypeOf - ? Object.setPrototypeOf(p, O) - : ((p.__proto__ = O), c(p, s, "GeneratorFunction")), - (p.prototype = Object.create(q)), - p - ); - }), - (t.awrap = function (p) { - return { __await: p }; - }), - z(H.prototype), - c(H.prototype, a, function () { - return this; - }), - (t.AsyncIterator = H), - (t.async = function (p, y, d, v, _) { - _ === void 0 && (_ = Promise); - var S = new H(u(p, y, d, v), _); - return t.isGeneratorFunction(y) - ? S - : S.next().then(function (b) { - return b.done ? b.value : S.next(); - }); - }), - z(q), - c(q, s, "Generator"), - c(q, o, function () { - return this; - }), - c(q, "toString", function () { - return "[object Generator]"; - }), - (t.keys = function (p) { - var y = Object(p), - d = []; - for (var v in y) d.push(v); - return ( - d.reverse(), - function _() { - for (; d.length; ) { - var S = d.pop(); - if (S in y) return (_.value = S), (_.done = !1), _; - } - return (_.done = !0), _; - } - ); - }), - (t.values = A), - (ne.prototype = { - constructor: ne, - reset: function (y) { - if ( - ((this.prev = 0), - (this.next = 0), - (this.sent = this._sent = void 0), - (this.done = !1), - (this.delegate = null), - (this.method = "next"), - (this.arg = void 0), - this.tryEntries.forEach(te), - !y) - ) - for (var d in this) - d.charAt(0) === "t" && - r.call(this, d) && - !isNaN(+d.slice(1)) && - (this[d] = void 0); - }, - stop: function () { - this.done = !0; - var y = this.tryEntries[0].completion; - if (y.type === "throw") throw y.arg; - return this.rval; - }, - dispatchException: function (y) { - if (this.done) throw y; - var d = this; - function v(C, E) { - return ( - (b.type = "throw"), - (b.arg = y), - (d.next = C), - E && ((d.method = "next"), (d.arg = void 0)), - !!E - ); - } - for (var _ = this.tryEntries.length - 1; _ >= 0; --_) { - var S = this.tryEntries[_], - b = S.completion; - if (S.tryLoc === "root") return v("end"); - if (S.tryLoc <= this.prev) { - var f = r.call(S, "catchLoc"), - x = r.call(S, "finallyLoc"); - if (f && x) { - if (this.prev < S.catchLoc) return v(S.catchLoc, !0); - if (this.prev < S.finallyLoc) return v(S.finallyLoc); - } else if (f) { - if (this.prev < S.catchLoc) return v(S.catchLoc, !0); - } else { - if (!x) - throw new Error("try statement without catch or finally"); - if (this.prev < S.finallyLoc) return v(S.finallyLoc); - } - } - } - }, - abrupt: function (y, d) { - for (var v = this.tryEntries.length - 1; v >= 0; --v) { - var _ = this.tryEntries[v]; - if ( - _.tryLoc <= this.prev && - r.call(_, "finallyLoc") && - this.prev < _.finallyLoc - ) { - var S = _; - break; - } - } - S && - (y === "break" || y === "continue") && - S.tryLoc <= d && - d <= S.finallyLoc && - (S = null); - var b = S ? S.completion : {}; - return ( - (b.type = y), - (b.arg = d), - S - ? ((this.method = "next"), (this.next = S.finallyLoc), w) - : this.complete(b) - ); - }, - complete: function (y, d) { - if (y.type === "throw") throw y.arg; - return ( - y.type === "break" || y.type === "continue" - ? (this.next = y.arg) - : y.type === "return" - ? ((this.rval = this.arg = y.arg), - (this.method = "return"), - (this.next = "end")) - : y.type === "normal" && d && (this.next = d), - w - ); - }, - finish: function (y) { - for (var d = this.tryEntries.length - 1; d >= 0; --d) { - var v = this.tryEntries[d]; - if (v.finallyLoc === y) - return this.complete(v.completion, v.afterLoc), te(v), w; - } - }, - catch: function (y) { - for (var d = this.tryEntries.length - 1; d >= 0; --d) { - var v = this.tryEntries[d]; - if (v.tryLoc === y) { - var _ = v.completion; - if (_.type === "throw") { - var S = _.arg; - te(v); - } - return S; - } - } - throw new Error("illegal catch attempt"); - }, - delegateYield: function (y, d, v) { - return ( - (this.delegate = { iterator: A(y), resultName: d, nextLoc: v }), - this.method === "next" && (this.arg = void 0), - w - ); - }, - }), - t - ); - } - (H_.exports = _$e), - (H_.exports.__esModule = !0), - (H_.exports.default = H_.exports); - }); - var A$e = I((kdn, S$e) => { - m(); - g(); - var gY = x$e()(); - S$e.exports = gY; - try { - regeneratorRuntime = gY; - } catch { - typeof globalThis == "object" - ? (globalThis.regeneratorRuntime = gY) - : Function("r", "regeneratorRuntime = r")(gY); - } - }); - var M$e = I((Pdn, hz) => { - m(); - g(); - function E$e(t, e, r, n, i, o, a) { - try { - var s = t[o](a), - c = s.value; - } catch (u) { - r(u); - return; - } - s.done ? e(c) : Promise.resolve(c).then(n, i); - } - function cnr(t) { - return function () { - var e = this, - r = arguments; - return new Promise(function (n, i) { - var o = t.apply(e, r); - function a(c) { - E$e(o, n, i, a, s, "next", c); - } - function s(c) { - E$e(o, n, i, a, s, "throw", c); - } - a(void 0); - }); - }; - } - (hz.exports = cnr), - (hz.exports.__esModule = !0), - (hz.exports.default = hz.exports); - }); - var k$e = I((bY) => { - "use strict"; - m(); - g(); - var M2 = lY(); - Object.defineProperty(bY, "__esModule", { value: !0 }); - bY.default = void 0; - var E2 = M2(A$e()), - vY = M2(M$e()), - lnr = M2(pY()), - fnr = M2(dY()), - dnr = M2(fY()), - hnr = M2(hY()), - pnr = M2(yY()), - T$e = M2(mY()), - ynr = lI(); - function mnr(t) { - var e = gnr(); - return function () { - var n = (0, T$e.default)(t), - i; - if (e) { - var o = (0, T$e.default)(this).constructor; - i = Reflect.construct(n, arguments, o); - } else i = n.apply(this, arguments); - return (0, pnr.default)(this, i); - }; - } - function gnr() { - if (typeof Reflect > "u" || !Reflect.construct || Reflect.construct.sham) - return !1; - if (typeof Proxy == "function") return !0; - try { - return ( - Boolean.prototype.valueOf.call( - Reflect.construct(Boolean, [], function () {}) - ), - !0 - ); - } catch { - return !1; - } - } - var vnr = function (t, e) { - var r = {}; - for (var n in t) - Object.prototype.hasOwnProperty.call(t, n) && - e.indexOf(n) < 0 && - (r[n] = t[n]); - if (t != null && typeof Object.getOwnPropertySymbols == "function") - for ( - var i = 0, n = Object.getOwnPropertySymbols(t); - i < n.length; - i++ - ) - e.indexOf(n[i]) < 0 && - Object.prototype.propertyIsEnumerable.call(t, n[i]) && - (r[n[i]] = t[n[i]]); - return r; - }, - bnr = (function (t) { - (0, hnr.default)(r, t); - var e = mnr(r); - function r(n) { - var i, - o = - arguments.length > 1 && arguments[1] !== void 0 - ? arguments[1] - : "ws://localhost:8080", - a = - arguments.length > 2 && arguments[2] !== void 0 - ? arguments[2] - : {}, - s = arguments.length > 3 ? arguments[3] : void 0; - (0, fnr.default)(this, r); - var c = a.autoconnect, - u = c === void 0 ? !0 : c, - h = a.reconnect, - w = h === void 0 ? !0 : h, - M = a.reconnect_interval, - k = M === void 0 ? 1e3 : M, - O = a.max_reconnects, - D = O === void 0 ? 5 : O, - F = vnr(a, [ - "autoconnect", - "reconnect", - "reconnect_interval", - "max_reconnects", - ]); - return ( - (i = e.call(this)), - (i.webSocketFactory = n), - (i.queue = {}), - (i.rpc_id = 0), - (i.address = o), - (i.autoconnect = u), - (i.ready = !1), - (i.reconnect = w), - (i.reconnect_interval = k), - (i.max_reconnects = D), - (i.rest_options = F), - (i.current_reconnects = 0), - (i.generate_request_id = - s || - function () { - return ++i.rpc_id; - }), - i.autoconnect && - i._connect( - i.address, - Object.assign( - { - autoconnect: i.autoconnect, - reconnect: i.reconnect, - reconnect_interval: i.reconnect_interval, - max_reconnects: i.max_reconnects, - }, - i.rest_options - ) - ), - i - ); - } - return ( - (0, dnr.default)(r, [ - { - key: "connect", - value: function () { - this.socket || - this._connect( - this.address, - Object.assign( - { - autoconnect: this.autoconnect, - reconnect: this.reconnect, - reconnect_interval: this.reconnect_interval, - max_reconnects: this.max_reconnects, - }, - this.rest_options - ) - ); - }, - }, - { - key: "call", - value: function (i, o, a, s) { - var c = this; - return ( - !s && - (0, lnr.default)(a) === "object" && - ((s = a), (a = null)), - new Promise(function (u, h) { - if (!c.ready) return h(new Error("socket not ready")); - var w = c.generate_request_id(i, o), - M = { - jsonrpc: "2.0", - method: i, - params: o || null, - id: w, - }; - c.socket.send(JSON.stringify(M), s, function (k) { - if (k) return h(k); - (c.queue[w] = { promise: [u, h] }), - a && - (c.queue[w].timeout = setTimeout(function () { - delete c.queue[w], h(new Error("reply timeout")); - }, a)); - }); - }) - ); - }, - }, - { - key: "login", - value: (function () { - var n = (0, vY.default)( - E2.default.mark(function o(a) { - var s; - return E2.default.wrap( - function (u) { - for (;;) - switch ((u.prev = u.next)) { - case 0: - return (u.next = 2), this.call("rpc.login", a); - case 2: - if (((s = u.sent), s)) { - u.next = 5; - break; - } - throw new Error("authentication failed"); - case 5: - return u.abrupt("return", s); - case 6: - case "end": - return u.stop(); - } - }, - o, - this - ); - }) - ); - function i(o) { - return n.apply(this, arguments); - } - return i; - })(), - }, - { - key: "listMethods", - value: (function () { - var n = (0, vY.default)( - E2.default.mark(function o() { - return E2.default.wrap( - function (s) { - for (;;) - switch ((s.prev = s.next)) { - case 0: - return (s.next = 2), this.call("__listMethods"); - case 2: - return s.abrupt("return", s.sent); - case 3: - case "end": - return s.stop(); - } - }, - o, - this - ); - }) - ); - function i() { - return n.apply(this, arguments); - } - return i; - })(), - }, - { - key: "notify", - value: function (i, o) { - var a = this; - return new Promise(function (s, c) { - if (!a.ready) return c(new Error("socket not ready")); - var u = { jsonrpc: "2.0", method: i, params: o || null }; - a.socket.send(JSON.stringify(u), function (h) { - if (h) return c(h); - s(); - }); - }); - }, - }, - { - key: "subscribe", - value: (function () { - var n = (0, vY.default)( - E2.default.mark(function o(a) { - var s; - return E2.default.wrap( - function (u) { - for (;;) - switch ((u.prev = u.next)) { - case 0: - return ( - typeof a == "string" && (a = [a]), - (u.next = 3), - this.call("rpc.on", a) - ); - case 3: - if ( - ((s = u.sent), - !(typeof a == "string" && s[a] !== "ok")) - ) { - u.next = 6; - break; - } - throw new Error( - "Failed subscribing to an event '" + - a + - "' with: " + - s[a] - ); - case 6: - return u.abrupt("return", s); - case 7: - case "end": - return u.stop(); - } - }, - o, - this - ); - }) - ); - function i(o) { - return n.apply(this, arguments); - } - return i; - })(), - }, - { - key: "unsubscribe", - value: (function () { - var n = (0, vY.default)( - E2.default.mark(function o(a) { - var s; - return E2.default.wrap( - function (u) { - for (;;) - switch ((u.prev = u.next)) { - case 0: - return ( - typeof a == "string" && (a = [a]), - (u.next = 3), - this.call("rpc.off", a) - ); - case 3: - if ( - ((s = u.sent), - !(typeof a == "string" && s[a] !== "ok")) - ) { - u.next = 6; - break; - } - throw new Error( - "Failed unsubscribing from an event with: " + s - ); - case 6: - return u.abrupt("return", s); - case 7: - case "end": - return u.stop(); - } - }, - o, - this - ); - }) - ); - function i(o) { - return n.apply(this, arguments); - } - return i; - })(), - }, - { - key: "close", - value: function (i, o) { - this.socket.close(i || 1e3, o); - }, - }, - { - key: "_connect", - value: function (i, o) { - var a = this; - (this.socket = this.webSocketFactory(i, o)), - this.socket.addEventListener("open", function () { - (a.ready = !0), a.emit("open"), (a.current_reconnects = 0); - }), - this.socket.addEventListener("message", function (s) { - var c = s.data; - c instanceof ArrayBuffer && (c = Buffer.from(c).toString()); - try { - c = JSON.parse(c); - } catch { - return; - } - if (c.notification && a.listeners(c.notification).length) { - if (!Object.keys(c.params).length) - return a.emit(c.notification); - var u = [c.notification]; - if (c.params.constructor === Object) u.push(c.params); - else - for (var h = 0; h < c.params.length; h++) - u.push(c.params[h]); - return Promise.resolve().then(function () { - a.emit.apply(a, u); - }); - } - if (!a.queue[c.id]) - return c.method && c.params - ? Promise.resolve().then(function () { - a.emit(c.method, c.params); - }) - : void 0; - "error" in c == "result" in c && - a.queue[c.id].promise[1]( - new Error( - 'Server response malformed. Response must include either "result" or "error", but not both.' - ) - ), - a.queue[c.id].timeout && - clearTimeout(a.queue[c.id].timeout), - c.error - ? a.queue[c.id].promise[1](c.error) - : a.queue[c.id].promise[0](c.result), - delete a.queue[c.id]; - }), - this.socket.addEventListener("error", function (s) { - return a.emit("error", s); - }), - this.socket.addEventListener("close", function (s) { - var c = s.code, - u = s.reason; - a.ready && - setTimeout(function () { - return a.emit("close", c, u); - }, 0), - (a.ready = !1), - (a.socket = void 0), - c !== 1e3 && - (a.current_reconnects++, - a.reconnect && - (a.max_reconnects > a.current_reconnects || - a.max_reconnects === 0) && - setTimeout(function () { - return a._connect(i, o); - }, a.reconnect_interval)); - }); - }, - }, - ]), - r - ); - })(ynr.EventEmitter); - bY.default = bnr; - }); - var O$e = I((wY) => { - "use strict"; - m(); - g(); - var UM = lY(); - Object.defineProperty(wY, "__esModule", { value: !0 }); - wY.Client = void 0; - var wnr = UM(fY()), - _nr = UM(dY()), - xnr = UM(hY()), - Snr = UM(yY()), - P$e = UM(mY()), - Anr = UM(w$e()), - Enr = UM(k$e()); - function Mnr(t) { - var e = Tnr(); - return function () { - var n = (0, P$e.default)(t), - i; - if (e) { - var o = (0, P$e.default)(this).constructor; - i = Reflect.construct(n, arguments, o); - } else i = n.apply(this, arguments); - return (0, Snr.default)(this, i); - }; - } - function Tnr() { - if (typeof Reflect > "u" || !Reflect.construct || Reflect.construct.sham) - return !1; - if (typeof Proxy == "function") return !0; - try { - return ( - Boolean.prototype.valueOf.call( - Reflect.construct(Boolean, [], function () {}) - ), - !0 - ); - } catch { - return !1; - } - } - var knr = (function (t) { - (0, xnr.default)(r, t); - var e = Mnr(r); - function r() { - var n = - arguments.length > 0 && arguments[0] !== void 0 - ? arguments[0] - : "ws://localhost:8080", - i = - arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, - o = i.autoconnect, - a = o === void 0 ? !0 : o, - s = i.reconnect, - c = s === void 0 ? !0 : s, - u = i.reconnect_interval, - h = u === void 0 ? 1e3 : u, - w = i.max_reconnects, - M = w === void 0 ? 5 : w, - k = arguments.length > 2 ? arguments[2] : void 0; - return ( - (0, _nr.default)(this, r), - e.call( - this, - Anr.default, - n, - { - autoconnect: a, - reconnect: c, - reconnect_interval: h, - max_reconnects: M, - }, - k - ) - ); - } - return (0, wnr.default)(r); - })(Enr.default); - wY.Client = knr; - }); - var I$e = I((Idn, B$e) => { - "use strict"; - m(); - g(); - var Pnr = ($pe(), jo(Jpe)).v4, - Onr = function (t, e, r, n) { - if (typeof t != "string") throw new TypeError(t + " must be a string"); - n = n || {}; - let i = typeof n.version == "number" ? n.version : 2; - if (i !== 1 && i !== 2) throw new TypeError(i + " must be 1 or 2"); - let o = { method: t }; - if ((i === 2 && (o.jsonrpc = "2.0"), e)) { - if (typeof e != "object" && !Array.isArray(e)) - throw new TypeError(e + " must be an object, array or omitted"); - o.params = e; - } - if (typeof r > "u") { - let a = - typeof n.generator == "function" - ? n.generator - : function () { - return Pnr(); - }; - o.id = a(o, n); - } else - i === 2 && r === null - ? n.notificationIdNull && (o.id = null) - : (o.id = r); - return o; - }; - B$e.exports = Onr; - }); - var R$e = I((Cdn, C$e) => { - "use strict"; - m(); - g(); - var Bnr = ($pe(), jo(Jpe)).v4, - Inr = I$e(), - pz = function (t, e) { - if (!(this instanceof pz)) return new pz(t, e); - e || (e = {}), - (this.options = { - reviver: typeof e.reviver < "u" ? e.reviver : null, - replacer: typeof e.replacer < "u" ? e.replacer : null, - generator: - typeof e.generator < "u" - ? e.generator - : function () { - return Bnr(); - }, - version: typeof e.version < "u" ? e.version : 2, - notificationIdNull: - typeof e.notificationIdNull == "boolean" - ? e.notificationIdNull - : !1, - }), - (this.callServer = t); - }; - C$e.exports = pz; - pz.prototype.request = function (t, e, r, n) { - let i = this, - o = null, - a = Array.isArray(t) && typeof e == "function"; - if (this.options.version === 1 && a) - throw new TypeError("JSON-RPC 1.0 does not support batching"); - if (a || (!a && t && typeof t == "object" && typeof e == "function")) - (n = e), (o = t); - else { - typeof r == "function" && ((n = r), (r = void 0)); - let u = typeof n == "function"; - try { - o = Inr(t, e, r, { - generator: this.options.generator, - version: this.options.version, - notificationIdNull: this.options.notificationIdNull, - }); - } catch (h) { - if (u) return n(h); - throw h; - } - if (!u) return o; - } - let c; - try { - c = JSON.stringify(o, this.options.replacer); - } catch (u) { - return n(u); - } - return ( - this.callServer(c, function (u, h) { - i._parseResponse(u, h, n); - }), - o - ); - }; - pz.prototype._parseResponse = function (t, e, r) { - if (t) { - r(t); - return; - } - if (!e) return r(); - let n; - try { - n = JSON.parse(e, this.options.reviver); - } catch (i) { - return r(i); - } - if (r.length === 3) - if (Array.isArray(n)) { - let i = function (a) { - return typeof a.error < "u"; - }, - o = function (a) { - return !i(a); - }; - return r(null, n.filter(i), n.filter(o)); - } else return r(null, n.error, n.result); - r(null, n); - }; - }); - var U$e = I((Io) => { - "use strict"; - m(); - g(); - Object.defineProperty(Io, "__esModule", { value: !0 }); - Io.shake256 = - Io.shake128 = - Io.keccak_512 = - Io.keccak_384 = - Io.keccak_256 = - Io.keccak_224 = - Io.sha3_512 = - Io.sha3_384 = - Io.sha3_256 = - Io.sha3_224 = - Io.Keccak = - Io.keccakP = - void 0; - var nC = T$(), - gz = ige(), - mz = r5(), - [F$e, L$e, q$e] = [[], [], []], - Cnr = BigInt(0), - yz = BigInt(1), - Rnr = BigInt(2), - Nnr = BigInt(7), - Dnr = BigInt(256), - Fnr = BigInt(113); - for (let t = 0, e = yz, r = 1, n = 0; t < 24; t++) { - ([r, n] = [n, (2 * r + 3 * n) % 5]), - F$e.push(2 * (5 * n + r)), - L$e.push((((t + 1) * (t + 2)) / 2) % 64); - let i = Cnr; - for (let o = 0; o < 7; o++) - (e = ((e << yz) ^ ((e >> Nnr) * Fnr)) % Dnr), - e & Rnr && (i ^= yz << ((yz << BigInt(o)) - yz)); - q$e.push(i); - } - var [Lnr, qnr] = gz.default.split(q$e, !0), - N$e = (t, e, r) => - r > 32 ? gz.default.rotlBH(t, e, r) : gz.default.rotlSH(t, e, r), - D$e = (t, e, r) => - r > 32 ? gz.default.rotlBL(t, e, r) : gz.default.rotlSL(t, e, r); - function z$e(t, e = 24) { - let r = new Uint32Array(10); - for (let n = 24 - e; n < 24; n++) { - for (let a = 0; a < 10; a++) - r[a] = t[a] ^ t[a + 10] ^ t[a + 20] ^ t[a + 30] ^ t[a + 40]; - for (let a = 0; a < 10; a += 2) { - let s = (a + 8) % 10, - c = (a + 2) % 10, - u = r[c], - h = r[c + 1], - w = N$e(u, h, 1) ^ r[s], - M = D$e(u, h, 1) ^ r[s + 1]; - for (let k = 0; k < 50; k += 10) (t[a + k] ^= w), (t[a + k + 1] ^= M); - } - let i = t[2], - o = t[3]; - for (let a = 0; a < 24; a++) { - let s = L$e[a], - c = N$e(i, o, s), - u = D$e(i, o, s), - h = F$e[a]; - (i = t[h]), (o = t[h + 1]), (t[h] = c), (t[h + 1] = u); - } - for (let a = 0; a < 50; a += 10) { - for (let s = 0; s < 10; s++) r[s] = t[a + s]; - for (let s = 0; s < 10; s++) - t[a + s] ^= ~r[(s + 2) % 10] & r[(s + 4) % 10]; - } - (t[0] ^= Lnr[n]), (t[1] ^= qnr[n]); - } - r.fill(0); - } - Io.keccakP = z$e; - var KM = class extends mz.Hash { - constructor(e, r, n, i = !1, o = 24) { - if ( - (super(), - (this.blockLen = e), - (this.suffix = r), - (this.outputLen = n), - (this.enableXOF = i), - (this.rounds = o), - (this.pos = 0), - (this.posOut = 0), - (this.finished = !1), - (this.destroyed = !1), - nC.default.number(n), - 0 >= this.blockLen || this.blockLen >= 200) - ) - throw new Error("Sha3 supports only keccak-f1600 function"); - (this.state = new Uint8Array(200)), - (this.state32 = (0, mz.u32)(this.state)); - } - keccak() { - z$e(this.state32, this.rounds), (this.posOut = 0), (this.pos = 0); - } - update(e) { - nC.default.exists(this); - let { blockLen: r, state: n } = this; - e = (0, mz.toBytes)(e); - let i = e.length; - for (let o = 0; o < i; ) { - let a = Math.min(r - this.pos, i - o); - for (let s = 0; s < a; s++) n[this.pos++] ^= e[o++]; - this.pos === r && this.keccak(); - } - return this; - } - finish() { - if (this.finished) return; - this.finished = !0; - let { state: e, suffix: r, pos: n, blockLen: i } = this; - (e[n] ^= r), - (r & 128) !== 0 && n === i - 1 && this.keccak(), - (e[i - 1] ^= 128), - this.keccak(); - } - writeInto(e) { - nC.default.exists(this, !1), nC.default.bytes(e), this.finish(); - let r = this.state, - { blockLen: n } = this; - for (let i = 0, o = e.length; i < o; ) { - this.posOut >= n && this.keccak(); - let a = Math.min(n - this.posOut, o - i); - e.set(r.subarray(this.posOut, this.posOut + a), i), - (this.posOut += a), - (i += a); - } - return e; - } - xofInto(e) { - if (!this.enableXOF) - throw new Error("XOF is not possible for this instance"); - return this.writeInto(e); - } - xof(e) { - return nC.default.number(e), this.xofInto(new Uint8Array(e)); - } - digestInto(e) { - if ((nC.default.output(e, this), this.finished)) - throw new Error("digest() was already called"); - return this.writeInto(e), this.destroy(), e; - } - digest() { - return this.digestInto(new Uint8Array(this.outputLen)); - } - destroy() { - (this.destroyed = !0), this.state.fill(0); - } - _cloneInto(e) { - let { - blockLen: r, - suffix: n, - outputLen: i, - rounds: o, - enableXOF: a, - } = this; - return ( - e || (e = new KM(r, n, i, a, o)), - e.state32.set(this.state32), - (e.pos = this.pos), - (e.posOut = this.posOut), - (e.finished = this.finished), - (e.rounds = o), - (e.suffix = n), - (e.outputLen = i), - (e.enableXOF = a), - (e.destroyed = this.destroyed), - e - ); - } - }; - Io.Keccak = KM; - var T2 = (t, e, r) => (0, mz.wrapConstructor)(() => new KM(e, t, r)); - Io.sha3_224 = T2(6, 144, 224 / 8); - Io.sha3_256 = T2(6, 136, 256 / 8); - Io.sha3_384 = T2(6, 104, 384 / 8); - Io.sha3_512 = T2(6, 72, 512 / 8); - Io.keccak_224 = T2(1, 144, 224 / 8); - Io.keccak_256 = T2(1, 136, 256 / 8); - Io.keccak_384 = T2(1, 104, 384 / 8); - Io.keccak_512 = T2(1, 72, 512 / 8); - var j$e = (t, e, r) => - (0, mz.wrapConstructorWithOpts)( - (n = {}) => new KM(e, t, n.dkLen === void 0 ? r : n.dkLen, !0) - ); - Io.shake128 = j$e(31, 168, 128 / 8); - Io.shake256 = j$e(31, 136, 256 / 8); - }); - var H$e = I((vz) => { - "use strict"; - m(); - g(); - Object.defineProperty(vz, "__esModule", { value: !0 }); - vz.hmac = void 0; - var _Y = T$(), - K$e = r5(), - xY = class extends K$e.Hash { - constructor(e, r) { - super(), - (this.finished = !1), - (this.destroyed = !1), - _Y.default.hash(e); - let n = (0, K$e.toBytes)(r); - if ( - ((this.iHash = e.create()), typeof this.iHash.update != "function") - ) - throw new TypeError( - "Expected instance of class which extends utils.Hash" - ); - (this.blockLen = this.iHash.blockLen), - (this.outputLen = this.iHash.outputLen); - let i = this.blockLen, - o = new Uint8Array(i); - o.set(n.length > i ? e.create().update(n).digest() : n); - for (let a = 0; a < o.length; a++) o[a] ^= 54; - this.iHash.update(o), (this.oHash = e.create()); - for (let a = 0; a < o.length; a++) o[a] ^= 106; - this.oHash.update(o), o.fill(0); - } - update(e) { - return _Y.default.exists(this), this.iHash.update(e), this; - } - digestInto(e) { - _Y.default.exists(this), - _Y.default.bytes(e, this.outputLen), - (this.finished = !0), - this.iHash.digestInto(e), - this.oHash.update(e), - this.oHash.digestInto(e), - this.destroy(); - } - digest() { - let e = new Uint8Array(this.oHash.outputLen); - return this.digestInto(e), e; - } - _cloneInto(e) { - e || (e = Object.create(Object.getPrototypeOf(this), {})); - let { - oHash: r, - iHash: n, - finished: i, - destroyed: o, - blockLen: a, - outputLen: s, - } = this; - return ( - (e = e), - (e.finished = i), - (e.destroyed = o), - (e.blockLen = a), - (e.outputLen = s), - (e.oHash = r._cloneInto(e.oHash)), - (e.iHash = n._cloneInto(e.iHash)), - e - ); - } - destroy() { - (this.destroyed = !0), this.oHash.destroy(), this.iHash.destroy(); - } - }, - znr = (t, e, r) => new xY(t, e).update(r).digest(); - vz.hmac = znr; - vz.hmac.create = (t, e) => new xY(t, e); - }); - var cZe = I((ti) => { - "use strict"; - m(); - g(); - Object.defineProperty(ti, "__esModule", { value: !0 }); - ti.utils = - ti.schnorr = - ti.verify = - ti.signSync = - ti.sign = - ti.getSharedSecret = - ti.recoverPublicKey = - ti.getPublicKey = - ti.Signature = - ti.Point = - ti.CURVE = - void 0; - var jnr = Rp(), - si = BigInt(0), - Vo = BigInt(1), - P2 = BigInt(2), - wz = BigInt(3), - Unr = BigInt(8), - $i = Object.freeze({ - a: si, - b: BigInt(7), - P: BigInt( - "0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f" - ), - n: BigInt( - "0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141" - ), - h: Vo, - Gx: BigInt( - "55066263022277343669578718895168534326250603453777594175500187360389116729240" - ), - Gy: BigInt( - "32670510020758816978083085130507043184471273380659243275938904335757337482424" - ), - beta: BigInt( - "0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee" - ), - }); - ti.CURVE = $i; - function V$e(t) { - let { a: e, b: r } = $i, - n = Qt(t * t), - i = Qt(n * t); - return Qt(i + e * t + r); - } - var SY = $i.a === si, - xz = class extends Error { - constructor(e) { - super(e); - } - }, - ji = class { - constructor(e, r, n) { - (this.x = e), (this.y = r), (this.z = n); - } - static fromAffine(e) { - if (!(e instanceof Oi)) - throw new TypeError("JacobianPoint#fromAffine: expected Point"); - return new ji(e.x, e.y, Vo); - } - static toAffineBatch(e) { - let r = Gnr(e.map((n) => n.z)); - return e.map((n, i) => n.toAffine(r[i])); - } - static normalizeZ(e) { - return ji.toAffineBatch(e).map(ji.fromAffine); - } - equals(e) { - if (!(e instanceof ji)) throw new TypeError("JacobianPoint expected"); - let { x: r, y: n, z: i } = this, - { x: o, y: a, z: s } = e, - c = Qt(i * i), - u = Qt(s * s), - h = Qt(r * u), - w = Qt(o * c), - M = Qt(Qt(n * s) * u), - k = Qt(Qt(a * i) * c); - return h === w && M === k; - } - negate() { - return new ji(this.x, Qt(-this.y), this.z); - } - double() { - let { x: e, y: r, z: n } = this, - i = Qt(e * e), - o = Qt(r * r), - a = Qt(o * o), - s = e + o, - c = Qt(P2 * (Qt(s * s) - i - a)), - u = Qt(wz * i), - h = Qt(u * u), - w = Qt(h - P2 * c), - M = Qt(u * (c - w) - Unr * a), - k = Qt(P2 * r * n); - return new ji(w, M, k); - } - add(e) { - if (!(e instanceof ji)) throw new TypeError("JacobianPoint expected"); - let { x: r, y: n, z: i } = this, - { x: o, y: a, z: s } = e; - if (o === si || a === si) return this; - if (r === si || n === si) return e; - let c = Qt(i * i), - u = Qt(s * s), - h = Qt(r * u), - w = Qt(o * c), - M = Qt(Qt(n * s) * u), - k = Qt(Qt(a * i) * c), - O = Qt(w - h), - D = Qt(k - M); - if (O === si) return D === si ? this.double() : ji.ZERO; - let F = Qt(O * O), - N = Qt(O * F), - q = Qt(h * F), - z = Qt(D * D - N - P2 * q), - H = Qt(D * (q - z) - M * N), - Z = Qt(i * s * O); - return new ji(z, H, Z); - } - subtract(e) { - return this.add(e.negate()); - } - multiplyUnsafe(e) { - let r = ji.ZERO; - if (typeof e == "bigint" && e === si) return r; - let n = J$e(e); - if (n === Vo) return this; - if (!SY) { - let w = r, - M = this; - for (; n > si; ) - n & Vo && (w = w.add(M)), (M = M.double()), (n >>= Vo); - return w; - } - let { k1neg: i, k1: o, k2neg: a, k2: s } = Z$e(n), - c = r, - u = r, - h = this; - for (; o > si || s > si; ) - o & Vo && (c = c.add(h)), - s & Vo && (u = u.add(h)), - (h = h.double()), - (o >>= Vo), - (s >>= Vo); - return ( - i && (c = c.negate()), - a && (u = u.negate()), - (u = new ji(Qt(u.x * $i.beta), u.y, u.z)), - c.add(u) - ); - } - precomputeWindow(e) { - let r = SY ? 128 / e + 1 : 256 / e + 1, - n = [], - i = this, - o = i; - for (let a = 0; a < r; a++) { - (o = i), n.push(o); - for (let s = 1; s < 2 ** (e - 1); s++) (o = o.add(i)), n.push(o); - i = o.double(); - } - return n; - } - wNAF(e, r) { - !r && this.equals(ji.BASE) && (r = Oi.BASE); - let n = (r && r._WINDOW_SIZE) || 1; - if (256 % n) - throw new Error( - "Point#wNAF: Invalid precomputation window, must be power of 2" - ); - let i = r && P1e.get(r); - i || - ((i = this.precomputeWindow(n)), - r && n !== 1 && ((i = ji.normalizeZ(i)), P1e.set(r, i))); - let o = ji.ZERO, - a = ji.ZERO, - s = 1 + (SY ? 128 / n : 256 / n), - c = 2 ** (n - 1), - u = BigInt(2 ** n - 1), - h = 2 ** n, - w = BigInt(n); - for (let M = 0; M < s; M++) { - let k = M * c, - O = Number(e & u); - if (((e >>= w), O > c && ((O -= h), (e += Vo)), O === 0)) { - let D = i[k]; - M % 2 && (D = D.negate()), (a = a.add(D)); - } else { - let D = i[k + Math.abs(O) - 1]; - O < 0 && (D = D.negate()), (o = o.add(D)); - } - } - return { p: o, f: a }; - } - multiply(e, r) { - let n = J$e(e), - i, - o; - if (SY) { - let { k1neg: a, k1: s, k2neg: c, k2: u } = Z$e(n), - { p: h, f: w } = this.wNAF(s, r), - { p: M, f: k } = this.wNAF(u, r); - a && (h = h.negate()), - c && (M = M.negate()), - (M = new ji(Qt(M.x * $i.beta), M.y, M.z)), - (i = h.add(M)), - (o = w.add(k)); - } else { - let { p: a, f: s } = this.wNAF(n, r); - (i = a), (o = s); - } - return ji.normalizeZ([i, o])[0]; - } - toAffine(e = cC(this.z)) { - let { x: r, y: n, z: i } = this, - o = e, - a = Qt(o * o), - s = Qt(a * o), - c = Qt(r * a), - u = Qt(n * s); - if (Qt(i * o) !== Vo) throw new Error("invZ was invalid"); - return new Oi(c, u); - } - }; - ji.BASE = new ji($i.Gx, $i.Gy, Vo); - ji.ZERO = new ji(si, Vo, si); - var P1e = new WeakMap(), - Oi = class { - constructor(e, r) { - (this.x = e), (this.y = r); - } - _setWindowSize(e) { - (this._WINDOW_SIZE = e), P1e.delete(this); - } - hasEvenY() { - return this.y % P2 === si; - } - static fromCompressedHex(e) { - let r = e.length === 32, - n = Ch(r ? e : e.subarray(1)); - if (!EY(n)) throw new Error("Point is not on curve"); - let i = V$e(n), - o = Wnr(i), - a = (o & Vo) === Vo; - r ? a && (o = Qt(-o)) : ((e[0] & 1) === 1) !== a && (o = Qt(-o)); - let s = new Oi(n, o); - return s.assertValidity(), s; - } - static fromUncompressedHex(e) { - let r = Ch(e.subarray(1, 33)), - n = Ch(e.subarray(33, 65)), - i = new Oi(r, n); - return i.assertValidity(), i; - } - static fromHex(e) { - let r = Ev(e), - n = r.length, - i = r[0]; - if (n === 32 || (n === 33 && (i === 2 || i === 3))) - return this.fromCompressedHex(r); - if (n === 65 && i === 4) return this.fromUncompressedHex(r); - throw new Error( - `Point.fromHex: received invalid point. Expected 32-33 compressed bytes or 65 uncompressed bytes, not ${n}` - ); - } - static fromPrivateKey(e) { - return Oi.BASE.multiply(HM(e)); - } - static fromSignature(e, r, n) { - e = Ev(e); - let i = Y$e(e), - { r: o, s: a } = eZe(r); - if (n !== 0 && n !== 1) - throw new Error("Cannot recover signature: invalid recovery bit"); - let s = n & 1 ? "03" : "02", - c = Oi.fromHex(s + O2(o)), - { n: u } = $i, - h = cC(o, u), - w = Qt(-i * h, u), - M = Qt(a * h, u), - k = Oi.BASE.multiplyAndAddUnsafe(c, w, M); - if (!k) - throw new Error("Cannot recover signature: point at infinify"); - return k.assertValidity(), k; - } - toRawBytes(e = !1) { - return B2(this.toHex(e)); - } - toHex(e = !1) { - let r = O2(this.x); - return e - ? `${this.hasEvenY() ? "02" : "03"}${r}` - : `04${r}${O2(this.y)}`; - } - toHexX() { - return this.toHex(!0).slice(2); - } - toRawX() { - return this.toRawBytes(!0).slice(1); - } - assertValidity() { - let e = "Point is not on elliptic curve", - { x: r, y: n } = this; - if (!EY(r) || !EY(n)) throw new Error(e); - let i = Qt(n * n), - o = V$e(r); - if (Qt(i - o) !== si) throw new Error(e); - } - equals(e) { - return this.x === e.x && this.y === e.y; - } - negate() { - return new Oi(this.x, Qt(-this.y)); - } - double() { - return ji.fromAffine(this).double().toAffine(); - } - add(e) { - return ji.fromAffine(this).add(ji.fromAffine(e)).toAffine(); - } - subtract(e) { - return this.add(e.negate()); - } - multiply(e) { - return ji.fromAffine(this).multiply(e, this).toAffine(); - } - multiplyAndAddUnsafe(e, r, n) { - let i = ji.fromAffine(this), - o = - r === si || r === Vo || this !== Oi.BASE - ? i.multiplyUnsafe(r) - : i.multiply(r), - a = ji.fromAffine(e).multiplyUnsafe(n), - s = o.add(a); - return s.equals(ji.ZERO) ? void 0 : s.toAffine(); - } - }; - ti.Point = Oi; - Oi.BASE = new Oi($i.Gx, $i.Gy); - Oi.ZERO = new Oi(si, si); - function W$e(t) { - return Number.parseInt(t[0], 16) >= 8 ? "00" + t : t; - } - function G$e(t) { - if (t.length < 2 || t[0] !== 2) - throw new Error(`Invalid signature integer tag: ${aC(t)}`); - let e = t[1], - r = t.subarray(2, e + 2); - if (!e || r.length !== e) - throw new Error("Invalid signature integer: wrong length"); - if (r[0] === 0 && r[1] <= 127) - throw new Error("Invalid signature integer: trailing length"); - return { data: Ch(r), left: t.subarray(e + 2) }; - } - function Knr(t) { - if (t.length < 2 || t[0] != 48) - throw new Error(`Invalid signature tag: ${aC(t)}`); - if (t[1] !== t.length - 2) - throw new Error("Invalid signature: incorrect length"); - let { data: e, left: r } = G$e(t.subarray(2)), - { data: n, left: i } = G$e(r); - if (i.length) - throw new Error( - `Invalid signature: left bytes after parsing: ${aC(i)}` - ); - return { r: e, s: n }; - } - var $m = class { - constructor(e, r) { - (this.r = e), (this.s = r), this.assertValidity(); - } - static fromCompact(e) { - let r = e instanceof Uint8Array, - n = "Signature.fromCompact"; - if (typeof e != "string" && !r) - throw new TypeError(`${n}: Expected string or Uint8Array`); - let i = r ? aC(e) : e; - if (i.length !== 128) throw new Error(`${n}: Expected 64-byte hex`); - return new $m(MY(i.slice(0, 64)), MY(i.slice(64, 128))); - } - static fromDER(e) { - let r = e instanceof Uint8Array; - if (typeof e != "string" && !r) - throw new TypeError( - "Signature.fromDER: Expected string or Uint8Array" - ); - let { r: n, s: i } = Knr(r ? e : B2(e)); - return new $m(n, i); - } - static fromHex(e) { - return this.fromDER(e); - } - assertValidity() { - let { r: e, s: r } = this; - if (!uC(e)) throw new Error("Invalid Signature: r must be 0 < r < n"); - if (!uC(r)) throw new Error("Invalid Signature: s must be 0 < s < n"); - } - hasHighS() { - let e = $i.n >> Vo; - return this.s > e; - } - normalizeS() { - return this.hasHighS() ? new $m(this.r, $i.n - this.s) : this; - } - toDERRawBytes(e = !1) { - return B2(this.toDERHex(e)); - } - toDERHex(e = !1) { - let r = W$e(bz(this.s)); - if (e) return r; - let n = W$e(bz(this.r)), - i = bz(n.length / 2), - o = bz(r.length / 2); - return `30${bz(n.length / 2 + r.length / 2 + 4)}02${i}${n}02${o}${r}`; - } - toRawBytes() { - return this.toDERRawBytes(); - } - toHex() { - return this.toDERHex(); - } - toCompactRawBytes() { - return B2(this.toCompactHex()); - } - toCompactHex() { - return O2(this.r) + O2(this.s); - } - }; - ti.Signature = $m; - function iC(...t) { - if (!t.every((n) => n instanceof Uint8Array)) - throw new Error("Uint8Array list expected"); - if (t.length === 1) return t[0]; - let e = t.reduce((n, i) => n + i.length, 0), - r = new Uint8Array(e); - for (let n = 0, i = 0; n < t.length; n++) { - let o = t[n]; - r.set(o, i), (i += o.length); - } - return r; - } - var Hnr = Array.from({ length: 256 }, (t, e) => - e.toString(16).padStart(2, "0") - ); - function aC(t) { - if (!(t instanceof Uint8Array)) throw new Error("Expected Uint8Array"); - let e = ""; - for (let r = 0; r < t.length; r++) e += Hnr[t[r]]; - return e; - } - var Vnr = BigInt( - "0x10000000000000000000000000000000000000000000000000000000000000000" - ); - function O2(t) { - if (typeof t != "bigint") throw new Error("Expected bigint"); - if (!(si <= t && t < Vnr)) throw new Error("Expected number < 2^256"); - return t.toString(16).padStart(64, "0"); - } - function sC(t) { - let e = B2(O2(t)); - if (e.length !== 32) throw new Error("Error: expected 32 bytes"); - return e; - } - function bz(t) { - let e = t.toString(16); - return e.length & 1 ? `0${e}` : e; - } - function MY(t) { - if (typeof t != "string") - throw new TypeError("hexToNumber: expected string, got " + typeof t); - return BigInt(`0x${t}`); - } - function B2(t) { - if (typeof t != "string") - throw new TypeError("hexToBytes: expected string, got " + typeof t); - if (t.length % 2) - throw new Error("hexToBytes: received invalid unpadded hex" + t.length); - let e = new Uint8Array(t.length / 2); - for (let r = 0; r < e.length; r++) { - let n = r * 2, - i = t.slice(n, n + 2), - o = Number.parseInt(i, 16); - if (Number.isNaN(o) || o < 0) throw new Error("Invalid byte sequence"); - e[r] = o; - } - return e; - } - function Ch(t) { - return MY(aC(t)); - } - function Ev(t) { - return t instanceof Uint8Array ? Uint8Array.from(t) : B2(t); - } - function J$e(t) { - if (typeof t == "number" && Number.isSafeInteger(t) && t > 0) - return BigInt(t); - if (typeof t == "bigint" && uC(t)) return t; - throw new TypeError( - "Expected valid private scalar: 0 < scalar < curve.n" - ); - } - function Qt(t, e = $i.P) { - let r = t % e; - return r >= si ? r : e + r; - } - function py(t, e) { - let { P: r } = $i, - n = t; - for (; e-- > si; ) (n *= n), (n %= r); - return n; - } - function Wnr(t) { - let { P: e } = $i, - r = BigInt(6), - n = BigInt(11), - i = BigInt(22), - o = BigInt(23), - a = BigInt(44), - s = BigInt(88), - c = (t * t * t) % e, - u = (c * c * t) % e, - h = (py(u, wz) * u) % e, - w = (py(h, wz) * u) % e, - M = (py(w, P2) * c) % e, - k = (py(M, n) * M) % e, - O = (py(k, i) * k) % e, - D = (py(O, a) * O) % e, - F = (py(D, s) * D) % e, - N = (py(F, a) * O) % e, - q = (py(N, wz) * u) % e, - z = (py(q, o) * k) % e, - H = (py(z, r) * c) % e; - return py(H, P2); - } - function cC(t, e = $i.P) { - if (t === si || e <= si) - throw new Error( - `invert: expected positive integers, got n=${t} mod=${e}` - ); - let r = Qt(t, e), - n = e, - i = si, - o = Vo, - a = Vo, - s = si; - for (; r !== si; ) { - let u = n / r, - h = n % r, - w = i - a * u, - M = o - s * u; - (n = r), (r = h), (i = a), (o = s), (a = w), (s = M); - } - if (n !== Vo) throw new Error("invert: does not exist"); - return Qt(i, e); - } - function Gnr(t, e = $i.P) { - let r = new Array(t.length), - n = t.reduce( - (o, a, s) => (a === si ? o : ((r[s] = o), Qt(o * a, e))), - Vo - ), - i = cC(n, e); - return ( - t.reduceRight( - (o, a, s) => - a === si ? o : ((r[s] = Qt(o * r[s], e)), Qt(o * a, e)), - i - ), - r - ); - } - var $$e = (t, e) => (t + e / P2) / e, - Jnr = { - a1: BigInt("0x3086d221a7d46bcde86c90e49284eb15"), - b1: -Vo * BigInt("0xe4437ed6010e88286f547fa90abfe4c3"), - a2: BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), - b2: BigInt("0x3086d221a7d46bcde86c90e49284eb15"), - POW_2_128: BigInt("0x100000000000000000000000000000000"), - }; - function Z$e(t) { - let { n: e } = $i, - { a1: r, b1: n, a2: i, b2: o, POW_2_128: a } = Jnr, - s = $$e(o * t, e), - c = $$e(-n * t, e), - u = Qt(t - s * r - c * i, e), - h = Qt(-s * n - c * o, e), - w = u > a, - M = h > a; - if ((w && (u = e - u), M && (h = e - h), u > a || h > a)) - throw new Error("splitScalarEndo: Endomorphism failed, k=" + t); - return { k1neg: w, k1: u, k2neg: M, k2: h }; - } - function Y$e(t) { - let { n: e } = $i, - n = t.length * 8 - 256, - i = Ch(t); - return n > 0 && (i = i >> BigInt(n)), i >= e && (i -= e), i; - } - var oC, - _z, - TY = class { - constructor() { - (this.v = new Uint8Array(32).fill(1)), - (this.k = new Uint8Array(32).fill(0)), - (this.counter = 0); - } - hmac(...e) { - return ti.utils.hmacSha256(this.k, ...e); - } - hmacSync(...e) { - return _z(this.k, ...e); - } - checkSync() { - if (typeof _z != "function") - throw new xz("hmacSha256Sync needs to be set"); - } - incr() { - if (this.counter >= 1e3) - throw new Error( - "Tried 1,000 k values for sign(), all were invalid" - ); - this.counter += 1; - } - async reseed(e = new Uint8Array()) { - (this.k = await this.hmac(this.v, Uint8Array.from([0]), e)), - (this.v = await this.hmac(this.v)), - e.length !== 0 && - ((this.k = await this.hmac(this.v, Uint8Array.from([1]), e)), - (this.v = await this.hmac(this.v))); - } - reseedSync(e = new Uint8Array()) { - this.checkSync(), - (this.k = this.hmacSync(this.v, Uint8Array.from([0]), e)), - (this.v = this.hmacSync(this.v)), - e.length !== 0 && - ((this.k = this.hmacSync(this.v, Uint8Array.from([1]), e)), - (this.v = this.hmacSync(this.v))); - } - async generate() { - return this.incr(), (this.v = await this.hmac(this.v)), this.v; - } - generateSync() { - return ( - this.checkSync(), - this.incr(), - (this.v = this.hmacSync(this.v)), - this.v - ); - } - }; - function uC(t) { - return si < t && t < $i.n; - } - function EY(t) { - return si < t && t < $i.P; - } - function Q$e(t, e, r) { - let n = Ch(t); - if (!uC(n)) return; - let { n: i } = $i, - o = Oi.BASE.multiply(n), - a = Qt(o.x, i); - if (a === si) return; - let s = Qt(cC(n, i) * Qt(e + r * a, i), i); - if (s === si) return; - let c = new $m(a, s), - u = (o.x === c.r ? 0 : 2) | Number(o.y & Vo); - return { sig: c, recovery: u }; - } - function HM(t) { - let e; - if (typeof t == "bigint") e = t; - else if (typeof t == "number" && Number.isSafeInteger(t) && t > 0) - e = BigInt(t); - else if (typeof t == "string") { - if (t.length !== 64) - throw new Error("Expected 32 bytes of private key"); - e = MY(t); - } else if (t instanceof Uint8Array) { - if (t.length !== 32) - throw new Error("Expected 32 bytes of private key"); - e = Ch(t); - } else throw new TypeError("Expected valid private key"); - if (!uC(e)) throw new Error("Expected private key: 0 < key < n"); - return e; - } - function O1e(t) { - return t instanceof Oi ? (t.assertValidity(), t) : Oi.fromHex(t); - } - function eZe(t) { - if (t instanceof $m) return t.assertValidity(), t; - try { - return $m.fromDER(t); - } catch { - return $m.fromCompact(t); - } - } - function $nr(t, e = !1) { - return Oi.fromPrivateKey(t).toRawBytes(e); - } - ti.getPublicKey = $nr; - function Znr(t, e, r, n = !1) { - return Oi.fromSignature(t, e, r).toRawBytes(n); - } - ti.recoverPublicKey = Znr; - function X$e(t) { - let e = t instanceof Uint8Array, - r = typeof t == "string", - n = (e || r) && t.length; - return e - ? n === 33 || n === 65 - : r - ? n === 66 || n === 130 - : t instanceof Oi; - } - function Xnr(t, e, r = !1) { - if (X$e(t)) - throw new TypeError("getSharedSecret: first arg must be private key"); - if (!X$e(e)) - throw new TypeError("getSharedSecret: second arg must be public key"); - let n = O1e(e); - return n.assertValidity(), n.multiply(HM(t)).toRawBytes(r); - } - ti.getSharedSecret = Xnr; - function tZe(t) { - let e = t.length > 32 ? t.slice(0, 32) : t; - return Ch(e); - } - function Ynr(t) { - let e = tZe(t), - r = Qt(e, $i.n); - return rZe(r < si ? e : r); - } - function rZe(t) { - return sC(t); - } - function nZe(t, e, r) { - if (t == null) - throw new Error(`sign: expected valid message hash, not "${t}"`); - let n = Ev(t), - i = HM(e), - o = [rZe(i), Ynr(n)]; - if (r != null) { - r === !0 && (r = ti.utils.randomBytes(32)); - let c = Ev(r); - if (c.length !== 32) - throw new Error("sign: Expected 32 bytes of extra data"); - o.push(c); - } - let a = iC(...o), - s = tZe(n); - return { seed: a, m: s, d: i }; - } - function iZe(t, e) { - let { sig: r, recovery: n } = t, - { - canonical: i, - der: o, - recovered: a, - } = Object.assign({ canonical: !0, der: !0 }, e); - i && r.hasHighS() && ((r = r.normalizeS()), (n ^= 1)); - let s = o ? r.toDERRawBytes() : r.toCompactRawBytes(); - return a ? [s, n] : s; - } - async function Qnr(t, e, r = {}) { - let { seed: n, m: i, d: o } = nZe(t, e, r.extraEntropy), - a, - s = new TY(); - for (await s.reseed(n); !(a = Q$e(await s.generate(), i, o)); ) - await s.reseed(); - return iZe(a, r); - } - ti.sign = Qnr; - function eir(t, e, r = {}) { - let { seed: n, m: i, d: o } = nZe(t, e, r.extraEntropy), - a, - s = new TY(); - for (s.reseedSync(n); !(a = Q$e(s.generateSync(), i, o)); ) - s.reseedSync(); - return iZe(a, r); - } - ti.signSync = eir; - var tir = { strict: !0 }; - function rir(t, e, r, n = tir) { - let i; - try { - (i = eZe(t)), (e = Ev(e)); - } catch { - return !1; - } - let { r: o, s: a } = i; - if (n.strict && i.hasHighS()) return !1; - let s = Y$e(e), - c; - try { - c = O1e(r); - } catch { - return !1; - } - let { n: u } = $i, - h = cC(a, u), - w = Qt(s * h, u), - M = Qt(o * h, u), - k = Oi.BASE.multiplyAndAddUnsafe(c, w, M); - return k ? Qt(k.x, u) === o : !1; - } - ti.verify = rir; - function kY(t) { - return Qt(Ch(t), $i.n); - } - var I2 = class { - constructor(e, r) { - (this.r = e), (this.s = r), this.assertValidity(); - } - static fromHex(e) { - let r = Ev(e); - if (r.length !== 64) - throw new TypeError( - `SchnorrSignature.fromHex: expected 64 bytes, not ${r.length}` - ); - let n = Ch(r.subarray(0, 32)), - i = Ch(r.subarray(32, 64)); - return new I2(n, i); - } - assertValidity() { - let { r: e, s: r } = this; - if (!EY(e) || !uC(r)) throw new Error("Invalid signature"); - } - toHex() { - return O2(this.r) + O2(this.s); - } - toRawBytes() { - return B2(this.toHex()); - } - }; - function nir(t) { - return Oi.fromPrivateKey(t).toRawX(); - } - var PY = class { - constructor(e, r, n = ti.utils.randomBytes()) { - if (e == null) - throw new TypeError(`sign: Expected valid message, not "${e}"`); - this.m = Ev(e); - let { x: i, scalar: o } = this.getScalar(HM(r)); - if ( - ((this.px = i), - (this.d = o), - (this.rand = Ev(n)), - this.rand.length !== 32) - ) - throw new TypeError("sign: Expected 32 bytes of aux randomness"); - } - getScalar(e) { - let r = Oi.fromPrivateKey(e), - n = r.hasEvenY() ? e : $i.n - e; - return { point: r, scalar: n, x: r.toRawX() }; - } - initNonce(e, r) { - return sC(e ^ Ch(r)); - } - finalizeNonce(e) { - let r = Qt(Ch(e), $i.n); - if (r === si) - throw new Error("sign: Creation of signature failed. k is zero"); - let { point: n, x: i, scalar: o } = this.getScalar(r); - return { R: n, rx: i, k: o }; - } - finalizeSig(e, r, n, i) { - return new I2(e.x, Qt(r + n * i, $i.n)).toRawBytes(); - } - error() { - throw new Error("sign: Invalid signature produced"); - } - async calc() { - let { m: e, d: r, px: n, rand: i } = this, - o = ti.utils.taggedHash, - a = this.initNonce(r, await o(k2.aux, i)), - { - R: s, - rx: c, - k: u, - } = this.finalizeNonce(await o(k2.nonce, a, n, e)), - h = kY(await o(k2.challenge, c, n, e)), - w = this.finalizeSig(s, u, h, r); - return (await sZe(w, e, n)) || this.error(), w; - } - calcSync() { - let { m: e, d: r, px: n, rand: i } = this, - o = ti.utils.taggedHashSync, - a = this.initNonce(r, o(k2.aux, i)), - { R: s, rx: c, k: u } = this.finalizeNonce(o(k2.nonce, a, n, e)), - h = kY(o(k2.challenge, c, n, e)), - w = this.finalizeSig(s, u, h, r); - return uZe(w, e, n) || this.error(), w; - } - }; - async function iir(t, e, r) { - return new PY(t, e, r).calc(); - } - function oir(t, e, r) { - return new PY(t, e, r).calcSync(); - } - function oZe(t, e, r) { - let n = t instanceof I2, - i = n ? t : I2.fromHex(t); - return n && i.assertValidity(), { ...i, m: Ev(e), P: O1e(r) }; - } - function aZe(t, e, r, n) { - let i = Oi.BASE.multiplyAndAddUnsafe(e, HM(r), Qt(-n, $i.n)); - return !(!i || !i.hasEvenY() || i.x !== t); - } - async function sZe(t, e, r) { - try { - let { r: n, s: i, m: o, P: a } = oZe(t, e, r), - s = kY(await ti.utils.taggedHash(k2.challenge, sC(n), a.toRawX(), o)); - return aZe(n, a, i, s); - } catch { - return !1; - } - } - function uZe(t, e, r) { - try { - let { r: n, s: i, m: o, P: a } = oZe(t, e, r), - s = kY(ti.utils.taggedHashSync(k2.challenge, sC(n), a.toRawX(), o)); - return aZe(n, a, i, s); - } catch (n) { - if (n instanceof xz) throw n; - return !1; - } - } - ti.schnorr = { - Signature: I2, - getPublicKey: nir, - sign: iir, - verify: sZe, - signSync: oir, - verifySync: uZe, - }; - Oi.BASE._setWindowSize(8); - var zp = { - node: jnr, - web: typeof self == "object" && "crypto" in self ? self.crypto : void 0, - }, - k2 = { - challenge: "BIP0340/challenge", - aux: "BIP0340/aux", - nonce: "BIP0340/nonce", - }, - AY = {}; - ti.utils = { - bytesToHex: aC, - hexToBytes: B2, - concatBytes: iC, - mod: Qt, - invert: cC, - isValidPrivateKey(t) { - try { - return HM(t), !0; - } catch { - return !1; - } - }, - _bigintTo32Bytes: sC, - _normalizePrivateKey: HM, - hashToPrivateKey: (t) => { - if (((t = Ev(t)), t.length < 40 || t.length > 1024)) - throw new Error( - "Expected 40-1024 bytes of private key as per FIPS 186" - ); - let e = Qt(Ch(t), $i.n - Vo) + Vo; - return sC(e); - }, - randomBytes: (t = 32) => { - if (zp.web) return zp.web.getRandomValues(new Uint8Array(t)); - if (zp.node) { - let { randomBytes: e } = zp.node; - return Uint8Array.from(e(t)); - } else - throw new Error("The environment doesn't have randomBytes function"); - }, - randomPrivateKey: () => - ti.utils.hashToPrivateKey(ti.utils.randomBytes(40)), - sha256: async (...t) => { - if (zp.web) { - let e = await zp.web.subtle.digest("SHA-256", iC(...t)); - return new Uint8Array(e); - } else if (zp.node) { - let { createHash: e } = zp.node, - r = e("sha256"); - return t.forEach((n) => r.update(n)), Uint8Array.from(r.digest()); - } else throw new Error("The environment doesn't have sha256 function"); - }, - hmacSha256: async (t, ...e) => { - if (zp.web) { - let r = await zp.web.subtle.importKey( - "raw", - t, - { name: "HMAC", hash: { name: "SHA-256" } }, - !1, - ["sign"] - ), - n = iC(...e), - i = await zp.web.subtle.sign("HMAC", r, n); - return new Uint8Array(i); - } else if (zp.node) { - let { createHmac: r } = zp.node, - n = r("sha256", t); - return e.forEach((i) => n.update(i)), Uint8Array.from(n.digest()); - } else - throw new Error("The environment doesn't have hmac-sha256 function"); - }, - sha256Sync: void 0, - hmacSha256Sync: void 0, - taggedHash: async (t, ...e) => { - let r = AY[t]; - if (r === void 0) { - let n = await ti.utils.sha256( - Uint8Array.from(t, (i) => i.charCodeAt(0)) - ); - (r = iC(n, n)), (AY[t] = r); - } - return ti.utils.sha256(r, ...e); - }, - taggedHashSync: (t, ...e) => { - if (typeof oC != "function") - throw new xz("sha256Sync is undefined, you need to set it"); - let r = AY[t]; - if (r === void 0) { - let n = oC(Uint8Array.from(t, (i) => i.charCodeAt(0))); - (r = iC(n, n)), (AY[t] = r); - } - return oC(r, ...e); - }, - precompute(t = 8, e = Oi.BASE) { - let r = e === Oi.BASE ? e : new Oi(e.x, e.y); - return r._setWindowSize(t), r.multiply(wz), r; - }, - }; - Object.defineProperties(ti.utils, { - sha256Sync: { - configurable: !1, - get() { - return oC; - }, - set(t) { - oC || (oC = t); - }, - }, - hmacSha256Sync: { - configurable: !1, - get() { - return _z; - }, - set(t) { - _z || (_z = t); - }, - }, - }); - }); - var Le = I((Gt) => { - "use strict"; - m(); - g(); - Object.defineProperty(Gt, "__esModule", { value: !0 }); - var Cr = Qr(), - air = Dze(), - sir = CX(), - uir = Ho(), - cir = xv(), - L1e = r$e(), - B1e = s$e(), - TZe = Sn(), - q1e = uY(), - X = y$e(), - lir = O$e(), - fir = R$e(), - lZe = U$e(), - dir = H$e(), - hir = cZe(); - function Y1e(t) { - return t && typeof t == "object" && "default" in t ? t : { default: t }; - } - function Q1e(t) { - if (t && t.__esModule) return t; - var e = Object.create(null); - return ( - t && - Object.keys(t).forEach(function (r) { - if (r !== "default") { - var n = Object.getOwnPropertyDescriptor(t, r); - Object.defineProperty( - e, - r, - n.get - ? n - : { - enumerable: !0, - get: function () { - return t[r]; - }, - } - ); - } - }), - (e.default = t), - Object.freeze(e) - ); - } - var D2 = Q1e(sir), - fZe = Y1e(uir), - nc = Y1e(cir), - Ne = Q1e(TZe), - pir = Y1e(fir), - qY = Q1e(hir); - D2.utils.sha512Sync = (...t) => air.sha512(D2.utils.concatBytes(...t)); - var yir = D2.utils.randomPrivateKey, - dZe = () => { - let t = D2.utils.randomPrivateKey(), - e = RY(t), - r = new Uint8Array(64); - return r.set(t), r.set(e, 32), { publicKey: e, secretKey: r }; - }, - RY = D2.sync.getPublicKey; - function hZe(t) { - try { - return D2.Point.fromHex(t, !0), !0; - } catch { - return !1; - } - } - var ewe = (t, e) => D2.sync.sign(t, e.slice(0, 32)), - mir = D2.sync.verify, - On = (t) => - Cr.Buffer.isBuffer(t) - ? t - : t instanceof Uint8Array - ? Cr.Buffer.from(t.buffer, t.byteOffset, t.byteLength) - : Cr.Buffer.from(t), - Tz = class { - constructor(e) { - Object.assign(this, e); - } - encode() { - return Cr.Buffer.from(B1e.serialize(Ez, this)); - } - static decode(e) { - return B1e.deserialize(Ez, this, e); - } - static decodeUnchecked(e) { - return B1e.deserializeUnchecked(Ez, this, e); - } - }, - z1e = class extends Tz { - constructor(e) { - if ((super(e), (this.enum = ""), Object.keys(e).length !== 1)) - throw new Error("Enum can only take single value"); - Object.keys(e).map((r) => { - this.enum = r; - }); - } - }, - Ez = new Map(), - kZe = 32, - yy = 32; - function gir(t) { - return t._bn !== void 0; - } - var pZe = 1, - $t = class extends Tz { - constructor(e) { - if ((super({}), (this._bn = void 0), gir(e))) this._bn = e._bn; - else { - if (typeof e == "string") { - let r = nc.default.decode(e); - if (r.length != yy) throw new Error("Invalid public key input"); - this._bn = new fZe.default(r); - } else this._bn = new fZe.default(e); - if (this._bn.byteLength() > 32) - throw new Error("Invalid public key input"); - } - } - static unique() { - let e = new $t(pZe); - return (pZe += 1), new $t(e.toBuffer()); - } - equals(e) { - return this._bn.eq(e._bn); - } - toBase58() { - return nc.default.encode(this.toBytes()); - } - toJSON() { - return this.toBase58(); - } - toBytes() { - return this.toBuffer(); - } - toBuffer() { - let e = this._bn.toArrayLike(Cr.Buffer); - if (e.length === yy) return e; - let r = Cr.Buffer.alloc(32); - return e.copy(r, 32 - e.length), r; - } - toString() { - return this.toBase58(); - } - static async createWithSeed(e, r, n) { - let i = Cr.Buffer.concat([ - e.toBuffer(), - Cr.Buffer.from(r), - n.toBuffer(), - ]), - o = L1e.sha256(i); - return new $t(o); - } - static createProgramAddressSync(e, r) { - let n = Cr.Buffer.alloc(0); - e.forEach(function (o) { - if (o.length > kZe) throw new TypeError("Max seed length exceeded"); - n = Cr.Buffer.concat([n, On(o)]); - }), - (n = Cr.Buffer.concat([ - n, - r.toBuffer(), - Cr.Buffer.from("ProgramDerivedAddress"), - ])); - let i = L1e.sha256(n); - if (hZe(i)) - throw new Error("Invalid seeds, address must fall off the curve"); - return new $t(i); - } - static async createProgramAddress(e, r) { - return this.createProgramAddressSync(e, r); - } - static findProgramAddressSync(e, r) { - let n = 255, - i; - for (; n != 0; ) { - try { - let o = e.concat(Cr.Buffer.from([n])); - i = this.createProgramAddressSync(o, r); - } catch (o) { - if (o instanceof TypeError) throw o; - n--; - continue; - } - return [i, n]; - } - throw new Error("Unable to find a viable program address nonce"); - } - static async findProgramAddress(e, r) { - return this.findProgramAddressSync(e, r); - } - static isOnCurve(e) { - let r = new $t(e); - return hZe(r.toBytes()); - } - }; - $t.default = new $t("11111111111111111111111111111111"); - Ez.set($t, { kind: "struct", fields: [["_bn", "u256"]] }); - var j1e = class { - constructor(e) { - if (((this._publicKey = void 0), (this._secretKey = void 0), e)) { - let r = On(e); - if (e.length !== 64) throw new Error("bad secret key size"); - (this._publicKey = r.slice(32, 64)), - (this._secretKey = r.slice(0, 32)); - } else - (this._secretKey = On(yir())), - (this._publicKey = On(RY(this._secretKey))); - } - get publicKey() { - return new $t(this._publicKey); - } - get secretKey() { - return Cr.Buffer.concat([this._secretKey, this._publicKey], 64); - } - }, - vir = new $t("BPFLoader1111111111111111111111111111111111"), - C2 = 1280 - 40 - 8, - zY = 127, - lC = 64, - kz = class extends Error { - constructor(e) { - super(`Signature ${e} has expired: block height exceeded.`), - (this.signature = void 0), - (this.signature = e); - } - }; - Object.defineProperty(kz.prototype, "name", { - value: "TransactionExpiredBlockheightExceededError", - }); - var Pz = class extends Error { - constructor(e, r) { - super( - `Transaction was not confirmed in ${r.toFixed( - 2 - )} seconds. It is unknown if it succeeded or failed. Check signature ${e} using the Solana Explorer or CLI tools.` - ), - (this.signature = void 0), - (this.signature = e); - } - }; - Object.defineProperty(Pz.prototype, "name", { - value: "TransactionExpiredTimeoutError", - }); - var WM = class { - constructor(e, r) { - (this.staticAccountKeys = void 0), - (this.accountKeysFromLookups = void 0), - (this.staticAccountKeys = e), - (this.accountKeysFromLookups = r); - } - keySegments() { - let e = [this.staticAccountKeys]; - return ( - this.accountKeysFromLookups && - (e.push(this.accountKeysFromLookups.writable), - e.push(this.accountKeysFromLookups.readonly)), - e - ); - } - get(e) { - for (let r of this.keySegments()) { - if (e < r.length) return r[e]; - e -= r.length; - } - } - get length() { - return this.keySegments().flat().length; - } - compileInstructions(e) { - if (this.length > 255 + 1) - throw new Error( - "Account index overflow encountered during compilation" - ); - let n = new Map(); - this.keySegments() - .flat() - .forEach((o, a) => { - n.set(o.toBase58(), a); - }); - let i = (o) => { - let a = n.get(o.toBase58()); - if (a === void 0) - throw new Error( - "Encountered an unknown instruction account key during compilation" - ); - return a; - }; - return e.map((o) => ({ - programIdIndex: i(o.programId), - accountKeyIndexes: o.keys.map((a) => i(a.pubkey)), - data: o.data, - })); - } - }, - Xn = (t = "publicKey") => Ne.blob(32, t), - bir = (t = "signature") => Ne.blob(64, t), - VM = (t = "string") => { - let e = Ne.struct( - [ - Ne.u32("length"), - Ne.u32("lengthPadding"), - Ne.blob(Ne.offset(Ne.u32(), -8), "chars"), - ], - t - ), - r = e.decode.bind(e), - n = e.encode.bind(e), - i = e; - return ( - (i.decode = (o, a) => r(o, a).chars.toString()), - (i.encode = (o, a, s) => { - let c = { chars: Cr.Buffer.from(o, "utf8") }; - return n(c, a, s); - }), - (i.alloc = (o) => - Ne.u32().span + Ne.u32().span + Cr.Buffer.from(o, "utf8").length), - i - ); - }, - wir = (t = "authorized") => - Ne.struct([Xn("staker"), Xn("withdrawer")], t), - _ir = (t = "lockup") => - Ne.struct( - [Ne.ns64("unixTimestamp"), Ne.ns64("epoch"), Xn("custodian")], - t - ), - xir = (t = "voteInit") => - Ne.struct( - [ - Xn("nodePubkey"), - Xn("authorizedVoter"), - Xn("authorizedWithdrawer"), - Ne.u8("commission"), - ], - t - ), - Sir = (t = "voteAuthorizeWithSeedArgs") => - Ne.struct( - [ - Ne.u32("voteAuthorizationType"), - Xn("currentAuthorityDerivedKeyOwnerPubkey"), - VM("currentAuthorityDerivedKeySeed"), - Xn("newAuthorized"), - ], - t - ); - function PZe(t, e) { - let r = (i) => { - if (i.span >= 0) return i.span; - if (typeof i.alloc == "function") return i.alloc(e[i.property]); - if ("count" in i && "elementLayout" in i) { - let o = e[i.property]; - if (Array.isArray(o)) return o.length * r(i.elementLayout); - } else if ("fields" in i) return PZe({ layout: i }, e[i.property]); - return 0; - }, - n = 0; - return ( - t.layout.fields.forEach((i) => { - n += r(i); - }), - n - ); - } - function Rh(t) { - let e = 0, - r = 0; - for (;;) { - let n = t.shift(); - if (((e |= (n & 127) << (r * 7)), (r += 1), (n & 128) === 0)) break; - } - return e; - } - function jp(t, e) { - let r = e; - for (;;) { - let n = r & 127; - if (((r >>= 7), r == 0)) { - t.push(n); - break; - } else (n |= 128), t.push(n); - } - } - function Ii(t, e) { - if (!t) throw new Error(e || "Assertion failed"); - } - var fC = class { - constructor(e, r) { - (this.payer = void 0), - (this.keyMetaMap = void 0), - (this.payer = e), - (this.keyMetaMap = r); - } - static compile(e, r) { - let n = new Map(), - i = (a) => { - let s = a.toBase58(), - c = n.get(s); - return ( - c === void 0 && - ((c = { isSigner: !1, isWritable: !1, isInvoked: !1 }), - n.set(s, c)), - c - ); - }, - o = i(r); - (o.isSigner = !0), (o.isWritable = !0); - for (let a of e) { - i(a.programId).isInvoked = !0; - for (let s of a.keys) { - let c = i(s.pubkey); - c.isSigner || (c.isSigner = s.isSigner), - c.isWritable || (c.isWritable = s.isWritable); - } - } - return new fC(r, n); - } - getMessageComponents() { - let e = [...this.keyMetaMap.entries()]; - Ii(e.length <= 256, "Max static account keys length exceeded"); - let r = e.filter(([, c]) => c.isSigner && c.isWritable), - n = e.filter(([, c]) => c.isSigner && !c.isWritable), - i = e.filter(([, c]) => !c.isSigner && c.isWritable), - o = e.filter(([, c]) => !c.isSigner && !c.isWritable), - a = { - numRequiredSignatures: r.length + n.length, - numReadonlySignedAccounts: n.length, - numReadonlyUnsignedAccounts: o.length, - }; - { - Ii(r.length > 0, "Expected at least one writable signer key"); - let [c] = r[0]; - Ii( - c === this.payer.toBase58(), - "Expected first writable signer key to be the fee payer" - ); - } - let s = [ - ...r.map(([c]) => new $t(c)), - ...n.map(([c]) => new $t(c)), - ...i.map(([c]) => new $t(c)), - ...o.map(([c]) => new $t(c)), - ]; - return [a, s]; - } - extractTableLookup(e) { - let [r, n] = this.drainKeysFoundInLookupTable( - e.state.addresses, - (a) => !a.isSigner && !a.isInvoked && a.isWritable - ), - [i, o] = this.drainKeysFoundInLookupTable( - e.state.addresses, - (a) => !a.isSigner && !a.isInvoked && !a.isWritable - ); - if (!(r.length === 0 && i.length === 0)) - return [ - { accountKey: e.key, writableIndexes: r, readonlyIndexes: i }, - { writable: n, readonly: o }, - ]; - } - drainKeysFoundInLookupTable(e, r) { - let n = new Array(), - i = new Array(); - for (let [o, a] of this.keyMetaMap.entries()) - if (r(a)) { - let s = new $t(o), - c = e.findIndex((u) => u.equals(s)); - c >= 0 && - (Ii(c < 256, "Max lookup table index exceeded"), - n.push(c), - i.push(s), - this.keyMetaMap.delete(o)); - } - return [n, i]; - } - }, - Up = class { - constructor(e) { - (this.header = void 0), - (this.accountKeys = void 0), - (this.recentBlockhash = void 0), - (this.instructions = void 0), - (this.indexToProgramIds = new Map()), - (this.header = e.header), - (this.accountKeys = e.accountKeys.map((r) => new $t(r))), - (this.recentBlockhash = e.recentBlockhash), - (this.instructions = e.instructions), - this.instructions.forEach((r) => - this.indexToProgramIds.set( - r.programIdIndex, - this.accountKeys[r.programIdIndex] - ) - ); - } - get version() { - return "legacy"; - } - get staticAccountKeys() { - return this.accountKeys; - } - get compiledInstructions() { - return this.instructions.map((e) => ({ - programIdIndex: e.programIdIndex, - accountKeyIndexes: e.accounts, - data: nc.default.decode(e.data), - })); - } - get addressTableLookups() { - return []; - } - getAccountKeys() { - return new WM(this.staticAccountKeys); - } - static compile(e) { - let r = fC.compile(e.instructions, e.payerKey), - [n, i] = r.getMessageComponents(), - a = new WM(i).compileInstructions(e.instructions).map((s) => ({ - programIdIndex: s.programIdIndex, - accounts: s.accountKeyIndexes, - data: nc.default.encode(s.data), - })); - return new Up({ - header: n, - accountKeys: i, - recentBlockhash: e.recentBlockhash, - instructions: a, - }); - } - isAccountSigner(e) { - return e < this.header.numRequiredSignatures; - } - isAccountWritable(e) { - let r = this.header.numRequiredSignatures; - if (e >= this.header.numRequiredSignatures) { - let n = e - r, - o = - this.accountKeys.length - - r - - this.header.numReadonlyUnsignedAccounts; - return n < o; - } else { - let n = r - this.header.numReadonlySignedAccounts; - return e < n; - } - } - isProgramId(e) { - return this.indexToProgramIds.has(e); - } - programIds() { - return [...this.indexToProgramIds.values()]; - } - nonProgramIds() { - return this.accountKeys.filter((e, r) => !this.isProgramId(r)); - } - serialize() { - let e = this.accountKeys.length, - r = []; - jp(r, e); - let n = this.instructions.map((w) => { - let { accounts: M, programIdIndex: k } = w, - O = Array.from(nc.default.decode(w.data)), - D = []; - jp(D, M.length); - let F = []; - return ( - jp(F, O.length), - { - programIdIndex: k, - keyIndicesCount: Cr.Buffer.from(D), - keyIndices: M, - dataLength: Cr.Buffer.from(F), - data: O, - } - ); - }), - i = []; - jp(i, n.length); - let o = Cr.Buffer.alloc(C2); - Cr.Buffer.from(i).copy(o); - let a = i.length; - n.forEach((w) => { - a += Ne.struct([ - Ne.u8("programIdIndex"), - Ne.blob(w.keyIndicesCount.length, "keyIndicesCount"), - Ne.seq(Ne.u8("keyIndex"), w.keyIndices.length, "keyIndices"), - Ne.blob(w.dataLength.length, "dataLength"), - Ne.seq(Ne.u8("userdatum"), w.data.length, "data"), - ]).encode(w, o, a); - }), - (o = o.slice(0, a)); - let s = Ne.struct([ - Ne.blob(1, "numRequiredSignatures"), - Ne.blob(1, "numReadonlySignedAccounts"), - Ne.blob(1, "numReadonlyUnsignedAccounts"), - Ne.blob(r.length, "keyCount"), - Ne.seq(Xn("key"), e, "keys"), - Xn("recentBlockhash"), - ]), - c = { - numRequiredSignatures: Cr.Buffer.from([ - this.header.numRequiredSignatures, - ]), - numReadonlySignedAccounts: Cr.Buffer.from([ - this.header.numReadonlySignedAccounts, - ]), - numReadonlyUnsignedAccounts: Cr.Buffer.from([ - this.header.numReadonlyUnsignedAccounts, - ]), - keyCount: Cr.Buffer.from(r), - keys: this.accountKeys.map((w) => On(w.toBytes())), - recentBlockhash: nc.default.decode(this.recentBlockhash), - }, - u = Cr.Buffer.alloc(2048), - h = s.encode(c, u); - return o.copy(u, h), u.slice(0, h + o.length); - } - static from(e) { - let r = [...e], - n = r.shift(); - if (n !== (n & zY)) - throw new Error( - "Versioned messages must be deserialized with VersionedMessage.deserialize()" - ); - let i = r.shift(), - o = r.shift(), - a = Rh(r), - s = []; - for (let M = 0; M < a; M++) { - let k = r.slice(0, yy); - (r = r.slice(yy)), s.push(new $t(Cr.Buffer.from(k))); - } - let c = r.slice(0, yy); - r = r.slice(yy); - let u = Rh(r), - h = []; - for (let M = 0; M < u; M++) { - let k = r.shift(), - O = Rh(r), - D = r.slice(0, O); - r = r.slice(O); - let F = Rh(r), - N = r.slice(0, F), - q = nc.default.encode(Cr.Buffer.from(N)); - (r = r.slice(F)), - h.push({ programIdIndex: k, accounts: D, data: q }); - } - let w = { - header: { - numRequiredSignatures: n, - numReadonlySignedAccounts: i, - numReadonlyUnsignedAccounts: o, - }, - recentBlockhash: nc.default.encode(Cr.Buffer.from(c)), - accountKeys: s, - instructions: h, - }; - return new Up(w); - } - }, - G_ = class { - constructor(e) { - (this.header = void 0), - (this.staticAccountKeys = void 0), - (this.recentBlockhash = void 0), - (this.compiledInstructions = void 0), - (this.addressTableLookups = void 0), - (this.header = e.header), - (this.staticAccountKeys = e.staticAccountKeys), - (this.recentBlockhash = e.recentBlockhash), - (this.compiledInstructions = e.compiledInstructions), - (this.addressTableLookups = e.addressTableLookups); - } - get version() { - return 0; - } - get numAccountKeysFromLookups() { - let e = 0; - for (let r of this.addressTableLookups) - e += r.readonlyIndexes.length + r.writableIndexes.length; - return e; - } - getAccountKeys(e) { - let r; - if (e && "accountKeysFromLookups" in e && e.accountKeysFromLookups) { - if ( - this.numAccountKeysFromLookups != - e.accountKeysFromLookups.writable.length + - e.accountKeysFromLookups.readonly.length - ) - throw new Error( - "Failed to get account keys because of a mismatch in the number of account keys from lookups" - ); - r = e.accountKeysFromLookups; - } else if ( - e && - "addressLookupTableAccounts" in e && - e.addressLookupTableAccounts - ) - r = this.resolveAddressTableLookups(e.addressLookupTableAccounts); - else if (this.addressTableLookups.length > 0) - throw new Error( - "Failed to get account keys because address table lookups were not resolved" - ); - return new WM(this.staticAccountKeys, r); - } - isAccountSigner(e) { - return e < this.header.numRequiredSignatures; - } - isAccountWritable(e) { - let r = this.header.numRequiredSignatures, - n = this.staticAccountKeys.length; - if (e >= n) { - let i = e - n, - o = this.addressTableLookups.reduce( - (a, s) => a + s.writableIndexes.length, - 0 - ); - return i < o; - } else if (e >= this.header.numRequiredSignatures) { - let i = e - r, - a = n - r - this.header.numReadonlyUnsignedAccounts; - return i < a; - } else { - let i = r - this.header.numReadonlySignedAccounts; - return e < i; - } - } - resolveAddressTableLookups(e) { - let r = { writable: [], readonly: [] }; - for (let n of this.addressTableLookups) { - let i = e.find((o) => o.key.equals(n.accountKey)); - if (!i) - throw new Error( - `Failed to find address lookup table account for table key ${n.accountKey.toBase58()}` - ); - for (let o of n.writableIndexes) - if (o < i.state.addresses.length) - r.writable.push(i.state.addresses[o]); - else - throw new Error( - `Failed to find address for index ${o} in address lookup table ${n.accountKey.toBase58()}` - ); - for (let o of n.readonlyIndexes) - if (o < i.state.addresses.length) - r.readonly.push(i.state.addresses[o]); - else - throw new Error( - `Failed to find address for index ${o} in address lookup table ${n.accountKey.toBase58()}` - ); - } - return r; - } - static compile(e) { - let r = fC.compile(e.instructions, e.payerKey), - n = new Array(), - i = { writable: new Array(), readonly: new Array() }, - o = e.addressLookupTableAccounts || []; - for (let h of o) { - let w = r.extractTableLookup(h); - if (w !== void 0) { - let [M, { writable: k, readonly: O }] = w; - n.push(M), i.writable.push(...k), i.readonly.push(...O); - } - } - let [a, s] = r.getMessageComponents(), - u = new WM(s, i).compileInstructions(e.instructions); - return new G_({ - header: a, - staticAccountKeys: s, - recentBlockhash: e.recentBlockhash, - compiledInstructions: u, - addressTableLookups: n, - }); - } - serialize() { - let e = Array(); - jp(e, this.staticAccountKeys.length); - let r = this.serializeInstructions(), - n = Array(); - jp(n, this.compiledInstructions.length); - let i = this.serializeAddressTableLookups(), - o = Array(); - jp(o, this.addressTableLookups.length); - let a = Ne.struct([ - Ne.u8("prefix"), - Ne.struct( - [ - Ne.u8("numRequiredSignatures"), - Ne.u8("numReadonlySignedAccounts"), - Ne.u8("numReadonlyUnsignedAccounts"), - ], - "header" - ), - Ne.blob(e.length, "staticAccountKeysLength"), - Ne.seq(Xn(), this.staticAccountKeys.length, "staticAccountKeys"), - Xn("recentBlockhash"), - Ne.blob(n.length, "instructionsLength"), - Ne.blob(r.length, "serializedInstructions"), - Ne.blob(o.length, "addressTableLookupsLength"), - Ne.blob(i.length, "serializedAddressTableLookups"), - ]), - s = new Uint8Array(C2), - c = 1 << 7, - u = a.encode( - { - prefix: c, - header: this.header, - staticAccountKeysLength: new Uint8Array(e), - staticAccountKeys: this.staticAccountKeys.map((h) => - h.toBytes() - ), - recentBlockhash: nc.default.decode(this.recentBlockhash), - instructionsLength: new Uint8Array(n), - serializedInstructions: r, - addressTableLookupsLength: new Uint8Array(o), - serializedAddressTableLookups: i, - }, - s - ); - return s.slice(0, u); - } - serializeInstructions() { - let e = 0, - r = new Uint8Array(C2); - for (let n of this.compiledInstructions) { - let i = Array(); - jp(i, n.accountKeyIndexes.length); - let o = Array(); - jp(o, n.data.length), - (e += Ne.struct([ - Ne.u8("programIdIndex"), - Ne.blob(i.length, "encodedAccountKeyIndexesLength"), - Ne.seq( - Ne.u8(), - n.accountKeyIndexes.length, - "accountKeyIndexes" - ), - Ne.blob(o.length, "encodedDataLength"), - Ne.blob(n.data.length, "data"), - ]).encode( - { - programIdIndex: n.programIdIndex, - encodedAccountKeyIndexesLength: new Uint8Array(i), - accountKeyIndexes: n.accountKeyIndexes, - encodedDataLength: new Uint8Array(o), - data: n.data, - }, - r, - e - )); - } - return r.slice(0, e); - } - serializeAddressTableLookups() { - let e = 0, - r = new Uint8Array(C2); - for (let n of this.addressTableLookups) { - let i = Array(); - jp(i, n.writableIndexes.length); - let o = Array(); - jp(o, n.readonlyIndexes.length), - (e += Ne.struct([ - Xn("accountKey"), - Ne.blob(i.length, "encodedWritableIndexesLength"), - Ne.seq(Ne.u8(), n.writableIndexes.length, "writableIndexes"), - Ne.blob(o.length, "encodedReadonlyIndexesLength"), - Ne.seq(Ne.u8(), n.readonlyIndexes.length, "readonlyIndexes"), - ]).encode( - { - accountKey: n.accountKey.toBytes(), - encodedWritableIndexesLength: new Uint8Array(i), - writableIndexes: n.writableIndexes, - encodedReadonlyIndexesLength: new Uint8Array(o), - readonlyIndexes: n.readonlyIndexes, - }, - r, - e - )); - } - return r.slice(0, e); - } - static deserialize(e) { - let r = [...e], - n = r.shift(), - i = n & zY; - Ii(n !== i, "Expected versioned message but received legacy message"); - let o = i; - Ii( - o === 0, - `Expected versioned message with version 0 but found version ${o}` - ); - let a = { - numRequiredSignatures: r.shift(), - numReadonlySignedAccounts: r.shift(), - numReadonlyUnsignedAccounts: r.shift(), - }, - s = [], - c = Rh(r); - for (let O = 0; O < c; O++) s.push(new $t(r.splice(0, yy))); - let u = nc.default.encode(r.splice(0, yy)), - h = Rh(r), - w = []; - for (let O = 0; O < h; O++) { - let D = r.shift(), - F = Rh(r), - N = r.splice(0, F), - q = Rh(r), - z = new Uint8Array(r.splice(0, q)); - w.push({ programIdIndex: D, accountKeyIndexes: N, data: z }); - } - let M = Rh(r), - k = []; - for (let O = 0; O < M; O++) { - let D = new $t(r.splice(0, yy)), - F = Rh(r), - N = r.splice(0, F), - q = Rh(r), - z = r.splice(0, q); - k.push({ accountKey: D, writableIndexes: N, readonlyIndexes: z }); - } - return new G_({ - header: a, - staticAccountKeys: s, - recentBlockhash: u, - compiledInstructions: w, - addressTableLookups: k, - }); - } - }, - twe = { - deserializeMessageVersion(t) { - let e = t[0], - r = e & zY; - return r === e ? "legacy" : r; - }, - deserialize: (t) => { - let e = twe.deserializeMessageVersion(t); - if (e === "legacy") return Up.from(t); - if (e === 0) return G_.deserialize(t); - throw new Error( - `Transaction message version ${e} deserialization is not supported` - ); - }, - }; - Gt.TransactionStatus = void 0; - (function (t) { - (t[(t.BLOCKHEIGHT_EXCEEDED = 0)] = "BLOCKHEIGHT_EXCEEDED"), - (t[(t.PROCESSED = 1)] = "PROCESSED"), - (t[(t.TIMED_OUT = 2)] = "TIMED_OUT"); - })(Gt.TransactionStatus || (Gt.TransactionStatus = {})); - var Air = Cr.Buffer.alloc(lC).fill(0), - ro = class { - constructor(e) { - (this.keys = void 0), - (this.programId = void 0), - (this.data = Cr.Buffer.alloc(0)), - (this.programId = e.programId), - (this.keys = e.keys), - e.data && (this.data = e.data); - } - toJSON() { - return { - keys: this.keys.map( - ({ pubkey: e, isSigner: r, isWritable: n }) => ({ - pubkey: e.toJSON(), - isSigner: r, - isWritable: n, - }) - ), - programId: this.programId.toJSON(), - data: [...this.data], - }; - } - }, - Bi = class { - get signature() { - return this.signatures.length > 0 - ? this.signatures[0].signature - : null; - } - constructor(e) { - if ( - ((this.signatures = []), - (this.feePayer = void 0), - (this.instructions = []), - (this.recentBlockhash = void 0), - (this.lastValidBlockHeight = void 0), - (this.nonceInfo = void 0), - (this._message = void 0), - (this._json = void 0), - !!e) - ) - if ( - (e.feePayer && (this.feePayer = e.feePayer), - e.signatures && (this.signatures = e.signatures), - Object.prototype.hasOwnProperty.call(e, "lastValidBlockHeight")) - ) { - let { blockhash: r, lastValidBlockHeight: n } = e; - (this.recentBlockhash = r), (this.lastValidBlockHeight = n); - } else { - let { recentBlockhash: r, nonceInfo: n } = e; - n && (this.nonceInfo = n), (this.recentBlockhash = r); - } - } - toJSON() { - return { - recentBlockhash: this.recentBlockhash || null, - feePayer: this.feePayer ? this.feePayer.toJSON() : null, - nonceInfo: this.nonceInfo - ? { - nonce: this.nonceInfo.nonce, - nonceInstruction: this.nonceInfo.nonceInstruction.toJSON(), - } - : null, - instructions: this.instructions.map((e) => e.toJSON()), - signers: this.signatures.map(({ publicKey: e }) => e.toJSON()), - }; - } - add(...e) { - if (e.length === 0) throw new Error("No instructions"); - return ( - e.forEach((r) => { - "instructions" in r - ? (this.instructions = this.instructions.concat(r.instructions)) - : "data" in r && "programId" in r && "keys" in r - ? this.instructions.push(r) - : this.instructions.push(new ro(r)); - }), - this - ); - } - compileMessage() { - if ( - this._message && - JSON.stringify(this.toJSON()) === JSON.stringify(this._json) - ) - return this._message; - let e, r; - if ( - (this.nonceInfo - ? ((e = this.nonceInfo.nonce), - this.instructions[0] != this.nonceInfo.nonceInstruction - ? (r = [ - this.nonceInfo.nonceInstruction, - ...this.instructions, - ]) - : (r = this.instructions)) - : ((e = this.recentBlockhash), (r = this.instructions)), - !e) - ) - throw new Error("Transaction recentBlockhash required"); - r.length < 1 && console.warn("No instructions provided"); - let n; - if (this.feePayer) n = this.feePayer; - else if (this.signatures.length > 0 && this.signatures[0].publicKey) - n = this.signatures[0].publicKey; - else throw new Error("Transaction fee payer required"); - for (let D = 0; D < r.length; D++) - if (r[D].programId === void 0) - throw new Error( - `Transaction instruction index ${D} has undefined program id` - ); - let i = [], - o = []; - r.forEach((D) => { - D.keys.forEach((N) => { - o.push({ ...N }); - }); - let F = D.programId.toString(); - i.includes(F) || i.push(F); - }), - i.forEach((D) => { - o.push({ pubkey: new $t(D), isSigner: !1, isWritable: !1 }); - }); - let a = []; - o.forEach((D) => { - let F = D.pubkey.toString(), - N = a.findIndex((q) => q.pubkey.toString() === F); - N > -1 - ? ((a[N].isWritable = a[N].isWritable || D.isWritable), - (a[N].isSigner = a[N].isSigner || D.isSigner)) - : a.push(D); - }), - a.sort(function (D, F) { - return D.isSigner !== F.isSigner - ? D.isSigner - ? -1 - : 1 - : D.isWritable !== F.isWritable - ? D.isWritable - ? -1 - : 1 - : D.pubkey.toBase58().localeCompare(F.pubkey.toBase58()); - }); - let s = a.findIndex((D) => D.pubkey.equals(n)); - if (s > -1) { - let [D] = a.splice(s, 1); - (D.isSigner = !0), (D.isWritable = !0), a.unshift(D); - } else a.unshift({ pubkey: n, isSigner: !0, isWritable: !0 }); - for (let D of this.signatures) { - let F = a.findIndex((N) => N.pubkey.equals(D.publicKey)); - if (F > -1) - a[F].isSigner || - ((a[F].isSigner = !0), - console.warn( - "Transaction references a signature that is unnecessary, only the fee payer and instruction signer accounts should sign a transaction. This behavior is deprecated and will throw an error in the next major version release." - )); - else throw new Error(`unknown signer: ${D.publicKey.toString()}`); - } - let c = 0, - u = 0, - h = 0, - w = [], - M = []; - a.forEach(({ pubkey: D, isSigner: F, isWritable: N }) => { - F - ? (w.push(D.toString()), (c += 1), N || (u += 1)) - : (M.push(D.toString()), N || (h += 1)); - }); - let k = w.concat(M), - O = r.map((D) => { - let { data: F, programId: N } = D; - return { - programIdIndex: k.indexOf(N.toString()), - accounts: D.keys.map((q) => k.indexOf(q.pubkey.toString())), - data: nc.default.encode(F), - }; - }); - return ( - O.forEach((D) => { - Ii(D.programIdIndex >= 0), D.accounts.forEach((F) => Ii(F >= 0)); - }), - new Up({ - header: { - numRequiredSignatures: c, - numReadonlySignedAccounts: u, - numReadonlyUnsignedAccounts: h, - }, - accountKeys: k, - recentBlockhash: e, - instructions: O, - }) - ); - } - _compile() { - let e = this.compileMessage(), - r = e.accountKeys.slice(0, e.header.numRequiredSignatures); - return ( - (this.signatures.length === r.length && - this.signatures.every((i, o) => r[o].equals(i.publicKey))) || - (this.signatures = r.map((n) => ({ - signature: null, - publicKey: n, - }))), - e - ); - } - serializeMessage() { - return this._compile().serialize(); - } - async getEstimatedFee(e) { - return (await e.getFeeForMessage(this.compileMessage())).value; - } - setSigners(...e) { - if (e.length === 0) throw new Error("No signers"); - let r = new Set(); - this.signatures = e - .filter((n) => { - let i = n.toString(); - return r.has(i) ? !1 : (r.add(i), !0); - }) - .map((n) => ({ signature: null, publicKey: n })); - } - sign(...e) { - if (e.length === 0) throw new Error("No signers"); - let r = new Set(), - n = []; - for (let o of e) { - let a = o.publicKey.toString(); - r.has(a) || (r.add(a), n.push(o)); - } - this.signatures = n.map((o) => ({ - signature: null, - publicKey: o.publicKey, - })); - let i = this._compile(); - this._partialSign(i, ...n); - } - partialSign(...e) { - if (e.length === 0) throw new Error("No signers"); - let r = new Set(), - n = []; - for (let o of e) { - let a = o.publicKey.toString(); - r.has(a) || (r.add(a), n.push(o)); - } - let i = this._compile(); - this._partialSign(i, ...n); - } - _partialSign(e, ...r) { - let n = e.serialize(); - r.forEach((i) => { - let o = ewe(n, i.secretKey); - this._addSignature(i.publicKey, On(o)); - }); - } - addSignature(e, r) { - this._compile(), this._addSignature(e, r); - } - _addSignature(e, r) { - Ii(r.length === 64); - let n = this.signatures.findIndex((i) => e.equals(i.publicKey)); - if (n < 0) throw new Error(`unknown signer: ${e.toString()}`); - this.signatures[n].signature = Cr.Buffer.from(r); - } - verifySignatures() { - return this._verifySignatures(this.serializeMessage(), !0); - } - _verifySignatures(e, r) { - for (let { signature: n, publicKey: i } of this.signatures) - if (n === null) { - if (r) return !1; - } else if (!mir(n, e, i.toBuffer())) return !1; - return !0; - } - serialize(e) { - let { requireAllSignatures: r, verifySignatures: n } = Object.assign( - { requireAllSignatures: !0, verifySignatures: !0 }, - e - ), - i = this.serializeMessage(); - if (n && !this._verifySignatures(i, r)) - throw new Error("Signature verification failed"); - return this._serialize(i); - } - _serialize(e) { - let { signatures: r } = this, - n = []; - jp(n, r.length); - let i = n.length + r.length * 64 + e.length, - o = Cr.Buffer.alloc(i); - return ( - Ii(r.length < 256), - Cr.Buffer.from(n).copy(o, 0), - r.forEach(({ signature: a }, s) => { - a !== null && - (Ii(a.length === 64, "signature has invalid length"), - Cr.Buffer.from(a).copy(o, n.length + s * 64)); - }), - e.copy(o, n.length + r.length * 64), - Ii(o.length <= C2, `Transaction too large: ${o.length} > ${C2}`), - o - ); - } - get keys() { - return ( - Ii(this.instructions.length === 1), - this.instructions[0].keys.map((e) => e.pubkey) - ); - } - get programId() { - return ( - Ii(this.instructions.length === 1), this.instructions[0].programId - ); - } - get data() { - return Ii(this.instructions.length === 1), this.instructions[0].data; - } - static from(e) { - let r = [...e], - n = Rh(r), - i = []; - for (let o = 0; o < n; o++) { - let a = r.slice(0, lC); - (r = r.slice(lC)), i.push(nc.default.encode(Cr.Buffer.from(a))); - } - return Bi.populate(Up.from(r), i); - } - static populate(e, r = []) { - let n = new Bi(); - return ( - (n.recentBlockhash = e.recentBlockhash), - e.header.numRequiredSignatures > 0 && - (n.feePayer = e.accountKeys[0]), - r.forEach((i, o) => { - let a = { - signature: - i == nc.default.encode(Air) ? null : nc.default.decode(i), - publicKey: e.accountKeys[o], - }; - n.signatures.push(a); - }), - e.instructions.forEach((i) => { - let o = i.accounts.map((a) => { - let s = e.accountKeys[a]; - return { - pubkey: s, - isSigner: - n.signatures.some( - (c) => c.publicKey.toString() === s.toString() - ) || e.isAccountSigner(a), - isWritable: e.isAccountWritable(a), - }; - }); - n.instructions.push( - new ro({ - keys: o, - programId: e.accountKeys[i.programIdIndex], - data: nc.default.decode(i.data), - }) - ); - }), - (n._message = e), - (n._json = n.toJSON()), - n - ); - } - }, - Oz = class { - constructor(e) { - (this.payerKey = void 0), - (this.instructions = void 0), - (this.recentBlockhash = void 0), - (this.payerKey = e.payerKey), - (this.instructions = e.instructions), - (this.recentBlockhash = e.recentBlockhash); - } - static decompile(e, r) { - let { header: n, compiledInstructions: i, recentBlockhash: o } = e, - { - numRequiredSignatures: a, - numReadonlySignedAccounts: s, - numReadonlyUnsignedAccounts: c, - } = n, - u = a - s; - Ii(u > 0, "Message header is invalid"); - let h = e.staticAccountKeys.length - c; - Ii(h >= 0, "Message header is invalid"); - let w = e.getAccountKeys(r), - M = w.get(0); - if (M === void 0) - throw new Error( - "Failed to decompile message because no account keys were found" - ); - let k = []; - for (let O of i) { - let D = []; - for (let N of O.accountKeyIndexes) { - let q = w.get(N); - if (q === void 0) - throw new Error( - `Failed to find key for account key index ${N}` - ); - let z = N < a, - H; - z - ? (H = N < u) - : N < w.staticAccountKeys.length - ? (H = N - a < h) - : (H = - N - w.staticAccountKeys.length < - w.accountKeysFromLookups.writable.length), - D.push({ - pubkey: q, - isSigner: N < n.numRequiredSignatures, - isWritable: H, - }); - } - let F = w.get(O.programIdIndex); - if (F === void 0) - throw new Error( - `Failed to find program id for program id index ${O.programIdIndex}` - ); - k.push(new ro({ programId: F, data: On(O.data), keys: D })); - } - return new Oz({ payerKey: M, instructions: k, recentBlockhash: o }); - } - compileToLegacyMessage() { - return Up.compile({ - payerKey: this.payerKey, - recentBlockhash: this.recentBlockhash, - instructions: this.instructions, - }); - } - compileToV0Message(e) { - return G_.compile({ - payerKey: this.payerKey, - recentBlockhash: this.recentBlockhash, - instructions: this.instructions, - addressLookupTableAccounts: e, - }); - } - }, - Bz = class { - get version() { - return this.message.version; - } - constructor(e, r) { - if ( - ((this.signatures = void 0), (this.message = void 0), r !== void 0) - ) - Ii( - r.length === e.header.numRequiredSignatures, - "Expected signatures length to be equal to the number of required signatures" - ), - (this.signatures = r); - else { - let n = []; - for (let i = 0; i < e.header.numRequiredSignatures; i++) - n.push(new Uint8Array(lC)); - this.signatures = n; - } - this.message = e; - } - serialize() { - let e = this.message.serialize(), - r = Array(); - jp(r, this.signatures.length); - let n = Ne.struct([ - Ne.blob(r.length, "encodedSignaturesLength"), - Ne.seq(bir(), this.signatures.length, "signatures"), - Ne.blob(e.length, "serializedMessage"), - ]), - i = new Uint8Array(2048), - o = n.encode( - { - encodedSignaturesLength: new Uint8Array(r), - signatures: this.signatures, - serializedMessage: e, - }, - i - ); - return i.slice(0, o); - } - static deserialize(e) { - let r = [...e], - n = [], - i = Rh(r); - for (let a = 0; a < i; a++) n.push(new Uint8Array(r.splice(0, lC))); - let o = twe.deserialize(new Uint8Array(r)); - return new Bz(o, n); - } - sign(e) { - let r = this.message.serialize(), - n = this.message.staticAccountKeys.slice( - 0, - this.message.header.numRequiredSignatures - ); - for (let i of e) { - let o = n.findIndex((a) => a.equals(i.publicKey)); - Ii( - o >= 0, - `Cannot sign with non signer key ${i.publicKey.toBase58()}` - ), - (this.signatures[o] = ewe(r, i.secretKey)); - } - } - addSignature(e, r) { - Ii(r.byteLength === 64, "Signature must be 64 bytes long"); - let i = this.message.staticAccountKeys - .slice(0, this.message.header.numRequiredSignatures) - .findIndex((o) => o.equals(e)); - Ii( - i >= 0, - `Can not add signature; \`${e.toBase58()}\` is not required to sign this transaction` - ), - (this.signatures[i] = r); - } - }, - Mv = new $t("SysvarC1ock11111111111111111111111111111111"), - Eir = new $t("SysvarEpochSchedu1e111111111111111111111111"), - Mir = new $t("Sysvar1nstructions1111111111111111111111111"), - BY = new $t("SysvarRecentB1ockHashes11111111111111111111"), - dC = new $t("SysvarRent111111111111111111111111111111111"), - Tir = new $t("SysvarRewards111111111111111111111111111111"), - kir = new $t("SysvarS1otHashes111111111111111111111111111"), - Pir = new $t("SysvarS1otHistory11111111111111111111111111"), - IY = new $t("SysvarStakeHistory1111111111111111111111111"); - async function CY(t, e, r, n) { - let i = n && { - skipPreflight: n.skipPreflight, - preflightCommitment: n.preflightCommitment || n.commitment, - maxRetries: n.maxRetries, - minContextSlot: n.minContextSlot, - }, - o = await t.sendTransaction(e, r, i), - a = - e.recentBlockhash != null && e.lastValidBlockHeight != null - ? ( - await t.confirmTransaction( - { - signature: o, - blockhash: e.recentBlockhash, - lastValidBlockHeight: e.lastValidBlockHeight, - }, - n && n.commitment - ) - ).value - : (await t.confirmTransaction(o, n && n.commitment)).value; - if (a.err) - throw new Error(`Transaction ${o} failed (${JSON.stringify(a)})`); - return o; - } - function Mz(t) { - return new Promise((e) => setTimeout(e, t)); - } - function Mi(t, e) { - let r = t.layout.span >= 0 ? t.layout.span : PZe(t, e), - n = Cr.Buffer.alloc(r), - i = Object.assign({ instruction: t.index }, e); - return t.layout.encode(i, n), n; - } - function Zi(t, e) { - let r; - try { - r = t.layout.decode(e); - } catch (n) { - throw new Error("invalid instruction; " + n); - } - if (r.instruction !== t.index) - throw new Error( - `invalid instruction; instruction index mismatch ${r.instruction} != ${t.index}` - ); - return r; - } - var OZe = Ne.nu64("lamportsPerSignature"), - BZe = Ne.struct([ - Ne.u32("version"), - Ne.u32("state"), - Xn("authorizedPubkey"), - Xn("nonce"), - Ne.struct([OZe], "feeCalculator"), - ]), - U1e = BZe.span, - hC = class { - constructor(e) { - (this.authorizedPubkey = void 0), - (this.nonce = void 0), - (this.feeCalculator = void 0), - (this.authorizedPubkey = e.authorizedPubkey), - (this.nonce = e.nonce), - (this.feeCalculator = e.feeCalculator); - } - static fromAccountData(e) { - let r = BZe.decode(On(e), 0); - return new hC({ - authorizedPubkey: new $t(r.authorizedPubkey), - nonce: new $t(r.nonce).toString(), - feeCalculator: r.feeCalculator, - }); - } - }, - Oir = (t) => { - let e = t.decode.bind(t), - r = t.encode.bind(t); - return { decode: e, encode: r }; - }, - Bir = (t) => (e) => { - let r = TZe.blob(t, e), - { encode: n, decode: i } = Oir(r), - o = r; - return ( - (o.decode = (a, s) => { - let c = i(a, s); - return q1e.toBigIntLE(Cr.Buffer.from(c)); - }), - (o.encode = (a, s, c) => { - let u = q1e.toBufferLE(a, t); - return n(u, s, c); - }), - o - ); - }, - pC = Bir(8), - K1e = class { - constructor() {} - static decodeInstructionType(e) { - this.checkProgramId(e.programId); - let n = Ne.u32("instruction").decode(e.data), - i; - for (let [o, a] of Object.entries(Co)) - if (a.index == n) { - i = o; - break; - } - if (!i) - throw new Error( - "Instruction type incorrect; not a SystemInstruction" - ); - return i; - } - static decodeCreateAccount(e) { - this.checkProgramId(e.programId), this.checkKeyLength(e.keys, 2); - let { lamports: r, space: n, programId: i } = Zi(Co.Create, e.data); - return { - fromPubkey: e.keys[0].pubkey, - newAccountPubkey: e.keys[1].pubkey, - lamports: r, - space: n, - programId: new $t(i), - }; - } - static decodeTransfer(e) { - this.checkProgramId(e.programId), this.checkKeyLength(e.keys, 2); - let { lamports: r } = Zi(Co.Transfer, e.data); - return { - fromPubkey: e.keys[0].pubkey, - toPubkey: e.keys[1].pubkey, - lamports: r, - }; - } - static decodeTransferWithSeed(e) { - this.checkProgramId(e.programId), this.checkKeyLength(e.keys, 3); - let { - lamports: r, - seed: n, - programId: i, - } = Zi(Co.TransferWithSeed, e.data); - return { - fromPubkey: e.keys[0].pubkey, - basePubkey: e.keys[1].pubkey, - toPubkey: e.keys[2].pubkey, - lamports: r, - seed: n, - programId: new $t(i), - }; - } - static decodeAllocate(e) { - this.checkProgramId(e.programId), this.checkKeyLength(e.keys, 1); - let { space: r } = Zi(Co.Allocate, e.data); - return { accountPubkey: e.keys[0].pubkey, space: r }; - } - static decodeAllocateWithSeed(e) { - this.checkProgramId(e.programId), this.checkKeyLength(e.keys, 1); - let { - base: r, - seed: n, - space: i, - programId: o, - } = Zi(Co.AllocateWithSeed, e.data); - return { - accountPubkey: e.keys[0].pubkey, - basePubkey: new $t(r), - seed: n, - space: i, - programId: new $t(o), - }; - } - static decodeAssign(e) { - this.checkProgramId(e.programId), this.checkKeyLength(e.keys, 1); - let { programId: r } = Zi(Co.Assign, e.data); - return { accountPubkey: e.keys[0].pubkey, programId: new $t(r) }; - } - static decodeAssignWithSeed(e) { - this.checkProgramId(e.programId), this.checkKeyLength(e.keys, 1); - let { - base: r, - seed: n, - programId: i, - } = Zi(Co.AssignWithSeed, e.data); - return { - accountPubkey: e.keys[0].pubkey, - basePubkey: new $t(r), - seed: n, - programId: new $t(i), - }; - } - static decodeCreateWithSeed(e) { - this.checkProgramId(e.programId), this.checkKeyLength(e.keys, 2); - let { - base: r, - seed: n, - lamports: i, - space: o, - programId: a, - } = Zi(Co.CreateWithSeed, e.data); - return { - fromPubkey: e.keys[0].pubkey, - newAccountPubkey: e.keys[1].pubkey, - basePubkey: new $t(r), - seed: n, - lamports: i, - space: o, - programId: new $t(a), - }; - } - static decodeNonceInitialize(e) { - this.checkProgramId(e.programId), this.checkKeyLength(e.keys, 3); - let { authorized: r } = Zi(Co.InitializeNonceAccount, e.data); - return { noncePubkey: e.keys[0].pubkey, authorizedPubkey: new $t(r) }; - } - static decodeNonceAdvance(e) { - return ( - this.checkProgramId(e.programId), - this.checkKeyLength(e.keys, 3), - Zi(Co.AdvanceNonceAccount, e.data), - { - noncePubkey: e.keys[0].pubkey, - authorizedPubkey: e.keys[2].pubkey, - } - ); - } - static decodeNonceWithdraw(e) { - this.checkProgramId(e.programId), this.checkKeyLength(e.keys, 5); - let { lamports: r } = Zi(Co.WithdrawNonceAccount, e.data); - return { - noncePubkey: e.keys[0].pubkey, - toPubkey: e.keys[1].pubkey, - authorizedPubkey: e.keys[4].pubkey, - lamports: r, - }; - } - static decodeNonceAuthorize(e) { - this.checkProgramId(e.programId), this.checkKeyLength(e.keys, 2); - let { authorized: r } = Zi(Co.AuthorizeNonceAccount, e.data); - return { - noncePubkey: e.keys[0].pubkey, - authorizedPubkey: e.keys[1].pubkey, - newAuthorizedPubkey: new $t(r), - }; - } - static checkProgramId(e) { - if (!e.equals(Js.programId)) - throw new Error( - "invalid instruction; programId is not SystemProgram" - ); - } - static checkKeyLength(e, r) { - if (e.length < r) - throw new Error( - `invalid instruction; found ${e.length} keys, expected at least ${r}` - ); - } - }, - Co = Object.freeze({ - Create: { - index: 0, - layout: Ne.struct([ - Ne.u32("instruction"), - Ne.ns64("lamports"), - Ne.ns64("space"), - Xn("programId"), - ]), - }, - Assign: { - index: 1, - layout: Ne.struct([Ne.u32("instruction"), Xn("programId")]), - }, - Transfer: { - index: 2, - layout: Ne.struct([Ne.u32("instruction"), pC("lamports")]), - }, - CreateWithSeed: { - index: 3, - layout: Ne.struct([ - Ne.u32("instruction"), - Xn("base"), - VM("seed"), - Ne.ns64("lamports"), - Ne.ns64("space"), - Xn("programId"), - ]), - }, - AdvanceNonceAccount: { - index: 4, - layout: Ne.struct([Ne.u32("instruction")]), - }, - WithdrawNonceAccount: { - index: 5, - layout: Ne.struct([Ne.u32("instruction"), Ne.ns64("lamports")]), - }, - InitializeNonceAccount: { - index: 6, - layout: Ne.struct([Ne.u32("instruction"), Xn("authorized")]), - }, - AuthorizeNonceAccount: { - index: 7, - layout: Ne.struct([Ne.u32("instruction"), Xn("authorized")]), - }, - Allocate: { - index: 8, - layout: Ne.struct([Ne.u32("instruction"), Ne.ns64("space")]), - }, - AllocateWithSeed: { - index: 9, - layout: Ne.struct([ - Ne.u32("instruction"), - Xn("base"), - VM("seed"), - Ne.ns64("space"), - Xn("programId"), - ]), - }, - AssignWithSeed: { - index: 10, - layout: Ne.struct([ - Ne.u32("instruction"), - Xn("base"), - VM("seed"), - Xn("programId"), - ]), - }, - TransferWithSeed: { - index: 11, - layout: Ne.struct([ - Ne.u32("instruction"), - pC("lamports"), - VM("seed"), - Xn("programId"), - ]), - }, - UpgradeNonceAccount: { - index: 12, - layout: Ne.struct([Ne.u32("instruction")]), - }, - }), - Js = class { - constructor() {} - static createAccount(e) { - let r = Co.Create, - n = Mi(r, { - lamports: e.lamports, - space: e.space, - programId: On(e.programId.toBuffer()), - }); - return new ro({ - keys: [ - { pubkey: e.fromPubkey, isSigner: !0, isWritable: !0 }, - { pubkey: e.newAccountPubkey, isSigner: !0, isWritable: !0 }, - ], - programId: this.programId, - data: n, - }); - } - static transfer(e) { - let r, n; - if ("basePubkey" in e) { - let i = Co.TransferWithSeed; - (r = Mi(i, { - lamports: BigInt(e.lamports), - seed: e.seed, - programId: On(e.programId.toBuffer()), - })), - (n = [ - { pubkey: e.fromPubkey, isSigner: !1, isWritable: !0 }, - { pubkey: e.basePubkey, isSigner: !0, isWritable: !1 }, - { pubkey: e.toPubkey, isSigner: !1, isWritable: !0 }, - ]); - } else { - let i = Co.Transfer; - (r = Mi(i, { lamports: BigInt(e.lamports) })), - (n = [ - { pubkey: e.fromPubkey, isSigner: !0, isWritable: !0 }, - { pubkey: e.toPubkey, isSigner: !1, isWritable: !0 }, - ]); - } - return new ro({ keys: n, programId: this.programId, data: r }); - } - static assign(e) { - let r, n; - if ("basePubkey" in e) { - let i = Co.AssignWithSeed; - (r = Mi(i, { - base: On(e.basePubkey.toBuffer()), - seed: e.seed, - programId: On(e.programId.toBuffer()), - })), - (n = [ - { pubkey: e.accountPubkey, isSigner: !1, isWritable: !0 }, - { pubkey: e.basePubkey, isSigner: !0, isWritable: !1 }, - ]); - } else { - let i = Co.Assign; - (r = Mi(i, { programId: On(e.programId.toBuffer()) })), - (n = [{ pubkey: e.accountPubkey, isSigner: !0, isWritable: !0 }]); - } - return new ro({ keys: n, programId: this.programId, data: r }); - } - static createAccountWithSeed(e) { - let r = Co.CreateWithSeed, - n = Mi(r, { - base: On(e.basePubkey.toBuffer()), - seed: e.seed, - lamports: e.lamports, - space: e.space, - programId: On(e.programId.toBuffer()), - }), - i = [ - { pubkey: e.fromPubkey, isSigner: !0, isWritable: !0 }, - { pubkey: e.newAccountPubkey, isSigner: !1, isWritable: !0 }, - ]; - return ( - e.basePubkey != e.fromPubkey && - i.push({ pubkey: e.basePubkey, isSigner: !0, isWritable: !1 }), - new ro({ keys: i, programId: this.programId, data: n }) - ); - } - static createNonceAccount(e) { - let r = new Bi(); - "basePubkey" in e && "seed" in e - ? r.add( - Js.createAccountWithSeed({ - fromPubkey: e.fromPubkey, - newAccountPubkey: e.noncePubkey, - basePubkey: e.basePubkey, - seed: e.seed, - lamports: e.lamports, - space: U1e, - programId: this.programId, - }) - ) - : r.add( - Js.createAccount({ - fromPubkey: e.fromPubkey, - newAccountPubkey: e.noncePubkey, - lamports: e.lamports, - space: U1e, - programId: this.programId, - }) - ); - let n = { - noncePubkey: e.noncePubkey, - authorizedPubkey: e.authorizedPubkey, - }; - return r.add(this.nonceInitialize(n)), r; - } - static nonceInitialize(e) { - let r = Co.InitializeNonceAccount, - n = Mi(r, { authorized: On(e.authorizedPubkey.toBuffer()) }), - i = { - keys: [ - { pubkey: e.noncePubkey, isSigner: !1, isWritable: !0 }, - { pubkey: BY, isSigner: !1, isWritable: !1 }, - { pubkey: dC, isSigner: !1, isWritable: !1 }, - ], - programId: this.programId, - data: n, - }; - return new ro(i); - } - static nonceAdvance(e) { - let r = Co.AdvanceNonceAccount, - n = Mi(r), - i = { - keys: [ - { pubkey: e.noncePubkey, isSigner: !1, isWritable: !0 }, - { pubkey: BY, isSigner: !1, isWritable: !1 }, - { pubkey: e.authorizedPubkey, isSigner: !0, isWritable: !1 }, - ], - programId: this.programId, - data: n, - }; - return new ro(i); - } - static nonceWithdraw(e) { - let r = Co.WithdrawNonceAccount, - n = Mi(r, { lamports: e.lamports }); - return new ro({ - keys: [ - { pubkey: e.noncePubkey, isSigner: !1, isWritable: !0 }, - { pubkey: e.toPubkey, isSigner: !1, isWritable: !0 }, - { pubkey: BY, isSigner: !1, isWritable: !1 }, - { pubkey: dC, isSigner: !1, isWritable: !1 }, - { pubkey: e.authorizedPubkey, isSigner: !0, isWritable: !1 }, - ], - programId: this.programId, - data: n, - }); - } - static nonceAuthorize(e) { - let r = Co.AuthorizeNonceAccount, - n = Mi(r, { authorized: On(e.newAuthorizedPubkey.toBuffer()) }); - return new ro({ - keys: [ - { pubkey: e.noncePubkey, isSigner: !1, isWritable: !0 }, - { pubkey: e.authorizedPubkey, isSigner: !0, isWritable: !1 }, - ], - programId: this.programId, - data: n, - }); - } - static allocate(e) { - let r, n; - if ("basePubkey" in e) { - let i = Co.AllocateWithSeed; - (r = Mi(i, { - base: On(e.basePubkey.toBuffer()), - seed: e.seed, - space: e.space, - programId: On(e.programId.toBuffer()), - })), - (n = [ - { pubkey: e.accountPubkey, isSigner: !1, isWritable: !0 }, - { pubkey: e.basePubkey, isSigner: !0, isWritable: !1 }, - ]); - } else { - let i = Co.Allocate; - (r = Mi(i, { space: e.space })), - (n = [{ pubkey: e.accountPubkey, isSigner: !0, isWritable: !0 }]); - } - return new ro({ keys: n, programId: this.programId, data: r }); - } - }; - Js.programId = new $t("11111111111111111111111111111111"); - var Iir = C2 - 300, - J_ = class { - constructor() {} - static getMinNumSignatures(e) { - return 2 * (Math.ceil(e / J_.chunkSize) + 1 + 1); - } - static async load(e, r, n, i, o) { - { - let w = await e.getMinimumBalanceForRentExemption(o.length), - M = await e.getAccountInfo(n.publicKey, "confirmed"), - k = null; - if (M !== null) { - if (M.executable) - return ( - console.error( - "Program load failed, account is already executable" - ), - !1 - ); - M.data.length !== o.length && - ((k = k || new Bi()), - k.add( - Js.allocate({ accountPubkey: n.publicKey, space: o.length }) - )), - M.owner.equals(i) || - ((k = k || new Bi()), - k.add( - Js.assign({ accountPubkey: n.publicKey, programId: i }) - )), - M.lamports < w && - ((k = k || new Bi()), - k.add( - Js.transfer({ - fromPubkey: r.publicKey, - toPubkey: n.publicKey, - lamports: w - M.lamports, - }) - )); - } else - k = new Bi().add( - Js.createAccount({ - fromPubkey: r.publicKey, - newAccountPubkey: n.publicKey, - lamports: w > 0 ? w : 1, - space: o.length, - programId: i, - }) - ); - k !== null && (await CY(e, k, [r, n], { commitment: "confirmed" })); - } - let a = Ne.struct([ - Ne.u32("instruction"), - Ne.u32("offset"), - Ne.u32("bytesLength"), - Ne.u32("bytesLengthPadding"), - Ne.seq(Ne.u8("byte"), Ne.offset(Ne.u32(), -8), "bytes"), - ]), - s = J_.chunkSize, - c = 0, - u = o, - h = []; - for (; u.length > 0; ) { - let w = u.slice(0, s), - M = Cr.Buffer.alloc(s + 16); - a.encode( - { - instruction: 0, - offset: c, - bytes: w, - bytesLength: 0, - bytesLengthPadding: 0, - }, - M - ); - let k = new Bi().add({ - keys: [{ pubkey: n.publicKey, isSigner: !0, isWritable: !0 }], - programId: i, - data: M, - }); - h.push(CY(e, k, [r, n], { commitment: "confirmed" })), - e._rpcEndpoint.includes("solana.com") && (await Mz(1e3 / 4)), - (c += s), - (u = u.slice(s)); - } - await Promise.all(h); - { - let w = Ne.struct([Ne.u32("instruction")]), - M = Cr.Buffer.alloc(w.span); - w.encode({ instruction: 1 }, M); - let k = new Bi().add({ - keys: [ - { pubkey: n.publicKey, isSigner: !0, isWritable: !0 }, - { pubkey: dC, isSigner: !1, isWritable: !1 }, - ], - programId: i, - data: M, - }); - await CY(e, k, [r, n], { commitment: "confirmed" }); - } - return !0; - } - }; - J_.chunkSize = Iir; - var Cir = new $t("BPFLoader2111111111111111111111111111111111"), - H1e = class { - static getMinNumSignatures(e) { - return J_.getMinNumSignatures(e); - } - static load(e, r, n, i, o) { - return J_.load(e, r, n, o, i); - } - }, - Rir = Object.prototype.toString, - Nir = - Object.keys || - function (t) { - var e = []; - for (var r in t) e.push(r); - return e; - }; - function Az(t, e) { - var r, n, i, o, a, s, c; - if (t === !0) return "true"; - if (t === !1) return "false"; - switch (typeof t) { - case "object": - if (t === null) return null; - if (t.toJSON && typeof t.toJSON == "function") - return Az(t.toJSON(), e); - if (((c = Rir.call(t)), c === "[object Array]")) { - for (i = "[", n = t.length - 1, r = 0; r < n; r++) - i += Az(t[r], !0) + ","; - return n > -1 && (i += Az(t[r], !0)), i + "]"; - } else if (c === "[object Object]") { - for (o = Nir(t).sort(), n = o.length, i = "", r = 0; r < n; ) - (a = o[r]), - (s = Az(t[a], !1)), - s !== void 0 && - (i && (i += ","), (i += JSON.stringify(a) + ":" + s)), - r++; - return "{" + i + "}"; - } else return JSON.stringify(t); - case "function": - case "undefined": - return e ? null : void 0; - case "string": - return JSON.stringify(t); - default: - return isFinite(t) ? t : null; - } - } - var Dir = function (t) { - var e = Az(t, !1); - if (e !== void 0) return "" + e; - }, - Fir = Dir, - Sz = 32; - function I1e(t) { - let e = 0; - for (; t > 1; ) (t /= 2), e++; - return e; - } - function Lir(t) { - return t === 0 - ? 1 - : (t--, - (t |= t >> 1), - (t |= t >> 2), - (t |= t >> 4), - (t |= t >> 8), - (t |= t >> 16), - (t |= t >> 32), - t + 1); - } - var NY = class { - constructor(e, r, n, i, o) { - (this.slotsPerEpoch = void 0), - (this.leaderScheduleSlotOffset = void 0), - (this.warmup = void 0), - (this.firstNormalEpoch = void 0), - (this.firstNormalSlot = void 0), - (this.slotsPerEpoch = e), - (this.leaderScheduleSlotOffset = r), - (this.warmup = n), - (this.firstNormalEpoch = i), - (this.firstNormalSlot = o); - } - getEpoch(e) { - return this.getEpochAndSlotIndex(e)[0]; - } - getEpochAndSlotIndex(e) { - if (e < this.firstNormalSlot) { - let r = I1e(Lir(e + Sz + 1)) - I1e(Sz) - 1, - n = this.getSlotsInEpoch(r), - i = e - (n - Sz); - return [r, i]; - } else { - let r = e - this.firstNormalSlot, - n = Math.floor(r / this.slotsPerEpoch), - i = this.firstNormalEpoch + n, - o = r % this.slotsPerEpoch; - return [i, o]; - } - } - getFirstSlotInEpoch(e) { - return e <= this.firstNormalEpoch - ? (Math.pow(2, e) - 1) * Sz - : (e - this.firstNormalEpoch) * this.slotsPerEpoch + - this.firstNormalSlot; - } - getLastSlotInEpoch(e) { - return this.getFirstSlotInEpoch(e) + this.getSlotsInEpoch(e) - 1; - } - getSlotsInEpoch(e) { - return e < this.firstNormalEpoch - ? Math.pow(2, e + I1e(Sz)) - : this.slotsPerEpoch; - } - }, - Iz = class extends Error { - constructor(e, r) { - super(e), (this.logs = void 0), (this.logs = r); - } - }, - qir = { - JSON_RPC_SERVER_ERROR_BLOCK_CLEANED_UP: -32001, - JSON_RPC_SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE: -32002, - JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_VERIFICATION_FAILURE: - -32003, - JSON_RPC_SERVER_ERROR_BLOCK_NOT_AVAILABLE: -32004, - JSON_RPC_SERVER_ERROR_NODE_UNHEALTHY: -32005, - JSON_RPC_SERVER_ERROR_TRANSACTION_PRECOMPILE_VERIFICATION_FAILURE: - -32006, - JSON_RPC_SERVER_ERROR_SLOT_SKIPPED: -32007, - JSON_RPC_SERVER_ERROR_NO_SNAPSHOT: -32008, - JSON_RPC_SERVER_ERROR_LONG_TERM_STORAGE_SLOT_SKIPPED: -32009, - JSON_RPC_SERVER_ERROR_KEY_EXCLUDED_FROM_SECONDARY_INDEX: -32010, - JSON_RPC_SERVER_ERROR_TRANSACTION_HISTORY_NOT_AVAILABLE: -32011, - JSON_RPC_SCAN_ERROR: -32012, - JSON_RPC_SERVER_ERROR_TRANSACTION_SIGNATURE_LEN_MISMATCH: -32013, - JSON_RPC_SERVER_ERROR_BLOCK_STATUS_NOT_AVAILABLE_YET: -32014, - JSON_RPC_SERVER_ERROR_UNSUPPORTED_TRANSACTION_VERSION: -32015, - JSON_RPC_SERVER_ERROR_MIN_CONTEXT_SLOT_NOT_REACHED: -32016, - }, - pr = class extends Error { - constructor({ code: e, message: r, data: n }, i) { - super(i != null ? `${i}: ${r}` : r), - (this.code = void 0), - (this.data = void 0), - (this.code = e), - (this.data = n), - (this.name = "SolanaJSONRPCError"); - } - }, - zir = globalThis.fetch, - jir = 160, - Uir = 64, - Kir = jir / Uir, - Hir = 1e3 / Kir; - function Vir(t, e) { - let r; - try { - r = t.layout.decode(e); - } catch (n) { - throw new Error("invalid instruction; " + n); - } - if (r.typeIndex !== t.index) - throw new Error( - `invalid account data; account type mismatch ${r.typeIndex} != ${t.index}` - ); - return r; - } - var yZe = 56, - Cz = class { - constructor(e) { - (this.key = void 0), - (this.state = void 0), - (this.key = e.key), - (this.state = e.state); - } - isActive() { - let e = BigInt("0xffffffffffffffff"); - return this.state.deactivationSlot === e; - } - static deserialize(e) { - let r = Vir(Wir, e), - n = e.length - yZe; - Ii(n >= 0, "lookup table is invalid"), - Ii(n % 32 === 0, "lookup table is invalid"); - let i = n / 32, - { addresses: o } = Ne.struct([Ne.seq(Xn(), i, "addresses")]).decode( - e.slice(yZe) - ); - return { - deactivationSlot: r.deactivationSlot, - lastExtendedSlot: r.lastExtendedSlot, - lastExtendedSlotStartIndex: r.lastExtendedStartIndex, - authority: - r.authority.length !== 0 ? new $t(r.authority[0]) : void 0, - addresses: o.map((a) => new $t(a)), - }; - } - }, - Wir = { - index: 1, - layout: Ne.struct([ - Ne.u32("typeIndex"), - pC("deactivationSlot"), - Ne.nu64("lastExtendedSlot"), - Ne.u8("lastExtendedStartIndex"), - Ne.u8(), - Ne.seq(Xn(), Ne.offset(Ne.u8(), -1), "authority"), - ]), - }, - Gir = /^[^:]+:\/\/([^:[]+|\[[^\]]+\])(:\d+)?(.*)/i; - function Jir(t) { - let e = t.match(Gir); - if (e == null) - throw TypeError(`Failed to validate endpoint URL \`${t}\``); - let [r, n, i, o] = e, - a = t.startsWith("https:") ? "wss:" : "ws:", - s = i == null ? null : parseInt(i.slice(1), 10), - c = s == null ? "" : `:${s + 1}`; - return `${a}//${n}${c}${o}`; - } - var C1e, - ws = X.coerce(X.instance($t), X.string(), (t) => new $t(t)), - IZe = X.tuple([X.string(), X.literal("base64")]), - rwe = X.coerce(X.instance(Cr.Buffer), IZe, (t) => - Cr.Buffer.from(t[0], "base64") - ), - CZe = 30 * 1e3; - function $ir(t) { - if (/^https?:/.test(t) === !1) - throw new TypeError( - "Endpoint URL must start with `http:` or `https:`." - ); - return t; - } - function ts(t) { - let e, r; - if (typeof t == "string") e = t; - else if (t) { - let { commitment: n, ...i } = t; - (e = n), (r = i); - } - return { commitment: e, config: r }; - } - function RZe(t) { - return X.union([ - X.type({ jsonrpc: X.literal("2.0"), id: X.string(), result: t }), - X.type({ - jsonrpc: X.literal("2.0"), - id: X.string(), - error: X.type({ - code: X.unknown(), - message: X.string(), - data: X.optional(X.any()), - }), - }), - ]); - } - var Zir = RZe(X.unknown()); - function Ei(t) { - return X.coerce(RZe(t), Zir, (e) => - "error" in e ? e : { ...e, result: X.create(e.result, t) } - ); - } - function Gs(t) { - return Ei(X.type({ context: X.type({ slot: X.number() }), value: t })); - } - function jY(t) { - return X.type({ context: X.type({ slot: X.number() }), value: t }); - } - function R1e(t, e) { - return t === 0 - ? new G_({ - header: e.header, - staticAccountKeys: e.accountKeys.map((r) => new $t(r)), - recentBlockhash: e.recentBlockhash, - compiledInstructions: e.instructions.map((r) => ({ - programIdIndex: r.programIdIndex, - accountKeyIndexes: r.accounts, - data: nc.default.decode(r.data), - })), - addressTableLookups: e.addressTableLookups, - }) - : new Up(e); - } - var Xir = X.type({ - foundation: X.number(), - foundationTerm: X.number(), - initial: X.number(), - taper: X.number(), - terminal: X.number(), - }), - Yir = Ei( - X.array( - X.nullable( - X.type({ - epoch: X.number(), - effectiveSlot: X.number(), - amount: X.number(), - postBalance: X.number(), - }) - ) - ) - ), - Qir = X.type({ - epoch: X.number(), - slotIndex: X.number(), - slotsInEpoch: X.number(), - absoluteSlot: X.number(), - blockHeight: X.optional(X.number()), - transactionCount: X.optional(X.number()), - }), - eor = X.type({ - slotsPerEpoch: X.number(), - leaderScheduleSlotOffset: X.number(), - warmup: X.boolean(), - firstNormalEpoch: X.number(), - firstNormalSlot: X.number(), - }), - tor = X.record(X.string(), X.array(X.number())), - JM = X.nullable(X.union([X.type({}), X.string()])), - ror = X.type({ err: JM }), - nor = X.literal("receivedSignature"), - ior = X.type({ - "solana-core": X.string(), - "feature-set": X.optional(X.number()), - }), - mZe = Gs( - X.type({ - err: X.nullable(X.union([X.type({}), X.string()])), - logs: X.nullable(X.array(X.string())), - accounts: X.optional( - X.nullable( - X.array( - X.nullable( - X.type({ - executable: X.boolean(), - owner: X.string(), - lamports: X.number(), - data: X.array(X.string()), - rentEpoch: X.optional(X.number()), - }) - ) - ) - ) - ), - unitsConsumed: X.optional(X.number()), - returnData: X.optional( - X.nullable( - X.type({ - programId: X.string(), - data: X.tuple([X.string(), X.literal("base64")]), - }) - ) - ), - }) - ), - oor = Gs( - X.type({ - byIdentity: X.record(X.string(), X.array(X.number())), - range: X.type({ firstSlot: X.number(), lastSlot: X.number() }), - }) - ); - function aor(t, e, r, n, i) { - let o = r || zir, - a; - return ( - n && - (a = async (c, u) => { - let h = await new Promise((w, M) => { - try { - n(c, u, (k, O) => w([k, O])); - } catch (k) { - M(k); - } - }); - return await o(...h); - }), - new pir.default(async (c, u) => { - let w = { - method: "POST", - body: c, - agent: void 0, - headers: Object.assign( - { "Content-Type": "application/json" }, - e || {}, - rar - ), - }; - try { - let M = 5, - k, - O = 500; - for ( - ; - a ? (k = await a(t, w)) : (k = await o(t, w)), - !(k.status !== 429 || i === !0 || ((M -= 1), M === 0)); - - ) - console.log( - `Server responded with ${k.status} ${k.statusText}. Retrying after ${O}ms delay...` - ), - await Mz(O), - (O *= 2); - let D = await k.text(); - k.ok - ? u(null, D) - : u(new Error(`${k.status} ${k.statusText}: ${D}`)); - } catch (M) { - M instanceof Error && u(M); - } finally { - } - }, {}) - ); - } - function sor(t) { - return (e, r) => - new Promise((n, i) => { - t.request(e, r, (o, a) => { - if (o) { - i(o); - return; - } - n(a); - }); - }); - } - function uor(t) { - return (e) => - new Promise((r, n) => { - e.length === 0 && r([]); - let i = e.map((o) => t.request(o.methodName, o.args)); - t.request(i, (o, a) => { - if (o) { - n(o); - return; - } - r(a); - }); - }); - } - var cor = Ei(Xir), - lor = Ei(Qir), - dor = Ei(eor), - hor = Ei(tor), - por = Ei(X.number()), - yor = Gs( - X.type({ - total: X.number(), - circulating: X.number(), - nonCirculating: X.number(), - nonCirculatingAccounts: X.array(ws), - }) - ), - V1e = X.type({ - amount: X.string(), - uiAmount: X.nullable(X.number()), - decimals: X.number(), - uiAmountString: X.optional(X.string()), - }), - mor = Gs( - X.array( - X.type({ - address: ws, - amount: X.string(), - uiAmount: X.nullable(X.number()), - decimals: X.number(), - uiAmountString: X.optional(X.string()), - }) - ) - ), - gor = Gs( - X.array( - X.type({ - pubkey: ws, - account: X.type({ - executable: X.boolean(), - owner: ws, - lamports: X.number(), - data: rwe, - rentEpoch: X.number(), - }), - }) - ) - ), - W1e = X.type({ - program: X.string(), - parsed: X.unknown(), - space: X.number(), - }), - vor = Gs( - X.array( - X.type({ - pubkey: ws, - account: X.type({ - executable: X.boolean(), - owner: ws, - lamports: X.number(), - data: W1e, - rentEpoch: X.number(), - }), - }) - ) - ), - bor = Gs(X.array(X.type({ lamports: X.number(), address: ws }))), - Rz = X.type({ - executable: X.boolean(), - owner: ws, - lamports: X.number(), - data: rwe, - rentEpoch: X.number(), - }), - wor = X.type({ pubkey: ws, account: Rz }), - _or = X.coerce( - X.union([X.instance(Cr.Buffer), W1e]), - X.union([IZe, W1e]), - (t) => (Array.isArray(t) ? X.create(t, rwe) : t) - ), - NZe = X.type({ - executable: X.boolean(), - owner: ws, - lamports: X.number(), - data: _or, - rentEpoch: X.number(), - }), - xor = X.type({ pubkey: ws, account: NZe }), - Sor = X.type({ - state: X.union([ - X.literal("active"), - X.literal("inactive"), - X.literal("activating"), - X.literal("deactivating"), - ]), - active: X.number(), - inactive: X.number(), - }), - Aor = Ei( - X.array( - X.type({ - signature: X.string(), - slot: X.number(), - err: JM, - memo: X.nullable(X.string()), - blockTime: X.optional(X.nullable(X.number())), - }) - ) - ), - Eor = Ei( - X.array( - X.type({ - signature: X.string(), - slot: X.number(), - err: JM, - memo: X.nullable(X.string()), - blockTime: X.optional(X.nullable(X.number())), - }) - ) - ), - Mor = X.type({ subscription: X.number(), result: jY(Rz) }), - Tor = X.type({ pubkey: ws, account: Rz }), - kor = X.type({ subscription: X.number(), result: jY(Tor) }), - Por = X.type({ parent: X.number(), slot: X.number(), root: X.number() }), - Oor = X.type({ subscription: X.number(), result: Por }), - Bor = X.union([ - X.type({ - type: X.union([ - X.literal("firstShredReceived"), - X.literal("completed"), - X.literal("optimisticConfirmation"), - X.literal("root"), - ]), - slot: X.number(), - timestamp: X.number(), - }), - X.type({ - type: X.literal("createdBank"), - parent: X.number(), - slot: X.number(), - timestamp: X.number(), - }), - X.type({ - type: X.literal("frozen"), - slot: X.number(), - timestamp: X.number(), - stats: X.type({ - numTransactionEntries: X.number(), - numSuccessfulTransactions: X.number(), - numFailedTransactions: X.number(), - maxTransactionsPerEntry: X.number(), - }), - }), - X.type({ - type: X.literal("dead"), - slot: X.number(), - timestamp: X.number(), - err: X.string(), - }), - ]), - Ior = X.type({ subscription: X.number(), result: Bor }), - Cor = X.type({ - subscription: X.number(), - result: jY(X.union([ror, nor])), - }), - Ror = X.type({ subscription: X.number(), result: X.number() }), - Nor = X.type({ - pubkey: X.string(), - gossip: X.nullable(X.string()), - tpu: X.nullable(X.string()), - rpc: X.nullable(X.string()), - version: X.nullable(X.string()), - }), - gZe = X.type({ - votePubkey: X.string(), - nodePubkey: X.string(), - activatedStake: X.number(), - epochVoteAccount: X.boolean(), - epochCredits: X.array(X.tuple([X.number(), X.number(), X.number()])), - commission: X.number(), - lastVote: X.number(), - rootSlot: X.nullable(X.number()), - }), - Dor = Ei(X.type({ current: X.array(gZe), delinquent: X.array(gZe) })), - For = X.union([ - X.literal("processed"), - X.literal("confirmed"), - X.literal("finalized"), - ]), - Lor = X.type({ - slot: X.number(), - confirmations: X.nullable(X.number()), - err: JM, - confirmationStatus: X.optional(For), - }), - qor = Gs(X.array(X.nullable(Lor))), - zor = Ei(X.number()), - DZe = X.type({ - accountKey: ws, - writableIndexes: X.array(X.number()), - readonlyIndexes: X.array(X.number()), - }), - nwe = X.type({ - signatures: X.array(X.string()), - message: X.type({ - accountKeys: X.array(X.string()), - header: X.type({ - numRequiredSignatures: X.number(), - numReadonlySignedAccounts: X.number(), - numReadonlyUnsignedAccounts: X.number(), - }), - instructions: X.array( - X.type({ - accounts: X.array(X.number()), - data: X.string(), - programIdIndex: X.number(), - }) - ), - recentBlockhash: X.string(), - addressTableLookups: X.optional(X.array(DZe)), - }), - }), - FZe = X.type({ parsed: X.unknown(), program: X.string(), programId: ws }), - LZe = X.type({ accounts: X.array(ws), data: X.string(), programId: ws }), - jor = X.union([LZe, FZe]), - Uor = X.union([ - X.type({ - parsed: X.unknown(), - program: X.string(), - programId: X.string(), - }), - X.type({ - accounts: X.array(X.string()), - data: X.string(), - programId: X.string(), - }), - ]), - qZe = X.coerce(jor, Uor, (t) => - "accounts" in t ? X.create(t, LZe) : X.create(t, FZe) - ), - Kor = X.type({ - signatures: X.array(X.string()), - message: X.type({ - accountKeys: X.array( - X.type({ - pubkey: ws, - signer: X.boolean(), - writable: X.boolean(), - source: X.optional( - X.union([X.literal("transaction"), X.literal("lookupTable")]) - ), - }) - ), - instructions: X.array(qZe), - recentBlockhash: X.string(), - addressTableLookups: X.optional(X.nullable(X.array(DZe))), - }), - }), - DY = X.type({ - accountIndex: X.number(), - mint: X.string(), - owner: X.optional(X.string()), - uiTokenAmount: V1e, - }), - zZe = X.type({ writable: X.array(ws), readonly: X.array(ws) }), - iwe = X.type({ - err: JM, - fee: X.number(), - innerInstructions: X.optional( - X.nullable( - X.array( - X.type({ - index: X.number(), - instructions: X.array( - X.type({ - accounts: X.array(X.number()), - data: X.string(), - programIdIndex: X.number(), - }) - ), - }) - ) - ) - ), - preBalances: X.array(X.number()), - postBalances: X.array(X.number()), - logMessages: X.optional(X.nullable(X.array(X.string()))), - preTokenBalances: X.optional(X.nullable(X.array(DY))), - postTokenBalances: X.optional(X.nullable(X.array(DY))), - loadedAddresses: X.optional(zZe), - computeUnitsConsumed: X.optional(X.number()), - }), - Hor = X.type({ - err: JM, - fee: X.number(), - innerInstructions: X.optional( - X.nullable( - X.array(X.type({ index: X.number(), instructions: X.array(qZe) })) - ) - ), - preBalances: X.array(X.number()), - postBalances: X.array(X.number()), - logMessages: X.optional(X.nullable(X.array(X.string()))), - preTokenBalances: X.optional(X.nullable(X.array(DY))), - postTokenBalances: X.optional(X.nullable(X.array(DY))), - loadedAddresses: X.optional(zZe), - computeUnitsConsumed: X.optional(X.number()), - }), - owe = X.union([X.literal(0), X.literal("legacy")]), - Vor = Ei( - X.nullable( - X.type({ - blockhash: X.string(), - previousBlockhash: X.string(), - parentSlot: X.number(), - transactions: X.array( - X.type({ - transaction: nwe, - meta: X.nullable(iwe), - version: X.optional(owe), - }) - ), - rewards: X.optional( - X.array( - X.type({ - pubkey: X.string(), - lamports: X.number(), - postBalance: X.nullable(X.number()), - rewardType: X.nullable(X.string()), - }) - ) - ), - blockTime: X.nullable(X.number()), - blockHeight: X.nullable(X.number()), - }) - ) - ), - Wor = Ei( - X.nullable( - X.type({ - blockhash: X.string(), - previousBlockhash: X.string(), - parentSlot: X.number(), - transactions: X.array( - X.type({ transaction: nwe, meta: X.nullable(iwe) }) - ), - rewards: X.optional( - X.array( - X.type({ - pubkey: X.string(), - lamports: X.number(), - postBalance: X.nullable(X.number()), - rewardType: X.nullable(X.string()), - }) - ) - ), - blockTime: X.nullable(X.number()), - }) - ) - ), - vZe = Ei( - X.nullable( - X.type({ - blockhash: X.string(), - previousBlockhash: X.string(), - parentSlot: X.number(), - signatures: X.array(X.string()), - blockTime: X.nullable(X.number()), - }) - ) - ), - N1e = Ei( - X.nullable( - X.type({ - slot: X.number(), - meta: iwe, - blockTime: X.optional(X.nullable(X.number())), - transaction: nwe, - version: X.optional(owe), - }) - ) - ), - OY = Ei( - X.nullable( - X.type({ - slot: X.number(), - transaction: Kor, - meta: X.nullable(Hor), - blockTime: X.optional(X.nullable(X.number())), - version: X.optional(owe), - }) - ) - ), - Gor = Gs( - X.type({ - blockhash: X.string(), - feeCalculator: X.type({ lamportsPerSignature: X.number() }), - }) - ), - Jor = Gs( - X.type({ blockhash: X.string(), lastValidBlockHeight: X.number() }) - ), - $or = X.type({ - slot: X.number(), - numTransactions: X.number(), - numSlots: X.number(), - samplePeriodSecs: X.number(), - }), - Zor = Ei(X.array($or)), - Xor = Gs( - X.nullable( - X.type({ - feeCalculator: X.type({ lamportsPerSignature: X.number() }), - }) - ) - ), - Yor = Ei(X.string()), - Qor = Ei(X.string()), - ear = X.type({ - err: JM, - logs: X.array(X.string()), - signature: X.string(), - }), - tar = X.type({ result: jY(ear), subscription: X.number() }), - rar = { - "solana-client": `js/${ - (C1e = "0.0.0-development") !== null && C1e !== void 0 - ? C1e - : "UNKNOWN" - }`, - }, - G1e = class { - constructor(e, r) { - (this._commitment = void 0), - (this._confirmTransactionInitialTimeout = void 0), - (this._rpcEndpoint = void 0), - (this._rpcWsEndpoint = void 0), - (this._rpcClient = void 0), - (this._rpcRequest = void 0), - (this._rpcBatchRequest = void 0), - (this._rpcWebSocket = void 0), - (this._rpcWebSocketConnected = !1), - (this._rpcWebSocketHeartbeat = null), - (this._rpcWebSocketIdleTimeout = null), - (this._rpcWebSocketGeneration = 0), - (this._disableBlockhashCaching = !1), - (this._pollingBlockhash = !1), - (this._blockhashInfo = { - latestBlockhash: null, - lastFetch: 0, - transactionSignatures: [], - simulatedSignatures: [], - }), - (this._nextClientSubscriptionId = 0), - (this._subscriptionDisposeFunctionsByClientSubscriptionId = {}), - (this._subscriptionCallbacksByServerSubscriptionId = {}), - (this._subscriptionsByHash = {}), - (this._subscriptionsAutoDisposedByRpc = new Set()); - let n, i, o, a, s; - r && typeof r == "string" - ? (this._commitment = r) - : r && - ((this._commitment = r.commitment), - (this._confirmTransactionInitialTimeout = - r.confirmTransactionInitialTimeout), - (n = r.wsEndpoint), - (i = r.httpHeaders), - (o = r.fetch), - (a = r.fetchMiddleware), - (s = r.disableRetryOnRateLimit)), - (this._rpcEndpoint = $ir(e)), - (this._rpcWsEndpoint = n || Jir(e)), - (this._rpcClient = aor(e, i, o, a, s)), - (this._rpcRequest = sor(this._rpcClient)), - (this._rpcBatchRequest = uor(this._rpcClient)), - (this._rpcWebSocket = new lir.Client(this._rpcWsEndpoint, { - autoconnect: !1, - max_reconnects: 1 / 0, - })), - this._rpcWebSocket.on("open", this._wsOnOpen.bind(this)), - this._rpcWebSocket.on("error", this._wsOnError.bind(this)), - this._rpcWebSocket.on("close", this._wsOnClose.bind(this)), - this._rpcWebSocket.on( - "accountNotification", - this._wsOnAccountNotification.bind(this) - ), - this._rpcWebSocket.on( - "programNotification", - this._wsOnProgramAccountNotification.bind(this) - ), - this._rpcWebSocket.on( - "slotNotification", - this._wsOnSlotNotification.bind(this) - ), - this._rpcWebSocket.on( - "slotsUpdatesNotification", - this._wsOnSlotUpdatesNotification.bind(this) - ), - this._rpcWebSocket.on( - "signatureNotification", - this._wsOnSignatureNotification.bind(this) - ), - this._rpcWebSocket.on( - "rootNotification", - this._wsOnRootNotification.bind(this) - ), - this._rpcWebSocket.on( - "logsNotification", - this._wsOnLogsNotification.bind(this) - ); - } - get commitment() { - return this._commitment; - } - get rpcEndpoint() { - return this._rpcEndpoint; - } - async getBalanceAndContext(e, r) { - let { commitment: n, config: i } = ts(r), - o = this._buildArgs([e.toBase58()], n, void 0, i), - a = await this._rpcRequest("getBalance", o), - s = X.create(a, Gs(X.number())); - if ("error" in s) - throw new pr(s.error, `failed to get balance for ${e.toBase58()}`); - return s.result; - } - async getBalance(e, r) { - return await this.getBalanceAndContext(e, r) - .then((n) => n.value) - .catch((n) => { - throw new Error( - "failed to get balance of account " + e.toBase58() + ": " + n - ); - }); - } - async getBlockTime(e) { - let r = await this._rpcRequest("getBlockTime", [e]), - n = X.create(r, Ei(X.nullable(X.number()))); - if ("error" in n) - throw new pr(n.error, `failed to get block time for slot ${e}`); - return n.result; - } - async getMinimumLedgerSlot() { - let e = await this._rpcRequest("minimumLedgerSlot", []), - r = X.create(e, Ei(X.number())); - if ("error" in r) - throw new pr(r.error, "failed to get minimum ledger slot"); - return r.result; - } - async getFirstAvailableBlock() { - let e = await this._rpcRequest("getFirstAvailableBlock", []), - r = X.create(e, por); - if ("error" in r) - throw new pr(r.error, "failed to get first available block"); - return r.result; - } - async getSupply(e) { - let r = {}; - typeof e == "string" - ? (r = { commitment: e }) - : e - ? (r = { ...e, commitment: (e && e.commitment) || this.commitment }) - : (r = { commitment: this.commitment }); - let n = await this._rpcRequest("getSupply", [r]), - i = X.create(n, yor); - if ("error" in i) throw new pr(i.error, "failed to get supply"); - return i.result; - } - async getTokenSupply(e, r) { - let n = this._buildArgs([e.toBase58()], r), - i = await this._rpcRequest("getTokenSupply", n), - o = X.create(i, Gs(V1e)); - if ("error" in o) throw new pr(o.error, "failed to get token supply"); - return o.result; - } - async getTokenAccountBalance(e, r) { - let n = this._buildArgs([e.toBase58()], r), - i = await this._rpcRequest("getTokenAccountBalance", n), - o = X.create(i, Gs(V1e)); - if ("error" in o) - throw new pr(o.error, "failed to get token account balance"); - return o.result; - } - async getTokenAccountsByOwner(e, r, n) { - let { commitment: i, config: o } = ts(n), - a = [e.toBase58()]; - "mint" in r - ? a.push({ mint: r.mint.toBase58() }) - : a.push({ programId: r.programId.toBase58() }); - let s = this._buildArgs(a, i, "base64", o), - c = await this._rpcRequest("getTokenAccountsByOwner", s), - u = X.create(c, gor); - if ("error" in u) - throw new pr( - u.error, - `failed to get token accounts owned by account ${e.toBase58()}` - ); - return u.result; - } - async getParsedTokenAccountsByOwner(e, r, n) { - let i = [e.toBase58()]; - "mint" in r - ? i.push({ mint: r.mint.toBase58() }) - : i.push({ programId: r.programId.toBase58() }); - let o = this._buildArgs(i, n, "jsonParsed"), - a = await this._rpcRequest("getTokenAccountsByOwner", o), - s = X.create(a, vor); - if ("error" in s) - throw new pr( - s.error, - `failed to get token accounts owned by account ${e.toBase58()}` - ); - return s.result; - } - async getLargestAccounts(e) { - let r = { ...e, commitment: (e && e.commitment) || this.commitment }, - n = r.filter || r.commitment ? [r] : [], - i = await this._rpcRequest("getLargestAccounts", n), - o = X.create(i, bor); - if ("error" in o) - throw new pr(o.error, "failed to get largest accounts"); - return o.result; - } - async getTokenLargestAccounts(e, r) { - let n = this._buildArgs([e.toBase58()], r), - i = await this._rpcRequest("getTokenLargestAccounts", n), - o = X.create(i, mor); - if ("error" in o) - throw new pr(o.error, "failed to get token largest accounts"); - return o.result; - } - async getAccountInfoAndContext(e, r) { - let { commitment: n, config: i } = ts(r), - o = this._buildArgs([e.toBase58()], n, "base64", i), - a = await this._rpcRequest("getAccountInfo", o), - s = X.create(a, Gs(X.nullable(Rz))); - if ("error" in s) - throw new pr( - s.error, - `failed to get info about account ${e.toBase58()}` - ); - return s.result; - } - async getParsedAccountInfo(e, r) { - let { commitment: n, config: i } = ts(r), - o = this._buildArgs([e.toBase58()], n, "jsonParsed", i), - a = await this._rpcRequest("getAccountInfo", o), - s = X.create(a, Gs(X.nullable(NZe))); - if ("error" in s) - throw new pr( - s.error, - `failed to get info about account ${e.toBase58()}` - ); - return s.result; - } - async getAccountInfo(e, r) { - try { - return (await this.getAccountInfoAndContext(e, r)).value; - } catch (n) { - throw new Error( - "failed to get info about account " + e.toBase58() + ": " + n - ); - } - } - async getMultipleAccountsInfoAndContext(e, r) { - let { commitment: n, config: i } = ts(r), - o = e.map((u) => u.toBase58()), - a = this._buildArgs([o], n, "base64", i), - s = await this._rpcRequest("getMultipleAccounts", a), - c = X.create(s, Gs(X.array(X.nullable(Rz)))); - if ("error" in c) - throw new pr(c.error, `failed to get info for accounts ${o}`); - return c.result; - } - async getMultipleAccountsInfo(e, r) { - return (await this.getMultipleAccountsInfoAndContext(e, r)).value; - } - async getStakeActivation(e, r, n) { - let { commitment: i, config: o } = ts(r), - a = this._buildArgs([e.toBase58()], i, void 0, { - ...o, - epoch: n ?? o?.epoch, - }), - s = await this._rpcRequest("getStakeActivation", a), - c = X.create(s, Ei(Sor)); - if ("error" in c) - throw new pr( - c.error, - `failed to get Stake Activation ${e.toBase58()}` - ); - return c.result; - } - async getProgramAccounts(e, r) { - let { commitment: n, config: i } = ts(r), - { encoding: o, ...a } = i || {}, - s = this._buildArgs([e.toBase58()], n, o || "base64", a), - c = await this._rpcRequest("getProgramAccounts", s), - u = X.create(c, Ei(X.array(wor))); - if ("error" in u) - throw new pr( - u.error, - `failed to get accounts owned by program ${e.toBase58()}` - ); - return u.result; - } - async getParsedProgramAccounts(e, r) { - let { commitment: n, config: i } = ts(r), - o = this._buildArgs([e.toBase58()], n, "jsonParsed", i), - a = await this._rpcRequest("getProgramAccounts", o), - s = X.create(a, Ei(X.array(xor))); - if ("error" in s) - throw new pr( - s.error, - `failed to get accounts owned by program ${e.toBase58()}` - ); - return s.result; - } - async confirmTransaction(e, r) { - let n; - typeof e == "string" ? (n = e) : (n = e.signature); - let i; - try { - i = nc.default.decode(n); - } catch { - throw new Error("signature must be base58 encoded: " + n); - } - Ii(i.length === 64, "signature has invalid length"); - let o = r || this.commitment, - a, - s, - c = !1, - u = new Promise((M, k) => { - try { - s = this.onSignature( - n, - (O, D) => { - s = void 0; - let F = { context: D, value: O }; - (c = !0), - M({ - __type: Gt.TransactionStatus.PROCESSED, - response: F, - }); - }, - o - ); - } catch (O) { - k(O); - } - }), - h = new Promise((M) => { - if (typeof e == "string") { - let k = this._confirmTransactionInitialTimeout || 6e4; - switch (o) { - case "processed": - case "recent": - case "single": - case "confirmed": - case "singleGossip": { - k = this._confirmTransactionInitialTimeout || 30 * 1e3; - break; - } - } - a = setTimeout( - () => - M({ __type: Gt.TransactionStatus.TIMED_OUT, timeoutMs: k }), - k - ); - } else { - let k = e, - O = async () => { - try { - return await this.getBlockHeight(r); - } catch { - return -1; - } - }; - (async () => { - let D = await O(); - if (!c) { - for (; D <= k.lastValidBlockHeight; ) - if ((await Mz(1e3), c || ((D = await O()), c))) return; - M({ __type: Gt.TransactionStatus.BLOCKHEIGHT_EXCEEDED }); - } - })(); - } - }), - w; - try { - let M = await Promise.race([u, h]); - switch (M.__type) { - case Gt.TransactionStatus.BLOCKHEIGHT_EXCEEDED: - throw new kz(n); - case Gt.TransactionStatus.PROCESSED: - w = M.response; - break; - case Gt.TransactionStatus.TIMED_OUT: - throw new Pz(n, M.timeoutMs / 1e3); - } - } finally { - clearTimeout(a), s && this.removeSignatureListener(s); - } - return w; - } - async getClusterNodes() { - let e = await this._rpcRequest("getClusterNodes", []), - r = X.create(e, Ei(X.array(Nor))); - if ("error" in r) - throw new pr(r.error, "failed to get cluster nodes"); - return r.result; - } - async getVoteAccounts(e) { - let r = this._buildArgs([], e), - n = await this._rpcRequest("getVoteAccounts", r), - i = X.create(n, Dor); - if ("error" in i) - throw new pr(i.error, "failed to get vote accounts"); - return i.result; - } - async getSlot(e) { - let { commitment: r, config: n } = ts(e), - i = this._buildArgs([], r, void 0, n), - o = await this._rpcRequest("getSlot", i), - a = X.create(o, Ei(X.number())); - if ("error" in a) throw new pr(a.error, "failed to get slot"); - return a.result; - } - async getSlotLeader(e) { - let { commitment: r, config: n } = ts(e), - i = this._buildArgs([], r, void 0, n), - o = await this._rpcRequest("getSlotLeader", i), - a = X.create(o, Ei(X.string())); - if ("error" in a) throw new pr(a.error, "failed to get slot leader"); - return a.result; - } - async getSlotLeaders(e, r) { - let n = [e, r], - i = await this._rpcRequest("getSlotLeaders", n), - o = X.create(i, Ei(X.array(ws))); - if ("error" in o) throw new pr(o.error, "failed to get slot leaders"); - return o.result; - } - async getSignatureStatus(e, r) { - let { context: n, value: i } = await this.getSignatureStatuses( - [e], - r - ); - Ii(i.length === 1); - let o = i[0]; - return { context: n, value: o }; - } - async getSignatureStatuses(e, r) { - let n = [e]; - r && n.push(r); - let i = await this._rpcRequest("getSignatureStatuses", n), - o = X.create(i, qor); - if ("error" in o) - throw new pr(o.error, "failed to get signature status"); - return o.result; - } - async getTransactionCount(e) { - let { commitment: r, config: n } = ts(e), - i = this._buildArgs([], r, void 0, n), - o = await this._rpcRequest("getTransactionCount", i), - a = X.create(o, Ei(X.number())); - if ("error" in a) - throw new pr(a.error, "failed to get transaction count"); - return a.result; - } - async getTotalSupply(e) { - return ( - await this.getSupply({ - commitment: e, - excludeNonCirculatingAccountsList: !0, - }) - ).value.total; - } - async getInflationGovernor(e) { - let r = this._buildArgs([], e), - n = await this._rpcRequest("getInflationGovernor", r), - i = X.create(n, cor); - if ("error" in i) throw new pr(i.error, "failed to get inflation"); - return i.result; - } - async getInflationReward(e, r, n) { - let { commitment: i, config: o } = ts(n), - a = this._buildArgs([e.map((u) => u.toBase58())], i, void 0, { - ...o, - epoch: r ?? o?.epoch, - }), - s = await this._rpcRequest("getInflationReward", a), - c = X.create(s, Yir); - if ("error" in c) - throw new pr(c.error, "failed to get inflation reward"); - return c.result; - } - async getEpochInfo(e) { - let { commitment: r, config: n } = ts(e), - i = this._buildArgs([], r, void 0, n), - o = await this._rpcRequest("getEpochInfo", i), - a = X.create(o, lor); - if ("error" in a) throw new pr(a.error, "failed to get epoch info"); - return a.result; - } - async getEpochSchedule() { - let e = await this._rpcRequest("getEpochSchedule", []), - r = X.create(e, dor); - if ("error" in r) - throw new pr(r.error, "failed to get epoch schedule"); - let n = r.result; - return new NY( - n.slotsPerEpoch, - n.leaderScheduleSlotOffset, - n.warmup, - n.firstNormalEpoch, - n.firstNormalSlot - ); - } - async getLeaderSchedule() { - let e = await this._rpcRequest("getLeaderSchedule", []), - r = X.create(e, hor); - if ("error" in r) - throw new pr(r.error, "failed to get leader schedule"); - return r.result; - } - async getMinimumBalanceForRentExemption(e, r) { - let n = this._buildArgs([e], r), - i = await this._rpcRequest("getMinimumBalanceForRentExemption", n), - o = X.create(i, zor); - return "error" in o - ? (console.warn( - "Unable to fetch minimum balance for rent exemption" - ), - 0) - : o.result; - } - async getRecentBlockhashAndContext(e) { - let r = this._buildArgs([], e), - n = await this._rpcRequest("getRecentBlockhash", r), - i = X.create(n, Gor); - if ("error" in i) - throw new pr(i.error, "failed to get recent blockhash"); - return i.result; - } - async getRecentPerformanceSamples(e) { - let r = await this._rpcRequest( - "getRecentPerformanceSamples", - e ? [e] : [] - ), - n = X.create(r, Zor); - if ("error" in n) - throw new pr(n.error, "failed to get recent performance samples"); - return n.result; - } - async getFeeCalculatorForBlockhash(e, r) { - let n = this._buildArgs([e], r), - i = await this._rpcRequest("getFeeCalculatorForBlockhash", n), - o = X.create(i, Xor); - if ("error" in o) - throw new pr(o.error, "failed to get fee calculator"); - let { context: a, value: s } = o.result; - return { context: a, value: s !== null ? s.feeCalculator : null }; - } - async getFeeForMessage(e, r) { - let n = e.serialize().toString("base64"), - i = this._buildArgs([n], r), - o = await this._rpcRequest("getFeeForMessage", i), - a = X.create(o, Gs(X.nullable(X.number()))); - if ("error" in a) throw new pr(a.error, "failed to get slot"); - if (a.result === null) throw new Error("invalid blockhash"); - return a.result; - } - async getRecentBlockhash(e) { - try { - return (await this.getRecentBlockhashAndContext(e)).value; - } catch (r) { - throw new Error("failed to get recent blockhash: " + r); - } - } - async getLatestBlockhash(e) { - try { - return (await this.getLatestBlockhashAndContext(e)).value; - } catch (r) { - throw new Error("failed to get recent blockhash: " + r); - } - } - async getLatestBlockhashAndContext(e) { - let { commitment: r, config: n } = ts(e), - i = this._buildArgs([], r, void 0, n), - o = await this._rpcRequest("getLatestBlockhash", i), - a = X.create(o, Jor); - if ("error" in a) - throw new pr(a.error, "failed to get latest blockhash"); - return a.result; - } - async getVersion() { - let e = await this._rpcRequest("getVersion", []), - r = X.create(e, Ei(ior)); - if ("error" in r) throw new pr(r.error, "failed to get version"); - return r.result; - } - async getGenesisHash() { - let e = await this._rpcRequest("getGenesisHash", []), - r = X.create(e, Ei(X.string())); - if ("error" in r) throw new pr(r.error, "failed to get genesis hash"); - return r.result; - } - async getBlock(e, r) { - let { commitment: n, config: i } = ts(r), - o = this._buildArgsAtLeastConfirmed([e], n, void 0, i), - a = await this._rpcRequest("getBlock", o), - s = X.create(a, Vor); - if ("error" in s) - throw new pr(s.error, "failed to get confirmed block"); - let c = s.result; - return ( - c && { - ...c, - transactions: c.transactions.map( - ({ transaction: u, meta: h, version: w }) => ({ - meta: h, - transaction: { ...u, message: R1e(w, u.message) }, - version: w, - }) - ), - } - ); - } - async getBlockHeight(e) { - let { commitment: r, config: n } = ts(e), - i = this._buildArgs([], r, void 0, n), - o = await this._rpcRequest("getBlockHeight", i), - a = X.create(o, Ei(X.number())); - if ("error" in a) - throw new pr(a.error, "failed to get block height information"); - return a.result; - } - async getBlockProduction(e) { - let r, n; - if (typeof e == "string") n = e; - else if (e) { - let { commitment: s, ...c } = e; - (n = s), (r = c); - } - let i = this._buildArgs([], n, "base64", r), - o = await this._rpcRequest("getBlockProduction", i), - a = X.create(o, oor); - if ("error" in a) - throw new pr(a.error, "failed to get block production information"); - return a.result; - } - async getTransaction(e, r) { - let { commitment: n, config: i } = ts(r), - o = this._buildArgsAtLeastConfirmed([e], n, void 0, i), - a = await this._rpcRequest("getTransaction", o), - s = X.create(a, N1e); - if ("error" in s) throw new pr(s.error, "failed to get transaction"); - let c = s.result; - return ( - c && { - ...c, - transaction: { - ...c.transaction, - message: R1e(c.version, c.transaction.message), - }, - } - ); - } - async getParsedTransaction(e, r) { - let { commitment: n, config: i } = ts(r), - o = this._buildArgsAtLeastConfirmed([e], n, "jsonParsed", i), - a = await this._rpcRequest("getTransaction", o), - s = X.create(a, OY); - if ("error" in s) throw new pr(s.error, "failed to get transaction"); - return s.result; - } - async getParsedTransactions(e, r) { - let { commitment: n, config: i } = ts(r), - o = e.map((c) => { - let u = this._buildArgsAtLeastConfirmed([c], n, "jsonParsed", i); - return { methodName: "getTransaction", args: u }; - }); - return (await this._rpcBatchRequest(o)).map((c) => { - let u = X.create(c, OY); - if ("error" in u) - throw new pr(u.error, "failed to get transactions"); - return u.result; - }); - } - async getTransactions(e, r) { - let { commitment: n, config: i } = ts(r), - o = e.map((c) => { - let u = this._buildArgsAtLeastConfirmed([c], n, void 0, i); - return { methodName: "getTransaction", args: u }; - }); - return (await this._rpcBatchRequest(o)).map((c) => { - let u = X.create(c, N1e); - if ("error" in u) - throw new pr(u.error, "failed to get transactions"); - let h = u.result; - return ( - h && { - ...h, - transaction: { - ...h.transaction, - message: R1e(h.version, h.transaction.message), - }, - } - ); - }); - } - async getConfirmedBlock(e, r) { - let n = this._buildArgsAtLeastConfirmed([e], r), - i = await this._rpcRequest("getConfirmedBlock", n), - o = X.create(i, Wor); - if ("error" in o) - throw new pr(o.error, "failed to get confirmed block"); - let a = o.result; - if (!a) throw new Error("Confirmed block " + e + " not found"); - let s = { - ...a, - transactions: a.transactions.map(({ transaction: c, meta: u }) => { - let h = new Up(c.message); - return { meta: u, transaction: { ...c, message: h } }; - }), - }; - return { - ...s, - transactions: s.transactions.map(({ transaction: c, meta: u }) => ({ - meta: u, - transaction: Bi.populate(c.message, c.signatures), - })), - }; - } - async getBlocks(e, r, n) { - let i = this._buildArgsAtLeastConfirmed( - r !== void 0 ? [e, r] : [e], - n - ), - o = await this._rpcRequest("getBlocks", i), - a = X.create(o, Ei(X.array(X.number()))); - if ("error" in a) throw new pr(a.error, "failed to get blocks"); - return a.result; - } - async getBlockSignatures(e, r) { - let n = this._buildArgsAtLeastConfirmed([e], r, void 0, { - transactionDetails: "signatures", - rewards: !1, - }), - i = await this._rpcRequest("getBlock", n), - o = X.create(i, vZe); - if ("error" in o) throw new pr(o.error, "failed to get block"); - let a = o.result; - if (!a) throw new Error("Block " + e + " not found"); - return a; - } - async getConfirmedBlockSignatures(e, r) { - let n = this._buildArgsAtLeastConfirmed([e], r, void 0, { - transactionDetails: "signatures", - rewards: !1, - }), - i = await this._rpcRequest("getConfirmedBlock", n), - o = X.create(i, vZe); - if ("error" in o) - throw new pr(o.error, "failed to get confirmed block"); - let a = o.result; - if (!a) throw new Error("Confirmed block " + e + " not found"); - return a; - } - async getConfirmedTransaction(e, r) { - let n = this._buildArgsAtLeastConfirmed([e], r), - i = await this._rpcRequest("getConfirmedTransaction", n), - o = X.create(i, N1e); - if ("error" in o) throw new pr(o.error, "failed to get transaction"); - let a = o.result; - if (!a) return a; - let s = new Up(a.transaction.message), - c = a.transaction.signatures; - return { ...a, transaction: Bi.populate(s, c) }; - } - async getParsedConfirmedTransaction(e, r) { - let n = this._buildArgsAtLeastConfirmed([e], r, "jsonParsed"), - i = await this._rpcRequest("getConfirmedTransaction", n), - o = X.create(i, OY); - if ("error" in o) - throw new pr(o.error, "failed to get confirmed transaction"); - return o.result; - } - async getParsedConfirmedTransactions(e, r) { - let n = e.map((a) => { - let s = this._buildArgsAtLeastConfirmed([a], r, "jsonParsed"); - return { methodName: "getConfirmedTransaction", args: s }; - }); - return (await this._rpcBatchRequest(n)).map((a) => { - let s = X.create(a, OY); - if ("error" in s) - throw new pr(s.error, "failed to get confirmed transactions"); - return s.result; - }); - } - async getConfirmedSignaturesForAddress(e, r, n) { - let i = {}, - o = await this.getFirstAvailableBlock(); - for (; !("until" in i) && (r--, !(r <= 0 || r < o)); ) - try { - let c = await this.getConfirmedBlockSignatures(r, "finalized"); - c.signatures.length > 0 && - (i.until = c.signatures[c.signatures.length - 1].toString()); - } catch (c) { - if (c instanceof Error && c.message.includes("skipped")) continue; - throw c; - } - let a = await this.getSlot("finalized"); - for (; !("before" in i) && (n++, !(n > a)); ) - try { - let c = await this.getConfirmedBlockSignatures(n); - c.signatures.length > 0 && - (i.before = c.signatures[c.signatures.length - 1].toString()); - } catch (c) { - if (c instanceof Error && c.message.includes("skipped")) continue; - throw c; - } - return (await this.getConfirmedSignaturesForAddress2(e, i)).map( - (c) => c.signature - ); - } - async getConfirmedSignaturesForAddress2(e, r, n) { - let i = this._buildArgsAtLeastConfirmed([e.toBase58()], n, void 0, r), - o = await this._rpcRequest("getConfirmedSignaturesForAddress2", i), - a = X.create(o, Aor); - if ("error" in a) - throw new pr( - a.error, - "failed to get confirmed signatures for address" - ); - return a.result; - } - async getSignaturesForAddress(e, r, n) { - let i = this._buildArgsAtLeastConfirmed([e.toBase58()], n, void 0, r), - o = await this._rpcRequest("getSignaturesForAddress", i), - a = X.create(o, Eor); - if ("error" in a) - throw new pr(a.error, "failed to get signatures for address"); - return a.result; - } - async getAddressLookupTable(e, r) { - let { context: n, value: i } = await this.getAccountInfoAndContext( - e, - r - ), - o = null; - return ( - i !== null && - (o = new Cz({ key: e, state: Cz.deserialize(i.data) })), - { context: n, value: o } - ); - } - async getNonceAndContext(e, r) { - let { context: n, value: i } = await this.getAccountInfoAndContext( - e, - r - ), - o = null; - return ( - i !== null && (o = hC.fromAccountData(i.data)), - { context: n, value: o } - ); - } - async getNonce(e, r) { - return await this.getNonceAndContext(e, r) - .then((n) => n.value) - .catch((n) => { - throw new Error( - "failed to get nonce for account " + e.toBase58() + ": " + n - ); - }); - } - async requestAirdrop(e, r) { - let n = await this._rpcRequest("requestAirdrop", [e.toBase58(), r]), - i = X.create(n, Yor); - if ("error" in i) - throw new pr(i.error, `airdrop to ${e.toBase58()} failed`); - return i.result; - } - async _blockhashWithExpiryBlockHeight(e) { - if (!e) { - for (; this._pollingBlockhash; ) await Mz(100); - let n = Date.now() - this._blockhashInfo.lastFetch >= CZe; - if (this._blockhashInfo.latestBlockhash !== null && !n) - return this._blockhashInfo.latestBlockhash; - } - return await this._pollNewBlockhash(); - } - async _pollNewBlockhash() { - this._pollingBlockhash = !0; - try { - let e = Date.now(), - r = this._blockhashInfo.latestBlockhash, - n = r ? r.blockhash : null; - for (let i = 0; i < 50; i++) { - let o = await this.getLatestBlockhash("finalized"); - if (n !== o.blockhash) - return ( - (this._blockhashInfo = { - latestBlockhash: o, - lastFetch: Date.now(), - transactionSignatures: [], - simulatedSignatures: [], - }), - o - ); - await Mz(Hir / 2); - } - throw new Error( - `Unable to obtain a new blockhash after ${Date.now() - e}ms` - ); - } finally { - this._pollingBlockhash = !1; - } - } - async getStakeMinimumDelegation(e) { - let { commitment: r, config: n } = ts(e), - i = this._buildArgs([], r, "base64", n), - o = await this._rpcRequest("getStakeMinimumDelegation", i), - a = X.create(o, Gs(X.number())); - if ("error" in a) - throw new pr(a.error, "failed to get stake minimum delegation"); - return a.result; - } - async simulateTransaction(e, r, n) { - if ("message" in e) { - let D = e.serialize(), - F = Cr.Buffer.from(D).toString("base64"); - if (Array.isArray(r) || n !== void 0) - throw new Error("Invalid arguments"); - let N = r || {}; - (N.encoding = "base64"), - "commitment" in N || (N.commitment = this.commitment); - let q = [F, N], - z = await this._rpcRequest("simulateTransaction", q), - H = X.create(z, mZe); - if ("error" in H) - throw new Error( - "failed to simulate transaction: " + H.error.message - ); - return H.result; - } - let i; - if (e instanceof Bi) { - let O = e; - (i = new Bi()), - (i.feePayer = O.feePayer), - (i.instructions = e.instructions), - (i.nonceInfo = O.nonceInfo), - (i.signatures = O.signatures); - } else (i = Bi.populate(e)), (i._message = i._json = void 0); - if (r !== void 0 && !Array.isArray(r)) - throw new Error("Invalid arguments"); - let o = r; - if (i.nonceInfo && o) i.sign(...o); - else { - let O = this._disableBlockhashCaching; - for (;;) { - let D = await this._blockhashWithExpiryBlockHeight(O); - if ( - ((i.lastValidBlockHeight = D.lastValidBlockHeight), - (i.recentBlockhash = D.blockhash), - !o) - ) - break; - if ((i.sign(...o), !i.signature)) throw new Error("!signature"); - let F = i.signature.toString("base64"); - if ( - !this._blockhashInfo.simulatedSignatures.includes(F) && - !this._blockhashInfo.transactionSignatures.includes(F) - ) { - this._blockhashInfo.simulatedSignatures.push(F); - break; - } else O = !0; - } - } - let a = i._compile(), - s = a.serialize(), - u = i._serialize(s).toString("base64"), - h = { encoding: "base64", commitment: this.commitment }; - if (n) { - let O = (Array.isArray(n) ? n : a.nonProgramIds()).map((D) => - D.toBase58() - ); - h.accounts = { encoding: "base64", addresses: O }; - } - o && (h.sigVerify = !0); - let w = [u, h], - M = await this._rpcRequest("simulateTransaction", w), - k = X.create(M, mZe); - if ("error" in k) { - let O; - if ( - "data" in k.error && - ((O = k.error.data.logs), O && Array.isArray(O)) - ) { - let D = ` - `, - F = D + O.join(D); - console.error(k.error.message, F); - } - throw new Iz( - "failed to simulate transaction: " + k.error.message, - O - ); - } - return k.result; - } - async sendTransaction(e, r, n) { - if ("version" in e) { - if (r && Array.isArray(r)) throw new Error("Invalid arguments"); - let a = e.serialize(); - return await this.sendRawTransaction(a, n); - } - if (r === void 0 || !Array.isArray(r)) - throw new Error("Invalid arguments"); - let i = r; - if (e.nonceInfo) e.sign(...i); - else { - let a = this._disableBlockhashCaching; - for (;;) { - let s = await this._blockhashWithExpiryBlockHeight(a); - if ( - ((e.lastValidBlockHeight = s.lastValidBlockHeight), - (e.recentBlockhash = s.blockhash), - e.sign(...i), - !e.signature) - ) - throw new Error("!signature"); - let c = e.signature.toString("base64"); - if (this._blockhashInfo.transactionSignatures.includes(c)) a = !0; - else { - this._blockhashInfo.transactionSignatures.push(c); - break; - } - } - } - let o = e.serialize(); - return await this.sendRawTransaction(o, n); - } - async sendRawTransaction(e, r) { - let n = On(e).toString("base64"); - return await this.sendEncodedTransaction(n, r); - } - async sendEncodedTransaction(e, r) { - let n = { encoding: "base64" }, - i = r && r.skipPreflight, - o = (r && r.preflightCommitment) || this.commitment; - r && r.maxRetries != null && (n.maxRetries = r.maxRetries), - r && - r.minContextSlot != null && - (n.minContextSlot = r.minContextSlot), - i && (n.skipPreflight = i), - o && (n.preflightCommitment = o); - let a = [e, n], - s = await this._rpcRequest("sendTransaction", a), - c = X.create(s, Qor); - if ("error" in c) { - let u; - throw ( - ("data" in c.error && (u = c.error.data.logs), - new Iz("failed to send transaction: " + c.error.message, u)) - ); - } - return c.result; - } - _wsOnOpen() { - (this._rpcWebSocketConnected = !0), - (this._rpcWebSocketHeartbeat = setInterval(() => { - this._rpcWebSocket.notify("ping").catch(() => {}); - }, 5e3)), - this._updateSubscriptions(); - } - _wsOnError(e) { - (this._rpcWebSocketConnected = !1), - console.error("ws error:", e.message); - } - _wsOnClose(e) { - if ( - ((this._rpcWebSocketConnected = !1), - this._rpcWebSocketGeneration++, - this._rpcWebSocketIdleTimeout && - (clearTimeout(this._rpcWebSocketIdleTimeout), - (this._rpcWebSocketIdleTimeout = null)), - this._rpcWebSocketHeartbeat && - (clearInterval(this._rpcWebSocketHeartbeat), - (this._rpcWebSocketHeartbeat = null)), - e === 1e3) - ) { - this._updateSubscriptions(); - return; - } - (this._subscriptionCallbacksByServerSubscriptionId = {}), - Object.entries(this._subscriptionsByHash).forEach(([r, n]) => { - this._subscriptionsByHash[r] = { ...n, state: "pending" }; - }); - } - async _updateSubscriptions() { - if (Object.keys(this._subscriptionsByHash).length === 0) { - this._rpcWebSocketConnected && - ((this._rpcWebSocketConnected = !1), - (this._rpcWebSocketIdleTimeout = setTimeout(() => { - this._rpcWebSocketIdleTimeout = null; - try { - this._rpcWebSocket.close(); - } catch (n) { - n instanceof Error && - console.log( - `Error when closing socket connection: ${n.message}` - ); - } - }, 500))); - return; - } - if ( - (this._rpcWebSocketIdleTimeout !== null && - (clearTimeout(this._rpcWebSocketIdleTimeout), - (this._rpcWebSocketIdleTimeout = null), - (this._rpcWebSocketConnected = !0)), - !this._rpcWebSocketConnected) - ) { - this._rpcWebSocket.connect(); - return; - } - let e = this._rpcWebSocketGeneration, - r = () => e === this._rpcWebSocketGeneration; - await Promise.all( - Object.keys(this._subscriptionsByHash).map(async (n) => { - let i = this._subscriptionsByHash[n]; - if (i !== void 0) - switch (i.state) { - case "pending": - case "unsubscribed": - if (i.callbacks.size === 0) { - delete this._subscriptionsByHash[n], - i.state === "unsubscribed" && - delete this - ._subscriptionCallbacksByServerSubscriptionId[ - i.serverSubscriptionId - ], - await this._updateSubscriptions(); - return; - } - await (async () => { - let { args: o, method: a } = i; - try { - this._subscriptionsByHash[n] = { - ...i, - state: "subscribing", - }; - let s = await this._rpcWebSocket.call(a, o); - (this._subscriptionsByHash[n] = { - ...i, - serverSubscriptionId: s, - state: "subscribed", - }), - (this._subscriptionCallbacksByServerSubscriptionId[ - s - ] = i.callbacks), - await this._updateSubscriptions(); - } catch (s) { - if ( - (s instanceof Error && - console.error( - `${a} error for argument`, - o, - s.message - ), - !r()) - ) - return; - (this._subscriptionsByHash[n] = { - ...i, - state: "pending", - }), - await this._updateSubscriptions(); - } - })(); - break; - case "subscribed": - i.callbacks.size === 0 && - (await (async () => { - let { serverSubscriptionId: o, unsubscribeMethod: a } = - i; - if (this._subscriptionsAutoDisposedByRpc.has(o)) - this._subscriptionsAutoDisposedByRpc.delete(o); - else { - this._subscriptionsByHash[n] = { - ...i, - state: "unsubscribing", - }; - try { - await this._rpcWebSocket.call(a, [o]); - } catch (s) { - if ( - (s instanceof Error && - console.error(`${a} error:`, s.message), - !r()) - ) - return; - (this._subscriptionsByHash[n] = { - ...i, - state: "subscribed", - }), - await this._updateSubscriptions(); - return; - } - } - (this._subscriptionsByHash[n] = { - ...i, - state: "unsubscribed", - }), - await this._updateSubscriptions(); - })()); - break; - } - }) - ); - } - _handleServerNotification(e, r) { - let n = this._subscriptionCallbacksByServerSubscriptionId[e]; - n !== void 0 && - n.forEach((i) => { - try { - i(...r); - } catch (o) { - console.error(o); - } - }); - } - _wsOnAccountNotification(e) { - let { result: r, subscription: n } = X.create(e, Mor); - this._handleServerNotification(n, [r.value, r.context]); - } - _makeSubscription(e, r) { - let n = this._nextClientSubscriptionId++, - i = Fir([e.method, r], !0), - o = this._subscriptionsByHash[i]; - return ( - o === void 0 - ? (this._subscriptionsByHash[i] = { - ...e, - args: r, - callbacks: new Set([e.callback]), - state: "pending", - }) - : o.callbacks.add(e.callback), - (this._subscriptionDisposeFunctionsByClientSubscriptionId[n] = - async () => { - delete this._subscriptionDisposeFunctionsByClientSubscriptionId[ - n - ]; - let a = this._subscriptionsByHash[i]; - Ii( - a !== void 0, - `Could not find a \`Subscription\` when tearing down client subscription #${n}` - ), - a.callbacks.delete(e.callback), - await this._updateSubscriptions(); - }), - this._updateSubscriptions(), - n - ); - } - onAccountChange(e, r, n) { - let i = this._buildArgs( - [e.toBase58()], - n || this._commitment || "finalized", - "base64" - ); - return this._makeSubscription( - { - callback: r, - method: "accountSubscribe", - unsubscribeMethod: "accountUnsubscribe", - }, - i - ); - } - async removeAccountChangeListener(e) { - await this._unsubscribeClientSubscription(e, "account change"); - } - _wsOnProgramAccountNotification(e) { - let { result: r, subscription: n } = X.create(e, kor); - this._handleServerNotification(n, [ - { accountId: r.value.pubkey, accountInfo: r.value.account }, - r.context, - ]); - } - onProgramAccountChange(e, r, n, i) { - let o = this._buildArgs( - [e.toBase58()], - n || this._commitment || "finalized", - "base64", - i ? { filters: i } : void 0 - ); - return this._makeSubscription( - { - callback: r, - method: "programSubscribe", - unsubscribeMethod: "programUnsubscribe", - }, - o - ); - } - async removeProgramAccountChangeListener(e) { - await this._unsubscribeClientSubscription( - e, - "program account change" - ); - } - onLogs(e, r, n) { - let i = this._buildArgs( - [typeof e == "object" ? { mentions: [e.toString()] } : e], - n || this._commitment || "finalized" - ); - return this._makeSubscription( - { - callback: r, - method: "logsSubscribe", - unsubscribeMethod: "logsUnsubscribe", - }, - i - ); - } - async removeOnLogsListener(e) { - await this._unsubscribeClientSubscription(e, "logs"); - } - _wsOnLogsNotification(e) { - let { result: r, subscription: n } = X.create(e, tar); - this._handleServerNotification(n, [r.value, r.context]); - } - _wsOnSlotNotification(e) { - let { result: r, subscription: n } = X.create(e, Oor); - this._handleServerNotification(n, [r]); - } - onSlotChange(e) { - return this._makeSubscription( - { - callback: e, - method: "slotSubscribe", - unsubscribeMethod: "slotUnsubscribe", - }, - [] - ); - } - async removeSlotChangeListener(e) { - await this._unsubscribeClientSubscription(e, "slot change"); - } - _wsOnSlotUpdatesNotification(e) { - let { result: r, subscription: n } = X.create(e, Ior); - this._handleServerNotification(n, [r]); - } - onSlotUpdate(e) { - return this._makeSubscription( - { - callback: e, - method: "slotsUpdatesSubscribe", - unsubscribeMethod: "slotsUpdatesUnsubscribe", - }, - [] - ); - } - async removeSlotUpdateListener(e) { - await this._unsubscribeClientSubscription(e, "slot update"); - } - async _unsubscribeClientSubscription(e, r) { - let n = this._subscriptionDisposeFunctionsByClientSubscriptionId[e]; - n - ? await n() - : console.warn( - `Ignored unsubscribe request because an active subscription with id \`${e}\` for '${r}' events could not be found.` - ); - } - _buildArgs(e, r, n, i) { - let o = r || this._commitment; - if (o || n || i) { - let a = {}; - n && (a.encoding = n), - o && (a.commitment = o), - i && (a = Object.assign(a, i)), - e.push(a); - } - return e; - } - _buildArgsAtLeastConfirmed(e, r, n, i) { - let o = r || this._commitment; - if (o && !["confirmed", "finalized"].includes(o)) - throw new Error( - "Using Connection with default commitment: `" + - this._commitment + - "`, but method requires at least `confirmed`" - ); - return this._buildArgs(e, r, n, i); - } - _wsOnSignatureNotification(e) { - let { result: r, subscription: n } = X.create(e, Cor); - r.value !== "receivedSignature" && - this._subscriptionsAutoDisposedByRpc.add(n), - this._handleServerNotification( - n, - r.value === "receivedSignature" - ? [{ type: "received" }, r.context] - : [{ type: "status", result: r.value }, r.context] - ); - } - onSignature(e, r, n) { - let i = this._buildArgs([e], n || this._commitment || "finalized"), - o = this._makeSubscription( - { - callback: (a, s) => { - if (a.type === "status") { - r(a.result, s); - try { - this.removeSignatureListener(o); - } catch {} - } - }, - method: "signatureSubscribe", - unsubscribeMethod: "signatureUnsubscribe", - }, - i - ); - return o; - } - onSignatureWithOptions(e, r, n) { - let { commitment: i, ...o } = { - ...n, - commitment: - (n && n.commitment) || this._commitment || "finalized", - }, - a = this._buildArgs([e], i, void 0, o), - s = this._makeSubscription( - { - callback: (c, u) => { - r(c, u); - try { - this.removeSignatureListener(s); - } catch {} - }, - method: "signatureSubscribe", - unsubscribeMethod: "signatureUnsubscribe", - }, - a - ); - return s; - } - async removeSignatureListener(e) { - await this._unsubscribeClientSubscription(e, "signature result"); - } - _wsOnRootNotification(e) { - let { result: r, subscription: n } = X.create(e, Ror); - this._handleServerNotification(n, [r]); - } - onRootChange(e) { - return this._makeSubscription( - { - callback: e, - method: "rootSubscribe", - unsubscribeMethod: "rootUnsubscribe", - }, - [] - ); - } - async removeRootChangeListener(e) { - await this._unsubscribeClientSubscription(e, "root change"); - } - }, - R2 = class { - constructor(e) { - (this._keypair = void 0), (this._keypair = e ?? dZe()); - } - static generate() { - return new R2(dZe()); - } - static fromSecretKey(e, r) { - if (e.byteLength !== 64) throw new Error("bad secret key size"); - let n = e.slice(32, 64); - if (!r || !r.skipValidation) { - let i = e.slice(0, 32), - o = RY(i); - for (let a = 0; a < 32; a++) - if (n[a] !== o[a]) - throw new Error("provided secretKey is invalid"); - } - return new R2({ publicKey: n, secretKey: e }); - } - static fromSeed(e) { - let r = RY(e), - n = new Uint8Array(64); - return n.set(e), n.set(r, 32), new R2({ publicKey: r, secretKey: n }); - } - get publicKey() { - return new $t(this._keypair.publicKey); - } - get secretKey() { - return new Uint8Array(this._keypair.secretKey); - } - }, - V_ = Object.freeze({ - CreateLookupTable: { - index: 0, - layout: Ne.struct([ - Ne.u32("instruction"), - pC("recentSlot"), - Ne.u8("bumpSeed"), - ]), - }, - FreezeLookupTable: { - index: 1, - layout: Ne.struct([Ne.u32("instruction")]), - }, - ExtendLookupTable: { - index: 2, - layout: Ne.struct([ - Ne.u32("instruction"), - pC(), - Ne.seq(Xn(), Ne.offset(Ne.u32(), -8), "addresses"), - ]), - }, - DeactivateLookupTable: { - index: 3, - layout: Ne.struct([Ne.u32("instruction")]), - }, - CloseLookupTable: { - index: 4, - layout: Ne.struct([Ne.u32("instruction")]), - }, - }), - J1e = class { - constructor() {} - static decodeInstructionType(e) { - this.checkProgramId(e.programId); - let n = Ne.u32("instruction").decode(e.data), - i; - for (let [o, a] of Object.entries(V_)) - if (a.index == n) { - i = o; - break; - } - if (!i) - throw new Error( - "Invalid Instruction. Should be a LookupTable Instruction" - ); - return i; - } - static decodeCreateLookupTable(e) { - this.checkProgramId(e.programId), this.checkKeysLength(e.keys, 4); - let { recentSlot: r } = Zi(V_.CreateLookupTable, e.data); - return { - authority: e.keys[1].pubkey, - payer: e.keys[2].pubkey, - recentSlot: Number(r), - }; - } - static decodeExtendLookupTable(e) { - if ((this.checkProgramId(e.programId), e.keys.length < 2)) - throw new Error( - `invalid instruction; found ${e.keys.length} keys, expected at least 2` - ); - let { addresses: r } = Zi(V_.ExtendLookupTable, e.data); - return { - lookupTable: e.keys[0].pubkey, - authority: e.keys[1].pubkey, - payer: e.keys.length > 2 ? e.keys[2].pubkey : void 0, - addresses: r.map((n) => new $t(n)), - }; - } - static decodeCloseLookupTable(e) { - return ( - this.checkProgramId(e.programId), - this.checkKeysLength(e.keys, 3), - { - lookupTable: e.keys[0].pubkey, - authority: e.keys[1].pubkey, - recipient: e.keys[2].pubkey, - } - ); - } - static decodeFreezeLookupTable(e) { - return ( - this.checkProgramId(e.programId), - this.checkKeysLength(e.keys, 2), - { lookupTable: e.keys[0].pubkey, authority: e.keys[1].pubkey } - ); - } - static decodeDeactivateLookupTable(e) { - return ( - this.checkProgramId(e.programId), - this.checkKeysLength(e.keys, 2), - { lookupTable: e.keys[0].pubkey, authority: e.keys[1].pubkey } - ); - } - static checkProgramId(e) { - if (!e.equals(Nz.programId)) - throw new Error( - "invalid instruction; programId is not AddressLookupTable Program" - ); - } - static checkKeysLength(e, r) { - if (e.length < r) - throw new Error( - `invalid instruction; found ${e.length} keys, expected at least ${r}` - ); - } - }, - Nz = class { - constructor() {} - static createLookupTable(e) { - let [r, n] = $t.findProgramAddressSync( - [e.authority.toBuffer(), q1e.toBufferLE(BigInt(e.recentSlot), 8)], - this.programId - ), - i = V_.CreateLookupTable, - o = Mi(i, { recentSlot: BigInt(e.recentSlot), bumpSeed: n }), - a = [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: e.authority, isSigner: !0, isWritable: !1 }, - { pubkey: e.payer, isSigner: !0, isWritable: !0 }, - { pubkey: Js.programId, isSigner: !1, isWritable: !1 }, - ]; - return [new ro({ programId: this.programId, keys: a, data: o }), r]; - } - static freezeLookupTable(e) { - let r = V_.FreezeLookupTable, - n = Mi(r), - i = [ - { pubkey: e.lookupTable, isSigner: !1, isWritable: !0 }, - { pubkey: e.authority, isSigner: !0, isWritable: !1 }, - ]; - return new ro({ programId: this.programId, keys: i, data: n }); - } - static extendLookupTable(e) { - let r = V_.ExtendLookupTable, - n = Mi(r, { addresses: e.addresses.map((o) => o.toBytes()) }), - i = [ - { pubkey: e.lookupTable, isSigner: !1, isWritable: !0 }, - { pubkey: e.authority, isSigner: !0, isWritable: !1 }, - ]; - return ( - e.payer && - i.push( - { pubkey: e.payer, isSigner: !0, isWritable: !0 }, - { pubkey: Js.programId, isSigner: !1, isWritable: !1 } - ), - new ro({ programId: this.programId, keys: i, data: n }) - ); - } - static deactivateLookupTable(e) { - let r = V_.DeactivateLookupTable, - n = Mi(r), - i = [ - { pubkey: e.lookupTable, isSigner: !1, isWritable: !0 }, - { pubkey: e.authority, isSigner: !0, isWritable: !1 }, - ]; - return new ro({ programId: this.programId, keys: i, data: n }); - } - static closeLookupTable(e) { - let r = V_.CloseLookupTable, - n = Mi(r), - i = [ - { pubkey: e.lookupTable, isSigner: !1, isWritable: !0 }, - { pubkey: e.authority, isSigner: !0, isWritable: !1 }, - { pubkey: e.recipient, isSigner: !1, isWritable: !0 }, - ]; - return new ro({ programId: this.programId, keys: i, data: n }); - } - }; - Nz.programId = new $t("AddressLookupTab1e1111111111111111111111111"); - var $1e = class { - constructor() {} - static decodeInstructionType(e) { - this.checkProgramId(e.programId); - let n = Ne.u8("instruction").decode(e.data), - i; - for (let [o, a] of Object.entries(Tv)) - if (a.index == n) { - i = o; - break; - } - if (!i) - throw new Error( - "Instruction type incorrect; not a ComputeBudgetInstruction" - ); - return i; - } - static decodeRequestUnits(e) { - this.checkProgramId(e.programId); - let { units: r, additionalFee: n } = Zi(Tv.RequestUnits, e.data); - return { units: r, additionalFee: n }; - } - static decodeRequestHeapFrame(e) { - this.checkProgramId(e.programId); - let { bytes: r } = Zi(Tv.RequestHeapFrame, e.data); - return { bytes: r }; - } - static decodeSetComputeUnitLimit(e) { - this.checkProgramId(e.programId); - let { units: r } = Zi(Tv.SetComputeUnitLimit, e.data); - return { units: r }; - } - static decodeSetComputeUnitPrice(e) { - this.checkProgramId(e.programId); - let { microLamports: r } = Zi(Tv.SetComputeUnitPrice, e.data); - return { microLamports: r }; - } - static checkProgramId(e) { - if (!e.equals(Dz.programId)) - throw new Error( - "invalid instruction; programId is not ComputeBudgetProgram" - ); - } - }, - Tv = Object.freeze({ - RequestUnits: { - index: 0, - layout: Ne.struct([ - Ne.u8("instruction"), - Ne.u32("units"), - Ne.u32("additionalFee"), - ]), - }, - RequestHeapFrame: { - index: 1, - layout: Ne.struct([Ne.u8("instruction"), Ne.u32("bytes")]), - }, - SetComputeUnitLimit: { - index: 2, - layout: Ne.struct([Ne.u8("instruction"), Ne.u32("units")]), - }, - SetComputeUnitPrice: { - index: 3, - layout: Ne.struct([Ne.u8("instruction"), pC("microLamports")]), - }, - }), - Dz = class { - constructor() {} - static requestUnits(e) { - let r = Tv.RequestUnits, - n = Mi(r, e); - return new ro({ keys: [], programId: this.programId, data: n }); - } - static requestHeapFrame(e) { - let r = Tv.RequestHeapFrame, - n = Mi(r, e); - return new ro({ keys: [], programId: this.programId, data: n }); - } - static setComputeUnitLimit(e) { - let r = Tv.SetComputeUnitLimit, - n = Mi(r, e); - return new ro({ keys: [], programId: this.programId, data: n }); - } - static setComputeUnitPrice(e) { - let r = Tv.SetComputeUnitPrice, - n = Mi(r, { microLamports: BigInt(e.microLamports) }); - return new ro({ keys: [], programId: this.programId, data: n }); - } - }; - Dz.programId = new $t("ComputeBudget111111111111111111111111111111"); - var bZe = 64, - wZe = 32, - _Ze = 64, - xZe = Ne.struct([ - Ne.u8("numSignatures"), - Ne.u8("padding"), - Ne.u16("signatureOffset"), - Ne.u16("signatureInstructionIndex"), - Ne.u16("publicKeyOffset"), - Ne.u16("publicKeyInstructionIndex"), - Ne.u16("messageDataOffset"), - Ne.u16("messageDataSize"), - Ne.u16("messageInstructionIndex"), - ]), - yC = class { - constructor() {} - static createInstructionWithPublicKey(e) { - let { - publicKey: r, - message: n, - signature: i, - instructionIndex: o, - } = e; - Ii( - r.length === wZe, - `Public Key must be ${wZe} bytes but received ${r.length} bytes` - ), - Ii( - i.length === _Ze, - `Signature must be ${_Ze} bytes but received ${i.length} bytes` - ); - let a = xZe.span, - s = a + r.length, - c = s + i.length, - u = 1, - h = Cr.Buffer.alloc(c + n.length), - w = o ?? 65535; - return ( - xZe.encode( - { - numSignatures: u, - padding: 0, - signatureOffset: s, - signatureInstructionIndex: w, - publicKeyOffset: a, - publicKeyInstructionIndex: w, - messageDataOffset: c, - messageDataSize: n.length, - messageInstructionIndex: w, - }, - h - ), - h.fill(r, a), - h.fill(i, s), - h.fill(n, c), - new ro({ keys: [], programId: yC.programId, data: h }) - ); - } - static createInstructionWithPrivateKey(e) { - let { privateKey: r, message: n, instructionIndex: i } = e; - Ii( - r.length === bZe, - `Private key must be ${bZe} bytes but received ${r.length} bytes` - ); - try { - let o = R2.fromSecretKey(r), - a = o.publicKey.toBytes(), - s = ewe(n, o.secretKey); - return this.createInstructionWithPublicKey({ - publicKey: a, - message: n, - signature: s, - instructionIndex: i, - }); - } catch (o) { - throw new Error(`Error creating instruction; ${o}`); - } - } - }; - yC.programId = new $t("Ed25519SigVerify111111111111111111111111111"); - qY.utils.hmacSha256Sync = (t, ...e) => { - let r = dir.hmac.create(L1e.sha256, t); - return e.forEach((n) => r.update(n)), r.digest(); - }; - var nar = (t, e) => qY.signSync(t, e, { der: !1, recovered: !0 }); - qY.utils.isValidPrivateKey; - var iar = qY.getPublicKey, - SZe = 32, - D1e = 20, - AZe = 64, - oar = 11, - F1e = Ne.struct([ - Ne.u8("numSignatures"), - Ne.u16("signatureOffset"), - Ne.u8("signatureInstructionIndex"), - Ne.u16("ethAddressOffset"), - Ne.u8("ethAddressInstructionIndex"), - Ne.u16("messageDataOffset"), - Ne.u16("messageDataSize"), - Ne.u8("messageInstructionIndex"), - Ne.blob(20, "ethAddress"), - Ne.blob(64, "signature"), - Ne.u8("recoveryId"), - ]), - N2 = class { - constructor() {} - static publicKeyToEthAddress(e) { - Ii( - e.length === AZe, - `Public key must be ${AZe} bytes but received ${e.length} bytes` - ); - try { - return Cr.Buffer.from(lZe.keccak_256(On(e))).slice(-D1e); - } catch (r) { - throw new Error(`Error constructing Ethereum address: ${r}`); - } - } - static createInstructionWithPublicKey(e) { - let { - publicKey: r, - message: n, - signature: i, - recoveryId: o, - instructionIndex: a, - } = e; - return N2.createInstructionWithEthAddress({ - ethAddress: N2.publicKeyToEthAddress(r), - message: n, - signature: i, - recoveryId: o, - instructionIndex: a, - }); - } - static createInstructionWithEthAddress(e) { - let { - ethAddress: r, - message: n, - signature: i, - recoveryId: o, - instructionIndex: a = 0, - } = e, - s; - typeof r == "string" - ? r.startsWith("0x") - ? (s = Cr.Buffer.from(r.substr(2), "hex")) - : (s = Cr.Buffer.from(r, "hex")) - : (s = r), - Ii( - s.length === D1e, - `Address must be ${D1e} bytes but received ${s.length} bytes` - ); - let c = 1 + oar, - u = c, - h = c + s.length, - w = h + i.length + 1, - M = 1, - k = Cr.Buffer.alloc(F1e.span + n.length); - return ( - F1e.encode( - { - numSignatures: M, - signatureOffset: h, - signatureInstructionIndex: a, - ethAddressOffset: u, - ethAddressInstructionIndex: a, - messageDataOffset: w, - messageDataSize: n.length, - messageInstructionIndex: a, - signature: On(i), - ethAddress: On(s), - recoveryId: o, - }, - k - ), - k.fill(On(n), F1e.span), - new ro({ keys: [], programId: N2.programId, data: k }) - ); - } - static createInstructionWithPrivateKey(e) { - let { privateKey: r, message: n, instructionIndex: i } = e; - Ii( - r.length === SZe, - `Private key must be ${SZe} bytes but received ${r.length} bytes` - ); - try { - let o = On(r), - a = iar(o, !1).slice(1), - s = Cr.Buffer.from(lZe.keccak_256(On(n))), - [c, u] = nar(s, o); - return this.createInstructionWithPublicKey({ - publicKey: a, - message: n, - signature: c, - recoveryId: u, - instructionIndex: i, - }); - } catch (o) { - throw new Error(`Error creating instruction; ${o}`); - } - } - }; - N2.programId = new $t("KeccakSecp256k11111111111111111111111111111"); - var jZe = new $t("StakeConfig11111111111111111111111111111111"), - FY = class { - constructor(e, r) { - (this.staker = void 0), - (this.withdrawer = void 0), - (this.staker = e), - (this.withdrawer = r); - } - }, - GM = class { - constructor(e, r, n) { - (this.unixTimestamp = void 0), - (this.epoch = void 0), - (this.custodian = void 0), - (this.unixTimestamp = e), - (this.epoch = r), - (this.custodian = n); - } - }; - GM.default = new GM(0, 0, $t.default); - var Z1e = class { - constructor() {} - static decodeInstructionType(e) { - this.checkProgramId(e.programId); - let n = Ne.u32("instruction").decode(e.data), - i; - for (let [o, a] of Object.entries(Su)) - if (a.index == n) { - i = o; - break; - } - if (!i) - throw new Error( - "Instruction type incorrect; not a StakeInstruction" - ); - return i; - } - static decodeInitialize(e) { - this.checkProgramId(e.programId), this.checkKeyLength(e.keys, 2); - let { authorized: r, lockup: n } = Zi(Su.Initialize, e.data); - return { - stakePubkey: e.keys[0].pubkey, - authorized: new FY(new $t(r.staker), new $t(r.withdrawer)), - lockup: new GM(n.unixTimestamp, n.epoch, new $t(n.custodian)), - }; - } - static decodeDelegate(e) { - return ( - this.checkProgramId(e.programId), - this.checkKeyLength(e.keys, 6), - Zi(Su.Delegate, e.data), - { - stakePubkey: e.keys[0].pubkey, - votePubkey: e.keys[1].pubkey, - authorizedPubkey: e.keys[5].pubkey, - } - ); - } - static decodeAuthorize(e) { - this.checkProgramId(e.programId), this.checkKeyLength(e.keys, 3); - let { newAuthorized: r, stakeAuthorizationType: n } = Zi( - Su.Authorize, - e.data - ), - i = { - stakePubkey: e.keys[0].pubkey, - authorizedPubkey: e.keys[2].pubkey, - newAuthorizedPubkey: new $t(r), - stakeAuthorizationType: { index: n }, - }; - return e.keys.length > 3 && (i.custodianPubkey = e.keys[3].pubkey), i; - } - static decodeAuthorizeWithSeed(e) { - this.checkProgramId(e.programId), this.checkKeyLength(e.keys, 2); - let { - newAuthorized: r, - stakeAuthorizationType: n, - authoritySeed: i, - authorityOwner: o, - } = Zi(Su.AuthorizeWithSeed, e.data), - a = { - stakePubkey: e.keys[0].pubkey, - authorityBase: e.keys[1].pubkey, - authoritySeed: i, - authorityOwner: new $t(o), - newAuthorizedPubkey: new $t(r), - stakeAuthorizationType: { index: n }, - }; - return e.keys.length > 3 && (a.custodianPubkey = e.keys[3].pubkey), a; - } - static decodeSplit(e) { - this.checkProgramId(e.programId), this.checkKeyLength(e.keys, 3); - let { lamports: r } = Zi(Su.Split, e.data); - return { - stakePubkey: e.keys[0].pubkey, - splitStakePubkey: e.keys[1].pubkey, - authorizedPubkey: e.keys[2].pubkey, - lamports: r, - }; - } - static decodeMerge(e) { - return ( - this.checkProgramId(e.programId), - this.checkKeyLength(e.keys, 3), - Zi(Su.Merge, e.data), - { - stakePubkey: e.keys[0].pubkey, - sourceStakePubKey: e.keys[1].pubkey, - authorizedPubkey: e.keys[4].pubkey, - } - ); - } - static decodeWithdraw(e) { - this.checkProgramId(e.programId), this.checkKeyLength(e.keys, 5); - let { lamports: r } = Zi(Su.Withdraw, e.data), - n = { - stakePubkey: e.keys[0].pubkey, - toPubkey: e.keys[1].pubkey, - authorizedPubkey: e.keys[4].pubkey, - lamports: r, - }; - return e.keys.length > 5 && (n.custodianPubkey = e.keys[5].pubkey), n; - } - static decodeDeactivate(e) { - return ( - this.checkProgramId(e.programId), - this.checkKeyLength(e.keys, 3), - Zi(Su.Deactivate, e.data), - { - stakePubkey: e.keys[0].pubkey, - authorizedPubkey: e.keys[2].pubkey, - } - ); - } - static checkProgramId(e) { - if (!e.equals(mC.programId)) - throw new Error( - "invalid instruction; programId is not StakeProgram" - ); - } - static checkKeyLength(e, r) { - if (e.length < r) - throw new Error( - `invalid instruction; found ${e.length} keys, expected at least ${r}` - ); - } - }, - Su = Object.freeze({ - Initialize: { - index: 0, - layout: Ne.struct([Ne.u32("instruction"), wir(), _ir()]), - }, - Authorize: { - index: 1, - layout: Ne.struct([ - Ne.u32("instruction"), - Xn("newAuthorized"), - Ne.u32("stakeAuthorizationType"), - ]), - }, - Delegate: { index: 2, layout: Ne.struct([Ne.u32("instruction")]) }, - Split: { - index: 3, - layout: Ne.struct([Ne.u32("instruction"), Ne.ns64("lamports")]), - }, - Withdraw: { - index: 4, - layout: Ne.struct([Ne.u32("instruction"), Ne.ns64("lamports")]), - }, - Deactivate: { index: 5, layout: Ne.struct([Ne.u32("instruction")]) }, - Merge: { index: 7, layout: Ne.struct([Ne.u32("instruction")]) }, - AuthorizeWithSeed: { - index: 8, - layout: Ne.struct([ - Ne.u32("instruction"), - Xn("newAuthorized"), - Ne.u32("stakeAuthorizationType"), - VM("authoritySeed"), - Xn("authorityOwner"), - ]), - }, - }), - aar = Object.freeze({ Staker: { index: 0 }, Withdrawer: { index: 1 } }), - mC = class { - constructor() {} - static initialize(e) { - let { stakePubkey: r, authorized: n, lockup: i } = e, - o = i || GM.default, - a = Su.Initialize, - s = Mi(a, { - authorized: { - staker: On(n.staker.toBuffer()), - withdrawer: On(n.withdrawer.toBuffer()), - }, - lockup: { - unixTimestamp: o.unixTimestamp, - epoch: o.epoch, - custodian: On(o.custodian.toBuffer()), - }, - }), - c = { - keys: [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: dC, isSigner: !1, isWritable: !1 }, - ], - programId: this.programId, - data: s, - }; - return new ro(c); - } - static createAccountWithSeed(e) { - let r = new Bi(); - r.add( - Js.createAccountWithSeed({ - fromPubkey: e.fromPubkey, - newAccountPubkey: e.stakePubkey, - basePubkey: e.basePubkey, - seed: e.seed, - lamports: e.lamports, - space: this.space, - programId: this.programId, - }) - ); - let { stakePubkey: n, authorized: i, lockup: o } = e; - return r.add( - this.initialize({ stakePubkey: n, authorized: i, lockup: o }) - ); - } - static createAccount(e) { - let r = new Bi(); - r.add( - Js.createAccount({ - fromPubkey: e.fromPubkey, - newAccountPubkey: e.stakePubkey, - lamports: e.lamports, - space: this.space, - programId: this.programId, - }) - ); - let { stakePubkey: n, authorized: i, lockup: o } = e; - return r.add( - this.initialize({ stakePubkey: n, authorized: i, lockup: o }) - ); - } - static delegate(e) { - let { stakePubkey: r, authorizedPubkey: n, votePubkey: i } = e, - o = Su.Delegate, - a = Mi(o); - return new Bi().add({ - keys: [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: i, isSigner: !1, isWritable: !1 }, - { pubkey: Mv, isSigner: !1, isWritable: !1 }, - { pubkey: IY, isSigner: !1, isWritable: !1 }, - { pubkey: jZe, isSigner: !1, isWritable: !1 }, - { pubkey: n, isSigner: !0, isWritable: !1 }, - ], - programId: this.programId, - data: a, - }); - } - static authorize(e) { - let { - stakePubkey: r, - authorizedPubkey: n, - newAuthorizedPubkey: i, - stakeAuthorizationType: o, - custodianPubkey: a, - } = e, - s = Su.Authorize, - c = Mi(s, { - newAuthorized: On(i.toBuffer()), - stakeAuthorizationType: o.index, - }), - u = [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: Mv, isSigner: !1, isWritable: !0 }, - { pubkey: n, isSigner: !0, isWritable: !1 }, - ]; - return ( - a && u.push({ pubkey: a, isSigner: !1, isWritable: !1 }), - new Bi().add({ keys: u, programId: this.programId, data: c }) - ); - } - static authorizeWithSeed(e) { - let { - stakePubkey: r, - authorityBase: n, - authoritySeed: i, - authorityOwner: o, - newAuthorizedPubkey: a, - stakeAuthorizationType: s, - custodianPubkey: c, - } = e, - u = Su.AuthorizeWithSeed, - h = Mi(u, { - newAuthorized: On(a.toBuffer()), - stakeAuthorizationType: s.index, - authoritySeed: i, - authorityOwner: On(o.toBuffer()), - }), - w = [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: n, isSigner: !0, isWritable: !1 }, - { pubkey: Mv, isSigner: !1, isWritable: !1 }, - ]; - return ( - c && w.push({ pubkey: c, isSigner: !1, isWritable: !1 }), - new Bi().add({ keys: w, programId: this.programId, data: h }) - ); - } - static splitInstruction(e) { - let { - stakePubkey: r, - authorizedPubkey: n, - splitStakePubkey: i, - lamports: o, - } = e, - a = Su.Split, - s = Mi(a, { lamports: o }); - return new ro({ - keys: [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: i, isSigner: !1, isWritable: !0 }, - { pubkey: n, isSigner: !0, isWritable: !1 }, - ], - programId: this.programId, - data: s, - }); - } - static split(e) { - let r = new Bi(); - return ( - r.add( - Js.createAccount({ - fromPubkey: e.authorizedPubkey, - newAccountPubkey: e.splitStakePubkey, - lamports: 0, - space: this.space, - programId: this.programId, - }) - ), - r.add(this.splitInstruction(e)) - ); - } - static splitWithSeed(e) { - let { - stakePubkey: r, - authorizedPubkey: n, - splitStakePubkey: i, - basePubkey: o, - seed: a, - lamports: s, - } = e, - c = new Bi(); - return ( - c.add( - Js.allocate({ - accountPubkey: i, - basePubkey: o, - seed: a, - space: this.space, - programId: this.programId, - }) - ), - c.add( - this.splitInstruction({ - stakePubkey: r, - authorizedPubkey: n, - splitStakePubkey: i, - lamports: s, - }) - ) - ); - } - static merge(e) { - let { stakePubkey: r, sourceStakePubKey: n, authorizedPubkey: i } = e, - o = Su.Merge, - a = Mi(o); - return new Bi().add({ - keys: [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: n, isSigner: !1, isWritable: !0 }, - { pubkey: Mv, isSigner: !1, isWritable: !1 }, - { pubkey: IY, isSigner: !1, isWritable: !1 }, - { pubkey: i, isSigner: !0, isWritable: !1 }, - ], - programId: this.programId, - data: a, - }); - } - static withdraw(e) { - let { - stakePubkey: r, - authorizedPubkey: n, - toPubkey: i, - lamports: o, - custodianPubkey: a, - } = e, - s = Su.Withdraw, - c = Mi(s, { lamports: o }), - u = [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: i, isSigner: !1, isWritable: !0 }, - { pubkey: Mv, isSigner: !1, isWritable: !1 }, - { pubkey: IY, isSigner: !1, isWritable: !1 }, - { pubkey: n, isSigner: !0, isWritable: !1 }, - ]; - return ( - a && u.push({ pubkey: a, isSigner: !1, isWritable: !1 }), - new Bi().add({ keys: u, programId: this.programId, data: c }) - ); - } - static deactivate(e) { - let { stakePubkey: r, authorizedPubkey: n } = e, - i = Su.Deactivate, - o = Mi(i); - return new Bi().add({ - keys: [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: Mv, isSigner: !1, isWritable: !1 }, - { pubkey: n, isSigner: !0, isWritable: !1 }, - ], - programId: this.programId, - data: o, - }); - } - }; - mC.programId = new $t("Stake11111111111111111111111111111111111111"); - mC.space = 200; - var LY = class { - constructor(e, r, n, i) { - (this.nodePubkey = void 0), - (this.authorizedVoter = void 0), - (this.authorizedWithdrawer = void 0), - (this.commission = void 0), - (this.nodePubkey = e), - (this.authorizedVoter = r), - (this.authorizedWithdrawer = n), - (this.commission = i); - } - }, - X1e = class { - constructor() {} - static decodeInstructionType(e) { - this.checkProgramId(e.programId); - let n = Ne.u32("instruction").decode(e.data), - i; - for (let [o, a] of Object.entries(W_)) - if (a.index == n) { - i = o; - break; - } - if (!i) - throw new Error( - "Instruction type incorrect; not a VoteInstruction" - ); - return i; - } - static decodeInitializeAccount(e) { - this.checkProgramId(e.programId), this.checkKeyLength(e.keys, 4); - let { voteInit: r } = Zi(W_.InitializeAccount, e.data); - return { - votePubkey: e.keys[0].pubkey, - nodePubkey: e.keys[3].pubkey, - voteInit: new LY( - new $t(r.nodePubkey), - new $t(r.authorizedVoter), - new $t(r.authorizedWithdrawer), - r.commission - ), - }; - } - static decodeAuthorize(e) { - this.checkProgramId(e.programId), this.checkKeyLength(e.keys, 3); - let { newAuthorized: r, voteAuthorizationType: n } = Zi( - W_.Authorize, - e.data - ); - return { - votePubkey: e.keys[0].pubkey, - authorizedPubkey: e.keys[2].pubkey, - newAuthorizedPubkey: new $t(r), - voteAuthorizationType: { index: n }, - }; - } - static decodeAuthorizeWithSeed(e) { - this.checkProgramId(e.programId), this.checkKeyLength(e.keys, 3); - let { - voteAuthorizeWithSeedArgs: { - currentAuthorityDerivedKeyOwnerPubkey: r, - currentAuthorityDerivedKeySeed: n, - newAuthorized: i, - voteAuthorizationType: o, - }, - } = Zi(W_.AuthorizeWithSeed, e.data); - return { - currentAuthorityDerivedKeyBasePubkey: e.keys[2].pubkey, - currentAuthorityDerivedKeyOwnerPubkey: new $t(r), - currentAuthorityDerivedKeySeed: n, - newAuthorizedPubkey: new $t(i), - voteAuthorizationType: { index: o }, - votePubkey: e.keys[0].pubkey, - }; - } - static decodeWithdraw(e) { - this.checkProgramId(e.programId), this.checkKeyLength(e.keys, 3); - let { lamports: r } = Zi(W_.Withdraw, e.data); - return { - votePubkey: e.keys[0].pubkey, - authorizedWithdrawerPubkey: e.keys[2].pubkey, - lamports: r, - toPubkey: e.keys[1].pubkey, - }; - } - static checkProgramId(e) { - if (!e.equals(F2.programId)) - throw new Error( - "invalid instruction; programId is not VoteProgram" - ); - } - static checkKeyLength(e, r) { - if (e.length < r) - throw new Error( - `invalid instruction; found ${e.length} keys, expected at least ${r}` - ); - } - }, - W_ = Object.freeze({ - InitializeAccount: { - index: 0, - layout: Ne.struct([Ne.u32("instruction"), xir()]), - }, - Authorize: { - index: 1, - layout: Ne.struct([ - Ne.u32("instruction"), - Xn("newAuthorized"), - Ne.u32("voteAuthorizationType"), - ]), - }, - Withdraw: { - index: 3, - layout: Ne.struct([Ne.u32("instruction"), Ne.ns64("lamports")]), - }, - AuthorizeWithSeed: { - index: 10, - layout: Ne.struct([Ne.u32("instruction"), Sir()]), - }, - }), - sar = Object.freeze({ Voter: { index: 0 }, Withdrawer: { index: 1 } }), - F2 = class { - constructor() {} - static initializeAccount(e) { - let { votePubkey: r, nodePubkey: n, voteInit: i } = e, - o = W_.InitializeAccount, - a = Mi(o, { - voteInit: { - nodePubkey: On(i.nodePubkey.toBuffer()), - authorizedVoter: On(i.authorizedVoter.toBuffer()), - authorizedWithdrawer: On(i.authorizedWithdrawer.toBuffer()), - commission: i.commission, - }, - }), - s = { - keys: [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: dC, isSigner: !1, isWritable: !1 }, - { pubkey: Mv, isSigner: !1, isWritable: !1 }, - { pubkey: n, isSigner: !0, isWritable: !1 }, - ], - programId: this.programId, - data: a, - }; - return new ro(s); - } - static createAccount(e) { - let r = new Bi(); - return ( - r.add( - Js.createAccount({ - fromPubkey: e.fromPubkey, - newAccountPubkey: e.votePubkey, - lamports: e.lamports, - space: this.space, - programId: this.programId, - }) - ), - r.add( - this.initializeAccount({ - votePubkey: e.votePubkey, - nodePubkey: e.voteInit.nodePubkey, - voteInit: e.voteInit, - }) - ) - ); - } - static authorize(e) { - let { - votePubkey: r, - authorizedPubkey: n, - newAuthorizedPubkey: i, - voteAuthorizationType: o, - } = e, - a = W_.Authorize, - s = Mi(a, { - newAuthorized: On(i.toBuffer()), - voteAuthorizationType: o.index, - }), - c = [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: Mv, isSigner: !1, isWritable: !1 }, - { pubkey: n, isSigner: !0, isWritable: !1 }, - ]; - return new Bi().add({ keys: c, programId: this.programId, data: s }); - } - static authorizeWithSeed(e) { - let { - currentAuthorityDerivedKeyBasePubkey: r, - currentAuthorityDerivedKeyOwnerPubkey: n, - currentAuthorityDerivedKeySeed: i, - newAuthorizedPubkey: o, - voteAuthorizationType: a, - votePubkey: s, - } = e, - c = W_.AuthorizeWithSeed, - u = Mi(c, { - voteAuthorizeWithSeedArgs: { - currentAuthorityDerivedKeyOwnerPubkey: On(n.toBuffer()), - currentAuthorityDerivedKeySeed: i, - newAuthorized: On(o.toBuffer()), - voteAuthorizationType: a.index, - }, - }), - h = [ - { pubkey: s, isSigner: !1, isWritable: !0 }, - { pubkey: Mv, isSigner: !1, isWritable: !1 }, - { pubkey: r, isSigner: !0, isWritable: !1 }, - ]; - return new Bi().add({ keys: h, programId: this.programId, data: u }); - } - static withdraw(e) { - let { - votePubkey: r, - authorizedWithdrawerPubkey: n, - lamports: i, - toPubkey: o, - } = e, - a = W_.Withdraw, - s = Mi(a, { lamports: i }), - c = [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: o, isSigner: !1, isWritable: !0 }, - { pubkey: n, isSigner: !0, isWritable: !1 }, - ]; - return new Bi().add({ keys: c, programId: this.programId, data: s }); - } - static safeWithdraw(e, r, n) { - if (e.lamports > r - n) - throw new Error( - "Withdraw will leave vote account with insuffcient funds." - ); - return F2.withdraw(e); - } - }; - F2.programId = new $t("Vote111111111111111111111111111111111111111"); - F2.space = 3731; - var UZe = new $t("Va1idator1nfo111111111111111111111111111111"), - uar = X.type({ - name: X.string(), - website: X.optional(X.string()), - details: X.optional(X.string()), - keybaseUsername: X.optional(X.string()), - }), - Fz = class { - constructor(e, r) { - (this.key = void 0), - (this.info = void 0), - (this.key = e), - (this.info = r); - } - static fromConfigData(e) { - let r = [...e]; - if (Rh(r) !== 2) return null; - let i = []; - for (let o = 0; o < 2; o++) { - let a = new $t(r.slice(0, yy)); - r = r.slice(yy); - let s = r.slice(0, 1)[0] === 1; - (r = r.slice(1)), i.push({ publicKey: a, isSigner: s }); - } - if (i[0].publicKey.equals(UZe) && i[1].isSigner) { - let o = VM().decode(Cr.Buffer.from(r)), - a = JSON.parse(o); - return X.assert(a, uar), new Fz(i[1].publicKey, a); - } - return null; - } - }, - car = new $t("Vote111111111111111111111111111111111111111"), - lar = Ne.struct([ - Xn("nodePubkey"), - Xn("authorizedWithdrawer"), - Ne.u8("commission"), - Ne.nu64(), - Ne.seq( - Ne.struct([Ne.nu64("slot"), Ne.u32("confirmationCount")]), - Ne.offset(Ne.u32(), -8), - "votes" - ), - Ne.u8("rootSlotValid"), - Ne.nu64("rootSlot"), - Ne.nu64(), - Ne.seq( - Ne.struct([Ne.nu64("epoch"), Xn("authorizedVoter")]), - Ne.offset(Ne.u32(), -8), - "authorizedVoters" - ), - Ne.struct( - [ - Ne.seq( - Ne.struct([ - Xn("authorizedPubkey"), - Ne.nu64("epochOfLastAuthorizedSwitch"), - Ne.nu64("targetEpoch"), - ]), - 32, - "buf" - ), - Ne.nu64("idx"), - Ne.u8("isEmpty"), - ], - "priorVoters" - ), - Ne.nu64(), - Ne.seq( - Ne.struct([ - Ne.nu64("epoch"), - Ne.nu64("credits"), - Ne.nu64("prevCredits"), - ]), - Ne.offset(Ne.u32(), -8), - "epochCredits" - ), - Ne.struct([Ne.nu64("slot"), Ne.nu64("timestamp")], "lastTimestamp"), - ]), - Lz = class { - constructor(e) { - (this.nodePubkey = void 0), - (this.authorizedWithdrawer = void 0), - (this.commission = void 0), - (this.rootSlot = void 0), - (this.votes = void 0), - (this.authorizedVoters = void 0), - (this.priorVoters = void 0), - (this.epochCredits = void 0), - (this.lastTimestamp = void 0), - (this.nodePubkey = e.nodePubkey), - (this.authorizedWithdrawer = e.authorizedWithdrawer), - (this.commission = e.commission), - (this.rootSlot = e.rootSlot), - (this.votes = e.votes), - (this.authorizedVoters = e.authorizedVoters), - (this.priorVoters = e.priorVoters), - (this.epochCredits = e.epochCredits), - (this.lastTimestamp = e.lastTimestamp); - } - static fromAccountData(e) { - let n = lar.decode(On(e), 4), - i = n.rootSlot; - return ( - n.rootSlotValid || (i = null), - new Lz({ - nodePubkey: new $t(n.nodePubkey), - authorizedWithdrawer: new $t(n.authorizedWithdrawer), - commission: n.commission, - votes: n.votes, - rootSlot: i, - authorizedVoters: n.authorizedVoters.map(far), - priorVoters: dar(n.priorVoters), - epochCredits: n.epochCredits, - lastTimestamp: n.lastTimestamp, - }) - ); - } - }; - function far({ authorizedVoter: t, epoch: e }) { - return { epoch: e, authorizedVoter: new $t(t) }; - } - function EZe({ - authorizedPubkey: t, - epochOfLastAuthorizedSwitch: e, - targetEpoch: r, - }) { - return { - authorizedPubkey: new $t(t), - epochOfLastAuthorizedSwitch: e, - targetEpoch: r, - }; - } - function dar({ buf: t, idx: e, isEmpty: r }) { - return r ? [] : [...t.slice(e + 1).map(EZe), ...t.slice(0, e).map(EZe)]; - } - var MZe = { - http: { - devnet: "http://api.devnet.solana.com", - testnet: "http://api.testnet.solana.com", - "mainnet-beta": "http://api.mainnet-beta.solana.com/", - }, - https: { - devnet: "https://api.devnet.solana.com", - testnet: "https://api.testnet.solana.com", - "mainnet-beta": "https://api.mainnet-beta.solana.com/", - }, - }; - function har(t, e) { - let r = e === !1 ? "http" : "https"; - if (!t) return MZe[r].devnet; - let n = MZe[r][t]; - if (!n) throw new Error(`Unknown ${r} cluster: ${t}`); - return n; - } - async function par(t, e, r, n) { - let i, o; - r && Object.prototype.hasOwnProperty.call(r, "lastValidBlockHeight") - ? ((i = r), (o = n)) - : (o = r); - let a = o && { - skipPreflight: o.skipPreflight, - preflightCommitment: o.preflightCommitment || o.commitment, - minContextSlot: o.minContextSlot, - }, - s = await t.sendRawTransaction(e, a), - c = o && o.commitment, - h = ( - await (i ? t.confirmTransaction(i, c) : t.confirmTransaction(s, c)) - ).value; - if (h.err) - throw new Error(`Raw transaction ${s} failed (${JSON.stringify(h)})`); - return s; - } - var yar = 1e9; - Gt.Account = j1e; - Gt.AddressLookupTableAccount = Cz; - Gt.AddressLookupTableInstruction = J1e; - Gt.AddressLookupTableProgram = Nz; - Gt.Authorized = FY; - Gt.BLOCKHASH_CACHE_TIMEOUT_MS = CZe; - Gt.BPF_LOADER_DEPRECATED_PROGRAM_ID = vir; - Gt.BPF_LOADER_PROGRAM_ID = Cir; - Gt.BpfLoader = H1e; - Gt.COMPUTE_BUDGET_INSTRUCTION_LAYOUTS = Tv; - Gt.ComputeBudgetInstruction = $1e; - Gt.ComputeBudgetProgram = Dz; - Gt.Connection = G1e; - Gt.Ed25519Program = yC; - Gt.Enum = z1e; - Gt.EpochSchedule = NY; - Gt.FeeCalculatorLayout = OZe; - Gt.Keypair = R2; - Gt.LAMPORTS_PER_SOL = yar; - Gt.LOOKUP_TABLE_INSTRUCTION_LAYOUTS = V_; - Gt.Loader = J_; - Gt.Lockup = GM; - Gt.MAX_SEED_LENGTH = kZe; - Gt.Message = Up; - Gt.MessageAccountKeys = WM; - Gt.MessageV0 = G_; - Gt.NONCE_ACCOUNT_LENGTH = U1e; - Gt.NonceAccount = hC; - Gt.PACKET_DATA_SIZE = C2; - Gt.PUBLIC_KEY_LENGTH = yy; - Gt.PublicKey = $t; - Gt.SIGNATURE_LENGTH_IN_BYTES = lC; - Gt.SOLANA_SCHEMA = Ez; - Gt.STAKE_CONFIG_ID = jZe; - Gt.STAKE_INSTRUCTION_LAYOUTS = Su; - Gt.SYSTEM_INSTRUCTION_LAYOUTS = Co; - Gt.SYSVAR_CLOCK_PUBKEY = Mv; - Gt.SYSVAR_EPOCH_SCHEDULE_PUBKEY = Eir; - Gt.SYSVAR_INSTRUCTIONS_PUBKEY = Mir; - Gt.SYSVAR_RECENT_BLOCKHASHES_PUBKEY = BY; - Gt.SYSVAR_RENT_PUBKEY = dC; - Gt.SYSVAR_REWARDS_PUBKEY = Tir; - Gt.SYSVAR_SLOT_HASHES_PUBKEY = kir; - Gt.SYSVAR_SLOT_HISTORY_PUBKEY = Pir; - Gt.SYSVAR_STAKE_HISTORY_PUBKEY = IY; - Gt.Secp256k1Program = N2; - Gt.SendTransactionError = Iz; - Gt.SolanaJSONRPCError = pr; - Gt.SolanaJSONRPCErrorCode = qir; - Gt.StakeAuthorizationLayout = aar; - Gt.StakeInstruction = Z1e; - Gt.StakeProgram = mC; - Gt.Struct = Tz; - Gt.SystemInstruction = K1e; - Gt.SystemProgram = Js; - Gt.Transaction = Bi; - Gt.TransactionExpiredBlockheightExceededError = kz; - Gt.TransactionExpiredTimeoutError = Pz; - Gt.TransactionInstruction = ro; - Gt.TransactionMessage = Oz; - Gt.VALIDATOR_INFO_KEY = UZe; - Gt.VERSION_PREFIX_MASK = zY; - Gt.VOTE_PROGRAM_ID = car; - Gt.ValidatorInfo = Fz; - Gt.VersionedMessage = twe; - Gt.VersionedTransaction = Bz; - Gt.VoteAccount = Lz; - Gt.VoteAuthorizationLayout = sar; - Gt.VoteInit = LY; - Gt.VoteInstruction = X1e; - Gt.VoteProgram = F2; - Gt.clusterApiUrl = har; - Gt.sendAndConfirmRawTransaction = par; - Gt.sendAndConfirmTransaction = CY; - }); - var HZe = I((Ldn, awe) => { - "use strict"; - m(); - g(); - var mar = (t) => { - let e = !1, - r = !1, - n = !1; - for (let i = 0; i < t.length; i++) { - let o = t[i]; - e && /[a-zA-Z]/.test(o) && o.toUpperCase() === o - ? ((t = t.slice(0, i) + "-" + t.slice(i)), - (e = !1), - (n = r), - (r = !0), - i++) - : r && n && /[a-zA-Z]/.test(o) && o.toLowerCase() === o - ? ((t = t.slice(0, i - 1) + "-" + t.slice(i - 1)), - (n = r), - (r = !1), - (e = !0)) - : ((e = o.toLowerCase() === o && o.toUpperCase() !== o), - (n = r), - (r = o.toUpperCase() === o && o.toLowerCase() !== o)); - } - return t; - }, - KZe = (t, e) => { - if (!(typeof t == "string" || Array.isArray(t))) - throw new TypeError("Expected the input to be `string | string[]`"); - e = Object.assign({ pascalCase: !1 }, e); - let r = (i) => - e.pascalCase ? i.charAt(0).toUpperCase() + i.slice(1) : i; - return ( - Array.isArray(t) - ? (t = t - .map((i) => i.trim()) - .filter((i) => i.length) - .join("-")) - : (t = t.trim()), - t.length === 0 - ? "" - : t.length === 1 - ? e.pascalCase - ? t.toUpperCase() - : t.toLowerCase() - : (t !== t.toLowerCase() && (t = mar(t)), - (t = t - .replace(/^[_.\- ]+/, "") - .toLowerCase() - .replace(/[_.\- ]+(\w|$)/g, (i, o) => o.toUpperCase()) - .replace(/\d+(\w|$)/g, (i) => i.toUpperCase())), - r(t)) - ); - }; - awe.exports = KZe; - awe.exports.default = KZe; - }); - var qz = I((exports, module) => { - m(); - g(); - (function () { - "use strict"; - var ERROR = "input is invalid type", - WINDOW = typeof window == "object", - root = WINDOW ? window : {}; - root.JS_SHA256_NO_WINDOW && (WINDOW = !1); - var WEB_WORKER = !WINDOW && typeof self == "object", - NODE_JS = - !root.JS_SHA256_NO_NODE_JS && - typeof process == "object" && - process.versions && - process.versions.node; - NODE_JS ? (root = window) : WEB_WORKER && (root = self); - var COMMON_JS = - !root.JS_SHA256_NO_COMMON_JS && - typeof module == "object" && - module.exports, - AMD = typeof define == "function" && define.amd, - ARRAY_BUFFER = - !root.JS_SHA256_NO_ARRAY_BUFFER && typeof ArrayBuffer < "u", - HEX_CHARS = "0123456789abcdef".split(""), - EXTRA = [-2147483648, 8388608, 32768, 128], - SHIFT = [24, 16, 8, 0], - K = [ - 1116352408, 1899447441, 3049323471, 3921009573, 961987163, 1508970993, - 2453635748, 2870763221, 3624381080, 310598401, 607225278, 1426881987, - 1925078388, 2162078206, 2614888103, 3248222580, 3835390401, - 4022224774, 264347078, 604807628, 770255983, 1249150122, 1555081692, - 1996064986, 2554220882, 2821834349, 2952996808, 3210313671, - 3336571891, 3584528711, 113926993, 338241895, 666307205, 773529912, - 1294757372, 1396182291, 1695183700, 1986661051, 2177026350, - 2456956037, 2730485921, 2820302411, 3259730800, 3345764771, - 3516065817, 3600352804, 4094571909, 275423344, 430227734, 506948616, - 659060556, 883997877, 958139571, 1322822218, 1537002063, 1747873779, - 1955562222, 2024104815, 2227730452, 2361852424, 2428436474, - 2756734187, 3204031479, 3329325298, - ], - OUTPUT_TYPES = ["hex", "array", "digest", "arrayBuffer"], - blocks = []; - (root.JS_SHA256_NO_NODE_JS || !Array.isArray) && - (Array.isArray = function (t) { - return Object.prototype.toString.call(t) === "[object Array]"; - }), - ARRAY_BUFFER && - (root.JS_SHA256_NO_ARRAY_BUFFER_IS_VIEW || !ArrayBuffer.isView) && - (ArrayBuffer.isView = function (t) { - return ( - typeof t == "object" && - t.buffer && - t.buffer.constructor === ArrayBuffer - ); - }); - var createOutputMethod = function (t, e) { - return function (r) { - return new Sha256(e, !0).update(r)[t](); - }; - }, - createMethod = function (t) { - var e = createOutputMethod("hex", t); - NODE_JS && (e = nodeWrap(e, t)), - (e.create = function () { - return new Sha256(t); - }), - (e.update = function (i) { - return e.create().update(i); - }); - for (var r = 0; r < OUTPUT_TYPES.length; ++r) { - var n = OUTPUT_TYPES[r]; - e[n] = createOutputMethod(n, t); - } - return e; - }, - nodeWrap = function (method, is224) { - var crypto = eval("require('crypto')"), - Buffer = eval("require('buffer').Buffer"), - algorithm = is224 ? "sha224" : "sha256", - nodeMethod = function (t) { - if (typeof t == "string") - return crypto - .createHash(algorithm) - .update(t, "utf8") - .digest("hex"); - if (t == null) throw new Error(ERROR); - return ( - t.constructor === ArrayBuffer && (t = new Uint8Array(t)), - Array.isArray(t) || - ArrayBuffer.isView(t) || - t.constructor === Buffer - ? crypto - .createHash(algorithm) - .update(new Buffer(t)) - .digest("hex") - : method(t) - ); - }; - return nodeMethod; - }, - createHmacOutputMethod = function (t, e) { - return function (r, n) { - return new HmacSha256(r, e, !0).update(n)[t](); - }; - }, - createHmacMethod = function (t) { - var e = createHmacOutputMethod("hex", t); - (e.create = function (i) { - return new HmacSha256(i, t); - }), - (e.update = function (i, o) { - return e.create(i).update(o); - }); - for (var r = 0; r < OUTPUT_TYPES.length; ++r) { - var n = OUTPUT_TYPES[r]; - e[n] = createHmacOutputMethod(n, t); - } - return e; - }; - function Sha256(t, e) { - e - ? ((blocks[0] = - blocks[16] = - blocks[1] = - blocks[2] = - blocks[3] = - blocks[4] = - blocks[5] = - blocks[6] = - blocks[7] = - blocks[8] = - blocks[9] = - blocks[10] = - blocks[11] = - blocks[12] = - blocks[13] = - blocks[14] = - blocks[15] = - 0), - (this.blocks = blocks)) - : (this.blocks = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), - t - ? ((this.h0 = 3238371032), - (this.h1 = 914150663), - (this.h2 = 812702999), - (this.h3 = 4144912697), - (this.h4 = 4290775857), - (this.h5 = 1750603025), - (this.h6 = 1694076839), - (this.h7 = 3204075428)) - : ((this.h0 = 1779033703), - (this.h1 = 3144134277), - (this.h2 = 1013904242), - (this.h3 = 2773480762), - (this.h4 = 1359893119), - (this.h5 = 2600822924), - (this.h6 = 528734635), - (this.h7 = 1541459225)), - (this.block = this.start = this.bytes = this.hBytes = 0), - (this.finalized = this.hashed = !1), - (this.first = !0), - (this.is224 = t); - } - (Sha256.prototype.update = function (t) { - if (!this.finalized) { - var e, - r = typeof t; - if (r !== "string") { - if (r === "object") { - if (t === null) throw new Error(ERROR); - if (ARRAY_BUFFER && t.constructor === ArrayBuffer) - t = new Uint8Array(t); - else if ( - !Array.isArray(t) && - (!ARRAY_BUFFER || !ArrayBuffer.isView(t)) - ) - throw new Error(ERROR); - } else throw new Error(ERROR); - e = !0; - } - for (var n, i = 0, o, a = t.length, s = this.blocks; i < a; ) { - if ( - (this.hashed && - ((this.hashed = !1), - (s[0] = this.block), - (s[16] = - s[1] = - s[2] = - s[3] = - s[4] = - s[5] = - s[6] = - s[7] = - s[8] = - s[9] = - s[10] = - s[11] = - s[12] = - s[13] = - s[14] = - s[15] = - 0)), - e) - ) - for (o = this.start; i < a && o < 64; ++i) - s[o >> 2] |= t[i] << SHIFT[o++ & 3]; - else - for (o = this.start; i < a && o < 64; ++i) - (n = t.charCodeAt(i)), - n < 128 - ? (s[o >> 2] |= n << SHIFT[o++ & 3]) - : n < 2048 - ? ((s[o >> 2] |= (192 | (n >> 6)) << SHIFT[o++ & 3]), - (s[o >> 2] |= (128 | (n & 63)) << SHIFT[o++ & 3])) - : n < 55296 || n >= 57344 - ? ((s[o >> 2] |= (224 | (n >> 12)) << SHIFT[o++ & 3]), - (s[o >> 2] |= (128 | ((n >> 6) & 63)) << SHIFT[o++ & 3]), - (s[o >> 2] |= (128 | (n & 63)) << SHIFT[o++ & 3])) - : ((n = - 65536 + - (((n & 1023) << 10) | (t.charCodeAt(++i) & 1023))), - (s[o >> 2] |= (240 | (n >> 18)) << SHIFT[o++ & 3]), - (s[o >> 2] |= (128 | ((n >> 12) & 63)) << SHIFT[o++ & 3]), - (s[o >> 2] |= (128 | ((n >> 6) & 63)) << SHIFT[o++ & 3]), - (s[o >> 2] |= (128 | (n & 63)) << SHIFT[o++ & 3])); - (this.lastByteIndex = o), - (this.bytes += o - this.start), - o >= 64 - ? ((this.block = s[16]), - (this.start = o - 64), - this.hash(), - (this.hashed = !0)) - : (this.start = o); - } - return ( - this.bytes > 4294967295 && - ((this.hBytes += (this.bytes / 4294967296) << 0), - (this.bytes = this.bytes % 4294967296)), - this - ); - } - }), - (Sha256.prototype.finalize = function () { - if (!this.finalized) { - this.finalized = !0; - var t = this.blocks, - e = this.lastByteIndex; - (t[16] = this.block), - (t[e >> 2] |= EXTRA[e & 3]), - (this.block = t[16]), - e >= 56 && - (this.hashed || this.hash(), - (t[0] = this.block), - (t[16] = - t[1] = - t[2] = - t[3] = - t[4] = - t[5] = - t[6] = - t[7] = - t[8] = - t[9] = - t[10] = - t[11] = - t[12] = - t[13] = - t[14] = - t[15] = - 0)), - (t[14] = (this.hBytes << 3) | (this.bytes >>> 29)), - (t[15] = this.bytes << 3), - this.hash(); - } - }), - (Sha256.prototype.hash = function () { - var t = this.h0, - e = this.h1, - r = this.h2, - n = this.h3, - i = this.h4, - o = this.h5, - a = this.h6, - s = this.h7, - c = this.blocks, - u, - h, - w, - M, - k, - O, - D, - F, - N, - q, - z; - for (u = 16; u < 64; ++u) - (k = c[u - 15]), - (h = - ((k >>> 7) | (k << 25)) ^ ((k >>> 18) | (k << 14)) ^ (k >>> 3)), - (k = c[u - 2]), - (w = - ((k >>> 17) | (k << 15)) ^ - ((k >>> 19) | (k << 13)) ^ - (k >>> 10)), - (c[u] = (c[u - 16] + h + c[u - 7] + w) << 0); - for (z = e & r, u = 0; u < 64; u += 4) - this.first - ? (this.is224 - ? ((F = 300032), - (k = c[0] - 1413257819), - (s = (k - 150054599) << 0), - (n = (k + 24177077) << 0)) - : ((F = 704751109), - (k = c[0] - 210244248), - (s = (k - 1521486534) << 0), - (n = (k + 143694565) << 0)), - (this.first = !1)) - : ((h = - ((t >>> 2) | (t << 30)) ^ - ((t >>> 13) | (t << 19)) ^ - ((t >>> 22) | (t << 10))), - (w = - ((i >>> 6) | (i << 26)) ^ - ((i >>> 11) | (i << 21)) ^ - ((i >>> 25) | (i << 7))), - (F = t & e), - (M = F ^ (t & r) ^ z), - (D = (i & o) ^ (~i & a)), - (k = s + w + D + K[u] + c[u]), - (O = h + M), - (s = (n + k) << 0), - (n = (k + O) << 0)), - (h = - ((n >>> 2) | (n << 30)) ^ - ((n >>> 13) | (n << 19)) ^ - ((n >>> 22) | (n << 10))), - (w = - ((s >>> 6) | (s << 26)) ^ - ((s >>> 11) | (s << 21)) ^ - ((s >>> 25) | (s << 7))), - (N = n & t), - (M = N ^ (n & e) ^ F), - (D = (s & i) ^ (~s & o)), - (k = a + w + D + K[u + 1] + c[u + 1]), - (O = h + M), - (a = (r + k) << 0), - (r = (k + O) << 0), - (h = - ((r >>> 2) | (r << 30)) ^ - ((r >>> 13) | (r << 19)) ^ - ((r >>> 22) | (r << 10))), - (w = - ((a >>> 6) | (a << 26)) ^ - ((a >>> 11) | (a << 21)) ^ - ((a >>> 25) | (a << 7))), - (q = r & n), - (M = q ^ (r & t) ^ N), - (D = (a & s) ^ (~a & i)), - (k = o + w + D + K[u + 2] + c[u + 2]), - (O = h + M), - (o = (e + k) << 0), - (e = (k + O) << 0), - (h = - ((e >>> 2) | (e << 30)) ^ - ((e >>> 13) | (e << 19)) ^ - ((e >>> 22) | (e << 10))), - (w = - ((o >>> 6) | (o << 26)) ^ - ((o >>> 11) | (o << 21)) ^ - ((o >>> 25) | (o << 7))), - (z = e & r), - (M = z ^ (e & n) ^ q), - (D = (o & a) ^ (~o & s)), - (k = i + w + D + K[u + 3] + c[u + 3]), - (O = h + M), - (i = (t + k) << 0), - (t = (k + O) << 0); - (this.h0 = (this.h0 + t) << 0), - (this.h1 = (this.h1 + e) << 0), - (this.h2 = (this.h2 + r) << 0), - (this.h3 = (this.h3 + n) << 0), - (this.h4 = (this.h4 + i) << 0), - (this.h5 = (this.h5 + o) << 0), - (this.h6 = (this.h6 + a) << 0), - (this.h7 = (this.h7 + s) << 0); - }), - (Sha256.prototype.hex = function () { - this.finalize(); - var t = this.h0, - e = this.h1, - r = this.h2, - n = this.h3, - i = this.h4, - o = this.h5, - a = this.h6, - s = this.h7, - c = - HEX_CHARS[(t >> 28) & 15] + - HEX_CHARS[(t >> 24) & 15] + - HEX_CHARS[(t >> 20) & 15] + - HEX_CHARS[(t >> 16) & 15] + - HEX_CHARS[(t >> 12) & 15] + - HEX_CHARS[(t >> 8) & 15] + - HEX_CHARS[(t >> 4) & 15] + - HEX_CHARS[t & 15] + - HEX_CHARS[(e >> 28) & 15] + - HEX_CHARS[(e >> 24) & 15] + - HEX_CHARS[(e >> 20) & 15] + - HEX_CHARS[(e >> 16) & 15] + - HEX_CHARS[(e >> 12) & 15] + - HEX_CHARS[(e >> 8) & 15] + - HEX_CHARS[(e >> 4) & 15] + - HEX_CHARS[e & 15] + - HEX_CHARS[(r >> 28) & 15] + - HEX_CHARS[(r >> 24) & 15] + - HEX_CHARS[(r >> 20) & 15] + - HEX_CHARS[(r >> 16) & 15] + - HEX_CHARS[(r >> 12) & 15] + - HEX_CHARS[(r >> 8) & 15] + - HEX_CHARS[(r >> 4) & 15] + - HEX_CHARS[r & 15] + - HEX_CHARS[(n >> 28) & 15] + - HEX_CHARS[(n >> 24) & 15] + - HEX_CHARS[(n >> 20) & 15] + - HEX_CHARS[(n >> 16) & 15] + - HEX_CHARS[(n >> 12) & 15] + - HEX_CHARS[(n >> 8) & 15] + - HEX_CHARS[(n >> 4) & 15] + - HEX_CHARS[n & 15] + - HEX_CHARS[(i >> 28) & 15] + - HEX_CHARS[(i >> 24) & 15] + - HEX_CHARS[(i >> 20) & 15] + - HEX_CHARS[(i >> 16) & 15] + - HEX_CHARS[(i >> 12) & 15] + - HEX_CHARS[(i >> 8) & 15] + - HEX_CHARS[(i >> 4) & 15] + - HEX_CHARS[i & 15] + - HEX_CHARS[(o >> 28) & 15] + - HEX_CHARS[(o >> 24) & 15] + - HEX_CHARS[(o >> 20) & 15] + - HEX_CHARS[(o >> 16) & 15] + - HEX_CHARS[(o >> 12) & 15] + - HEX_CHARS[(o >> 8) & 15] + - HEX_CHARS[(o >> 4) & 15] + - HEX_CHARS[o & 15] + - HEX_CHARS[(a >> 28) & 15] + - HEX_CHARS[(a >> 24) & 15] + - HEX_CHARS[(a >> 20) & 15] + - HEX_CHARS[(a >> 16) & 15] + - HEX_CHARS[(a >> 12) & 15] + - HEX_CHARS[(a >> 8) & 15] + - HEX_CHARS[(a >> 4) & 15] + - HEX_CHARS[a & 15]; - return ( - this.is224 || - (c += - HEX_CHARS[(s >> 28) & 15] + - HEX_CHARS[(s >> 24) & 15] + - HEX_CHARS[(s >> 20) & 15] + - HEX_CHARS[(s >> 16) & 15] + - HEX_CHARS[(s >> 12) & 15] + - HEX_CHARS[(s >> 8) & 15] + - HEX_CHARS[(s >> 4) & 15] + - HEX_CHARS[s & 15]), - c - ); - }), - (Sha256.prototype.toString = Sha256.prototype.hex), - (Sha256.prototype.digest = function () { - this.finalize(); - var t = this.h0, - e = this.h1, - r = this.h2, - n = this.h3, - i = this.h4, - o = this.h5, - a = this.h6, - s = this.h7, - c = [ - (t >> 24) & 255, - (t >> 16) & 255, - (t >> 8) & 255, - t & 255, - (e >> 24) & 255, - (e >> 16) & 255, - (e >> 8) & 255, - e & 255, - (r >> 24) & 255, - (r >> 16) & 255, - (r >> 8) & 255, - r & 255, - (n >> 24) & 255, - (n >> 16) & 255, - (n >> 8) & 255, - n & 255, - (i >> 24) & 255, - (i >> 16) & 255, - (i >> 8) & 255, - i & 255, - (o >> 24) & 255, - (o >> 16) & 255, - (o >> 8) & 255, - o & 255, - (a >> 24) & 255, - (a >> 16) & 255, - (a >> 8) & 255, - a & 255, - ]; - return ( - this.is224 || - c.push((s >> 24) & 255, (s >> 16) & 255, (s >> 8) & 255, s & 255), - c - ); - }), - (Sha256.prototype.array = Sha256.prototype.digest), - (Sha256.prototype.arrayBuffer = function () { - this.finalize(); - var t = new ArrayBuffer(this.is224 ? 28 : 32), - e = new DataView(t); - return ( - e.setUint32(0, this.h0), - e.setUint32(4, this.h1), - e.setUint32(8, this.h2), - e.setUint32(12, this.h3), - e.setUint32(16, this.h4), - e.setUint32(20, this.h5), - e.setUint32(24, this.h6), - this.is224 || e.setUint32(28, this.h7), - t - ); - }); - function HmacSha256(t, e, r) { - var n, - i = typeof t; - if (i === "string") { - var o = [], - a = t.length, - s = 0, - c; - for (n = 0; n < a; ++n) - (c = t.charCodeAt(n)), - c < 128 - ? (o[s++] = c) - : c < 2048 - ? ((o[s++] = 192 | (c >> 6)), (o[s++] = 128 | (c & 63))) - : c < 55296 || c >= 57344 - ? ((o[s++] = 224 | (c >> 12)), - (o[s++] = 128 | ((c >> 6) & 63)), - (o[s++] = 128 | (c & 63))) - : ((c = - 65536 + (((c & 1023) << 10) | (t.charCodeAt(++n) & 1023))), - (o[s++] = 240 | (c >> 18)), - (o[s++] = 128 | ((c >> 12) & 63)), - (o[s++] = 128 | ((c >> 6) & 63)), - (o[s++] = 128 | (c & 63))); - t = o; - } else if (i === "object") { - if (t === null) throw new Error(ERROR); - if (ARRAY_BUFFER && t.constructor === ArrayBuffer) - t = new Uint8Array(t); - else if ( - !Array.isArray(t) && - (!ARRAY_BUFFER || !ArrayBuffer.isView(t)) - ) - throw new Error(ERROR); - } else throw new Error(ERROR); - t.length > 64 && (t = new Sha256(e, !0).update(t).array()); - var u = [], - h = []; - for (n = 0; n < 64; ++n) { - var w = t[n] || 0; - (u[n] = 92 ^ w), (h[n] = 54 ^ w); - } - Sha256.call(this, e, r), - this.update(h), - (this.oKeyPad = u), - (this.inner = !0), - (this.sharedMemory = r); - } - (HmacSha256.prototype = new Sha256()), - (HmacSha256.prototype.finalize = function () { - if ((Sha256.prototype.finalize.call(this), this.inner)) { - this.inner = !1; - var t = this.array(); - Sha256.call(this, this.is224, this.sharedMemory), - this.update(this.oKeyPad), - this.update(t), - Sha256.prototype.finalize.call(this); - } - }); - var exports = createMethod(); - (exports.sha256 = exports), - (exports.sha224 = createMethod(!0)), - (exports.sha256.hmac = createHmacMethod()), - (exports.sha224.hmac = createHmacMethod(!0)), - COMMON_JS - ? (module.exports = exports) - : ((root.sha256 = exports.sha256), - (root.sha224 = exports.sha224), - AMD && - define(function () { - return exports; - })); - })(); - }); - var hwe = I((ar) => { - "use strict"; - m(); - g(); - var Ui = class { - constructor(e, r) { - if (!Number.isInteger(e)) - throw new TypeError("span must be an integer"); - (this.span = e), (this.property = r); - } - makeDestinationObject() { - return {}; - } - decode(e, r) { - throw new Error("Layout is abstract"); - } - encode(e, r, n) { - throw new Error("Layout is abstract"); - } - getSpan(e, r) { - if (0 > this.span) throw new RangeError("indeterminate span"); - return this.span; - } - replicate(e) { - let r = Object.create(this.constructor.prototype); - return Object.assign(r, this), (r.property = e), r; - } - fromArray(e) {} - }; - ar.Layout = Ui; - function dwe(t, e) { - return e.property ? t + "[" + e.property + "]" : t; - } - ar.nameWithProperty = dwe; - function gar(t, e) { - if (typeof t != "function") - throw new TypeError("Class must be constructor"); - if (t.hasOwnProperty("layout_")) - throw new Error("Class is already bound to a layout"); - if (!(e && e instanceof Ui)) - throw new TypeError("layout must be a Layout"); - if (e.hasOwnProperty("boundConstructor_")) - throw new Error("layout is already bound to a constructor"); - (t.layout_ = e), - (e.boundConstructor_ = t), - (e.makeDestinationObject = () => new t()), - Object.defineProperty(t.prototype, "encode", { - value: function (r, n) { - return e.encode(this, r, n); - }, - writable: !0, - }), - Object.defineProperty(t, "decode", { - value: function (r, n) { - return e.decode(r, n); - }, - writable: !0, - }); - } - ar.bindConstructorLayout = gar; - var Uc = class extends Ui { - isCount() { - throw new Error("ExternalLayout is abstract"); - } - }, - UY = class extends Uc { - constructor(e, r) { - if ((e === void 0 && (e = 1), !Number.isInteger(e) || 0 >= e)) - throw new TypeError("elementSpan must be a (positive) integer"); - super(-1, r), (this.elementSpan = e); - } - isCount() { - return !0; - } - decode(e, r) { - r === void 0 && (r = 0); - let n = e.length - r; - return Math.floor(n / this.elementSpan); - } - encode(e, r, n) { - return 0; - } - }, - zz = class extends Uc { - constructor(e, r, n) { - if (!(e instanceof Ui)) - throw new TypeError("layout must be a Layout"); - if (r === void 0) r = 0; - else if (!Number.isInteger(r)) - throw new TypeError("offset must be integer or undefined"); - super(e.span, n || e.property), (this.layout = e), (this.offset = r); - } - isCount() { - return this.layout instanceof my || this.layout instanceof Zm; - } - decode(e, r) { - return ( - r === void 0 && (r = 0), this.layout.decode(e, r + this.offset) - ); - } - encode(e, r, n) { - return ( - n === void 0 && (n = 0), this.layout.encode(e, r, n + this.offset) - ); - } - }, - my = class extends Ui { - constructor(e, r) { - if ((super(e, r), 6 < this.span)) - throw new RangeError("span must not exceed 6 bytes"); - } - decode(e, r) { - return r === void 0 && (r = 0), e.readUIntLE(r, this.span); - } - encode(e, r, n) { - return ( - n === void 0 && (n = 0), r.writeUIntLE(e, n, this.span), this.span - ); - } - }, - Zm = class extends Ui { - constructor(e, r) { - if ((super(e, r), 6 < this.span)) - throw new RangeError("span must not exceed 6 bytes"); - } - decode(e, r) { - return r === void 0 && (r = 0), e.readUIntBE(r, this.span); - } - encode(e, r, n) { - return ( - n === void 0 && (n = 0), r.writeUIntBE(e, n, this.span), this.span - ); - } - }, - $_ = class extends Ui { - constructor(e, r) { - if ((super(e, r), 6 < this.span)) - throw new RangeError("span must not exceed 6 bytes"); - } - decode(e, r) { - return r === void 0 && (r = 0), e.readIntLE(r, this.span); - } - encode(e, r, n) { - return ( - n === void 0 && (n = 0), r.writeIntLE(e, n, this.span), this.span - ); - } - }, - L2 = class extends Ui { - constructor(e, r) { - if ((super(e, r), 6 < this.span)) - throw new RangeError("span must not exceed 6 bytes"); - } - decode(e, r) { - return r === void 0 && (r = 0), e.readIntBE(r, this.span); - } - encode(e, r, n) { - return ( - n === void 0 && (n = 0), r.writeIntBE(e, n, this.span), this.span - ); - } - }, - swe = Math.pow(2, 32); - function tQ(t) { - let e = Math.floor(t / swe), - r = t - e * swe; - return { hi32: e, lo32: r }; - } - function rQ(t, e) { - return t * swe + e; - } - var uwe = class extends Ui { - constructor(e) { - super(8, e); - } - decode(e, r) { - r === void 0 && (r = 0); - let n = e.readUInt32LE(r), - i = e.readUInt32LE(r + 4); - return rQ(i, n); - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = tQ(e); - return r.writeUInt32LE(i.lo32, n), r.writeUInt32LE(i.hi32, n + 4), 8; - } - }, - cwe = class extends Ui { - constructor(e) { - super(8, e); - } - decode(e, r) { - r === void 0 && (r = 0); - let n = e.readUInt32BE(r), - i = e.readUInt32BE(r + 4); - return rQ(n, i); - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = tQ(e); - return r.writeUInt32BE(i.hi32, n), r.writeUInt32BE(i.lo32, n + 4), 8; - } - }, - lwe = class extends Ui { - constructor(e) { - super(8, e); - } - decode(e, r) { - r === void 0 && (r = 0); - let n = e.readUInt32LE(r), - i = e.readInt32LE(r + 4); - return rQ(i, n); - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = tQ(e); - return r.writeUInt32LE(i.lo32, n), r.writeInt32LE(i.hi32, n + 4), 8; - } - }, - fwe = class extends Ui { - constructor(e) { - super(8, e); - } - decode(e, r) { - r === void 0 && (r = 0); - let n = e.readInt32BE(r), - i = e.readUInt32BE(r + 4); - return rQ(n, i); - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = tQ(e); - return r.writeInt32BE(i.hi32, n), r.writeUInt32BE(i.lo32, n + 4), 8; - } - }, - KY = class extends Ui { - constructor(e) { - super(4, e); - } - decode(e, r) { - return r === void 0 && (r = 0), e.readFloatLE(r); - } - encode(e, r, n) { - return n === void 0 && (n = 0), r.writeFloatLE(e, n), 4; - } - }, - HY = class extends Ui { - constructor(e) { - super(4, e); - } - decode(e, r) { - return r === void 0 && (r = 0), e.readFloatBE(r); - } - encode(e, r, n) { - return n === void 0 && (n = 0), r.writeFloatBE(e, n), 4; - } - }, - VY = class extends Ui { - constructor(e) { - super(8, e); - } - decode(e, r) { - return r === void 0 && (r = 0), e.readDoubleLE(r); - } - encode(e, r, n) { - return n === void 0 && (n = 0), r.writeDoubleLE(e, n), 8; - } - }, - WY = class extends Ui { - constructor(e) { - super(8, e); - } - decode(e, r) { - return r === void 0 && (r = 0), e.readDoubleBE(r); - } - encode(e, r, n) { - return n === void 0 && (n = 0), r.writeDoubleBE(e, n), 8; - } - }, - GY = class extends Ui { - constructor(e, r, n) { - if (!(e instanceof Ui)) - throw new TypeError("elementLayout must be a Layout"); - if ( - !( - (r instanceof Uc && r.isCount()) || - (Number.isInteger(r) && 0 <= r) - ) - ) - throw new TypeError( - "count must be non-negative integer or an unsigned integer ExternalLayout" - ); - let i = -1; - !(r instanceof Uc) && 0 < e.span && (i = r * e.span), - super(i, n), - (this.elementLayout = e), - (this.count = r); - } - getSpan(e, r) { - if (0 <= this.span) return this.span; - r === void 0 && (r = 0); - let n = 0, - i = this.count; - if ( - (i instanceof Uc && (i = i.decode(e, r)), - 0 < this.elementLayout.span) - ) - n = i * this.elementLayout.span; - else { - let o = 0; - for (; o < i; ) (n += this.elementLayout.getSpan(e, r + n)), ++o; - } - return n; - } - decode(e, r) { - r === void 0 && (r = 0); - let n = [], - i = 0, - o = this.count; - for (o instanceof Uc && (o = o.decode(e, r)); i < o; ) - n.push(this.elementLayout.decode(e, r)), - (r += this.elementLayout.getSpan(e, r)), - (i += 1); - return n; - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = this.elementLayout, - o = e.reduce((a, s) => a + i.encode(s, r, n + a), 0); - return ( - this.count instanceof Uc && this.count.encode(e.length, r, n), o - ); - } - }, - JY = class extends Ui { - constructor(e, r, n) { - if ( - !(Array.isArray(e) && e.reduce((o, a) => o && a instanceof Ui, !0)) - ) - throw new TypeError("fields must be array of Layout instances"); - typeof r == "boolean" && n === void 0 && ((n = r), (r = void 0)); - for (let o of e) - if (0 > o.span && o.property === void 0) - throw new Error( - "fields cannot contain unnamed variable-length layout" - ); - let i = -1; - try { - i = e.reduce((o, a) => o + a.getSpan(), 0); - } catch {} - super(i, r), (this.fields = e), (this.decodePrefixes = !!n); - } - getSpan(e, r) { - if (0 <= this.span) return this.span; - r === void 0 && (r = 0); - let n = 0; - try { - n = this.fields.reduce((i, o) => { - let a = o.getSpan(e, r); - return (r += a), i + a; - }, 0); - } catch { - throw new RangeError("indeterminate span"); - } - return n; - } - decode(e, r) { - r === void 0 && (r = 0); - let n = this.makeDestinationObject(); - for (let i of this.fields) - if ( - (i.property !== void 0 && (n[i.property] = i.decode(e, r)), - (r += i.getSpan(e, r)), - this.decodePrefixes && e.length === r) - ) - break; - return n; - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = n, - o = 0, - a = 0; - for (let s of this.fields) { - let c = s.span; - if (((a = 0 < c ? c : 0), s.property !== void 0)) { - let u = e[s.property]; - u !== void 0 && - ((a = s.encode(u, r, n)), 0 > c && (c = s.getSpan(r, n))); - } - (o = n), (n += c); - } - return o + a - i; - } - fromArray(e) { - let r = this.makeDestinationObject(); - for (let n of this.fields) - n.property !== void 0 && - 0 < e.length && - (r[n.property] = e.shift()); - return r; - } - layoutFor(e) { - if (typeof e != "string") - throw new TypeError("property must be string"); - for (let r of this.fields) if (r.property === e) return r; - } - offsetOf(e) { - if (typeof e != "string") - throw new TypeError("property must be string"); - let r = 0; - for (let n of this.fields) { - if (n.property === e) return r; - 0 > n.span ? (r = -1) : 0 <= r && (r += n.span); - } - } - }, - jz = class { - constructor(e) { - this.property = e; - } - decode() { - throw new Error("UnionDiscriminator is abstract"); - } - encode() { - throw new Error("UnionDiscriminator is abstract"); - } - }, - vC = class extends jz { - constructor(e, r) { - if (!(e instanceof Uc && e.isCount())) - throw new TypeError( - "layout must be an unsigned integer ExternalLayout" - ); - super(r || e.property || "variant"), (this.layout = e); - } - decode(e, r) { - return this.layout.decode(e, r); - } - encode(e, r, n) { - return this.layout.encode(e, r, n); - } - }, - Uz = class extends Ui { - constructor(e, r, n) { - let i = e instanceof my || e instanceof Zm; - if (i) e = new vC(new zz(e)); - else if (e instanceof Uc && e.isCount()) e = new vC(e); - else if (!(e instanceof jz)) - throw new TypeError( - "discr must be a UnionDiscriminator or an unsigned integer layout" - ); - if ((r === void 0 && (r = null), !(r === null || r instanceof Ui))) - throw new TypeError("defaultLayout must be null or a Layout"); - if (r !== null) { - if (0 > r.span) - throw new Error("defaultLayout must have constant span"); - r.property === void 0 && (r = r.replicate("content")); - } - let o = -1; - r && ((o = r.span), 0 <= o && i && (o += e.layout.span)), - super(o, n), - (this.discriminator = e), - (this.usesPrefixDiscriminator = i), - (this.defaultLayout = r), - (this.registry = {}); - let a = this.defaultGetSourceVariant.bind(this); - (this.getSourceVariant = function (s) { - return a(s); - }), - (this.configGetSourceVariant = function (s) { - a = s.bind(this); - }); - } - getSpan(e, r) { - if (0 <= this.span) return this.span; - r === void 0 && (r = 0); - let n = this.getVariant(e, r); - if (!n) - throw new Error( - "unable to determine span for unrecognized variant" - ); - return n.getSpan(e, r); - } - defaultGetSourceVariant(e) { - if (e.hasOwnProperty(this.discriminator.property)) { - if ( - this.defaultLayout && - e.hasOwnProperty(this.defaultLayout.property) - ) - return; - let r = this.registry[e[this.discriminator.property]]; - if (r && (!r.layout || e.hasOwnProperty(r.property))) return r; - } else - for (let r in this.registry) { - let n = this.registry[r]; - if (e.hasOwnProperty(n.property)) return n; - } - throw new Error("unable to infer src variant"); - } - decode(e, r) { - r === void 0 && (r = 0); - let n, - i = this.discriminator, - o = i.decode(e, r), - a = this.registry[o]; - if (a === void 0) { - let s = 0; - (a = this.defaultLayout), - this.usesPrefixDiscriminator && (s = i.layout.span), - (n = this.makeDestinationObject()), - (n[i.property] = o), - (n[a.property] = this.defaultLayout.decode(e, r + s)); - } else n = a.decode(e, r); - return n; - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = this.getSourceVariant(e); - if (i === void 0) { - let o = this.discriminator, - a = this.defaultLayout, - s = 0; - return ( - this.usesPrefixDiscriminator && (s = o.layout.span), - o.encode(e[o.property], r, n), - s + a.encode(e[a.property], r, n + s) - ); - } - return i.encode(e, r, n); - } - addVariant(e, r, n) { - let i = new $Y(this, e, r, n); - return (this.registry[e] = i), i; - } - getVariant(e, r) { - let n = e; - return ( - Buffer.isBuffer(e) && - (r === void 0 && (r = 0), (n = this.discriminator.decode(e, r))), - this.registry[n] - ); - } - }, - $Y = class extends Ui { - constructor(e, r, n, i) { - if (!(e instanceof Uz)) throw new TypeError("union must be a Union"); - if (!Number.isInteger(r) || 0 > r) - throw new TypeError("variant must be a (non-negative) integer"); - if ( - (typeof n == "string" && i === void 0 && ((i = n), (n = null)), n) - ) { - if (!(n instanceof Ui)) - throw new TypeError("layout must be a Layout"); - if ( - e.defaultLayout !== null && - 0 <= n.span && - n.span > e.defaultLayout.span - ) - throw new Error("variant span exceeds span of containing union"); - if (typeof i != "string") - throw new TypeError("variant must have a String property"); - } - let o = e.span; - 0 > e.span && - ((o = n ? n.span : 0), - 0 <= o && - e.usesPrefixDiscriminator && - (o += e.discriminator.layout.span)), - super(o, i), - (this.union = e), - (this.variant = r), - (this.layout = n || null); - } - getSpan(e, r) { - if (0 <= this.span) return this.span; - r === void 0 && (r = 0); - let n = 0; - return ( - this.union.usesPrefixDiscriminator && - (n = this.union.discriminator.layout.span), - n + this.layout.getSpan(e, r + n) - ); - } - decode(e, r) { - let n = this.makeDestinationObject(); - if ((r === void 0 && (r = 0), this !== this.union.getVariant(e, r))) - throw new Error("variant mismatch"); - let i = 0; - return ( - this.union.usesPrefixDiscriminator && - (i = this.union.discriminator.layout.span), - this.layout - ? (n[this.property] = this.layout.decode(e, r + i)) - : this.property - ? (n[this.property] = !0) - : this.union.usesPrefixDiscriminator && - (n[this.union.discriminator.property] = this.variant), - n - ); - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = 0; - if ( - (this.union.usesPrefixDiscriminator && - (i = this.union.discriminator.layout.span), - this.layout && !e.hasOwnProperty(this.property)) - ) - throw new TypeError("variant lacks property " + this.property); - this.union.discriminator.encode(this.variant, r, n); - let o = i; - if ( - this.layout && - (this.layout.encode(e[this.property], r, n + i), - (o += this.layout.getSpan(r, n + i)), - 0 <= this.union.span && o > this.union.span) - ) - throw new Error("encoded variant overruns containing union"); - return o; - } - fromArray(e) { - if (this.layout) return this.layout.fromArray(e); - } - }; - function gC(t) { - return 0 > t && (t += 4294967296), t; - } - var Kz = class extends Ui { - constructor(e, r, n) { - if (!(e instanceof my || e instanceof Zm)) - throw new TypeError("word must be a UInt or UIntBE layout"); - if ( - (typeof r == "string" && n === void 0 && ((n = r), (r = void 0)), - 4 < e.span) - ) - throw new RangeError("word cannot exceed 32 bits"); - super(e.span, n), - (this.word = e), - (this.msb = !!r), - (this.fields = []); - let i = 0; - (this._packedSetValue = function (o) { - return (i = gC(o)), this; - }), - (this._packedGetValue = function () { - return i; - }); - } - decode(e, r) { - let n = this.makeDestinationObject(); - r === void 0 && (r = 0); - let i = this.word.decode(e, r); - this._packedSetValue(i); - for (let o of this.fields) - o.property !== void 0 && (n[o.property] = o.decode(i)); - return n; - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = this.word.decode(r, n); - this._packedSetValue(i); - for (let o of this.fields) - if (o.property !== void 0) { - let a = e[o.property]; - a !== void 0 && o.encode(a); - } - return this.word.encode(this._packedGetValue(), r, n); - } - addField(e, r) { - let n = new $M(this, e, r); - return this.fields.push(n), n; - } - addBoolean(e) { - let r = new ZY(this, e); - return this.fields.push(r), r; - } - fieldFor(e) { - if (typeof e != "string") - throw new TypeError("property must be string"); - for (let r of this.fields) if (r.property === e) return r; - } - }, - $M = class { - constructor(e, r, n) { - if (!(e instanceof Kz)) - throw new TypeError("container must be a BitStructure"); - if (!Number.isInteger(r) || 0 >= r) - throw new TypeError("bits must be positive integer"); - let i = 8 * e.span, - o = e.fields.reduce((a, s) => a + s.bits, 0); - if (r + o > i) - throw new Error( - "bits too long for span remainder (" + - (i - o) + - " of " + - i + - " remain)" - ); - (this.container = e), - (this.bits = r), - (this.valueMask = (1 << r) - 1), - r === 32 && (this.valueMask = 4294967295), - (this.start = o), - this.container.msb && (this.start = i - o - r), - (this.wordMask = gC(this.valueMask << this.start)), - (this.property = n); - } - decode() { - let e = this.container._packedGetValue(); - return gC(e & this.wordMask) >>> this.start; - } - encode(e) { - if (!Number.isInteger(e) || e !== gC(e & this.valueMask)) - throw new TypeError( - dwe("BitField.encode", this) + - " value must be integer not exceeding " + - this.valueMask - ); - let r = this.container._packedGetValue(), - n = gC(e << this.start); - this.container._packedSetValue(gC(r & ~this.wordMask) | n); - } - }, - ZY = class extends $M { - constructor(e, r) { - super(e, 1, r); - } - decode(e, r) { - return !!$M.prototype.decode.call(this, e, r); - } - encode(e) { - return ( - typeof e == "boolean" && (e = +e), $M.prototype.encode.call(this, e) - ); - } - }, - XY = class extends Ui { - constructor(e, r) { - if ( - !( - (e instanceof Uc && e.isCount()) || - (Number.isInteger(e) && 0 <= e) - ) - ) - throw new TypeError( - "length must be positive integer or an unsigned integer ExternalLayout" - ); - let n = -1; - e instanceof Uc || (n = e), super(n, r), (this.length = e); - } - getSpan(e, r) { - let n = this.span; - return 0 > n && (n = this.length.decode(e, r)), n; - } - decode(e, r) { - r === void 0 && (r = 0); - let n = this.span; - return 0 > n && (n = this.length.decode(e, r)), e.slice(r, r + n); - } - encode(e, r, n) { - let i = this.length; - if ( - (this.length instanceof Uc && (i = e.length), - !(Buffer.isBuffer(e) && i === e.length)) - ) - throw new TypeError( - dwe("Blob.encode", this) + - " requires (length " + - i + - ") Buffer as src" - ); - if (n + i > r.length) - throw new RangeError("encoding overruns Buffer"); - return ( - r.write(e.toString("hex"), n, i, "hex"), - this.length instanceof Uc && this.length.encode(i, r, n), - i - ); - } - }, - YY = class extends Ui { - constructor(e) { - super(-1, e); - } - getSpan(e, r) { - if (!Buffer.isBuffer(e)) throw new TypeError("b must be a Buffer"); - r === void 0 && (r = 0); - let n = r; - for (; n < e.length && e[n] !== 0; ) n += 1; - return 1 + n - r; - } - decode(e, r, n) { - r === void 0 && (r = 0); - let i = this.getSpan(e, r); - return e.slice(r, r + i - 1).toString("utf-8"); - } - encode(e, r, n) { - n === void 0 && (n = 0), typeof e != "string" && (e = e.toString()); - let i = new Buffer(e, "utf8"), - o = i.length; - if (n + o > r.length) - throw new RangeError("encoding overruns Buffer"); - return i.copy(r, n), (r[n + o] = 0), o + 1; - } - }, - QY = class extends Ui { - constructor(e, r) { - if ( - (typeof e == "string" && r === void 0 && ((r = e), (e = void 0)), - e === void 0) - ) - e = -1; - else if (!Number.isInteger(e)) - throw new TypeError("maxSpan must be an integer"); - super(-1, r), (this.maxSpan = e); - } - getSpan(e, r) { - if (!Buffer.isBuffer(e)) throw new TypeError("b must be a Buffer"); - return r === void 0 && (r = 0), e.length - r; - } - decode(e, r, n) { - r === void 0 && (r = 0); - let i = this.getSpan(e, r); - if (0 <= this.maxSpan && this.maxSpan < i) - throw new RangeError("text length exceeds maxSpan"); - return e.slice(r, r + i).toString("utf-8"); - } - encode(e, r, n) { - n === void 0 && (n = 0), typeof e != "string" && (e = e.toString()); - let i = new Buffer(e, "utf8"), - o = i.length; - if (0 <= this.maxSpan && this.maxSpan < o) - throw new RangeError("text length exceeds maxSpan"); - if (n + o > r.length) - throw new RangeError("encoding overruns Buffer"); - return i.copy(r, n), o; - } - }, - eQ = class extends Ui { - constructor(e, r) { - super(0, r), (this.value = e); - } - decode(e, r, n) { - return this.value; - } - encode(e, r, n) { - return 0; - } - }; - ar.ExternalLayout = Uc; - ar.GreedyCount = UY; - ar.OffsetLayout = zz; - ar.UInt = my; - ar.UIntBE = Zm; - ar.Int = $_; - ar.IntBE = L2; - ar.Float = KY; - ar.FloatBE = HY; - ar.Double = VY; - ar.DoubleBE = WY; - ar.Sequence = GY; - ar.Structure = JY; - ar.UnionDiscriminator = jz; - ar.UnionLayoutDiscriminator = vC; - ar.Union = Uz; - ar.VariantLayout = $Y; - ar.BitStructure = Kz; - ar.BitField = $M; - ar.Boolean = ZY; - ar.Blob = XY; - ar.CString = YY; - ar.UTF8 = QY; - ar.Constant = eQ; - ar.greedy = (t, e) => new UY(t, e); - ar.offset = (t, e, r) => new zz(t, e, r); - ar.u8 = (t) => new my(1, t); - ar.u16 = (t) => new my(2, t); - ar.u24 = (t) => new my(3, t); - ar.u32 = (t) => new my(4, t); - ar.u40 = (t) => new my(5, t); - ar.u48 = (t) => new my(6, t); - ar.nu64 = (t) => new uwe(t); - ar.u16be = (t) => new Zm(2, t); - ar.u24be = (t) => new Zm(3, t); - ar.u32be = (t) => new Zm(4, t); - ar.u40be = (t) => new Zm(5, t); - ar.u48be = (t) => new Zm(6, t); - ar.nu64be = (t) => new cwe(t); - ar.s8 = (t) => new $_(1, t); - ar.s16 = (t) => new $_(2, t); - ar.s24 = (t) => new $_(3, t); - ar.s32 = (t) => new $_(4, t); - ar.s40 = (t) => new $_(5, t); - ar.s48 = (t) => new $_(6, t); - ar.ns64 = (t) => new lwe(t); - ar.s16be = (t) => new L2(2, t); - ar.s24be = (t) => new L2(3, t); - ar.s32be = (t) => new L2(4, t); - ar.s40be = (t) => new L2(5, t); - ar.s48be = (t) => new L2(6, t); - ar.ns64be = (t) => new fwe(t); - ar.f32 = (t) => new KY(t); - ar.f32be = (t) => new HY(t); - ar.f64 = (t) => new VY(t); - ar.f64be = (t) => new WY(t); - ar.struct = (t, e, r) => new JY(t, e, r); - ar.bits = (t, e, r) => new Kz(t, e, r); - ar.seq = (t, e, r) => new GY(t, e, r); - ar.union = (t, e, r) => new Uz(t, e, r); - ar.unionLayoutDiscriminator = (t, e) => new vC(t, e); - ar.blob = (t, e) => new XY(t, e); - ar.cstr = (t) => new YY(t); - ar.utf8 = (t, e) => new QY(t, e); - ar.const = (t, e) => new eQ(t, e); - }); - var GZe = I((Rr) => { - "use strict"; - m(); - g(); - var bar = - (Rr && Rr.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Rr, "__esModule", { value: !0 }); - Rr.map = - Rr.array = - Rr.rustEnum = - Rr.str = - Rr.vecU8 = - Rr.tagged = - Rr.vec = - Rr.bool = - Rr.option = - Rr.publicKey = - Rr.i128 = - Rr.u128 = - Rr.i64 = - Rr.u64 = - Rr.struct = - Rr.f64 = - Rr.f32 = - Rr.i32 = - Rr.u32 = - Rr.i16 = - Rr.u16 = - Rr.i8 = - Rr.u8 = - void 0; - var Wo = hwe(), - war = Le(), - _ar = bar(Ho()), - Z_ = hwe(); - Object.defineProperty(Rr, "u8", { - enumerable: !0, - get: function () { - return Z_.u8; - }, - }); - Object.defineProperty(Rr, "i8", { - enumerable: !0, - get: function () { - return Z_.s8; - }, - }); - Object.defineProperty(Rr, "u16", { - enumerable: !0, - get: function () { - return Z_.u16; - }, - }); - Object.defineProperty(Rr, "i16", { - enumerable: !0, - get: function () { - return Z_.s16; - }, - }); - Object.defineProperty(Rr, "u32", { - enumerable: !0, - get: function () { - return Z_.u32; - }, - }); - Object.defineProperty(Rr, "i32", { - enumerable: !0, - get: function () { - return Z_.s32; - }, - }); - Object.defineProperty(Rr, "f32", { - enumerable: !0, - get: function () { - return Z_.f32; - }, - }); - Object.defineProperty(Rr, "f64", { - enumerable: !0, - get: function () { - return Z_.f64; - }, - }); - Object.defineProperty(Rr, "struct", { - enumerable: !0, - get: function () { - return Z_.struct; - }, - }); - var bC = class extends Wo.Layout { - constructor(e, r, n) { - super(e, n), (this.blob = Wo.blob(e)), (this.signed = r); - } - decode(e, r = 0) { - let n = new _ar.default(this.blob.decode(e, r), 10, "le"); - return this.signed ? n.fromTwos(this.span * 8).clone() : n; - } - encode(e, r, n = 0) { - return ( - this.signed && (e = e.toTwos(this.span * 8)), - this.blob.encode(e.toArrayLike(Buffer, "le", this.span), r, n) - ); - } - }; - function VZe(t) { - return new bC(8, !1, t); - } - Rr.u64 = VZe; - function xar(t) { - return new bC(8, !0, t); - } - Rr.i64 = xar; - function Sar(t) { - return new bC(16, !1, t); - } - Rr.u128 = Sar; - function Aar(t) { - return new bC(16, !0, t); - } - Rr.i128 = Aar; - var kv = class extends Wo.Layout { - constructor(e, r, n, i) { - super(e.span, i), - (this.layout = e), - (this.decoder = r), - (this.encoder = n); - } - decode(e, r) { - return this.decoder(this.layout.decode(e, r)); - } - encode(e, r, n) { - return this.layout.encode(this.encoder(e), r, n); - } - getSpan(e, r) { - return this.layout.getSpan(e, r); - } - }; - function Ear(t) { - return new kv( - Wo.blob(32), - (e) => new war.PublicKey(e), - (e) => e.toBuffer(), - t - ); - } - Rr.publicKey = Ear; - var pwe = class extends Wo.Layout { - constructor(e, r) { - super(-1, r), (this.layout = e), (this.discriminator = Wo.u8()); - } - encode(e, r, n = 0) { - return e == null - ? this.discriminator.encode(0, r, n) - : (this.discriminator.encode(1, r, n), - this.layout.encode(e, r, n + 1) + 1); - } - decode(e, r = 0) { - let n = this.discriminator.decode(e, r); - if (n === 0) return null; - if (n === 1) return this.layout.decode(e, r + 1); - throw new Error("Invalid option " + this.property); - } - getSpan(e, r = 0) { - let n = this.discriminator.decode(e, r); - if (n === 0) return 1; - if (n === 1) return this.layout.getSpan(e, r + 1) + 1; - throw new Error("Invalid option " + this.property); - } - }; - function Mar(t, e) { - return new pwe(t, e); - } - Rr.option = Mar; - function Tar(t) { - return new kv(Wo.u8(), kar, Par, t); - } - Rr.bool = Tar; - function kar(t) { - if (t === 0) return !1; - if (t === 1) return !0; - throw new Error("Invalid bool: " + t); - } - function Par(t) { - return t ? 1 : 0; - } - function Oar(t, e) { - let r = Wo.u32("length"), - n = Wo.struct([r, Wo.seq(t, Wo.offset(r, -r.span), "values")]); - return new kv( - n, - ({ values: i }) => i, - (i) => ({ values: i }), - e - ); - } - Rr.vec = Oar; - function Bar(t, e, r) { - let n = Wo.struct([VZe("tag"), e.replicate("data")]); - function i({ tag: o, data: a }) { - if (!o.eq(t)) - throw new Error( - "Invalid tag, expected: " + - t.toString("hex") + - ", got: " + - o.toString("hex") - ); - return a; - } - return new kv(n, i, (o) => ({ tag: t, data: o }), r); - } - Rr.tagged = Bar; - function WZe(t) { - let e = Wo.u32("length"), - r = Wo.struct([e, Wo.blob(Wo.offset(e, -e.span), "data")]); - return new kv( - r, - ({ data: n }) => n, - (n) => ({ data: n }), - t - ); - } - Rr.vecU8 = WZe; - function Iar(t) { - return new kv( - WZe(), - (e) => e.toString("utf-8"), - (e) => Buffer.from(e, "utf-8"), - t - ); - } - Rr.str = Iar; - function Car(t, e, r) { - let n = Wo.union(r ?? Wo.u8(), e); - return t.forEach((i, o) => n.addVariant(o, i, i.property)), n; - } - Rr.rustEnum = Car; - function Rar(t, e, r) { - let n = Wo.struct([Wo.seq(t, e, "values")]); - return new kv( - n, - ({ values: i }) => i, - (i) => ({ values: i }), - r - ); - } - Rr.array = Rar; - var ywe = class extends Wo.Layout { - constructor(e, r, n) { - super(e.span + r.span, n), (this.keyLayout = e), (this.valueLayout = r); - } - decode(e, r) { - r = r || 0; - let n = this.keyLayout.decode(e, r), - i = this.valueLayout.decode(e, r + this.keyLayout.getSpan(e, r)); - return [n, i]; - } - encode(e, r, n) { - n = n || 0; - let i = this.keyLayout.encode(e[0], r, n), - o = this.valueLayout.encode(e[1], r, n + i); - return i + o; - } - getSpan(e, r) { - return this.keyLayout.getSpan(e, r) + this.valueLayout.getSpan(e, r); - } - }; - function Nar(t, e, r) { - let n = Wo.u32("length"), - i = Wo.struct([ - n, - Wo.seq(new ywe(t, e), Wo.offset(n, -n.span), "values"), - ]); - return new kv( - i, - ({ values: o }) => new Map(o), - (o) => ({ values: Array.from(o.entries()) }), - r - ); - } - Rr.map = Nar; - }); - var Kwe = I(($dn, yYe) => { - "use strict"; - m(); - g(); - function MC(t) { - return ( - typeof Symbol == "function" && typeof Symbol.iterator == "symbol" - ? (MC = function (r) { - return typeof r; - }) - : (MC = function (r) { - return r && - typeof Symbol == "function" && - r.constructor === Symbol && - r !== Symbol.prototype - ? "symbol" - : typeof r; - }), - MC(t) - ); - } - function bcr(t, e) { - if (!(t instanceof e)) - throw new TypeError("Cannot call a class as a function"); - } - function wcr(t, e) { - return e && (MC(e) === "object" || typeof e == "function") ? e : _cr(t); - } - function _cr(t) { - if (t === void 0) - throw new ReferenceError( - "this hasn't been initialised - super() hasn't been called" - ); - return t; - } - function jwe(t) { - return ( - (jwe = Object.setPrototypeOf - ? Object.getPrototypeOf - : function (r) { - return r.__proto__ || Object.getPrototypeOf(r); - }), - jwe(t) - ); - } - function xcr(t, e) { - if (typeof e != "function" && e !== null) - throw new TypeError( - "Super expression must either be null or a function" - ); - (t.prototype = Object.create(e && e.prototype, { - constructor: { value: t, writable: !0, configurable: !0 }, - })), - e && Uwe(t, e); - } - function Uwe(t, e) { - return ( - (Uwe = - Object.setPrototypeOf || - function (n, i) { - return (n.__proto__ = i), n; - }), - Uwe(t, e) - ); - } - var pYe = {}, - TC, - zwe; - function uj(t, e, r) { - r || (r = Error); - function n(o, a, s) { - return typeof e == "string" ? e : e(o, a, s); - } - var i = (function (o) { - xcr(a, o); - function a(s, c, u) { - var h; - return ( - bcr(this, a), - (h = wcr(this, jwe(a).call(this, n(s, c, u)))), - (h.code = t), - h - ); - } - return a; - })(r); - pYe[t] = i; - } - function hYe(t, e) { - if (Array.isArray(t)) { - var r = t.length; - return ( - (t = t.map(function (n) { - return String(n); - })), - r > 2 - ? "one of " - .concat(e, " ") - .concat(t.slice(0, r - 1).join(", "), ", or ") + t[r - 1] - : r === 2 - ? "one of ".concat(e, " ").concat(t[0], " or ").concat(t[1]) - : "of ".concat(e, " ").concat(t[0]) - ); - } else return "of ".concat(e, " ").concat(String(t)); - } - function Scr(t, e, r) { - return t.substr(!r || r < 0 ? 0 : +r, e.length) === e; - } - function Acr(t, e, r) { - return ( - (r === void 0 || r > t.length) && (r = t.length), - t.substring(r - e.length, r) === e - ); - } - function Ecr(t, e, r) { - return ( - typeof r != "number" && (r = 0), - r + e.length > t.length ? !1 : t.indexOf(e, r) !== -1 - ); - } - uj( - "ERR_AMBIGUOUS_ARGUMENT", - 'The "%s" argument is ambiguous. %s', - TypeError - ); - uj( - "ERR_INVALID_ARG_TYPE", - function (t, e, r) { - TC === void 0 && (TC = Dr()), - TC(typeof t == "string", "'name' must be a string"); - var n; - typeof e == "string" && Scr(e, "not ") - ? ((n = "must not be"), (e = e.replace(/^not /, ""))) - : (n = "must be"); - var i; - if (Acr(t, " argument")) - i = "The ".concat(t, " ").concat(n, " ").concat(hYe(e, "type")); - else { - var o = Ecr(t, ".") ? "property" : "argument"; - i = 'The "' - .concat(t, '" ') - .concat(o, " ") - .concat(n, " ") - .concat(hYe(e, "type")); - } - return (i += ". Received type ".concat(MC(r))), i; - }, - TypeError - ); - uj( - "ERR_INVALID_ARG_VALUE", - function (t, e) { - var r = - arguments.length > 2 && arguments[2] !== void 0 - ? arguments[2] - : "is invalid"; - zwe === void 0 && (zwe = es()); - var n = zwe.inspect(e); - return ( - n.length > 128 && (n = "".concat(n.slice(0, 128), "...")), - "The argument '".concat(t, "' ").concat(r, ". Received ").concat(n) - ); - }, - TypeError, - RangeError - ); - uj( - "ERR_INVALID_RETURN_VALUE", - function (t, e, r) { - var n; - return ( - r && r.constructor && r.constructor.name - ? (n = "instance of ".concat(r.constructor.name)) - : (n = "type ".concat(MC(r))), - "Expected ".concat(t, ' to be returned from the "').concat(e, '"') + - " function but got ".concat(n, ".") - ); - }, - TypeError - ); - uj( - "ERR_MISSING_ARGS", - function () { - for (var t = arguments.length, e = new Array(t), r = 0; r < t; r++) - e[r] = arguments[r]; - TC === void 0 && (TC = Dr()), - TC(e.length > 0, "At least one arg needs to be specified"); - var n = "The ", - i = e.length; - switch ( - ((e = e.map(function (o) { - return '"'.concat(o, '"'); - })), - i) - ) { - case 1: - n += "".concat(e[0], " argument"); - break; - case 2: - n += "".concat(e[0], " and ").concat(e[1], " arguments"); - break; - default: - (n += e.slice(0, i - 1).join(", ")), - (n += ", and ".concat(e[i - 1], " arguments")); - break; - } - return "".concat(n, " must be specified"); - }, - TypeError - ); - yYe.exports.codes = pYe; - }); - var wYe = I((Zdn, bYe) => { - "use strict"; - m(); - g(); - function Mcr(t) { - for (var e = 1; e < arguments.length; e++) { - var r = arguments[e] != null ? arguments[e] : {}, - n = Object.keys(r); - typeof Object.getOwnPropertySymbols == "function" && - (n = n.concat( - Object.getOwnPropertySymbols(r).filter(function (i) { - return Object.getOwnPropertyDescriptor(r, i).enumerable; - }) - )), - n.forEach(function (i) { - Tcr(t, i, r[i]); - }); - } - return t; - } - function Tcr(t, e, r) { - return ( - e in t - ? Object.defineProperty(t, e, { - value: r, - enumerable: !0, - configurable: !0, - writable: !0, - }) - : (t[e] = r), - t - ); - } - function kcr(t, e) { - if (!(t instanceof e)) - throw new TypeError("Cannot call a class as a function"); - } - function mYe(t, e) { - for (var r = 0; r < e.length; r++) { - var n = e[r]; - (n.enumerable = n.enumerable || !1), - (n.configurable = !0), - "value" in n && (n.writable = !0), - Object.defineProperty(t, n.key, n); - } - } - function Pcr(t, e, r) { - return e && mYe(t.prototype, e), r && mYe(t, r), t; - } - function kC(t, e) { - return e && (by(e) === "object" || typeof e == "function") ? e : Hwe(t); - } - function Hwe(t) { - if (t === void 0) - throw new ReferenceError( - "this hasn't been initialised - super() hasn't been called" - ); - return t; - } - function Ocr(t, e) { - if (typeof e != "function" && e !== null) - throw new TypeError( - "Super expression must either be null or a function" - ); - (t.prototype = Object.create(e && e.prototype, { - constructor: { value: t, writable: !0, configurable: !0 }, - })), - e && dj(t, e); - } - function Vwe(t) { - var e = typeof Map == "function" ? new Map() : void 0; - return ( - (Vwe = function (n) { - if (n === null || !Icr(n)) return n; - if (typeof n != "function") - throw new TypeError( - "Super expression must either be null or a function" - ); - if (typeof e < "u") { - if (e.has(n)) return e.get(n); - e.set(n, i); - } - function i() { - return vQ(n, arguments, W2(this).constructor); - } - return ( - (i.prototype = Object.create(n.prototype, { - constructor: { - value: i, - enumerable: !1, - writable: !0, - configurable: !0, - }, - })), - dj(i, n) - ); - }), - Vwe(t) - ); - } - function Bcr() { - if (typeof Reflect > "u" || !Reflect.construct || Reflect.construct.sham) - return !1; - if (typeof Proxy == "function") return !0; - try { - return ( - Date.prototype.toString.call( - Reflect.construct(Date, [], function () {}) - ), - !0 - ); - } catch { - return !1; - } - } - function vQ(t, e, r) { - return ( - Bcr() - ? (vQ = Reflect.construct) - : (vQ = function (i, o, a) { - var s = [null]; - s.push.apply(s, o); - var c = Function.bind.apply(i, s), - u = new c(); - return a && dj(u, a.prototype), u; - }), - vQ.apply(null, arguments) - ); - } - function Icr(t) { - return Function.toString.call(t).indexOf("[native code]") !== -1; - } - function dj(t, e) { - return ( - (dj = - Object.setPrototypeOf || - function (n, i) { - return (n.__proto__ = i), n; - }), - dj(t, e) - ); - } - function W2(t) { - return ( - (W2 = Object.setPrototypeOf - ? Object.getPrototypeOf - : function (r) { - return r.__proto__ || Object.getPrototypeOf(r); - }), - W2(t) - ); - } - function by(t) { - return ( - typeof Symbol == "function" && typeof Symbol.iterator == "symbol" - ? (by = function (r) { - return typeof r; - }) - : (by = function (r) { - return r && - typeof Symbol == "function" && - r.constructor === Symbol && - r !== Symbol.prototype - ? "symbol" - : typeof r; - }), - by(t) - ); - } - var Ccr = es(), - Wwe = Ccr.inspect, - Rcr = Kwe(), - Ncr = Rcr.codes.ERR_INVALID_ARG_TYPE; - function gYe(t, e, r) { - return ( - (r === void 0 || r > t.length) && (r = t.length), - t.substring(r - e.length, r) === e - ); - } - function Dcr(t, e) { - if (((e = Math.floor(e)), t.length == 0 || e == 0)) return ""; - var r = t.length * e; - for (e = Math.floor(Math.log(e) / Math.log(2)); e; ) (t += t), e--; - return (t += t.substring(0, r - t.length)), t; - } - var Ym = "", - cj = "", - lj = "", - oc = "", - nT = { - deepStrictEqual: "Expected values to be strictly deep-equal:", - strictEqual: "Expected values to be strictly equal:", - strictEqualObject: - 'Expected "actual" to be reference-equal to "expected":', - deepEqual: "Expected values to be loosely deep-equal:", - equal: "Expected values to be loosely equal:", - notDeepStrictEqual: - 'Expected "actual" not to be strictly deep-equal to:', - notStrictEqual: 'Expected "actual" to be strictly unequal to:', - notStrictEqualObject: - 'Expected "actual" not to be reference-equal to "expected":', - notDeepEqual: 'Expected "actual" not to be loosely deep-equal to:', - notEqual: 'Expected "actual" to be loosely unequal to:', - notIdentical: "Values identical but not reference-equal:", - }, - Fcr = 10; - function vYe(t) { - var e = Object.keys(t), - r = Object.create(Object.getPrototypeOf(t)); - return ( - e.forEach(function (n) { - r[n] = t[n]; - }), - Object.defineProperty(r, "message", { value: t.message }), - r - ); - } - function fj(t) { - return Wwe(t, { - compact: !1, - customInspect: !1, - depth: 1e3, - maxArrayLength: 1 / 0, - showHidden: !1, - breakLength: 1 / 0, - showProxy: !1, - sorted: !0, - getters: !0, - }); - } - function Lcr(t, e, r) { - var n = "", - i = "", - o = 0, - a = "", - s = !1, - c = fj(t), - u = c.split(` -`), - h = fj(e).split(` -`), - w = 0, - M = ""; - if ( - (r === "strictEqual" && - by(t) === "object" && - by(e) === "object" && - t !== null && - e !== null && - (r = "strictEqualObject"), - u.length === 1 && h.length === 1 && u[0] !== h[0]) - ) { - var k = u[0].length + h[0].length; - if (k <= Fcr) { - if ( - (by(t) !== "object" || t === null) && - (by(e) !== "object" || e === null) && - (t !== 0 || e !== 0) - ) - return ( - "".concat( - nT[r], - ` - -` - ) + - "".concat(u[0], " !== ").concat( - h[0], - ` -` - ) - ); - } else if (r !== "strictEqualObject") { - var O = - process.stderr && process.stderr.isTTY - ? process.stderr.columns - : 80; - if (k < O) { - for (; u[0][w] === h[0][w]; ) w++; - w > 2 && - ((M = ` - `.concat(Dcr(" ", w), "^")), - (w = 0)); - } - } - } - for ( - var D = u[u.length - 1], F = h[h.length - 1]; - D === F && - (w++ < 2 - ? (a = ` - ` - .concat(D) - .concat(a)) - : (n = D), - u.pop(), - h.pop(), - !(u.length === 0 || h.length === 0)); - - ) - (D = u[u.length - 1]), (F = h[h.length - 1]); - var N = Math.max(u.length, h.length); - if (N === 0) { - var q = c.split(` -`); - if (q.length > 30) - for (q[26] = "".concat(Ym, "...").concat(oc); q.length > 27; ) - q.pop(); - return "" - .concat( - nT.notIdentical, - ` - -` - ) - .concat( - q.join(` -`), - ` -` - ); - } - w > 3 && - ((a = ` -` - .concat(Ym, "...") - .concat(oc) - .concat(a)), - (s = !0)), - n !== "" && - ((a = ` - ` - .concat(n) - .concat(a)), - (n = "")); - var z = 0, - H = - nT[r] + - ` -` - .concat(cj, "+ actual") - .concat(oc, " ") - .concat(lj, "- expected") - .concat(oc), - Z = " ".concat(Ym, "...").concat(oc, " Lines skipped"); - for (w = 0; w < N; w++) { - var $ = w - o; - if (u.length < w + 1) - $ > 1 && - w > 2 && - ($ > 4 - ? ((i += ` -` - .concat(Ym, "...") - .concat(oc)), - (s = !0)) - : $ > 3 && - ((i += ` - `.concat(h[w - 2])), - z++), - (i += ` - `.concat(h[w - 1])), - z++), - (o = w), - (n += ` -` - .concat(lj, "-") - .concat(oc, " ") - .concat(h[w])), - z++; - else if (h.length < w + 1) - $ > 1 && - w > 2 && - ($ > 4 - ? ((i += ` -` - .concat(Ym, "...") - .concat(oc)), - (s = !0)) - : $ > 3 && - ((i += ` - `.concat(u[w - 2])), - z++), - (i += ` - `.concat(u[w - 1])), - z++), - (o = w), - (i += ` -` - .concat(cj, "+") - .concat(oc, " ") - .concat(u[w])), - z++; - else { - var ue = h[w], - te = u[w], - ne = te !== ue && (!gYe(te, ",") || te.slice(0, -1) !== ue); - ne && - gYe(ue, ",") && - ue.slice(0, -1) === te && - ((ne = !1), (te += ",")), - ne - ? ($ > 1 && - w > 2 && - ($ > 4 - ? ((i += ` -` - .concat(Ym, "...") - .concat(oc)), - (s = !0)) - : $ > 3 && - ((i += ` - `.concat(u[w - 2])), - z++), - (i += ` - `.concat(u[w - 1])), - z++), - (o = w), - (i += ` -` - .concat(cj, "+") - .concat(oc, " ") - .concat(te)), - (n += ` -` - .concat(lj, "-") - .concat(oc, " ") - .concat(ue)), - (z += 2)) - : ((i += n), - (n = ""), - ($ === 1 || w === 0) && - ((i += ` - `.concat(te)), - z++)); - } - if (z > 20 && w < N - 2) - return ( - "" - .concat(H) - .concat( - Z, - ` -` - ) - .concat( - i, - ` -` - ) - .concat(Ym, "...") - .concat(oc) - .concat( - n, - ` -` - ) + "".concat(Ym, "...").concat(oc) - ); - } - return "" - .concat(H) - .concat( - s ? Z : "", - ` -` - ) - .concat(i) - .concat(n) - .concat(a) - .concat(M); - } - var qcr = (function (t) { - Ocr(e, t); - function e(r) { - var n; - if ((kcr(this, e), by(r) !== "object" || r === null)) - throw new Ncr("options", "Object", r); - var i = r.message, - o = r.operator, - a = r.stackStartFn, - s = r.actual, - c = r.expected, - u = Error.stackTraceLimit; - if (((Error.stackTraceLimit = 0), i != null)) - n = kC(this, W2(e).call(this, String(i))); - else if ( - (process.stderr && - process.stderr.isTTY && - (process.stderr && - process.stderr.getColorDepth && - process.stderr.getColorDepth() !== 1 - ? ((Ym = "\x1B[34m"), - (cj = "\x1B[32m"), - (oc = "\x1B[39m"), - (lj = "\x1B[31m")) - : ((Ym = ""), (cj = ""), (oc = ""), (lj = ""))), - by(s) === "object" && - s !== null && - by(c) === "object" && - c !== null && - "stack" in s && - s instanceof Error && - "stack" in c && - c instanceof Error && - ((s = vYe(s)), (c = vYe(c))), - o === "deepStrictEqual" || o === "strictEqual") - ) - n = kC(this, W2(e).call(this, Lcr(s, c, o))); - else if (o === "notDeepStrictEqual" || o === "notStrictEqual") { - var h = nT[o], - w = fj(s).split(` -`); - if ( - (o === "notStrictEqual" && - by(s) === "object" && - s !== null && - (h = nT.notStrictEqualObject), - w.length > 30) - ) - for (w[26] = "".concat(Ym, "...").concat(oc); w.length > 27; ) - w.pop(); - w.length === 1 - ? (n = kC(this, W2(e).call(this, "".concat(h, " ").concat(w[0])))) - : (n = kC( - this, - W2(e).call( - this, - "" - .concat( - h, - ` - -` - ) - .concat( - w.join(` -`), - ` -` - ) - ) - )); - } else { - var M = fj(s), - k = "", - O = nT[o]; - o === "notDeepEqual" || o === "notEqual" - ? ((M = "" - .concat( - nT[o], - ` - -` - ) - .concat(M)), - M.length > 1024 && (M = "".concat(M.slice(0, 1021), "..."))) - : ((k = "".concat(fj(c))), - M.length > 512 && (M = "".concat(M.slice(0, 509), "...")), - k.length > 512 && (k = "".concat(k.slice(0, 509), "...")), - o === "deepEqual" || o === "equal" - ? (M = "" - .concat( - O, - ` - -` - ) - .concat( - M, - ` - -should equal - -` - )) - : (k = " ".concat(o, " ").concat(k))), - (n = kC(this, W2(e).call(this, "".concat(M).concat(k)))); - } - return ( - (Error.stackTraceLimit = u), - (n.generatedMessage = !i), - Object.defineProperty(Hwe(n), "name", { - value: "AssertionError [ERR_ASSERTION]", - enumerable: !1, - writable: !0, - configurable: !0, - }), - (n.code = "ERR_ASSERTION"), - (n.actual = s), - (n.expected = c), - (n.operator = o), - Error.captureStackTrace && Error.captureStackTrace(Hwe(n), a), - n.stack, - (n.name = "AssertionError"), - kC(n) - ); - } - return ( - Pcr(e, [ - { - key: "toString", - value: function () { - return "" - .concat(this.name, " [") - .concat(this.code, "]: ") - .concat(this.message); - }, - }, - { - key: Wwe.custom, - value: function (n, i) { - return Wwe(this, Mcr({}, i, { customInspect: !1, depth: 0 })); - }, - }, - ]), - e - ); - })(Vwe(Error)); - bYe.exports = qcr; - }); - var SYe = I((Xdn, xYe) => { - "use strict"; - m(); - g(); - function _Ye(t, e) { - if (t == null) - throw new TypeError("Cannot convert first argument to object"); - for (var r = Object(t), n = 1; n < arguments.length; n++) { - var i = arguments[n]; - if (i != null) - for ( - var o = Object.keys(Object(i)), a = 0, s = o.length; - a < s; - a++ - ) { - var c = o[a], - u = Object.getOwnPropertyDescriptor(i, c); - u !== void 0 && u.enumerable && (r[c] = i[c]); - } - } - return r; - } - function zcr() { - Object.assign || - Object.defineProperty(Object, "assign", { - enumerable: !1, - configurable: !0, - writable: !0, - value: _Ye, - }); - } - xYe.exports = { assign: _Ye, polyfill: zcr }; - }); - var Gwe = I((Ydn, EYe) => { - "use strict"; - m(); - g(); - var AYe = Object.prototype.toString; - EYe.exports = function (e) { - var r = AYe.call(e), - n = r === "[object Arguments]"; - return ( - n || - (n = - r !== "[object Array]" && - e !== null && - typeof e == "object" && - typeof e.length == "number" && - e.length >= 0 && - AYe.call(e.callee) === "[object Function]"), - n - ); - }; - }); - var RYe = I((Qdn, CYe) => { - "use strict"; - m(); - g(); - var IYe; - Object.keys || - ((hj = Object.prototype.hasOwnProperty), - (Jwe = Object.prototype.toString), - (MYe = Gwe()), - ($we = Object.prototype.propertyIsEnumerable), - (TYe = !$we.call({ toString: null }, "toString")), - (kYe = $we.call(function () {}, "prototype")), - (pj = [ - "toString", - "toLocaleString", - "valueOf", - "hasOwnProperty", - "isPrototypeOf", - "propertyIsEnumerable", - "constructor", - ]), - (bQ = function (t) { - var e = t.constructor; - return e && e.prototype === t; - }), - (PYe = { - $applicationCache: !0, - $console: !0, - $external: !0, - $frame: !0, - $frameElement: !0, - $frames: !0, - $innerHeight: !0, - $innerWidth: !0, - $onmozfullscreenchange: !0, - $onmozfullscreenerror: !0, - $outerHeight: !0, - $outerWidth: !0, - $pageXOffset: !0, - $pageYOffset: !0, - $parent: !0, - $scrollLeft: !0, - $scrollTop: !0, - $scrollX: !0, - $scrollY: !0, - $self: !0, - $webkitIndexedDB: !0, - $webkitStorageInfo: !0, - $window: !0, - }), - (OYe = (function () { - if (typeof window > "u") return !1; - for (var t in window) - try { - if ( - !PYe["$" + t] && - hj.call(window, t) && - window[t] !== null && - typeof window[t] == "object" - ) - try { - bQ(window[t]); - } catch { - return !0; - } - } catch { - return !0; - } - return !1; - })()), - (BYe = function (t) { - if (typeof window > "u" || !OYe) return bQ(t); - try { - return bQ(t); - } catch { - return !1; - } - }), - (IYe = function (e) { - var r = e !== null && typeof e == "object", - n = Jwe.call(e) === "[object Function]", - i = MYe(e), - o = r && Jwe.call(e) === "[object String]", - a = []; - if (!r && !n && !i) - throw new TypeError("Object.keys called on a non-object"); - var s = kYe && n; - if (o && e.length > 0 && !hj.call(e, 0)) - for (var c = 0; c < e.length; ++c) a.push(String(c)); - if (i && e.length > 0) - for (var u = 0; u < e.length; ++u) a.push(String(u)); - else - for (var h in e) - !(s && h === "prototype") && hj.call(e, h) && a.push(String(h)); - if (TYe) - for (var w = BYe(e), M = 0; M < pj.length; ++M) - !(w && pj[M] === "constructor") && - hj.call(e, pj[M]) && - a.push(pj[M]); - return a; - })); - var hj, Jwe, MYe, $we, TYe, kYe, pj, bQ, PYe, OYe, BYe; - CYe.exports = IYe; - }); - var LYe = I((ehn, FYe) => { - "use strict"; - m(); - g(); - var jcr = Array.prototype.slice, - Ucr = Gwe(), - NYe = Object.keys, - wQ = NYe - ? function (e) { - return NYe(e); - } - : RYe(), - DYe = Object.keys; - wQ.shim = function () { - if (Object.keys) { - var e = (function () { - var r = Object.keys(arguments); - return r && r.length === arguments.length; - })(1, 2); - e || - (Object.keys = function (n) { - return Ucr(n) ? DYe(jcr.call(n)) : DYe(n); - }); - } else Object.keys = wQ; - return Object.keys || wQ; - }; - FYe.exports = wQ; - }); - var zYe = I((thn, qYe) => { - "use strict"; - m(); - g(); - var Kcr = nq(), - Zwe = Kcr("%Object.defineProperty%", !0), - Xwe = function () { - if (Zwe) - try { - return Zwe({}, "a", { value: 1 }), !0; - } catch { - return !1; - } - return !1; - }; - Xwe.hasArrayLengthDefineBug = function () { - if (!Xwe()) return null; - try { - return Zwe([], "length", { value: 1 }).length !== 1; - } catch { - return !0; - } - }; - qYe.exports = Xwe; - }); - var yj = I((rhn, HYe) => { - "use strict"; - m(); - g(); - var Hcr = LYe(), - Vcr = typeof Symbol == "function" && typeof Symbol("foo") == "symbol", - Wcr = Object.prototype.toString, - Gcr = Array.prototype.concat, - jYe = Object.defineProperty, - Jcr = function (t) { - return typeof t == "function" && Wcr.call(t) === "[object Function]"; - }, - $cr = zYe()(), - UYe = jYe && $cr, - Zcr = function (t, e, r, n) { - (e in t && (!Jcr(n) || !n())) || - (UYe - ? jYe(t, e, { - configurable: !0, - enumerable: !1, - value: r, - writable: !0, - }) - : (t[e] = r)); - }, - KYe = function (t, e) { - var r = arguments.length > 2 ? arguments[2] : {}, - n = Hcr(e); - Vcr && (n = Gcr.call(n, Object.getOwnPropertySymbols(e))); - for (var i = 0; i < n.length; i += 1) Zcr(t, n[i], e[n[i]], r[n[i]]); - }; - KYe.supportsDescriptors = !!UYe; - HYe.exports = KYe; - }); - var Ywe = I((nhn, WYe) => { - "use strict"; - m(); - g(); - var VYe = function (t) { - return t !== t; - }; - WYe.exports = function (e, r) { - return e === 0 && r === 0 - ? 1 / e === 1 / r - : !!(e === r || (VYe(e) && VYe(r))); - }; - }); - var Qwe = I((ihn, GYe) => { - "use strict"; - m(); - g(); - var Xcr = Ywe(); - GYe.exports = function () { - return typeof Object.is == "function" ? Object.is : Xcr; - }; - }); - var $Ye = I((ohn, JYe) => { - "use strict"; - m(); - g(); - var Ycr = Qwe(), - Qcr = yj(); - JYe.exports = function () { - var e = Ycr(); - return ( - Qcr( - Object, - { is: e }, - { - is: function () { - return Object.is !== e; - }, - } - ), - e - ); - }; - }); - var e_e = I((ahn, YYe) => { - "use strict"; - m(); - g(); - var elr = yj(), - tlr = j$(), - rlr = Ywe(), - ZYe = Qwe(), - nlr = $Ye(), - XYe = tlr(ZYe(), Object); - elr(XYe, { getPolyfill: ZYe, implementation: rlr, shim: nlr }); - YYe.exports = XYe; - }); - var t_e = I((shn, QYe) => { - "use strict"; - m(); - g(); - QYe.exports = function (e) { - return e !== e; - }; - }); - var r_e = I((uhn, eQe) => { - "use strict"; - m(); - g(); - var ilr = t_e(); - eQe.exports = function () { - return Number.isNaN && Number.isNaN(NaN) && !Number.isNaN("a") - ? Number.isNaN - : ilr; - }; - }); - var rQe = I((chn, tQe) => { - "use strict"; - m(); - g(); - var olr = yj(), - alr = r_e(); - tQe.exports = function () { - var e = alr(); - return ( - olr( - Number, - { isNaN: e }, - { - isNaN: function () { - return Number.isNaN !== e; - }, - } - ), - e - ); - }; - }); - var aQe = I((lhn, oQe) => { - "use strict"; - m(); - g(); - var slr = j$(), - ulr = yj(), - clr = t_e(), - nQe = r_e(), - llr = rQe(), - iQe = slr(nQe(), Number); - ulr(iQe, { getPolyfill: nQe, implementation: clr, shim: llr }); - oQe.exports = iQe; - }); - var EQe = I((fhn, AQe) => { - "use strict"; - m(); - g(); - function sQe(t, e) { - return hlr(t) || dlr(t, e) || flr(); - } - function flr() { - throw new TypeError( - "Invalid attempt to destructure non-iterable instance" - ); - } - function dlr(t, e) { - var r = [], - n = !0, - i = !1, - o = void 0; - try { - for ( - var a = t[Symbol.iterator](), s; - !(n = (s = a.next()).done) && - (r.push(s.value), !(e && r.length === e)); - n = !0 - ); - } catch (c) { - (i = !0), (o = c); - } finally { - try { - !n && a.return != null && a.return(); - } finally { - if (i) throw o; - } - } - return r; - } - function hlr(t) { - if (Array.isArray(t)) return t; - } - function Kp(t) { - return ( - typeof Symbol == "function" && typeof Symbol.iterator == "symbol" - ? (Kp = function (r) { - return typeof r; - }) - : (Kp = function (r) { - return r && - typeof Symbol == "function" && - r.constructor === Symbol && - r !== Symbol.prototype - ? "symbol" - : typeof r; - }), - Kp(t) - ); - } - var plr = /a/g.flags !== void 0, - TQ = function (e) { - var r = []; - return ( - e.forEach(function (n) { - return r.push(n); - }), - r - ); - }, - uQe = function (e) { - var r = []; - return ( - e.forEach(function (n, i) { - return r.push([i, n]); - }), - r - ); - }, - bQe = Object.is ? Object.is : e_e(), - EQ = Object.getOwnPropertySymbols - ? Object.getOwnPropertySymbols - : function () { - return []; - }, - n_e = Number.isNaN ? Number.isNaN : aQe(); - function o_e(t) { - return t.call.bind(t); - } - var gj = o_e(Object.prototype.hasOwnProperty), - MQ = o_e(Object.prototype.propertyIsEnumerable), - cQe = o_e(Object.prototype.toString), - Hd = es().types, - ylr = Hd.isAnyArrayBuffer, - mlr = Hd.isArrayBufferView, - lQe = Hd.isDate, - _Q = Hd.isMap, - fQe = Hd.isRegExp, - xQ = Hd.isSet, - glr = Hd.isNativeError, - vlr = Hd.isBoxedPrimitive, - dQe = Hd.isNumberObject, - hQe = Hd.isStringObject, - pQe = Hd.isBooleanObject, - yQe = Hd.isBigIntObject, - blr = Hd.isSymbolObject, - wlr = Hd.isFloat32Array, - _lr = Hd.isFloat64Array; - function xlr(t) { - if (t.length === 0 || t.length > 10) return !0; - for (var e = 0; e < t.length; e++) { - var r = t.charCodeAt(e); - if (r < 48 || r > 57) return !0; - } - return t.length === 10 && t >= Math.pow(2, 32); - } - function SQ(t) { - return Object.keys(t) - .filter(xlr) - .concat(EQ(t).filter(Object.prototype.propertyIsEnumerable.bind(t))); - } - function wQe(t, e) { - if (t === e) return 0; - for ( - var r = t.length, n = e.length, i = 0, o = Math.min(r, n); - i < o; - ++i - ) - if (t[i] !== e[i]) { - (r = t[i]), (n = e[i]); - break; - } - return r < n ? -1 : n < r ? 1 : 0; - } - var AQ = void 0, - Slr = !0, - Alr = !1, - i_e = 0, - a_e = 1, - _Qe = 2, - xQe = 3; - function Elr(t, e) { - return plr - ? t.source === e.source && t.flags === e.flags - : RegExp.prototype.toString.call(t) === - RegExp.prototype.toString.call(e); - } - function Mlr(t, e) { - if (t.byteLength !== e.byteLength) return !1; - for (var r = 0; r < t.byteLength; r++) if (t[r] !== e[r]) return !1; - return !0; - } - function Tlr(t, e) { - return t.byteLength !== e.byteLength - ? !1 - : wQe( - new Uint8Array(t.buffer, t.byteOffset, t.byteLength), - new Uint8Array(e.buffer, e.byteOffset, e.byteLength) - ) === 0; - } - function klr(t, e) { - return ( - t.byteLength === e.byteLength && - wQe(new Uint8Array(t), new Uint8Array(e)) === 0 - ); - } - function Plr(t, e) { - return dQe(t) - ? dQe(e) && - bQe( - Number.prototype.valueOf.call(t), - Number.prototype.valueOf.call(e) - ) - : hQe(t) - ? hQe(e) && - String.prototype.valueOf.call(t) === String.prototype.valueOf.call(e) - : pQe(t) - ? pQe(e) && - Boolean.prototype.valueOf.call(t) === - Boolean.prototype.valueOf.call(e) - : yQe(t) - ? yQe(e) && - BigInt.prototype.valueOf.call(t) === BigInt.prototype.valueOf.call(e) - : blr(e) && - Symbol.prototype.valueOf.call(t) === Symbol.prototype.valueOf.call(e); - } - function wy(t, e, r, n) { - if (t === e) return t !== 0 ? !0 : r ? bQe(t, e) : !0; - if (r) { - if (Kp(t) !== "object") return typeof t == "number" && n_e(t) && n_e(e); - if ( - Kp(e) !== "object" || - t === null || - e === null || - Object.getPrototypeOf(t) !== Object.getPrototypeOf(e) - ) - return !1; - } else { - if (t === null || Kp(t) !== "object") - return e === null || Kp(e) !== "object" ? t == e : !1; - if (e === null || Kp(e) !== "object") return !1; - } - var i = cQe(t), - o = cQe(e); - if (i !== o) return !1; - if (Array.isArray(t)) { - if (t.length !== e.length) return !1; - var a = SQ(t, AQ), - s = SQ(e, AQ); - return a.length !== s.length ? !1 : mj(t, e, r, n, a_e, a); - } - if (i === "[object Object]" && ((!_Q(t) && _Q(e)) || (!xQ(t) && xQ(e)))) - return !1; - if (lQe(t)) { - if ( - !lQe(e) || - Date.prototype.getTime.call(t) !== Date.prototype.getTime.call(e) - ) - return !1; - } else if (fQe(t)) { - if (!fQe(e) || !Elr(t, e)) return !1; - } else if (glr(t) || t instanceof Error) { - if (t.message !== e.message || t.name !== e.name) return !1; - } else if (mlr(t)) { - if (!r && (wlr(t) || _lr(t))) { - if (!Mlr(t, e)) return !1; - } else if (!Tlr(t, e)) return !1; - var c = SQ(t, AQ), - u = SQ(e, AQ); - return c.length !== u.length ? !1 : mj(t, e, r, n, i_e, c); - } else { - if (xQ(t)) - return !xQ(e) || t.size !== e.size ? !1 : mj(t, e, r, n, _Qe); - if (_Q(t)) - return !_Q(e) || t.size !== e.size ? !1 : mj(t, e, r, n, xQe); - if (ylr(t)) { - if (!klr(t, e)) return !1; - } else if (vlr(t) && !Plr(t, e)) return !1; - } - return mj(t, e, r, n, i_e); - } - function mQe(t, e) { - return e.filter(function (r) { - return MQ(t, r); - }); - } - function mj(t, e, r, n, i, o) { - if (arguments.length === 5) { - o = Object.keys(t); - var a = Object.keys(e); - if (o.length !== a.length) return !1; - } - for (var s = 0; s < o.length; s++) if (!gj(e, o[s])) return !1; - if (r && arguments.length === 5) { - var c = EQ(t); - if (c.length !== 0) { - var u = 0; - for (s = 0; s < c.length; s++) { - var h = c[s]; - if (MQ(t, h)) { - if (!MQ(e, h)) return !1; - o.push(h), u++; - } else if (MQ(e, h)) return !1; - } - var w = EQ(e); - if (c.length !== w.length && mQe(e, w).length !== u) return !1; - } else { - var M = EQ(e); - if (M.length !== 0 && mQe(e, M).length !== 0) return !1; - } - } - if ( - o.length === 0 && - (i === i_e || (i === a_e && t.length === 0) || t.size === 0) - ) - return !0; - if (n === void 0) n = { val1: new Map(), val2: new Map(), position: 0 }; - else { - var k = n.val1.get(t); - if (k !== void 0) { - var O = n.val2.get(e); - if (O !== void 0) return k === O; - } - n.position++; - } - n.val1.set(t, n.position), n.val2.set(e, n.position); - var D = Rlr(t, e, r, o, n, i); - return n.val1.delete(t), n.val2.delete(e), D; - } - function gQe(t, e, r, n) { - for (var i = TQ(t), o = 0; o < i.length; o++) { - var a = i[o]; - if (wy(e, a, r, n)) return t.delete(a), !0; - } - return !1; - } - function SQe(t) { - switch (Kp(t)) { - case "undefined": - return null; - case "object": - return; - case "symbol": - return !1; - case "string": - t = +t; - case "number": - if (n_e(t)) return !1; - } - return !0; - } - function Olr(t, e, r) { - var n = SQe(r); - return n ?? (e.has(n) && !t.has(n)); - } - function Blr(t, e, r, n, i) { - var o = SQe(r); - if (o != null) return o; - var a = e.get(o); - return (a === void 0 && !e.has(o)) || !wy(n, a, !1, i) - ? !1 - : !t.has(o) && wy(n, a, !1, i); - } - function Ilr(t, e, r, n) { - for (var i = null, o = TQ(t), a = 0; a < o.length; a++) { - var s = o[a]; - if (Kp(s) === "object" && s !== null) - i === null && (i = new Set()), i.add(s); - else if (!e.has(s)) { - if (r || !Olr(t, e, s)) return !1; - i === null && (i = new Set()), i.add(s); - } - } - if (i !== null) { - for (var c = TQ(e), u = 0; u < c.length; u++) { - var h = c[u]; - if (Kp(h) === "object" && h !== null) { - if (!gQe(i, h, r, n)) return !1; - } else if (!r && !t.has(h) && !gQe(i, h, r, n)) return !1; - } - return i.size === 0; - } - return !0; - } - function vQe(t, e, r, n, i, o) { - for (var a = TQ(t), s = 0; s < a.length; s++) { - var c = a[s]; - if (wy(r, c, i, o) && wy(n, e.get(c), i, o)) return t.delete(c), !0; - } - return !1; - } - function Clr(t, e, r, n) { - for (var i = null, o = uQe(t), a = 0; a < o.length; a++) { - var s = sQe(o[a], 2), - c = s[0], - u = s[1]; - if (Kp(c) === "object" && c !== null) - i === null && (i = new Set()), i.add(c); - else { - var h = e.get(c); - if ((h === void 0 && !e.has(c)) || !wy(u, h, r, n)) { - if (r || !Blr(t, e, c, u, n)) return !1; - i === null && (i = new Set()), i.add(c); - } - } - } - if (i !== null) { - for (var w = uQe(e), M = 0; M < w.length; M++) { - var k = sQe(w[M], 2), - c = k[0], - O = k[1]; - if (Kp(c) === "object" && c !== null) { - if (!vQe(i, t, c, O, r, n)) return !1; - } else if ( - !r && - (!t.has(c) || !wy(t.get(c), O, !1, n)) && - !vQe(i, t, c, O, !1, n) - ) - return !1; - } - return i.size === 0; - } - return !0; - } - function Rlr(t, e, r, n, i, o) { - var a = 0; - if (o === _Qe) { - if (!Ilr(t, e, r, i)) return !1; - } else if (o === xQe) { - if (!Clr(t, e, r, i)) return !1; - } else if (o === a_e) - for (; a < t.length; a++) - if (gj(t, a)) { - if (!gj(e, a) || !wy(t[a], e[a], r, i)) return !1; - } else { - if (gj(e, a)) return !1; - for (var s = Object.keys(t); a < s.length; a++) { - var c = s[a]; - if (!gj(e, c) || !wy(t[c], e[c], r, i)) return !1; - } - return s.length === Object.keys(e).length; - } - for (a = 0; a < n.length; a++) { - var u = n[a]; - if (!wy(t[u], e[u], r, i)) return !1; - } - return !0; - } - function Nlr(t, e) { - return wy(t, e, Alr); - } - function Dlr(t, e) { - return wy(t, e, Slr); - } - AQe.exports = { isDeepEqual: Nlr, isDeepStrictEqual: Dlr }; - }); - var Dr = I((dhn, jQe) => { - "use strict"; - m(); - g(); - function G2(t) { - return ( - typeof Symbol == "function" && typeof Symbol.iterator == "symbol" - ? (G2 = function (r) { - return typeof r; - }) - : (G2 = function (r) { - return r && - typeof Symbol == "function" && - r.constructor === Symbol && - r !== Symbol.prototype - ? "symbol" - : typeof r; - }), - G2(t) - ); - } - function Flr(t, e) { - if (!(t instanceof e)) - throw new TypeError("Cannot call a class as a function"); - } - var Llr = Kwe(), - bj = Llr.codes, - MQe = bj.ERR_AMBIGUOUS_ARGUMENT, - vj = bj.ERR_INVALID_ARG_TYPE, - qlr = bj.ERR_INVALID_ARG_VALUE, - zlr = bj.ERR_INVALID_RETURN_VALUE, - $2 = bj.ERR_MISSING_ARGS, - iT = wYe(), - jlr = es(), - Ulr = jlr.inspect, - OQe = es().types, - Klr = OQe.isPromise, - s_e = OQe.isRegExp, - Hlr = Object.assign ? Object.assign : SYe().assign, - BQe = Object.is ? Object.is : e_e(), - J2, - kQ; - function wj() { - var t = EQe(); - (J2 = t.isDeepEqual), (kQ = t.isDeepStrictEqual); - } - var TQe = !1, - oa = (jQe.exports = u_e), - PQ = {}; - function Qm(t) { - throw t.message instanceof Error ? t.message : new iT(t); - } - function IQe(t, e, r, n, i) { - var o = arguments.length, - a; - if (o === 0) a = "Failed"; - else if (o === 1) (r = t), (t = void 0); - else { - if (TQe === !1) { - TQe = !0; - var s = process.emitWarning - ? process.emitWarning - : console.warn.bind(console); - s( - "assert.fail() with more than one argument is deprecated. Please use assert.strictEqual() instead or only pass a message.", - "DeprecationWarning", - "DEP0094" - ); - } - o === 2 && (n = "!="); - } - if (r instanceof Error) throw r; - var c = { - actual: t, - expected: e, - operator: n === void 0 ? "fail" : n, - stackStartFn: i || IQe, - }; - r !== void 0 && (c.message = r); - var u = new iT(c); - throw (a && ((u.message = a), (u.generatedMessage = !0)), u); - } - oa.fail = IQe; - oa.AssertionError = iT; - function CQe(t, e, r, n) { - if (!r) { - var i = !1; - if (e === 0) - (i = !0), (n = "No value argument passed to `assert.ok()`"); - else if (n instanceof Error) throw n; - var o = new iT({ - actual: r, - expected: !0, - message: n, - operator: "==", - stackStartFn: t, - }); - throw ((o.generatedMessage = i), o); - } - } - function u_e() { - for (var t = arguments.length, e = new Array(t), r = 0; r < t; r++) - e[r] = arguments[r]; - CQe.apply(void 0, [u_e, e.length].concat(e)); - } - oa.ok = u_e; - oa.equal = function t(e, r, n) { - if (arguments.length < 2) throw new $2("actual", "expected"); - e != r && - Qm({ - actual: e, - expected: r, - message: n, - operator: "==", - stackStartFn: t, - }); - }; - oa.notEqual = function t(e, r, n) { - if (arguments.length < 2) throw new $2("actual", "expected"); - e == r && - Qm({ - actual: e, - expected: r, - message: n, - operator: "!=", - stackStartFn: t, - }); - }; - oa.deepEqual = function t(e, r, n) { - if (arguments.length < 2) throw new $2("actual", "expected"); - J2 === void 0 && wj(), - J2(e, r) || - Qm({ - actual: e, - expected: r, - message: n, - operator: "deepEqual", - stackStartFn: t, - }); - }; - oa.notDeepEqual = function t(e, r, n) { - if (arguments.length < 2) throw new $2("actual", "expected"); - J2 === void 0 && wj(), - J2(e, r) && - Qm({ - actual: e, - expected: r, - message: n, - operator: "notDeepEqual", - stackStartFn: t, - }); - }; - oa.deepStrictEqual = function t(e, r, n) { - if (arguments.length < 2) throw new $2("actual", "expected"); - J2 === void 0 && wj(), - kQ(e, r) || - Qm({ - actual: e, - expected: r, - message: n, - operator: "deepStrictEqual", - stackStartFn: t, - }); - }; - oa.notDeepStrictEqual = RQe; - function RQe(t, e, r) { - if (arguments.length < 2) throw new $2("actual", "expected"); - J2 === void 0 && wj(), - kQ(t, e) && - Qm({ - actual: t, - expected: e, - message: r, - operator: "notDeepStrictEqual", - stackStartFn: RQe, - }); - } - oa.strictEqual = function t(e, r, n) { - if (arguments.length < 2) throw new $2("actual", "expected"); - BQe(e, r) || - Qm({ - actual: e, - expected: r, - message: n, - operator: "strictEqual", - stackStartFn: t, - }); - }; - oa.notStrictEqual = function t(e, r, n) { - if (arguments.length < 2) throw new $2("actual", "expected"); - BQe(e, r) && - Qm({ - actual: e, - expected: r, - message: n, - operator: "notStrictEqual", - stackStartFn: t, - }); - }; - var kQe = function t(e, r, n) { - var i = this; - Flr(this, t), - r.forEach(function (o) { - o in e && - (n !== void 0 && - typeof n[o] == "string" && - s_e(e[o]) && - e[o].test(n[o]) - ? (i[o] = n[o]) - : (i[o] = e[o])); - }); - }; - function Vlr(t, e, r, n, i, o) { - if (!(r in t) || !kQ(t[r], e[r])) { - if (!n) { - var a = new kQe(t, i), - s = new kQe(e, i, t), - c = new iT({ - actual: a, - expected: s, - operator: "deepStrictEqual", - stackStartFn: o, - }); - throw ((c.actual = t), (c.expected = e), (c.operator = o.name), c); - } - Qm({ - actual: t, - expected: e, - message: n, - operator: o.name, - stackStartFn: o, - }); - } - } - function NQe(t, e, r, n) { - if (typeof e != "function") { - if (s_e(e)) return e.test(t); - if (arguments.length === 2) - throw new vj("expected", ["Function", "RegExp"], e); - if (G2(t) !== "object" || t === null) { - var i = new iT({ - actual: t, - expected: e, - message: r, - operator: "deepStrictEqual", - stackStartFn: n, - }); - throw ((i.operator = n.name), i); - } - var o = Object.keys(e); - if (e instanceof Error) o.push("name", "message"); - else if (o.length === 0) - throw new qlr("error", e, "may not be an empty object"); - return ( - J2 === void 0 && wj(), - o.forEach(function (a) { - (typeof t[a] == "string" && s_e(e[a]) && e[a].test(t[a])) || - Vlr(t, e, a, r, o, n); - }), - !0 - ); - } - return e.prototype !== void 0 && t instanceof e - ? !0 - : Error.isPrototypeOf(e) - ? !1 - : e.call({}, t) === !0; - } - function DQe(t) { - if (typeof t != "function") throw new vj("fn", "Function", t); - try { - t(); - } catch (e) { - return e; - } - return PQ; - } - function PQe(t) { - return ( - Klr(t) || - (t !== null && - G2(t) === "object" && - typeof t.then == "function" && - typeof t.catch == "function") - ); - } - function FQe(t) { - return Promise.resolve().then(function () { - var e; - if (typeof t == "function") { - if (((e = t()), !PQe(e))) - throw new zlr("instance of Promise", "promiseFn", e); - } else if (PQe(t)) e = t; - else throw new vj("promiseFn", ["Function", "Promise"], t); - return Promise.resolve() - .then(function () { - return e; - }) - .then(function () { - return PQ; - }) - .catch(function (r) { - return r; - }); - }); - } - function LQe(t, e, r, n) { - if (typeof r == "string") { - if (arguments.length === 4) - throw new vj("error", ["Object", "Error", "Function", "RegExp"], r); - if (G2(e) === "object" && e !== null) { - if (e.message === r) - throw new MQe( - "error/message", - 'The error message "'.concat( - e.message, - '" is identical to the message.' - ) - ); - } else if (e === r) - throw new MQe( - "error/message", - 'The error "'.concat(e, '" is identical to the message.') - ); - (n = r), (r = void 0); - } else if (r != null && G2(r) !== "object" && typeof r != "function") - throw new vj("error", ["Object", "Error", "Function", "RegExp"], r); - if (e === PQ) { - var i = ""; - r && r.name && (i += " (".concat(r.name, ")")), - (i += n ? ": ".concat(n) : "."); - var o = t.name === "rejects" ? "rejection" : "exception"; - Qm({ - actual: void 0, - expected: r, - operator: t.name, - message: "Missing expected ".concat(o).concat(i), - stackStartFn: t, - }); - } - if (r && !NQe(e, r, n, t)) throw e; - } - function qQe(t, e, r, n) { - if (e !== PQ) { - if ( - (typeof r == "string" && ((n = r), (r = void 0)), !r || NQe(e, r)) - ) { - var i = n ? ": ".concat(n) : ".", - o = t.name === "doesNotReject" ? "rejection" : "exception"; - Qm({ - actual: e, - expected: r, - operator: t.name, - message: - "Got unwanted ".concat(o).concat( - i, - ` -` - ) + 'Actual message: "'.concat(e && e.message, '"'), - stackStartFn: t, - }); - } - throw e; - } - } - oa.throws = function t(e) { - for ( - var r = arguments.length, n = new Array(r > 1 ? r - 1 : 0), i = 1; - i < r; - i++ - ) - n[i - 1] = arguments[i]; - LQe.apply(void 0, [t, DQe(e)].concat(n)); - }; - oa.rejects = function t(e) { - for ( - var r = arguments.length, n = new Array(r > 1 ? r - 1 : 0), i = 1; - i < r; - i++ - ) - n[i - 1] = arguments[i]; - return FQe(e).then(function (o) { - return LQe.apply(void 0, [t, o].concat(n)); - }); - }; - oa.doesNotThrow = function t(e) { - for ( - var r = arguments.length, n = new Array(r > 1 ? r - 1 : 0), i = 1; - i < r; - i++ - ) - n[i - 1] = arguments[i]; - qQe.apply(void 0, [t, DQe(e)].concat(n)); - }; - oa.doesNotReject = function t(e) { - for ( - var r = arguments.length, n = new Array(r > 1 ? r - 1 : 0), i = 1; - i < r; - i++ - ) - n[i - 1] = arguments[i]; - return FQe(e).then(function (o) { - return qQe.apply(void 0, [t, o].concat(n)); - }); - }; - oa.ifError = function t(e) { - if (e != null) { - var r = "ifError got unwanted exception: "; - G2(e) === "object" && typeof e.message == "string" - ? e.message.length === 0 && e.constructor - ? (r += e.constructor.name) - : (r += e.message) - : (r += Ulr(e)); - var n = new iT({ - actual: e, - expected: null, - operator: "ifError", - message: r, - stackStartFn: t, - }), - i = e.stack; - if (typeof i == "string") { - var o = i.split(` -`); - o.shift(); - for ( - var a = n.stack.split(` -`), - s = 0; - s < o.length; - s++ - ) { - var c = a.indexOf(o[s]); - if (c !== -1) { - a = a.slice(0, c); - break; - } - } - n.stack = "" - .concat( - a.join(` -`), - ` -` - ) - .concat( - o.join(` -`) - ); - } - throw n; - } - }; - function zQe() { - for (var t = arguments.length, e = new Array(t), r = 0; r < t; r++) - e[r] = arguments[r]; - CQe.apply(void 0, [zQe, e.length].concat(e)); - } - oa.strict = Hlr(zQe, oa, { - equal: oa.strictEqual, - deepEqual: oa.deepStrictEqual, - notEqual: oa.notStrictEqual, - notDeepEqual: oa.notDeepStrictEqual, - }); - oa.strict.strict = oa.strict; - }); - var Det = I((LC, Net) => { - "use strict"; - m(); - g(); - var Zfr = function () { - if (typeof self < "u") return self; - if (typeof window < "u") return window; - if (typeof ix < "u") return ix; - throw new Error("unable to locate global object"); - }, - ix = Zfr(); - Net.exports = LC = ix.fetch; - ix.fetch && (LC.default = ix.fetch.bind(ix)); - LC.Headers = ix.Headers; - LC.Request = ix.Request; - LC.Response = ix.Response; - }); - var Let = I((jhn, Fet) => { - "use strict"; - m(); - g(); - function mee() { - (this._types = Object.create(null)), - (this._extensions = Object.create(null)); - for (let t = 0; t < arguments.length; t++) this.define(arguments[t]); - (this.define = this.define.bind(this)), - (this.getType = this.getType.bind(this)), - (this.getExtension = this.getExtension.bind(this)); - } - mee.prototype.define = function (t, e) { - for (let r in t) { - let n = t[r].map(function (i) { - return i.toLowerCase(); - }); - r = r.toLowerCase(); - for (let i = 0; i < n.length; i++) { - let o = n[i]; - if (o[0] !== "*") { - if (!e && o in this._types) - throw new Error( - 'Attempt to change mapping for "' + - o + - '" extension from "' + - this._types[o] + - '" to "' + - r + - '". Pass `force=true` to allow this, otherwise remove "' + - o + - '" from the list of extensions for "' + - r + - '".' - ); - this._types[o] = r; - } - } - if (e || !this._extensions[r]) { - let i = n[0]; - this._extensions[r] = i[0] !== "*" ? i : i.substr(1); - } - } - }; - mee.prototype.getType = function (t) { - t = String(t); - let e = t.replace(/^.*[/\\]/, "").toLowerCase(), - r = e.replace(/^.*\./, "").toLowerCase(), - n = e.length < t.length; - return ((r.length < e.length - 1 || !n) && this._types[r]) || null; - }; - mee.prototype.getExtension = function (t) { - return ( - (t = /^\s*([^;\s]*)/.test(t) && RegExp.$1), - (t && this._extensions[t.toLowerCase()]) || null - ); - }; - Fet.exports = mee; - }); - var zet = I((Uhn, qet) => { - m(); - g(); - qet.exports = { - "application/andrew-inset": ["ez"], - "application/applixware": ["aw"], - "application/atom+xml": ["atom"], - "application/atomcat+xml": ["atomcat"], - "application/atomdeleted+xml": ["atomdeleted"], - "application/atomsvc+xml": ["atomsvc"], - "application/atsc-dwd+xml": ["dwd"], - "application/atsc-held+xml": ["held"], - "application/atsc-rsat+xml": ["rsat"], - "application/bdoc": ["bdoc"], - "application/calendar+xml": ["xcs"], - "application/ccxml+xml": ["ccxml"], - "application/cdfx+xml": ["cdfx"], - "application/cdmi-capability": ["cdmia"], - "application/cdmi-container": ["cdmic"], - "application/cdmi-domain": ["cdmid"], - "application/cdmi-object": ["cdmio"], - "application/cdmi-queue": ["cdmiq"], - "application/cu-seeme": ["cu"], - "application/dash+xml": ["mpd"], - "application/davmount+xml": ["davmount"], - "application/docbook+xml": ["dbk"], - "application/dssc+der": ["dssc"], - "application/dssc+xml": ["xdssc"], - "application/ecmascript": ["es", "ecma"], - "application/emma+xml": ["emma"], - "application/emotionml+xml": ["emotionml"], - "application/epub+zip": ["epub"], - "application/exi": ["exi"], - "application/express": ["exp"], - "application/fdt+xml": ["fdt"], - "application/font-tdpfr": ["pfr"], - "application/geo+json": ["geojson"], - "application/gml+xml": ["gml"], - "application/gpx+xml": ["gpx"], - "application/gxf": ["gxf"], - "application/gzip": ["gz"], - "application/hjson": ["hjson"], - "application/hyperstudio": ["stk"], - "application/inkml+xml": ["ink", "inkml"], - "application/ipfix": ["ipfix"], - "application/its+xml": ["its"], - "application/java-archive": ["jar", "war", "ear"], - "application/java-serialized-object": ["ser"], - "application/java-vm": ["class"], - "application/javascript": ["js", "mjs"], - "application/json": ["json", "map"], - "application/json5": ["json5"], - "application/jsonml+json": ["jsonml"], - "application/ld+json": ["jsonld"], - "application/lgr+xml": ["lgr"], - "application/lost+xml": ["lostxml"], - "application/mac-binhex40": ["hqx"], - "application/mac-compactpro": ["cpt"], - "application/mads+xml": ["mads"], - "application/manifest+json": ["webmanifest"], - "application/marc": ["mrc"], - "application/marcxml+xml": ["mrcx"], - "application/mathematica": ["ma", "nb", "mb"], - "application/mathml+xml": ["mathml"], - "application/mbox": ["mbox"], - "application/mediaservercontrol+xml": ["mscml"], - "application/metalink+xml": ["metalink"], - "application/metalink4+xml": ["meta4"], - "application/mets+xml": ["mets"], - "application/mmt-aei+xml": ["maei"], - "application/mmt-usd+xml": ["musd"], - "application/mods+xml": ["mods"], - "application/mp21": ["m21", "mp21"], - "application/mp4": ["mp4s", "m4p"], - "application/msword": ["doc", "dot"], - "application/mxf": ["mxf"], - "application/n-quads": ["nq"], - "application/n-triples": ["nt"], - "application/node": ["cjs"], - "application/octet-stream": [ - "bin", - "dms", - "lrf", - "mar", - "so", - "dist", - "distz", - "pkg", - "bpk", - "dump", - "elc", - "deploy", - "exe", - "dll", - "deb", - "dmg", - "iso", - "img", - "msi", - "msp", - "msm", - "buffer", - ], - "application/oda": ["oda"], - "application/oebps-package+xml": ["opf"], - "application/ogg": ["ogx"], - "application/omdoc+xml": ["omdoc"], - "application/onenote": ["onetoc", "onetoc2", "onetmp", "onepkg"], - "application/oxps": ["oxps"], - "application/p2p-overlay+xml": ["relo"], - "application/patch-ops-error+xml": ["xer"], - "application/pdf": ["pdf"], - "application/pgp-encrypted": ["pgp"], - "application/pgp-signature": ["asc", "sig"], - "application/pics-rules": ["prf"], - "application/pkcs10": ["p10"], - "application/pkcs7-mime": ["p7m", "p7c"], - "application/pkcs7-signature": ["p7s"], - "application/pkcs8": ["p8"], - "application/pkix-attr-cert": ["ac"], - "application/pkix-cert": ["cer"], - "application/pkix-crl": ["crl"], - "application/pkix-pkipath": ["pkipath"], - "application/pkixcmp": ["pki"], - "application/pls+xml": ["pls"], - "application/postscript": ["ai", "eps", "ps"], - "application/provenance+xml": ["provx"], - "application/pskc+xml": ["pskcxml"], - "application/raml+yaml": ["raml"], - "application/rdf+xml": ["rdf", "owl"], - "application/reginfo+xml": ["rif"], - "application/relax-ng-compact-syntax": ["rnc"], - "application/resource-lists+xml": ["rl"], - "application/resource-lists-diff+xml": ["rld"], - "application/rls-services+xml": ["rs"], - "application/route-apd+xml": ["rapd"], - "application/route-s-tsid+xml": ["sls"], - "application/route-usd+xml": ["rusd"], - "application/rpki-ghostbusters": ["gbr"], - "application/rpki-manifest": ["mft"], - "application/rpki-roa": ["roa"], - "application/rsd+xml": ["rsd"], - "application/rss+xml": ["rss"], - "application/rtf": ["rtf"], - "application/sbml+xml": ["sbml"], - "application/scvp-cv-request": ["scq"], - "application/scvp-cv-response": ["scs"], - "application/scvp-vp-request": ["spq"], - "application/scvp-vp-response": ["spp"], - "application/sdp": ["sdp"], - "application/senml+xml": ["senmlx"], - "application/sensml+xml": ["sensmlx"], - "application/set-payment-initiation": ["setpay"], - "application/set-registration-initiation": ["setreg"], - "application/shf+xml": ["shf"], - "application/sieve": ["siv", "sieve"], - "application/smil+xml": ["smi", "smil"], - "application/sparql-query": ["rq"], - "application/sparql-results+xml": ["srx"], - "application/srgs": ["gram"], - "application/srgs+xml": ["grxml"], - "application/sru+xml": ["sru"], - "application/ssdl+xml": ["ssdl"], - "application/ssml+xml": ["ssml"], - "application/swid+xml": ["swidtag"], - "application/tei+xml": ["tei", "teicorpus"], - "application/thraud+xml": ["tfi"], - "application/timestamped-data": ["tsd"], - "application/toml": ["toml"], - "application/trig": ["trig"], - "application/ttml+xml": ["ttml"], - "application/ubjson": ["ubj"], - "application/urc-ressheet+xml": ["rsheet"], - "application/urc-targetdesc+xml": ["td"], - "application/voicexml+xml": ["vxml"], - "application/wasm": ["wasm"], - "application/widget": ["wgt"], - "application/winhlp": ["hlp"], - "application/wsdl+xml": ["wsdl"], - "application/wspolicy+xml": ["wspolicy"], - "application/xaml+xml": ["xaml"], - "application/xcap-att+xml": ["xav"], - "application/xcap-caps+xml": ["xca"], - "application/xcap-diff+xml": ["xdf"], - "application/xcap-el+xml": ["xel"], - "application/xcap-ns+xml": ["xns"], - "application/xenc+xml": ["xenc"], - "application/xhtml+xml": ["xhtml", "xht"], - "application/xliff+xml": ["xlf"], - "application/xml": ["xml", "xsl", "xsd", "rng"], - "application/xml-dtd": ["dtd"], - "application/xop+xml": ["xop"], - "application/xproc+xml": ["xpl"], - "application/xslt+xml": ["*xsl", "xslt"], - "application/xspf+xml": ["xspf"], - "application/xv+xml": ["mxml", "xhvml", "xvml", "xvm"], - "application/yang": ["yang"], - "application/yin+xml": ["yin"], - "application/zip": ["zip"], - "audio/3gpp": ["*3gpp"], - "audio/adpcm": ["adp"], - "audio/amr": ["amr"], - "audio/basic": ["au", "snd"], - "audio/midi": ["mid", "midi", "kar", "rmi"], - "audio/mobile-xmf": ["mxmf"], - "audio/mp3": ["*mp3"], - "audio/mp4": ["m4a", "mp4a"], - "audio/mpeg": ["mpga", "mp2", "mp2a", "mp3", "m2a", "m3a"], - "audio/ogg": ["oga", "ogg", "spx", "opus"], - "audio/s3m": ["s3m"], - "audio/silk": ["sil"], - "audio/wav": ["wav"], - "audio/wave": ["*wav"], - "audio/webm": ["weba"], - "audio/xm": ["xm"], - "font/collection": ["ttc"], - "font/otf": ["otf"], - "font/ttf": ["ttf"], - "font/woff": ["woff"], - "font/woff2": ["woff2"], - "image/aces": ["exr"], - "image/apng": ["apng"], - "image/avif": ["avif"], - "image/bmp": ["bmp"], - "image/cgm": ["cgm"], - "image/dicom-rle": ["drle"], - "image/emf": ["emf"], - "image/fits": ["fits"], - "image/g3fax": ["g3"], - "image/gif": ["gif"], - "image/heic": ["heic"], - "image/heic-sequence": ["heics"], - "image/heif": ["heif"], - "image/heif-sequence": ["heifs"], - "image/hej2k": ["hej2"], - "image/hsj2": ["hsj2"], - "image/ief": ["ief"], - "image/jls": ["jls"], - "image/jp2": ["jp2", "jpg2"], - "image/jpeg": ["jpeg", "jpg", "jpe"], - "image/jph": ["jph"], - "image/jphc": ["jhc"], - "image/jpm": ["jpm"], - "image/jpx": ["jpx", "jpf"], - "image/jxr": ["jxr"], - "image/jxra": ["jxra"], - "image/jxrs": ["jxrs"], - "image/jxs": ["jxs"], - "image/jxsc": ["jxsc"], - "image/jxsi": ["jxsi"], - "image/jxss": ["jxss"], - "image/ktx": ["ktx"], - "image/ktx2": ["ktx2"], - "image/png": ["png"], - "image/sgi": ["sgi"], - "image/svg+xml": ["svg", "svgz"], - "image/t38": ["t38"], - "image/tiff": ["tif", "tiff"], - "image/tiff-fx": ["tfx"], - "image/webp": ["webp"], - "image/wmf": ["wmf"], - "message/disposition-notification": ["disposition-notification"], - "message/global": ["u8msg"], - "message/global-delivery-status": ["u8dsn"], - "message/global-disposition-notification": ["u8mdn"], - "message/global-headers": ["u8hdr"], - "message/rfc822": ["eml", "mime"], - "model/3mf": ["3mf"], - "model/gltf+json": ["gltf"], - "model/gltf-binary": ["glb"], - "model/iges": ["igs", "iges"], - "model/mesh": ["msh", "mesh", "silo"], - "model/mtl": ["mtl"], - "model/obj": ["obj"], - "model/step+xml": ["stpx"], - "model/step+zip": ["stpz"], - "model/step-xml+zip": ["stpxz"], - "model/stl": ["stl"], - "model/vrml": ["wrl", "vrml"], - "model/x3d+binary": ["*x3db", "x3dbz"], - "model/x3d+fastinfoset": ["x3db"], - "model/x3d+vrml": ["*x3dv", "x3dvz"], - "model/x3d+xml": ["x3d", "x3dz"], - "model/x3d-vrml": ["x3dv"], - "text/cache-manifest": ["appcache", "manifest"], - "text/calendar": ["ics", "ifb"], - "text/coffeescript": ["coffee", "litcoffee"], - "text/css": ["css"], - "text/csv": ["csv"], - "text/html": ["html", "htm", "shtml"], - "text/jade": ["jade"], - "text/jsx": ["jsx"], - "text/less": ["less"], - "text/markdown": ["markdown", "md"], - "text/mathml": ["mml"], - "text/mdx": ["mdx"], - "text/n3": ["n3"], - "text/plain": ["txt", "text", "conf", "def", "list", "log", "in", "ini"], - "text/richtext": ["rtx"], - "text/rtf": ["*rtf"], - "text/sgml": ["sgml", "sgm"], - "text/shex": ["shex"], - "text/slim": ["slim", "slm"], - "text/spdx": ["spdx"], - "text/stylus": ["stylus", "styl"], - "text/tab-separated-values": ["tsv"], - "text/troff": ["t", "tr", "roff", "man", "me", "ms"], - "text/turtle": ["ttl"], - "text/uri-list": ["uri", "uris", "urls"], - "text/vcard": ["vcard"], - "text/vtt": ["vtt"], - "text/xml": ["*xml"], - "text/yaml": ["yaml", "yml"], - "video/3gpp": ["3gp", "3gpp"], - "video/3gpp2": ["3g2"], - "video/h261": ["h261"], - "video/h263": ["h263"], - "video/h264": ["h264"], - "video/iso.segment": ["m4s"], - "video/jpeg": ["jpgv"], - "video/jpm": ["*jpm", "jpgm"], - "video/mj2": ["mj2", "mjp2"], - "video/mp2t": ["ts"], - "video/mp4": ["mp4", "mp4v", "mpg4"], - "video/mpeg": ["mpeg", "mpg", "mpe", "m1v", "m2v"], - "video/ogg": ["ogv"], - "video/quicktime": ["qt", "mov"], - "video/webm": ["webm"], - }; - }); - var Uet = I((Khn, jet) => { - m(); - g(); - jet.exports = { - "application/prs.cww": ["cww"], - "application/vnd.1000minds.decision-model+xml": ["1km"], - "application/vnd.3gpp.pic-bw-large": ["plb"], - "application/vnd.3gpp.pic-bw-small": ["psb"], - "application/vnd.3gpp.pic-bw-var": ["pvb"], - "application/vnd.3gpp2.tcap": ["tcap"], - "application/vnd.3m.post-it-notes": ["pwn"], - "application/vnd.accpac.simply.aso": ["aso"], - "application/vnd.accpac.simply.imp": ["imp"], - "application/vnd.acucobol": ["acu"], - "application/vnd.acucorp": ["atc", "acutc"], - "application/vnd.adobe.air-application-installer-package+zip": ["air"], - "application/vnd.adobe.formscentral.fcdt": ["fcdt"], - "application/vnd.adobe.fxp": ["fxp", "fxpl"], - "application/vnd.adobe.xdp+xml": ["xdp"], - "application/vnd.adobe.xfdf": ["xfdf"], - "application/vnd.ahead.space": ["ahead"], - "application/vnd.airzip.filesecure.azf": ["azf"], - "application/vnd.airzip.filesecure.azs": ["azs"], - "application/vnd.amazon.ebook": ["azw"], - "application/vnd.americandynamics.acc": ["acc"], - "application/vnd.amiga.ami": ["ami"], - "application/vnd.android.package-archive": ["apk"], - "application/vnd.anser-web-certificate-issue-initiation": ["cii"], - "application/vnd.anser-web-funds-transfer-initiation": ["fti"], - "application/vnd.antix.game-component": ["atx"], - "application/vnd.apple.installer+xml": ["mpkg"], - "application/vnd.apple.keynote": ["key"], - "application/vnd.apple.mpegurl": ["m3u8"], - "application/vnd.apple.numbers": ["numbers"], - "application/vnd.apple.pages": ["pages"], - "application/vnd.apple.pkpass": ["pkpass"], - "application/vnd.aristanetworks.swi": ["swi"], - "application/vnd.astraea-software.iota": ["iota"], - "application/vnd.audiograph": ["aep"], - "application/vnd.balsamiq.bmml+xml": ["bmml"], - "application/vnd.blueice.multipass": ["mpm"], - "application/vnd.bmi": ["bmi"], - "application/vnd.businessobjects": ["rep"], - "application/vnd.chemdraw+xml": ["cdxml"], - "application/vnd.chipnuts.karaoke-mmd": ["mmd"], - "application/vnd.cinderella": ["cdy"], - "application/vnd.citationstyles.style+xml": ["csl"], - "application/vnd.claymore": ["cla"], - "application/vnd.cloanto.rp9": ["rp9"], - "application/vnd.clonk.c4group": ["c4g", "c4d", "c4f", "c4p", "c4u"], - "application/vnd.cluetrust.cartomobile-config": ["c11amc"], - "application/vnd.cluetrust.cartomobile-config-pkg": ["c11amz"], - "application/vnd.commonspace": ["csp"], - "application/vnd.contact.cmsg": ["cdbcmsg"], - "application/vnd.cosmocaller": ["cmc"], - "application/vnd.crick.clicker": ["clkx"], - "application/vnd.crick.clicker.keyboard": ["clkk"], - "application/vnd.crick.clicker.palette": ["clkp"], - "application/vnd.crick.clicker.template": ["clkt"], - "application/vnd.crick.clicker.wordbank": ["clkw"], - "application/vnd.criticaltools.wbs+xml": ["wbs"], - "application/vnd.ctc-posml": ["pml"], - "application/vnd.cups-ppd": ["ppd"], - "application/vnd.curl.car": ["car"], - "application/vnd.curl.pcurl": ["pcurl"], - "application/vnd.dart": ["dart"], - "application/vnd.data-vision.rdz": ["rdz"], - "application/vnd.dbf": ["dbf"], - "application/vnd.dece.data": ["uvf", "uvvf", "uvd", "uvvd"], - "application/vnd.dece.ttml+xml": ["uvt", "uvvt"], - "application/vnd.dece.unspecified": ["uvx", "uvvx"], - "application/vnd.dece.zip": ["uvz", "uvvz"], - "application/vnd.denovo.fcselayout-link": ["fe_launch"], - "application/vnd.dna": ["dna"], - "application/vnd.dolby.mlp": ["mlp"], - "application/vnd.dpgraph": ["dpg"], - "application/vnd.dreamfactory": ["dfac"], - "application/vnd.ds-keypoint": ["kpxx"], - "application/vnd.dvb.ait": ["ait"], - "application/vnd.dvb.service": ["svc"], - "application/vnd.dynageo": ["geo"], - "application/vnd.ecowin.chart": ["mag"], - "application/vnd.enliven": ["nml"], - "application/vnd.epson.esf": ["esf"], - "application/vnd.epson.msf": ["msf"], - "application/vnd.epson.quickanime": ["qam"], - "application/vnd.epson.salt": ["slt"], - "application/vnd.epson.ssf": ["ssf"], - "application/vnd.eszigno3+xml": ["es3", "et3"], - "application/vnd.ezpix-album": ["ez2"], - "application/vnd.ezpix-package": ["ez3"], - "application/vnd.fdf": ["fdf"], - "application/vnd.fdsn.mseed": ["mseed"], - "application/vnd.fdsn.seed": ["seed", "dataless"], - "application/vnd.flographit": ["gph"], - "application/vnd.fluxtime.clip": ["ftc"], - "application/vnd.framemaker": ["fm", "frame", "maker", "book"], - "application/vnd.frogans.fnc": ["fnc"], - "application/vnd.frogans.ltf": ["ltf"], - "application/vnd.fsc.weblaunch": ["fsc"], - "application/vnd.fujitsu.oasys": ["oas"], - "application/vnd.fujitsu.oasys2": ["oa2"], - "application/vnd.fujitsu.oasys3": ["oa3"], - "application/vnd.fujitsu.oasysgp": ["fg5"], - "application/vnd.fujitsu.oasysprs": ["bh2"], - "application/vnd.fujixerox.ddd": ["ddd"], - "application/vnd.fujixerox.docuworks": ["xdw"], - "application/vnd.fujixerox.docuworks.binder": ["xbd"], - "application/vnd.fuzzysheet": ["fzs"], - "application/vnd.genomatix.tuxedo": ["txd"], - "application/vnd.geogebra.file": ["ggb"], - "application/vnd.geogebra.tool": ["ggt"], - "application/vnd.geometry-explorer": ["gex", "gre"], - "application/vnd.geonext": ["gxt"], - "application/vnd.geoplan": ["g2w"], - "application/vnd.geospace": ["g3w"], - "application/vnd.gmx": ["gmx"], - "application/vnd.google-apps.document": ["gdoc"], - "application/vnd.google-apps.presentation": ["gslides"], - "application/vnd.google-apps.spreadsheet": ["gsheet"], - "application/vnd.google-earth.kml+xml": ["kml"], - "application/vnd.google-earth.kmz": ["kmz"], - "application/vnd.grafeq": ["gqf", "gqs"], - "application/vnd.groove-account": ["gac"], - "application/vnd.groove-help": ["ghf"], - "application/vnd.groove-identity-message": ["gim"], - "application/vnd.groove-injector": ["grv"], - "application/vnd.groove-tool-message": ["gtm"], - "application/vnd.groove-tool-template": ["tpl"], - "application/vnd.groove-vcard": ["vcg"], - "application/vnd.hal+xml": ["hal"], - "application/vnd.handheld-entertainment+xml": ["zmm"], - "application/vnd.hbci": ["hbci"], - "application/vnd.hhe.lesson-player": ["les"], - "application/vnd.hp-hpgl": ["hpgl"], - "application/vnd.hp-hpid": ["hpid"], - "application/vnd.hp-hps": ["hps"], - "application/vnd.hp-jlyt": ["jlt"], - "application/vnd.hp-pcl": ["pcl"], - "application/vnd.hp-pclxl": ["pclxl"], - "application/vnd.hydrostatix.sof-data": ["sfd-hdstx"], - "application/vnd.ibm.minipay": ["mpy"], - "application/vnd.ibm.modcap": ["afp", "listafp", "list3820"], - "application/vnd.ibm.rights-management": ["irm"], - "application/vnd.ibm.secure-container": ["sc"], - "application/vnd.iccprofile": ["icc", "icm"], - "application/vnd.igloader": ["igl"], - "application/vnd.immervision-ivp": ["ivp"], - "application/vnd.immervision-ivu": ["ivu"], - "application/vnd.insors.igm": ["igm"], - "application/vnd.intercon.formnet": ["xpw", "xpx"], - "application/vnd.intergeo": ["i2g"], - "application/vnd.intu.qbo": ["qbo"], - "application/vnd.intu.qfx": ["qfx"], - "application/vnd.ipunplugged.rcprofile": ["rcprofile"], - "application/vnd.irepository.package+xml": ["irp"], - "application/vnd.is-xpr": ["xpr"], - "application/vnd.isac.fcs": ["fcs"], - "application/vnd.jam": ["jam"], - "application/vnd.jcp.javame.midlet-rms": ["rms"], - "application/vnd.jisp": ["jisp"], - "application/vnd.joost.joda-archive": ["joda"], - "application/vnd.kahootz": ["ktz", "ktr"], - "application/vnd.kde.karbon": ["karbon"], - "application/vnd.kde.kchart": ["chrt"], - "application/vnd.kde.kformula": ["kfo"], - "application/vnd.kde.kivio": ["flw"], - "application/vnd.kde.kontour": ["kon"], - "application/vnd.kde.kpresenter": ["kpr", "kpt"], - "application/vnd.kde.kspread": ["ksp"], - "application/vnd.kde.kword": ["kwd", "kwt"], - "application/vnd.kenameaapp": ["htke"], - "application/vnd.kidspiration": ["kia"], - "application/vnd.kinar": ["kne", "knp"], - "application/vnd.koan": ["skp", "skd", "skt", "skm"], - "application/vnd.kodak-descriptor": ["sse"], - "application/vnd.las.las+xml": ["lasxml"], - "application/vnd.llamagraphics.life-balance.desktop": ["lbd"], - "application/vnd.llamagraphics.life-balance.exchange+xml": ["lbe"], - "application/vnd.lotus-1-2-3": ["123"], - "application/vnd.lotus-approach": ["apr"], - "application/vnd.lotus-freelance": ["pre"], - "application/vnd.lotus-notes": ["nsf"], - "application/vnd.lotus-organizer": ["org"], - "application/vnd.lotus-screencam": ["scm"], - "application/vnd.lotus-wordpro": ["lwp"], - "application/vnd.macports.portpkg": ["portpkg"], - "application/vnd.mapbox-vector-tile": ["mvt"], - "application/vnd.mcd": ["mcd"], - "application/vnd.medcalcdata": ["mc1"], - "application/vnd.mediastation.cdkey": ["cdkey"], - "application/vnd.mfer": ["mwf"], - "application/vnd.mfmp": ["mfm"], - "application/vnd.micrografx.flo": ["flo"], - "application/vnd.micrografx.igx": ["igx"], - "application/vnd.mif": ["mif"], - "application/vnd.mobius.daf": ["daf"], - "application/vnd.mobius.dis": ["dis"], - "application/vnd.mobius.mbk": ["mbk"], - "application/vnd.mobius.mqy": ["mqy"], - "application/vnd.mobius.msl": ["msl"], - "application/vnd.mobius.plc": ["plc"], - "application/vnd.mobius.txf": ["txf"], - "application/vnd.mophun.application": ["mpn"], - "application/vnd.mophun.certificate": ["mpc"], - "application/vnd.mozilla.xul+xml": ["xul"], - "application/vnd.ms-artgalry": ["cil"], - "application/vnd.ms-cab-compressed": ["cab"], - "application/vnd.ms-excel": ["xls", "xlm", "xla", "xlc", "xlt", "xlw"], - "application/vnd.ms-excel.addin.macroenabled.12": ["xlam"], - "application/vnd.ms-excel.sheet.binary.macroenabled.12": ["xlsb"], - "application/vnd.ms-excel.sheet.macroenabled.12": ["xlsm"], - "application/vnd.ms-excel.template.macroenabled.12": ["xltm"], - "application/vnd.ms-fontobject": ["eot"], - "application/vnd.ms-htmlhelp": ["chm"], - "application/vnd.ms-ims": ["ims"], - "application/vnd.ms-lrm": ["lrm"], - "application/vnd.ms-officetheme": ["thmx"], - "application/vnd.ms-outlook": ["msg"], - "application/vnd.ms-pki.seccat": ["cat"], - "application/vnd.ms-pki.stl": ["*stl"], - "application/vnd.ms-powerpoint": ["ppt", "pps", "pot"], - "application/vnd.ms-powerpoint.addin.macroenabled.12": ["ppam"], - "application/vnd.ms-powerpoint.presentation.macroenabled.12": ["pptm"], - "application/vnd.ms-powerpoint.slide.macroenabled.12": ["sldm"], - "application/vnd.ms-powerpoint.slideshow.macroenabled.12": ["ppsm"], - "application/vnd.ms-powerpoint.template.macroenabled.12": ["potm"], - "application/vnd.ms-project": ["mpp", "mpt"], - "application/vnd.ms-word.document.macroenabled.12": ["docm"], - "application/vnd.ms-word.template.macroenabled.12": ["dotm"], - "application/vnd.ms-works": ["wps", "wks", "wcm", "wdb"], - "application/vnd.ms-wpl": ["wpl"], - "application/vnd.ms-xpsdocument": ["xps"], - "application/vnd.mseq": ["mseq"], - "application/vnd.musician": ["mus"], - "application/vnd.muvee.style": ["msty"], - "application/vnd.mynfc": ["taglet"], - "application/vnd.neurolanguage.nlu": ["nlu"], - "application/vnd.nitf": ["ntf", "nitf"], - "application/vnd.noblenet-directory": ["nnd"], - "application/vnd.noblenet-sealer": ["nns"], - "application/vnd.noblenet-web": ["nnw"], - "application/vnd.nokia.n-gage.ac+xml": ["*ac"], - "application/vnd.nokia.n-gage.data": ["ngdat"], - "application/vnd.nokia.n-gage.symbian.install": ["n-gage"], - "application/vnd.nokia.radio-preset": ["rpst"], - "application/vnd.nokia.radio-presets": ["rpss"], - "application/vnd.novadigm.edm": ["edm"], - "application/vnd.novadigm.edx": ["edx"], - "application/vnd.novadigm.ext": ["ext"], - "application/vnd.oasis.opendocument.chart": ["odc"], - "application/vnd.oasis.opendocument.chart-template": ["otc"], - "application/vnd.oasis.opendocument.database": ["odb"], - "application/vnd.oasis.opendocument.formula": ["odf"], - "application/vnd.oasis.opendocument.formula-template": ["odft"], - "application/vnd.oasis.opendocument.graphics": ["odg"], - "application/vnd.oasis.opendocument.graphics-template": ["otg"], - "application/vnd.oasis.opendocument.image": ["odi"], - "application/vnd.oasis.opendocument.image-template": ["oti"], - "application/vnd.oasis.opendocument.presentation": ["odp"], - "application/vnd.oasis.opendocument.presentation-template": ["otp"], - "application/vnd.oasis.opendocument.spreadsheet": ["ods"], - "application/vnd.oasis.opendocument.spreadsheet-template": ["ots"], - "application/vnd.oasis.opendocument.text": ["odt"], - "application/vnd.oasis.opendocument.text-master": ["odm"], - "application/vnd.oasis.opendocument.text-template": ["ott"], - "application/vnd.oasis.opendocument.text-web": ["oth"], - "application/vnd.olpc-sugar": ["xo"], - "application/vnd.oma.dd2+xml": ["dd2"], - "application/vnd.openblox.game+xml": ["obgx"], - "application/vnd.openofficeorg.extension": ["oxt"], - "application/vnd.openstreetmap.data+xml": ["osm"], - "application/vnd.openxmlformats-officedocument.presentationml.presentation": - ["pptx"], - "application/vnd.openxmlformats-officedocument.presentationml.slide": [ - "sldx", - ], - "application/vnd.openxmlformats-officedocument.presentationml.slideshow": - ["ppsx"], - "application/vnd.openxmlformats-officedocument.presentationml.template": [ - "potx", - ], - "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": [ - "xlsx", - ], - "application/vnd.openxmlformats-officedocument.spreadsheetml.template": [ - "xltx", - ], - "application/vnd.openxmlformats-officedocument.wordprocessingml.document": - ["docx"], - "application/vnd.openxmlformats-officedocument.wordprocessingml.template": - ["dotx"], - "application/vnd.osgeo.mapguide.package": ["mgp"], - "application/vnd.osgi.dp": ["dp"], - "application/vnd.osgi.subsystem": ["esa"], - "application/vnd.palm": ["pdb", "pqa", "oprc"], - "application/vnd.pawaafile": ["paw"], - "application/vnd.pg.format": ["str"], - "application/vnd.pg.osasli": ["ei6"], - "application/vnd.picsel": ["efif"], - "application/vnd.pmi.widget": ["wg"], - "application/vnd.pocketlearn": ["plf"], - "application/vnd.powerbuilder6": ["pbd"], - "application/vnd.previewsystems.box": ["box"], - "application/vnd.proteus.magazine": ["mgz"], - "application/vnd.publishare-delta-tree": ["qps"], - "application/vnd.pvi.ptid1": ["ptid"], - "application/vnd.quark.quarkxpress": [ - "qxd", - "qxt", - "qwd", - "qwt", - "qxl", - "qxb", - ], - "application/vnd.rar": ["rar"], - "application/vnd.realvnc.bed": ["bed"], - "application/vnd.recordare.musicxml": ["mxl"], - "application/vnd.recordare.musicxml+xml": ["musicxml"], - "application/vnd.rig.cryptonote": ["cryptonote"], - "application/vnd.rim.cod": ["cod"], - "application/vnd.rn-realmedia": ["rm"], - "application/vnd.rn-realmedia-vbr": ["rmvb"], - "application/vnd.route66.link66+xml": ["link66"], - "application/vnd.sailingtracker.track": ["st"], - "application/vnd.seemail": ["see"], - "application/vnd.sema": ["sema"], - "application/vnd.semd": ["semd"], - "application/vnd.semf": ["semf"], - "application/vnd.shana.informed.formdata": ["ifm"], - "application/vnd.shana.informed.formtemplate": ["itp"], - "application/vnd.shana.informed.interchange": ["iif"], - "application/vnd.shana.informed.package": ["ipk"], - "application/vnd.simtech-mindmapper": ["twd", "twds"], - "application/vnd.smaf": ["mmf"], - "application/vnd.smart.teacher": ["teacher"], - "application/vnd.software602.filler.form+xml": ["fo"], - "application/vnd.solent.sdkm+xml": ["sdkm", "sdkd"], - "application/vnd.spotfire.dxp": ["dxp"], - "application/vnd.spotfire.sfs": ["sfs"], - "application/vnd.stardivision.calc": ["sdc"], - "application/vnd.stardivision.draw": ["sda"], - "application/vnd.stardivision.impress": ["sdd"], - "application/vnd.stardivision.math": ["smf"], - "application/vnd.stardivision.writer": ["sdw", "vor"], - "application/vnd.stardivision.writer-global": ["sgl"], - "application/vnd.stepmania.package": ["smzip"], - "application/vnd.stepmania.stepchart": ["sm"], - "application/vnd.sun.wadl+xml": ["wadl"], - "application/vnd.sun.xml.calc": ["sxc"], - "application/vnd.sun.xml.calc.template": ["stc"], - "application/vnd.sun.xml.draw": ["sxd"], - "application/vnd.sun.xml.draw.template": ["std"], - "application/vnd.sun.xml.impress": ["sxi"], - "application/vnd.sun.xml.impress.template": ["sti"], - "application/vnd.sun.xml.math": ["sxm"], - "application/vnd.sun.xml.writer": ["sxw"], - "application/vnd.sun.xml.writer.global": ["sxg"], - "application/vnd.sun.xml.writer.template": ["stw"], - "application/vnd.sus-calendar": ["sus", "susp"], - "application/vnd.svd": ["svd"], - "application/vnd.symbian.install": ["sis", "sisx"], - "application/vnd.syncml+xml": ["xsm"], - "application/vnd.syncml.dm+wbxml": ["bdm"], - "application/vnd.syncml.dm+xml": ["xdm"], - "application/vnd.syncml.dmddf+xml": ["ddf"], - "application/vnd.tao.intent-module-archive": ["tao"], - "application/vnd.tcpdump.pcap": ["pcap", "cap", "dmp"], - "application/vnd.tmobile-livetv": ["tmo"], - "application/vnd.trid.tpt": ["tpt"], - "application/vnd.triscape.mxs": ["mxs"], - "application/vnd.trueapp": ["tra"], - "application/vnd.ufdl": ["ufd", "ufdl"], - "application/vnd.uiq.theme": ["utz"], - "application/vnd.umajin": ["umj"], - "application/vnd.unity": ["unityweb"], - "application/vnd.uoml+xml": ["uoml"], - "application/vnd.vcx": ["vcx"], - "application/vnd.visio": ["vsd", "vst", "vss", "vsw"], - "application/vnd.visionary": ["vis"], - "application/vnd.vsf": ["vsf"], - "application/vnd.wap.wbxml": ["wbxml"], - "application/vnd.wap.wmlc": ["wmlc"], - "application/vnd.wap.wmlscriptc": ["wmlsc"], - "application/vnd.webturbo": ["wtb"], - "application/vnd.wolfram.player": ["nbp"], - "application/vnd.wordperfect": ["wpd"], - "application/vnd.wqd": ["wqd"], - "application/vnd.wt.stf": ["stf"], - "application/vnd.xara": ["xar"], - "application/vnd.xfdl": ["xfdl"], - "application/vnd.yamaha.hv-dic": ["hvd"], - "application/vnd.yamaha.hv-script": ["hvs"], - "application/vnd.yamaha.hv-voice": ["hvp"], - "application/vnd.yamaha.openscoreformat": ["osf"], - "application/vnd.yamaha.openscoreformat.osfpvg+xml": ["osfpvg"], - "application/vnd.yamaha.smaf-audio": ["saf"], - "application/vnd.yamaha.smaf-phrase": ["spf"], - "application/vnd.yellowriver-custom-menu": ["cmp"], - "application/vnd.zul": ["zir", "zirz"], - "application/vnd.zzazz.deck+xml": ["zaz"], - "application/x-7z-compressed": ["7z"], - "application/x-abiword": ["abw"], - "application/x-ace-compressed": ["ace"], - "application/x-apple-diskimage": ["*dmg"], - "application/x-arj": ["arj"], - "application/x-authorware-bin": ["aab", "x32", "u32", "vox"], - "application/x-authorware-map": ["aam"], - "application/x-authorware-seg": ["aas"], - "application/x-bcpio": ["bcpio"], - "application/x-bdoc": ["*bdoc"], - "application/x-bittorrent": ["torrent"], - "application/x-blorb": ["blb", "blorb"], - "application/x-bzip": ["bz"], - "application/x-bzip2": ["bz2", "boz"], - "application/x-cbr": ["cbr", "cba", "cbt", "cbz", "cb7"], - "application/x-cdlink": ["vcd"], - "application/x-cfs-compressed": ["cfs"], - "application/x-chat": ["chat"], - "application/x-chess-pgn": ["pgn"], - "application/x-chrome-extension": ["crx"], - "application/x-cocoa": ["cco"], - "application/x-conference": ["nsc"], - "application/x-cpio": ["cpio"], - "application/x-csh": ["csh"], - "application/x-debian-package": ["*deb", "udeb"], - "application/x-dgc-compressed": ["dgc"], - "application/x-director": [ - "dir", - "dcr", - "dxr", - "cst", - "cct", - "cxt", - "w3d", - "fgd", - "swa", - ], - "application/x-doom": ["wad"], - "application/x-dtbncx+xml": ["ncx"], - "application/x-dtbook+xml": ["dtb"], - "application/x-dtbresource+xml": ["res"], - "application/x-dvi": ["dvi"], - "application/x-envoy": ["evy"], - "application/x-eva": ["eva"], - "application/x-font-bdf": ["bdf"], - "application/x-font-ghostscript": ["gsf"], - "application/x-font-linux-psf": ["psf"], - "application/x-font-pcf": ["pcf"], - "application/x-font-snf": ["snf"], - "application/x-font-type1": ["pfa", "pfb", "pfm", "afm"], - "application/x-freearc": ["arc"], - "application/x-futuresplash": ["spl"], - "application/x-gca-compressed": ["gca"], - "application/x-glulx": ["ulx"], - "application/x-gnumeric": ["gnumeric"], - "application/x-gramps-xml": ["gramps"], - "application/x-gtar": ["gtar"], - "application/x-hdf": ["hdf"], - "application/x-httpd-php": ["php"], - "application/x-install-instructions": ["install"], - "application/x-iso9660-image": ["*iso"], - "application/x-iwork-keynote-sffkey": ["*key"], - "application/x-iwork-numbers-sffnumbers": ["*numbers"], - "application/x-iwork-pages-sffpages": ["*pages"], - "application/x-java-archive-diff": ["jardiff"], - "application/x-java-jnlp-file": ["jnlp"], - "application/x-keepass2": ["kdbx"], - "application/x-latex": ["latex"], - "application/x-lua-bytecode": ["luac"], - "application/x-lzh-compressed": ["lzh", "lha"], - "application/x-makeself": ["run"], - "application/x-mie": ["mie"], - "application/x-mobipocket-ebook": ["prc", "mobi"], - "application/x-ms-application": ["application"], - "application/x-ms-shortcut": ["lnk"], - "application/x-ms-wmd": ["wmd"], - "application/x-ms-wmz": ["wmz"], - "application/x-ms-xbap": ["xbap"], - "application/x-msaccess": ["mdb"], - "application/x-msbinder": ["obd"], - "application/x-mscardfile": ["crd"], - "application/x-msclip": ["clp"], - "application/x-msdos-program": ["*exe"], - "application/x-msdownload": ["*exe", "*dll", "com", "bat", "*msi"], - "application/x-msmediaview": ["mvb", "m13", "m14"], - "application/x-msmetafile": ["*wmf", "*wmz", "*emf", "emz"], - "application/x-msmoney": ["mny"], - "application/x-mspublisher": ["pub"], - "application/x-msschedule": ["scd"], - "application/x-msterminal": ["trm"], - "application/x-mswrite": ["wri"], - "application/x-netcdf": ["nc", "cdf"], - "application/x-ns-proxy-autoconfig": ["pac"], - "application/x-nzb": ["nzb"], - "application/x-perl": ["pl", "pm"], - "application/x-pilot": ["*prc", "*pdb"], - "application/x-pkcs12": ["p12", "pfx"], - "application/x-pkcs7-certificates": ["p7b", "spc"], - "application/x-pkcs7-certreqresp": ["p7r"], - "application/x-rar-compressed": ["*rar"], - "application/x-redhat-package-manager": ["rpm"], - "application/x-research-info-systems": ["ris"], - "application/x-sea": ["sea"], - "application/x-sh": ["sh"], - "application/x-shar": ["shar"], - "application/x-shockwave-flash": ["swf"], - "application/x-silverlight-app": ["xap"], - "application/x-sql": ["sql"], - "application/x-stuffit": ["sit"], - "application/x-stuffitx": ["sitx"], - "application/x-subrip": ["srt"], - "application/x-sv4cpio": ["sv4cpio"], - "application/x-sv4crc": ["sv4crc"], - "application/x-t3vm-image": ["t3"], - "application/x-tads": ["gam"], - "application/x-tar": ["tar"], - "application/x-tcl": ["tcl", "tk"], - "application/x-tex": ["tex"], - "application/x-tex-tfm": ["tfm"], - "application/x-texinfo": ["texinfo", "texi"], - "application/x-tgif": ["*obj"], - "application/x-ustar": ["ustar"], - "application/x-virtualbox-hdd": ["hdd"], - "application/x-virtualbox-ova": ["ova"], - "application/x-virtualbox-ovf": ["ovf"], - "application/x-virtualbox-vbox": ["vbox"], - "application/x-virtualbox-vbox-extpack": ["vbox-extpack"], - "application/x-virtualbox-vdi": ["vdi"], - "application/x-virtualbox-vhd": ["vhd"], - "application/x-virtualbox-vmdk": ["vmdk"], - "application/x-wais-source": ["src"], - "application/x-web-app-manifest+json": ["webapp"], - "application/x-x509-ca-cert": ["der", "crt", "pem"], - "application/x-xfig": ["fig"], - "application/x-xliff+xml": ["*xlf"], - "application/x-xpinstall": ["xpi"], - "application/x-xz": ["xz"], - "application/x-zmachine": [ - "z1", - "z2", - "z3", - "z4", - "z5", - "z6", - "z7", - "z8", - ], - "audio/vnd.dece.audio": ["uva", "uvva"], - "audio/vnd.digital-winds": ["eol"], - "audio/vnd.dra": ["dra"], - "audio/vnd.dts": ["dts"], - "audio/vnd.dts.hd": ["dtshd"], - "audio/vnd.lucent.voice": ["lvp"], - "audio/vnd.ms-playready.media.pya": ["pya"], - "audio/vnd.nuera.ecelp4800": ["ecelp4800"], - "audio/vnd.nuera.ecelp7470": ["ecelp7470"], - "audio/vnd.nuera.ecelp9600": ["ecelp9600"], - "audio/vnd.rip": ["rip"], - "audio/x-aac": ["aac"], - "audio/x-aiff": ["aif", "aiff", "aifc"], - "audio/x-caf": ["caf"], - "audio/x-flac": ["flac"], - "audio/x-m4a": ["*m4a"], - "audio/x-matroska": ["mka"], - "audio/x-mpegurl": ["m3u"], - "audio/x-ms-wax": ["wax"], - "audio/x-ms-wma": ["wma"], - "audio/x-pn-realaudio": ["ram", "ra"], - "audio/x-pn-realaudio-plugin": ["rmp"], - "audio/x-realaudio": ["*ra"], - "audio/x-wav": ["*wav"], - "chemical/x-cdx": ["cdx"], - "chemical/x-cif": ["cif"], - "chemical/x-cmdf": ["cmdf"], - "chemical/x-cml": ["cml"], - "chemical/x-csml": ["csml"], - "chemical/x-xyz": ["xyz"], - "image/prs.btif": ["btif"], - "image/prs.pti": ["pti"], - "image/vnd.adobe.photoshop": ["psd"], - "image/vnd.airzip.accelerator.azv": ["azv"], - "image/vnd.dece.graphic": ["uvi", "uvvi", "uvg", "uvvg"], - "image/vnd.djvu": ["djvu", "djv"], - "image/vnd.dvb.subtitle": ["*sub"], - "image/vnd.dwg": ["dwg"], - "image/vnd.dxf": ["dxf"], - "image/vnd.fastbidsheet": ["fbs"], - "image/vnd.fpx": ["fpx"], - "image/vnd.fst": ["fst"], - "image/vnd.fujixerox.edmics-mmr": ["mmr"], - "image/vnd.fujixerox.edmics-rlc": ["rlc"], - "image/vnd.microsoft.icon": ["ico"], - "image/vnd.ms-dds": ["dds"], - "image/vnd.ms-modi": ["mdi"], - "image/vnd.ms-photo": ["wdp"], - "image/vnd.net-fpx": ["npx"], - "image/vnd.pco.b16": ["b16"], - "image/vnd.tencent.tap": ["tap"], - "image/vnd.valve.source.texture": ["vtf"], - "image/vnd.wap.wbmp": ["wbmp"], - "image/vnd.xiff": ["xif"], - "image/vnd.zbrush.pcx": ["pcx"], - "image/x-3ds": ["3ds"], - "image/x-cmu-raster": ["ras"], - "image/x-cmx": ["cmx"], - "image/x-freehand": ["fh", "fhc", "fh4", "fh5", "fh7"], - "image/x-icon": ["*ico"], - "image/x-jng": ["jng"], - "image/x-mrsid-image": ["sid"], - "image/x-ms-bmp": ["*bmp"], - "image/x-pcx": ["*pcx"], - "image/x-pict": ["pic", "pct"], - "image/x-portable-anymap": ["pnm"], - "image/x-portable-bitmap": ["pbm"], - "image/x-portable-graymap": ["pgm"], - "image/x-portable-pixmap": ["ppm"], - "image/x-rgb": ["rgb"], - "image/x-tga": ["tga"], - "image/x-xbitmap": ["xbm"], - "image/x-xpixmap": ["xpm"], - "image/x-xwindowdump": ["xwd"], - "message/vnd.wfa.wsc": ["wsc"], - "model/vnd.collada+xml": ["dae"], - "model/vnd.dwf": ["dwf"], - "model/vnd.gdl": ["gdl"], - "model/vnd.gtw": ["gtw"], - "model/vnd.mts": ["mts"], - "model/vnd.opengex": ["ogex"], - "model/vnd.parasolid.transmit.binary": ["x_b"], - "model/vnd.parasolid.transmit.text": ["x_t"], - "model/vnd.sap.vds": ["vds"], - "model/vnd.usdz+zip": ["usdz"], - "model/vnd.valve.source.compiled-map": ["bsp"], - "model/vnd.vtu": ["vtu"], - "text/prs.lines.tag": ["dsc"], - "text/vnd.curl": ["curl"], - "text/vnd.curl.dcurl": ["dcurl"], - "text/vnd.curl.mcurl": ["mcurl"], - "text/vnd.curl.scurl": ["scurl"], - "text/vnd.dvb.subtitle": ["sub"], - "text/vnd.fly": ["fly"], - "text/vnd.fmi.flexstor": ["flx"], - "text/vnd.graphviz": ["gv"], - "text/vnd.in3d.3dml": ["3dml"], - "text/vnd.in3d.spot": ["spot"], - "text/vnd.sun.j2me.app-descriptor": ["jad"], - "text/vnd.wap.wml": ["wml"], - "text/vnd.wap.wmlscript": ["wmls"], - "text/x-asm": ["s", "asm"], - "text/x-c": ["c", "cc", "cxx", "cpp", "h", "hh", "dic"], - "text/x-component": ["htc"], - "text/x-fortran": ["f", "for", "f77", "f90"], - "text/x-handlebars-template": ["hbs"], - "text/x-java-source": ["java"], - "text/x-lua": ["lua"], - "text/x-markdown": ["mkd"], - "text/x-nfo": ["nfo"], - "text/x-opml": ["opml"], - "text/x-org": ["*org"], - "text/x-pascal": ["p", "pas"], - "text/x-processing": ["pde"], - "text/x-sass": ["sass"], - "text/x-scss": ["scss"], - "text/x-setext": ["etx"], - "text/x-sfv": ["sfv"], - "text/x-suse-ymp": ["ymp"], - "text/x-uuencode": ["uu"], - "text/x-vcalendar": ["vcs"], - "text/x-vcard": ["vcf"], - "video/vnd.dece.hd": ["uvh", "uvvh"], - "video/vnd.dece.mobile": ["uvm", "uvvm"], - "video/vnd.dece.pd": ["uvp", "uvvp"], - "video/vnd.dece.sd": ["uvs", "uvvs"], - "video/vnd.dece.video": ["uvv", "uvvv"], - "video/vnd.dvb.file": ["dvb"], - "video/vnd.fvt": ["fvt"], - "video/vnd.mpegurl": ["mxu", "m4u"], - "video/vnd.ms-playready.media.pyv": ["pyv"], - "video/vnd.uvvu.mp4": ["uvu", "uvvu"], - "video/vnd.vivo": ["viv"], - "video/x-f4v": ["f4v"], - "video/x-fli": ["fli"], - "video/x-flv": ["flv"], - "video/x-m4v": ["m4v"], - "video/x-matroska": ["mkv", "mk3d", "mks"], - "video/x-mng": ["mng"], - "video/x-ms-asf": ["asf", "asx"], - "video/x-ms-vob": ["vob"], - "video/x-ms-wm": ["wm"], - "video/x-ms-wmv": ["wmv"], - "video/x-ms-wmx": ["wmx"], - "video/x-ms-wvx": ["wvx"], - "video/x-msvideo": ["avi"], - "video/x-sgi-movie": ["movie"], - "video/x-smv": ["smv"], - "x-conference/x-cooltalk": ["ice"], - }; - }); - var Het = I((Hhn, Ket) => { - "use strict"; - m(); - g(); - var Xfr = Let(); - Ket.exports = new Xfr(zet(), Uet()); - }); - var mxe = I((Upn, ftt) => { - "use strict"; - m(); - g(); - ftt.exports = function (e, r) { - return function () { - for (var i = new Array(arguments.length), o = 0; o < i.length; o++) - i[o] = arguments[o]; - return e.apply(r, i); - }; - }; - }); - var Vd = I((Kpn, ytt) => { - "use strict"; - m(); - g(); - var rdr = mxe(), - oA = Object.prototype.toString; - function bxe(t) { - return Array.isArray(t); - } - function gxe(t) { - return typeof t > "u"; - } - function ndr(t) { - return ( - t !== null && - !gxe(t) && - t.constructor !== null && - !gxe(t.constructor) && - typeof t.constructor.isBuffer == "function" && - t.constructor.isBuffer(t) - ); - } - function dtt(t) { - return oA.call(t) === "[object ArrayBuffer]"; - } - function idr(t) { - return oA.call(t) === "[object FormData]"; - } - function odr(t) { - var e; - return ( - typeof ArrayBuffer < "u" && ArrayBuffer.isView - ? (e = ArrayBuffer.isView(t)) - : (e = t && t.buffer && dtt(t.buffer)), - e - ); - } - function adr(t) { - return typeof t == "string"; - } - function sdr(t) { - return typeof t == "number"; - } - function htt(t) { - return t !== null && typeof t == "object"; - } - function Cee(t) { - if (oA.call(t) !== "[object Object]") return !1; - var e = Object.getPrototypeOf(t); - return e === null || e === Object.prototype; - } - function udr(t) { - return oA.call(t) === "[object Date]"; - } - function cdr(t) { - return oA.call(t) === "[object File]"; - } - function ldr(t) { - return oA.call(t) === "[object Blob]"; - } - function ptt(t) { - return oA.call(t) === "[object Function]"; - } - function fdr(t) { - return htt(t) && ptt(t.pipe); - } - function ddr(t) { - return oA.call(t) === "[object URLSearchParams]"; - } - function hdr(t) { - return t.trim ? t.trim() : t.replace(/^\s+|\s+$/g, ""); - } - function pdr() { - return typeof navigator < "u" && - (navigator.product === "ReactNative" || - navigator.product === "NativeScript" || - navigator.product === "NS") - ? !1 - : typeof window < "u" && typeof document < "u"; - } - function wxe(t, e) { - if (!(t === null || typeof t > "u")) - if ((typeof t != "object" && (t = [t]), bxe(t))) - for (var r = 0, n = t.length; r < n; r++) e.call(null, t[r], r, t); - else - for (var i in t) - Object.prototype.hasOwnProperty.call(t, i) && - e.call(null, t[i], i, t); - } - function vxe() { - var t = {}; - function e(i, o) { - Cee(t[o]) && Cee(i) - ? (t[o] = vxe(t[o], i)) - : Cee(i) - ? (t[o] = vxe({}, i)) - : bxe(i) - ? (t[o] = i.slice()) - : (t[o] = i); - } - for (var r = 0, n = arguments.length; r < n; r++) wxe(arguments[r], e); - return t; - } - function ydr(t, e, r) { - return ( - wxe(e, function (i, o) { - r && typeof i == "function" ? (t[o] = rdr(i, r)) : (t[o] = i); - }), - t - ); - } - function mdr(t) { - return t.charCodeAt(0) === 65279 && (t = t.slice(1)), t; - } - ytt.exports = { - isArray: bxe, - isArrayBuffer: dtt, - isBuffer: ndr, - isFormData: idr, - isArrayBufferView: odr, - isString: adr, - isNumber: sdr, - isObject: htt, - isPlainObject: Cee, - isUndefined: gxe, - isDate: udr, - isFile: cdr, - isBlob: ldr, - isFunction: ptt, - isStream: fdr, - isURLSearchParams: ddr, - isStandardBrowserEnv: pdr, - forEach: wxe, - merge: vxe, - extend: ydr, - trim: hdr, - stripBOM: mdr, - }; - }); - var _xe = I((Hpn, gtt) => { - "use strict"; - m(); - g(); - var UC = Vd(); - function mtt(t) { - return encodeURIComponent(t) - .replace(/%3A/gi, ":") - .replace(/%24/g, "$") - .replace(/%2C/gi, ",") - .replace(/%20/g, "+") - .replace(/%5B/gi, "[") - .replace(/%5D/gi, "]"); - } - gtt.exports = function (e, r, n) { - if (!r) return e; - var i; - if (n) i = n(r); - else if (UC.isURLSearchParams(r)) i = r.toString(); - else { - var o = []; - UC.forEach(r, function (c, u) { - c === null || - typeof c > "u" || - (UC.isArray(c) ? (u = u + "[]") : (c = [c]), - UC.forEach(c, function (w) { - UC.isDate(w) - ? (w = w.toISOString()) - : UC.isObject(w) && (w = JSON.stringify(w)), - o.push(mtt(u) + "=" + mtt(w)); - })); - }), - (i = o.join("&")); - } - if (i) { - var a = e.indexOf("#"); - a !== -1 && (e = e.slice(0, a)), - (e += (e.indexOf("?") === -1 ? "?" : "&") + i); - } - return e; - }; - }); - var btt = I((Vpn, vtt) => { - "use strict"; - m(); - g(); - var gdr = Vd(); - function Ree() { - this.handlers = []; - } - Ree.prototype.use = function (e, r, n) { - return ( - this.handlers.push({ - fulfilled: e, - rejected: r, - synchronous: n ? n.synchronous : !1, - runWhen: n ? n.runWhen : null, - }), - this.handlers.length - 1 - ); - }; - Ree.prototype.eject = function (e) { - this.handlers[e] && (this.handlers[e] = null); - }; - Ree.prototype.forEach = function (e) { - gdr.forEach(this.handlers, function (n) { - n !== null && e(n); - }); - }; - vtt.exports = Ree; - }); - var _tt = I((Wpn, wtt) => { - "use strict"; - m(); - g(); - var vdr = Vd(); - wtt.exports = function (e, r) { - vdr.forEach(e, function (i, o) { - o !== r && - o.toUpperCase() === r.toUpperCase() && - ((e[r] = i), delete e[o]); - }); - }; - }); - var xxe = I((Gpn, xtt) => { - "use strict"; - m(); - g(); - xtt.exports = function (e, r, n, i, o) { - return ( - (e.config = r), - n && (e.code = n), - (e.request = i), - (e.response = o), - (e.isAxiosError = !0), - (e.toJSON = function () { - return { - message: this.message, - name: this.name, - description: this.description, - number: this.number, - fileName: this.fileName, - lineNumber: this.lineNumber, - columnNumber: this.columnNumber, - stack: this.stack, - config: this.config, - code: this.code, - status: - this.response && this.response.status - ? this.response.status - : null, - }; - }), - e - ); - }; - }); - var Sxe = I((Jpn, Stt) => { - "use strict"; - m(); - g(); - var bdr = xxe(); - Stt.exports = function (e, r, n, i, o) { - var a = new Error(e); - return bdr(a, r, n, i, o); - }; - }); - var Ett = I(($pn, Att) => { - "use strict"; - m(); - g(); - var wdr = Sxe(); - Att.exports = function (e, r, n) { - var i = n.config.validateStatus; - !n.status || !i || i(n.status) - ? e(n) - : r( - wdr( - "Request failed with status code " + n.status, - n.config, - null, - n.request, - n - ) - ); - }; - }); - var Ttt = I((Zpn, Mtt) => { - "use strict"; - m(); - g(); - var Nee = Vd(); - Mtt.exports = Nee.isStandardBrowserEnv() - ? (function () { - return { - write: function (r, n, i, o, a, s) { - var c = []; - c.push(r + "=" + encodeURIComponent(n)), - Nee.isNumber(i) && - c.push("expires=" + new Date(i).toGMTString()), - Nee.isString(o) && c.push("path=" + o), - Nee.isString(a) && c.push("domain=" + a), - s === !0 && c.push("secure"), - (document.cookie = c.join("; ")); - }, - read: function (r) { - var n = document.cookie.match( - new RegExp("(^|;\\s*)(" + r + ")=([^;]*)") - ); - return n ? decodeURIComponent(n[3]) : null; - }, - remove: function (r) { - this.write(r, "", Date.now() - 864e5); - }, - }; - })() - : (function () { - return { - write: function () {}, - read: function () { - return null; - }, - remove: function () {}, - }; - })(); - }); - var Ptt = I((Xpn, ktt) => { - "use strict"; - m(); - g(); - ktt.exports = function (e) { - return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(e); - }; - }); - var Btt = I((Ypn, Ott) => { - "use strict"; - m(); - g(); - Ott.exports = function (e, r) { - return r ? e.replace(/\/+$/, "") + "/" + r.replace(/^\/+/, "") : e; - }; - }); - var Ctt = I((Qpn, Itt) => { - "use strict"; - m(); - g(); - var _dr = Ptt(), - xdr = Btt(); - Itt.exports = function (e, r) { - return e && !_dr(r) ? xdr(e, r) : r; - }; - }); - var Ntt = I((e0n, Rtt) => { - "use strict"; - m(); - g(); - var Axe = Vd(), - Sdr = [ - "age", - "authorization", - "content-length", - "content-type", - "etag", - "expires", - "from", - "host", - "if-modified-since", - "if-unmodified-since", - "last-modified", - "location", - "max-forwards", - "proxy-authorization", - "referer", - "retry-after", - "user-agent", - ]; - Rtt.exports = function (e) { - var r = {}, - n, - i, - o; - return ( - e && - Axe.forEach( - e.split(` -`), - function (s) { - if ( - ((o = s.indexOf(":")), - (n = Axe.trim(s.substr(0, o)).toLowerCase()), - (i = Axe.trim(s.substr(o + 1))), - n) - ) { - if (r[n] && Sdr.indexOf(n) >= 0) return; - n === "set-cookie" - ? (r[n] = (r[n] ? r[n] : []).concat([i])) - : (r[n] = r[n] ? r[n] + ", " + i : i); - } - } - ), - r - ); - }; - }); - var Ltt = I((t0n, Ftt) => { - "use strict"; - m(); - g(); - var Dtt = Vd(); - Ftt.exports = Dtt.isStandardBrowserEnv() - ? (function () { - var e = /(msie|trident)/i.test(navigator.userAgent), - r = document.createElement("a"), - n; - function i(o) { - var a = o; - return ( - e && (r.setAttribute("href", a), (a = r.href)), - r.setAttribute("href", a), - { - href: r.href, - protocol: r.protocol ? r.protocol.replace(/:$/, "") : "", - host: r.host, - search: r.search ? r.search.replace(/^\?/, "") : "", - hash: r.hash ? r.hash.replace(/^#/, "") : "", - hostname: r.hostname, - port: r.port, - pathname: - r.pathname.charAt(0) === "/" ? r.pathname : "/" + r.pathname, - } - ); - } - return ( - (n = i(window.location.href)), - function (a) { - var s = Dtt.isString(a) ? i(a) : a; - return s.protocol === n.protocol && s.host === n.host; - } - ); - })() - : (function () { - return function () { - return !0; - }; - })(); - }); - var Lj = I((r0n, qtt) => { - "use strict"; - m(); - g(); - function Exe(t) { - this.message = t; - } - Exe.prototype.toString = function () { - return "Cancel" + (this.message ? ": " + this.message : ""); - }; - Exe.prototype.__CANCEL__ = !0; - qtt.exports = Exe; - }); - var Txe = I((n0n, ztt) => { - "use strict"; - m(); - g(); - var Dee = Vd(), - Adr = Ett(), - Edr = Ttt(), - Mdr = _xe(), - Tdr = Ctt(), - kdr = Ntt(), - Pdr = Ltt(), - Mxe = Sxe(), - Odr = qj(), - Bdr = Lj(); - ztt.exports = function (e) { - return new Promise(function (n, i) { - var o = e.data, - a = e.headers, - s = e.responseType, - c; - function u() { - e.cancelToken && e.cancelToken.unsubscribe(c), - e.signal && e.signal.removeEventListener("abort", c); - } - Dee.isFormData(o) && delete a["Content-Type"]; - var h = new XMLHttpRequest(); - if (e.auth) { - var w = e.auth.username || "", - M = e.auth.password - ? unescape(encodeURIComponent(e.auth.password)) - : ""; - a.Authorization = "Basic " + btoa(w + ":" + M); - } - var k = Tdr(e.baseURL, e.url); - h.open( - e.method.toUpperCase(), - Mdr(k, e.params, e.paramsSerializer), - !0 - ), - (h.timeout = e.timeout); - function O() { - if (!!h) { - var F = - "getAllResponseHeaders" in h - ? kdr(h.getAllResponseHeaders()) - : null, - N = - !s || s === "text" || s === "json" - ? h.responseText - : h.response, - q = { - data: N, - status: h.status, - statusText: h.statusText, - headers: F, - config: e, - request: h, - }; - Adr( - function (H) { - n(H), u(); - }, - function (H) { - i(H), u(); - }, - q - ), - (h = null); - } - } - if ( - ("onloadend" in h - ? (h.onloadend = O) - : (h.onreadystatechange = function () { - !h || - h.readyState !== 4 || - (h.status === 0 && - !(h.responseURL && h.responseURL.indexOf("file:") === 0)) || - setTimeout(O); - }), - (h.onabort = function () { - !h || (i(Mxe("Request aborted", e, "ECONNABORTED", h)), (h = null)); - }), - (h.onerror = function () { - i(Mxe("Network Error", e, null, h)), (h = null); - }), - (h.ontimeout = function () { - var N = e.timeout - ? "timeout of " + e.timeout + "ms exceeded" - : "timeout exceeded", - q = e.transitional || Odr.transitional; - e.timeoutErrorMessage && (N = e.timeoutErrorMessage), - i( - Mxe( - N, - e, - q.clarifyTimeoutError ? "ETIMEDOUT" : "ECONNABORTED", - h - ) - ), - (h = null); - }), - Dee.isStandardBrowserEnv()) - ) { - var D = - (e.withCredentials || Pdr(k)) && e.xsrfCookieName - ? Edr.read(e.xsrfCookieName) - : void 0; - D && (a[e.xsrfHeaderName] = D); - } - "setRequestHeader" in h && - Dee.forEach(a, function (N, q) { - typeof o > "u" && q.toLowerCase() === "content-type" - ? delete a[q] - : h.setRequestHeader(q, N); - }), - Dee.isUndefined(e.withCredentials) || - (h.withCredentials = !!e.withCredentials), - s && s !== "json" && (h.responseType = e.responseType), - typeof e.onDownloadProgress == "function" && - h.addEventListener("progress", e.onDownloadProgress), - typeof e.onUploadProgress == "function" && - h.upload && - h.upload.addEventListener("progress", e.onUploadProgress), - (e.cancelToken || e.signal) && - ((c = function (F) { - !h || - (i(!F || (F && F.type) ? new Bdr("canceled") : F), - h.abort(), - (h = null)); - }), - e.cancelToken && e.cancelToken.subscribe(c), - e.signal && - (e.signal.aborted ? c() : e.signal.addEventListener("abort", c))), - o || (o = null), - h.send(o); - }); - }; - }); - var qj = I((i0n, Ktt) => { - "use strict"; - m(); - g(); - var ac = Vd(), - jtt = _tt(), - Idr = xxe(), - Cdr = { "Content-Type": "application/x-www-form-urlencoded" }; - function Utt(t, e) { - !ac.isUndefined(t) && - ac.isUndefined(t["Content-Type"]) && - (t["Content-Type"] = e); - } - function Rdr() { - var t; - return ( - typeof XMLHttpRequest < "u" - ? (t = Txe()) - : typeof process < "u" && - Object.prototype.toString.call(process) === "[object process]" && - (t = Txe()), - t - ); - } - function Ndr(t, e, r) { - if (ac.isString(t)) - try { - return (e || JSON.parse)(t), ac.trim(t); - } catch (n) { - if (n.name !== "SyntaxError") throw n; - } - return (r || JSON.stringify)(t); - } - var Fee = { - transitional: { - silentJSONParsing: !0, - forcedJSONParsing: !0, - clarifyTimeoutError: !1, - }, - adapter: Rdr(), - transformRequest: [ - function (e, r) { - return ( - jtt(r, "Accept"), - jtt(r, "Content-Type"), - ac.isFormData(e) || - ac.isArrayBuffer(e) || - ac.isBuffer(e) || - ac.isStream(e) || - ac.isFile(e) || - ac.isBlob(e) - ? e - : ac.isArrayBufferView(e) - ? e.buffer - : ac.isURLSearchParams(e) - ? (Utt(r, "application/x-www-form-urlencoded;charset=utf-8"), - e.toString()) - : ac.isObject(e) || - (r && r["Content-Type"] === "application/json") - ? (Utt(r, "application/json"), Ndr(e)) - : e - ); - }, - ], - transformResponse: [ - function (e) { - var r = this.transitional || Fee.transitional, - n = r && r.silentJSONParsing, - i = r && r.forcedJSONParsing, - o = !n && this.responseType === "json"; - if (o || (i && ac.isString(e) && e.length)) - try { - return JSON.parse(e); - } catch (a) { - if (o) - throw a.name === "SyntaxError" - ? Idr(a, this, "E_JSON_PARSE") - : a; - } - return e; - }, - ], - timeout: 0, - xsrfCookieName: "XSRF-TOKEN", - xsrfHeaderName: "X-XSRF-TOKEN", - maxContentLength: -1, - maxBodyLength: -1, - validateStatus: function (e) { - return e >= 200 && e < 300; - }, - headers: { common: { Accept: "application/json, text/plain, */*" } }, - }; - ac.forEach(["delete", "get", "head"], function (e) { - Fee.headers[e] = {}; - }); - ac.forEach(["post", "put", "patch"], function (e) { - Fee.headers[e] = ac.merge(Cdr); - }); - Ktt.exports = Fee; - }); - var Vtt = I((o0n, Htt) => { - "use strict"; - m(); - g(); - var Ddr = Vd(), - Fdr = qj(); - Htt.exports = function (e, r, n) { - var i = this || Fdr; - return ( - Ddr.forEach(n, function (a) { - e = a.call(i, e, r); - }), - e - ); - }; - }); - var kxe = I((a0n, Wtt) => { - "use strict"; - m(); - g(); - Wtt.exports = function (e) { - return !!(e && e.__CANCEL__); - }; - }); - var $tt = I((s0n, Jtt) => { - "use strict"; - m(); - g(); - var Gtt = Vd(), - Pxe = Vtt(), - Ldr = kxe(), - qdr = qj(), - zdr = Lj(); - function Oxe(t) { - if ( - (t.cancelToken && t.cancelToken.throwIfRequested(), - t.signal && t.signal.aborted) - ) - throw new zdr("canceled"); - } - Jtt.exports = function (e) { - Oxe(e), - (e.headers = e.headers || {}), - (e.data = Pxe.call(e, e.data, e.headers, e.transformRequest)), - (e.headers = Gtt.merge( - e.headers.common || {}, - e.headers[e.method] || {}, - e.headers - )), - Gtt.forEach( - ["delete", "get", "head", "post", "put", "patch", "common"], - function (i) { - delete e.headers[i]; - } - ); - var r = e.adapter || qdr.adapter; - return r(e).then( - function (i) { - return ( - Oxe(e), - (i.data = Pxe.call(e, i.data, i.headers, e.transformResponse)), - i - ); - }, - function (i) { - return ( - Ldr(i) || - (Oxe(e), - i && - i.response && - (i.response.data = Pxe.call( - e, - i.response.data, - i.response.headers, - e.transformResponse - ))), - Promise.reject(i) - ); - } - ); - }; - }); - var Bxe = I((u0n, Ztt) => { - "use strict"; - m(); - g(); - var Vp = Vd(); - Ztt.exports = function (e, r) { - r = r || {}; - var n = {}; - function i(h, w) { - return Vp.isPlainObject(h) && Vp.isPlainObject(w) - ? Vp.merge(h, w) - : Vp.isPlainObject(w) - ? Vp.merge({}, w) - : Vp.isArray(w) - ? w.slice() - : w; - } - function o(h) { - if (Vp.isUndefined(r[h])) { - if (!Vp.isUndefined(e[h])) return i(void 0, e[h]); - } else return i(e[h], r[h]); - } - function a(h) { - if (!Vp.isUndefined(r[h])) return i(void 0, r[h]); - } - function s(h) { - if (Vp.isUndefined(r[h])) { - if (!Vp.isUndefined(e[h])) return i(void 0, e[h]); - } else return i(void 0, r[h]); - } - function c(h) { - if (h in r) return i(e[h], r[h]); - if (h in e) return i(void 0, e[h]); - } - var u = { - url: a, - method: a, - data: a, - baseURL: s, - transformRequest: s, - transformResponse: s, - paramsSerializer: s, - timeout: s, - timeoutMessage: s, - withCredentials: s, - adapter: s, - responseType: s, - xsrfCookieName: s, - xsrfHeaderName: s, - onUploadProgress: s, - onDownloadProgress: s, - decompress: s, - maxContentLength: s, - maxBodyLength: s, - transport: s, - httpAgent: s, - httpsAgent: s, - cancelToken: s, - socketPath: s, - responseEncoding: s, - validateStatus: c, - }; - return ( - Vp.forEach(Object.keys(e).concat(Object.keys(r)), function (w) { - var M = u[w] || o, - k = M(w); - (Vp.isUndefined(k) && M !== c) || (n[w] = k); - }), - n - ); - }; - }); - var Ixe = I((c0n, Xtt) => { - m(); - g(); - Xtt.exports = { version: "0.25.0" }; - }); - var ert = I((l0n, Qtt) => { - "use strict"; - m(); - g(); - var jdr = Ixe().version, - Cxe = {}; - ["object", "boolean", "number", "function", "string", "symbol"].forEach( - function (t, e) { - Cxe[t] = function (n) { - return typeof n === t || "a" + (e < 1 ? "n " : " ") + t; - }; - } - ); - var Ytt = {}; - Cxe.transitional = function (e, r, n) { - function i(o, a) { - return ( - "[Axios v" + - jdr + - "] Transitional option '" + - o + - "'" + - a + - (n ? ". " + n : "") - ); - } - return function (o, a, s) { - if (e === !1) - throw new Error(i(a, " has been removed" + (r ? " in " + r : ""))); - return ( - r && - !Ytt[a] && - ((Ytt[a] = !0), - console.warn( - i( - a, - " has been deprecated since v" + - r + - " and will be removed in the near future" - ) - )), - e ? e(o, a, s) : !0 - ); - }; - }; - function Udr(t, e, r) { - if (typeof t != "object") - throw new TypeError("options must be an object"); - for (var n = Object.keys(t), i = n.length; i-- > 0; ) { - var o = n[i], - a = e[o]; - if (a) { - var s = t[o], - c = s === void 0 || a(s, o, t); - if (c !== !0) throw new TypeError("option " + o + " must be " + c); - continue; - } - if (r !== !0) throw Error("Unknown option " + o); - } - } - Qtt.exports = { assertOptions: Udr, validators: Cxe }; - }); - var art = I((f0n, ort) => { - "use strict"; - m(); - g(); - var nrt = Vd(), - Kdr = _xe(), - trt = btt(), - rrt = $tt(), - Lee = Bxe(), - irt = ert(), - KC = irt.validators; - function zj(t) { - (this.defaults = t), - (this.interceptors = { request: new trt(), response: new trt() }); - } - zj.prototype.request = function (e, r) { - if ( - (typeof e == "string" ? ((r = r || {}), (r.url = e)) : (r = e || {}), - !r.url) - ) - throw new Error("Provided config url is not valid"); - (r = Lee(this.defaults, r)), - r.method - ? (r.method = r.method.toLowerCase()) - : this.defaults.method - ? (r.method = this.defaults.method.toLowerCase()) - : (r.method = "get"); - var n = r.transitional; - n !== void 0 && - irt.assertOptions( - n, - { - silentJSONParsing: KC.transitional(KC.boolean), - forcedJSONParsing: KC.transitional(KC.boolean), - clarifyTimeoutError: KC.transitional(KC.boolean), - }, - !1 - ); - var i = [], - o = !0; - this.interceptors.request.forEach(function (k) { - (typeof k.runWhen == "function" && k.runWhen(r) === !1) || - ((o = o && k.synchronous), i.unshift(k.fulfilled, k.rejected)); - }); - var a = []; - this.interceptors.response.forEach(function (k) { - a.push(k.fulfilled, k.rejected); - }); - var s; - if (!o) { - var c = [rrt, void 0]; - for ( - Array.prototype.unshift.apply(c, i), - c = c.concat(a), - s = Promise.resolve(r); - c.length; - - ) - s = s.then(c.shift(), c.shift()); - return s; - } - for (var u = r; i.length; ) { - var h = i.shift(), - w = i.shift(); - try { - u = h(u); - } catch (M) { - w(M); - break; - } - } - try { - s = rrt(u); - } catch (M) { - return Promise.reject(M); - } - for (; a.length; ) s = s.then(a.shift(), a.shift()); - return s; - }; - zj.prototype.getUri = function (e) { - if (!e.url) throw new Error("Provided config url is not valid"); - return ( - (e = Lee(this.defaults, e)), - Kdr(e.url, e.params, e.paramsSerializer).replace(/^\?/, "") - ); - }; - nrt.forEach(["delete", "get", "head", "options"], function (e) { - zj.prototype[e] = function (r, n) { - return this.request( - Lee(n || {}, { method: e, url: r, data: (n || {}).data }) - ); - }; - }); - nrt.forEach(["post", "put", "patch"], function (e) { - zj.prototype[e] = function (r, n, i) { - return this.request(Lee(i || {}, { method: e, url: r, data: n })); - }; - }); - ort.exports = zj; - }); - var urt = I((d0n, srt) => { - "use strict"; - m(); - g(); - var Hdr = Lj(); - function HC(t) { - if (typeof t != "function") - throw new TypeError("executor must be a function."); - var e; - this.promise = new Promise(function (i) { - e = i; - }); - var r = this; - this.promise.then(function (n) { - if (!!r._listeners) { - var i, - o = r._listeners.length; - for (i = 0; i < o; i++) r._listeners[i](n); - r._listeners = null; - } - }), - (this.promise.then = function (n) { - var i, - o = new Promise(function (a) { - r.subscribe(a), (i = a); - }).then(n); - return ( - (o.cancel = function () { - r.unsubscribe(i); - }), - o - ); - }), - t(function (i) { - r.reason || ((r.reason = new Hdr(i)), e(r.reason)); - }); - } - HC.prototype.throwIfRequested = function () { - if (this.reason) throw this.reason; - }; - HC.prototype.subscribe = function (e) { - if (this.reason) { - e(this.reason); - return; - } - this._listeners ? this._listeners.push(e) : (this._listeners = [e]); - }; - HC.prototype.unsubscribe = function (e) { - if (!!this._listeners) { - var r = this._listeners.indexOf(e); - r !== -1 && this._listeners.splice(r, 1); - } - }; - HC.source = function () { - var e, - r = new HC(function (i) { - e = i; - }); - return { token: r, cancel: e }; - }; - srt.exports = HC; - }); - var lrt = I((h0n, crt) => { - "use strict"; - m(); - g(); - crt.exports = function (e) { - return function (n) { - return e.apply(null, n); - }; - }; - }); - var drt = I((p0n, frt) => { - "use strict"; - m(); - g(); - var Vdr = Vd(); - frt.exports = function (e) { - return Vdr.isObject(e) && e.isAxiosError === !0; - }; - }); - var yrt = I((y0n, Rxe) => { - "use strict"; - m(); - g(); - var hrt = Vd(), - Wdr = mxe(), - qee = art(), - Gdr = Bxe(), - Jdr = qj(); - function prt(t) { - var e = new qee(t), - r = Wdr(qee.prototype.request, e); - return ( - hrt.extend(r, qee.prototype, e), - hrt.extend(r, e), - (r.create = function (i) { - return prt(Gdr(t, i)); - }), - r - ); - } - var Dv = prt(Jdr); - Dv.Axios = qee; - Dv.Cancel = Lj(); - Dv.CancelToken = urt(); - Dv.isCancel = kxe(); - Dv.VERSION = Ixe().version; - Dv.all = function (e) { - return Promise.all(e); - }; - Dv.spread = lrt(); - Dv.isAxiosError = drt(); - Rxe.exports = Dv; - Rxe.exports.default = Dv; - }); - var zee = I((m0n, mrt) => { - m(); - g(); - mrt.exports = yrt(); - }); - var grt = I((jj) => { - "use strict"; - m(); - g(); - var $dr = - (jj && jj.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(jj, "__esModule", { value: !0 }); - var Zdr = $dr(zee()), - Nxe = class { - constructor(e) { - (this.METHOD_GET = "GET"), - (this.METHOD_POST = "POST"), - this.applyConfig(e); - } - applyConfig(e) { - this.config = this.mergeDefaults(e); - } - getConfig() { - return this.config; - } - mergeDefaults(e) { - let r = e.protocol || "http", - n = e.port || (r === "https" ? 443 : 80); - return { - host: e.host || "127.0.0.1", - protocol: r, - port: n, - timeout: e.timeout || 2e4, - logging: e.logging || !1, - logger: e.logger || console.log, - }; - } - async get(e, r) { - try { - return await this.request().get(e, r); - } catch (n) { - if (n.response && n.response.status) return n.response; - throw n; - } - } - async post(e, r, n) { - try { - return await this.request().post(e, r, n); - } catch (i) { - if (i.response && i.response.status) return i.response; - throw i; - } - } - request() { - let e = Zdr.default.create({ - baseURL: `${this.config.protocol}://${this.config.host}:${this.config.port}`, - timeout: this.config.timeout, - maxContentLength: 536870912, - }); - return ( - this.config.logging && - (e.interceptors.request.use( - (r) => ( - this.config.logger(`Requesting: ${r.baseURL}/${r.url}`), r - ) - ), - e.interceptors.response.use( - (r) => ( - this.config.logger( - `Response: ${r.config.url} - ${r.status}` - ), - r - ) - )), - e - ); - } - }; - jj.default = Nxe; - }); - var Dxe = I((co) => { - "use strict"; - m(); - g(); - var Xdr = - (co && co.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Ydr = - (co && co.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Qdr = - (co && co.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - Xdr(e, t, r); - return Ydr(e, t), e; - }; - Object.defineProperty(co, "__esModule", { value: !0 }); - co.b64UrlDecode = - co.b64UrlEncode = - co.bufferTob64Url = - co.bufferTob64 = - co.b64UrlToBuffer = - co.stringToB64Url = - co.stringToBuffer = - co.bufferToString = - co.b64UrlToString = - co.concatBuffers = - void 0; - var vrt = Qdr(QI()); - function ehr(t) { - let e = 0; - for (let i = 0; i < t.length; i++) e += t[i].byteLength; - let r = new Uint8Array(e), - n = 0; - r.set(new Uint8Array(t[0]), n), (n += t[0].byteLength); - for (let i = 1; i < t.length; i++) - r.set(new Uint8Array(t[i]), n), (n += t[i].byteLength); - return r; - } - co.concatBuffers = ehr; - function thr(t) { - let e = _rt(t); - return brt(e); - } - co.b64UrlToString = thr; - function brt(t) { - if (typeof TextDecoder > "u") { - let e = es().TextDecoder; - return new e("utf-8", { fatal: !0 }).decode(t); - } - return new TextDecoder("utf-8", { fatal: !0 }).decode(t); - } - co.bufferToString = brt; - function wrt(t) { - if (typeof TextEncoder > "u") { - let e = es().TextEncoder; - return new e().encode(t); - } - return new TextEncoder().encode(t); - } - co.stringToBuffer = wrt; - function rhr(t) { - return Srt(wrt(t)); - } - co.stringToB64Url = rhr; - function _rt(t) { - return new Uint8Array(vrt.toByteArray(Ert(t))); - } - co.b64UrlToBuffer = _rt; - function xrt(t) { - return vrt.fromByteArray(new Uint8Array(t)); - } - co.bufferTob64 = xrt; - function Srt(t) { - return Art(xrt(t)); - } - co.bufferTob64Url = Srt; - function Art(t) { - return t.replace(/\+/g, "-").replace(/\//g, "_").replace(/\=/g, ""); - } - co.b64UrlEncode = Art; - function Ert(t) { - t = t.replace(/\-/g, "+").replace(/\_/g, "/"); - let e; - return ( - t.length % 4 == 0 ? (e = 0) : (e = 4 - (t.length % 4)), - t.concat("=".repeat(e)) - ); - } - co.b64UrlDecode = Ert; - }); - var VC = I((Gc) => { - "use strict"; - m(); - g(); - Object.defineProperty(Gc, "__esModule", { value: !0 }); - Gc.isBrowser = - Gc.arraybufferEqual = - Gc.byteArrayToLong = - Gc.longTo32ByteArray = - Gc.longTo16ByteArray = - Gc.shortTo2ByteArray = - Gc.longTo8ByteArray = - void 0; - function nhr(t) { - let e = [0, 0, 0, 0, 0, 0, 0, 0]; - for (let r = 0; r < e.length; r++) { - let n = t & 255; - (e[r] = n), (t = (t - n) / 256); - } - return Uint8Array.from(e); - } - Gc.longTo8ByteArray = nhr; - function ihr(t) { - if (t > (2 ^ (32 - 1))) throw new Error("Short too long"); - let e = [0, 0]; - for (let r = 0; r < e.length; r++) { - let n = t & 255; - (e[r] = n), (t = (t - n) / 256); - } - return Uint8Array.from(e); - } - Gc.shortTo2ByteArray = ihr; - function ohr(t) { - let e = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; - for (let r = 0; r < e.length; r++) { - let n = t & 255; - (e[r] = n), (t = (t - n) / 256); - } - return e; - } - Gc.longTo16ByteArray = ohr; - function ahr(t) { - let e = [ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - ]; - for (let r = 0; r < e.length; r++) { - let n = t & 255; - (e[r] = n), (t = (t - n) / 256); - } - return Uint8Array.from(e); - } - Gc.longTo32ByteArray = ahr; - function shr(t) { - let e = 0; - for (let r = t.length - 1; r >= 0; r--) e = e * 256 + t[r]; - return e; - } - Gc.byteArrayToLong = shr; - function uhr(t, e) { - let r = t.buffer, - n = e.buffer; - if (r === n) return !0; - if (r.byteLength !== n.byteLength) return !1; - let i = new DataView(r), - o = new DataView(n), - a = r.byteLength; - for (; a--; ) if (i.getUint8(a) !== o.getUint8(a)) return !1; - return !0; - } - Gc.arraybufferEqual = uhr; - Gc.isBrowser = typeof window < "u" && typeof window.document < "u"; - }); - var Sy = I((Mrt, jee) => { - m(); - g(); - (function (t) { - "use strict"; - var e, - r = /^-?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i, - n = Math.ceil, - i = Math.floor, - o = "[BigNumber Error] ", - a = o + "Number primitive has more than 15 significant digits: ", - s = 1e14, - c = 14, - u = 9007199254740991, - h = [ - 1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, - ], - w = 1e7, - M = 1e9; - function k(Z) { - var $, - ue, - te, - ne = (B.prototype = { - constructor: B, - toString: null, - valueOf: null, - }), - A = new B(1), - l = 20, - p = 4, - y = -7, - d = 21, - v = -1e7, - _ = 1e7, - S = !1, - b = 1, - f = 0, - x = { - prefix: "", - groupSize: 3, - secondaryGroupSize: 0, - groupSeparator: ",", - decimalSeparator: ".", - fractionGroupSize: 0, - fractionGroupSeparator: "\xA0", - suffix: "", - }, - C = "0123456789abcdefghijklmnopqrstuvwxyz", - E = !0; - function B(V, ye) { - var ae, - le, - Me, - de, - ve, - De, - me, - _e, - Ye = this; - if (!(Ye instanceof B)) return new B(V, ye); - if (ye == null) { - if (V && V._isBigNumber === !0) { - (Ye.s = V.s), - !V.c || V.e > _ - ? (Ye.c = Ye.e = null) - : V.e < v - ? (Ye.c = [(Ye.e = 0)]) - : ((Ye.e = V.e), (Ye.c = V.c.slice())); - return; - } - if ((De = typeof V == "number") && V * 0 == 0) { - if (((Ye.s = 1 / V < 0 ? ((V = -V), -1) : 1), V === ~~V)) { - for (de = 0, ve = V; ve >= 10; ve /= 10, de++); - de > _ ? (Ye.c = Ye.e = null) : ((Ye.e = de), (Ye.c = [V])); - return; - } - _e = String(V); - } else { - if (!r.test((_e = String(V)))) return te(Ye, _e, De); - Ye.s = _e.charCodeAt(0) == 45 ? ((_e = _e.slice(1)), -1) : 1; - } - (de = _e.indexOf(".")) > -1 && (_e = _e.replace(".", "")), - (ve = _e.search(/e/i)) > 0 - ? (de < 0 && (de = ve), - (de += +_e.slice(ve + 1)), - (_e = _e.substring(0, ve))) - : de < 0 && (de = _e.length); - } else { - if ((N(ye, 2, C.length, "Base"), ye == 10 && E)) - return (Ye = new B(V)), ge(Ye, l + Ye.e + 1, p); - if (((_e = String(V)), (De = typeof V == "number"))) { - if (V * 0 != 0) return te(Ye, _e, De, ye); - if ( - ((Ye.s = 1 / V < 0 ? ((_e = _e.slice(1)), -1) : 1), - B.DEBUG && _e.replace(/^0\.0*|\./, "").length > 15) - ) - throw Error(a + V); - } else - Ye.s = _e.charCodeAt(0) === 45 ? ((_e = _e.slice(1)), -1) : 1; - for ( - ae = C.slice(0, ye), de = ve = 0, me = _e.length; - ve < me; - ve++ - ) - if (ae.indexOf((le = _e.charAt(ve))) < 0) { - if (le == ".") { - if (ve > de) { - de = me; - continue; - } - } else if ( - !Me && - ((_e == _e.toUpperCase() && (_e = _e.toLowerCase())) || - (_e == _e.toLowerCase() && (_e = _e.toUpperCase()))) - ) { - (Me = !0), (ve = -1), (de = 0); - continue; - } - return te(Ye, String(V), De, ye); - } - (De = !1), - (_e = ue(_e, ye, 10, Ye.s)), - (de = _e.indexOf(".")) > -1 - ? (_e = _e.replace(".", "")) - : (de = _e.length); - } - for (ve = 0; _e.charCodeAt(ve) === 48; ve++); - for (me = _e.length; _e.charCodeAt(--me) === 48; ); - if ((_e = _e.slice(ve, ++me))) { - if (((me -= ve), De && B.DEBUG && me > 15 && (V > u || V !== i(V)))) - throw Error(a + Ye.s * V); - if ((de = de - ve - 1) > _) Ye.c = Ye.e = null; - else if (de < v) Ye.c = [(Ye.e = 0)]; - else { - if ( - ((Ye.e = de), - (Ye.c = []), - (ve = (de + 1) % c), - de < 0 && (ve += c), - ve < me) - ) { - for (ve && Ye.c.push(+_e.slice(0, ve)), me -= c; ve < me; ) - Ye.c.push(+_e.slice(ve, (ve += c))); - ve = c - (_e = _e.slice(ve)).length; - } else ve -= me; - for (; ve--; _e += "0"); - Ye.c.push(+_e); - } - } else Ye.c = [(Ye.e = 0)]; - } - (B.clone = k), - (B.ROUND_UP = 0), - (B.ROUND_DOWN = 1), - (B.ROUND_CEIL = 2), - (B.ROUND_FLOOR = 3), - (B.ROUND_HALF_UP = 4), - (B.ROUND_HALF_DOWN = 5), - (B.ROUND_HALF_EVEN = 6), - (B.ROUND_HALF_CEIL = 7), - (B.ROUND_HALF_FLOOR = 8), - (B.EUCLID = 9), - (B.config = B.set = - function (V) { - var ye, ae; - if (V != null) - if (typeof V == "object") { - if ( - (V.hasOwnProperty((ye = "DECIMAL_PLACES")) && - ((ae = V[ye]), N(ae, 0, M, ye), (l = ae)), - V.hasOwnProperty((ye = "ROUNDING_MODE")) && - ((ae = V[ye]), N(ae, 0, 8, ye), (p = ae)), - V.hasOwnProperty((ye = "EXPONENTIAL_AT")) && - ((ae = V[ye]), - ae && ae.pop - ? (N(ae[0], -M, 0, ye), - N(ae[1], 0, M, ye), - (y = ae[0]), - (d = ae[1])) - : (N(ae, -M, M, ye), (y = -(d = ae < 0 ? -ae : ae)))), - V.hasOwnProperty((ye = "RANGE"))) - ) - if (((ae = V[ye]), ae && ae.pop)) - N(ae[0], -M, -1, ye), - N(ae[1], 1, M, ye), - (v = ae[0]), - (_ = ae[1]); - else if ((N(ae, -M, M, ye), ae)) - v = -(_ = ae < 0 ? -ae : ae); - else throw Error(o + ye + " cannot be zero: " + ae); - if (V.hasOwnProperty((ye = "CRYPTO"))) - if (((ae = V[ye]), ae === !!ae)) - if (ae) - if ( - typeof crypto < "u" && - crypto && - (crypto.getRandomValues || crypto.randomBytes) - ) - S = ae; - else throw ((S = !ae), Error(o + "crypto unavailable")); - else S = ae; - else throw Error(o + ye + " not true or false: " + ae); - if ( - (V.hasOwnProperty((ye = "MODULO_MODE")) && - ((ae = V[ye]), N(ae, 0, 9, ye), (b = ae)), - V.hasOwnProperty((ye = "POW_PRECISION")) && - ((ae = V[ye]), N(ae, 0, M, ye), (f = ae)), - V.hasOwnProperty((ye = "FORMAT"))) - ) - if (((ae = V[ye]), typeof ae == "object")) x = ae; - else throw Error(o + ye + " not an object: " + ae); - if (V.hasOwnProperty((ye = "ALPHABET"))) - if ( - ((ae = V[ye]), - typeof ae == "string" && - !/^.?$|[+\-.\s]|(.).*\1/.test(ae)) - ) - (E = ae.slice(0, 10) == "0123456789"), (C = ae); - else throw Error(o + ye + " invalid: " + ae); - } else throw Error(o + "Object expected: " + V); - return { - DECIMAL_PLACES: l, - ROUNDING_MODE: p, - EXPONENTIAL_AT: [y, d], - RANGE: [v, _], - CRYPTO: S, - MODULO_MODE: b, - POW_PRECISION: f, - FORMAT: x, - ALPHABET: C, - }; - }), - (B.isBigNumber = function (V) { - if (!V || V._isBigNumber !== !0) return !1; - if (!B.DEBUG) return !0; - var ye, - ae, - le = V.c, - Me = V.e, - de = V.s; - e: if ({}.toString.call(le) == "[object Array]") { - if ( - (de === 1 || de === -1) && - Me >= -M && - Me <= M && - Me === i(Me) - ) { - if (le[0] === 0) { - if (Me === 0 && le.length === 1) return !0; - break e; - } - if ( - ((ye = (Me + 1) % c), - ye < 1 && (ye += c), - String(le[0]).length == ye) - ) { - for (ye = 0; ye < le.length; ye++) - if (((ae = le[ye]), ae < 0 || ae >= s || ae !== i(ae))) - break e; - if (ae !== 0) return !0; - } - } - } else if ( - le === null && - Me === null && - (de === null || de === 1 || de === -1) - ) - return !0; - throw Error(o + "Invalid BigNumber: " + V); - }), - (B.maximum = B.max = - function () { - return L(arguments, ne.lt); - }), - (B.minimum = B.min = - function () { - return L(arguments, ne.gt); - }), - (B.random = (function () { - var V = 9007199254740992, - ye = - (Math.random() * V) & 2097151 - ? function () { - return i(Math.random() * V); - } - : function () { - return ( - ((Math.random() * 1073741824) | 0) * 8388608 + - ((Math.random() * 8388608) | 0) - ); - }; - return function (ae) { - var le, - Me, - de, - ve, - De, - me = 0, - _e = [], - Ye = new B(A); - if ((ae == null ? (ae = l) : N(ae, 0, M), (ve = n(ae / c)), S)) - if (crypto.getRandomValues) { - for ( - le = crypto.getRandomValues(new Uint32Array((ve *= 2))); - me < ve; - - ) - (De = le[me] * 131072 + (le[me + 1] >>> 11)), - De >= 9e15 - ? ((Me = crypto.getRandomValues(new Uint32Array(2))), - (le[me] = Me[0]), - (le[me + 1] = Me[1])) - : (_e.push(De % 1e14), (me += 2)); - me = ve / 2; - } else if (crypto.randomBytes) { - for (le = crypto.randomBytes((ve *= 7)); me < ve; ) - (De = - (le[me] & 31) * 281474976710656 + - le[me + 1] * 1099511627776 + - le[me + 2] * 4294967296 + - le[me + 3] * 16777216 + - (le[me + 4] << 16) + - (le[me + 5] << 8) + - le[me + 6]), - De >= 9e15 - ? crypto.randomBytes(7).copy(le, me) - : (_e.push(De % 1e14), (me += 7)); - me = ve / 7; - } else throw ((S = !1), Error(o + "crypto unavailable")); - if (!S) - for (; me < ve; ) - (De = ye()), De < 9e15 && (_e[me++] = De % 1e14); - for ( - ve = _e[--me], - ae %= c, - ve && ae && ((De = h[c - ae]), (_e[me] = i(ve / De) * De)); - _e[me] === 0; - _e.pop(), me-- - ); - if (me < 0) _e = [(de = 0)]; - else { - for (de = -1; _e[0] === 0; _e.splice(0, 1), de -= c); - for (me = 1, De = _e[0]; De >= 10; De /= 10, me++); - me < c && (de -= c - me); - } - return (Ye.e = de), (Ye.c = _e), Ye; - }; - })()), - (B.sum = function () { - for (var V = 1, ye = arguments, ae = new B(ye[0]); V < ye.length; ) - ae = ae.plus(ye[V++]); - return ae; - }), - (ue = (function () { - var V = "0123456789"; - function ye(ae, le, Me, de) { - for (var ve, De = [0], me, _e = 0, Ye = ae.length; _e < Ye; ) { - for (me = De.length; me--; De[me] *= le); - for ( - De[0] += de.indexOf(ae.charAt(_e++)), ve = 0; - ve < De.length; - ve++ - ) - De[ve] > Me - 1 && - (De[ve + 1] == null && (De[ve + 1] = 0), - (De[ve + 1] += (De[ve] / Me) | 0), - (De[ve] %= Me)); - } - return De.reverse(); - } - return function (ae, le, Me, de, ve) { - var De, - me, - _e, - Ye, - Ee, - Be, - kt, - Ve, - We = ae.indexOf("."), - er = l, - Ue = p; - for ( - We >= 0 && - ((Ye = f), - (f = 0), - (ae = ae.replace(".", "")), - (Ve = new B(le)), - (Be = Ve.pow(ae.length - We)), - (f = Ye), - (Ve.c = ye(H(D(Be.c), Be.e, "0"), 10, Me, V)), - (Ve.e = Ve.c.length)), - kt = ye(ae, le, Me, ve ? ((De = C), V) : ((De = V), C)), - _e = Ye = kt.length; - kt[--Ye] == 0; - kt.pop() - ); - if (!kt[0]) return De.charAt(0); - if ( - (We < 0 - ? --_e - : ((Be.c = kt), - (Be.e = _e), - (Be.s = de), - (Be = $(Be, Ve, er, Ue, Me)), - (kt = Be.c), - (Ee = Be.r), - (_e = Be.e)), - (me = _e + er + 1), - (We = kt[me]), - (Ye = Me / 2), - (Ee = Ee || me < 0 || kt[me + 1] != null), - (Ee = - Ue < 4 - ? (We != null || Ee) && - (Ue == 0 || Ue == (Be.s < 0 ? 3 : 2)) - : We > Ye || - (We == Ye && - (Ue == 4 || - Ee || - (Ue == 6 && kt[me - 1] & 1) || - Ue == (Be.s < 0 ? 8 : 7)))), - me < 1 || !kt[0]) - ) - ae = Ee ? H(De.charAt(1), -er, De.charAt(0)) : De.charAt(0); - else { - if (((kt.length = me), Ee)) - for (--Me; ++kt[--me] > Me; ) - (kt[me] = 0), me || (++_e, (kt = [1].concat(kt))); - for (Ye = kt.length; !kt[--Ye]; ); - for (We = 0, ae = ""; We <= Ye; ae += De.charAt(kt[We++])); - ae = H(ae, _e, De.charAt(0)); - } - return ae; - }; - })()), - ($ = (function () { - function V(le, Me, de) { - var ve, - De, - me, - _e, - Ye = 0, - Ee = le.length, - Be = Me % w, - kt = (Me / w) | 0; - for (le = le.slice(); Ee--; ) - (me = le[Ee] % w), - (_e = (le[Ee] / w) | 0), - (ve = kt * me + _e * Be), - (De = Be * me + (ve % w) * w + Ye), - (Ye = ((De / de) | 0) + ((ve / w) | 0) + kt * _e), - (le[Ee] = De % de); - return Ye && (le = [Ye].concat(le)), le; - } - function ye(le, Me, de, ve) { - var De, me; - if (de != ve) me = de > ve ? 1 : -1; - else - for (De = me = 0; De < de; De++) - if (le[De] != Me[De]) { - me = le[De] > Me[De] ? 1 : -1; - break; - } - return me; - } - function ae(le, Me, de, ve) { - for (var De = 0; de--; ) - (le[de] -= De), - (De = le[de] < Me[de] ? 1 : 0), - (le[de] = De * ve + le[de] - Me[de]); - for (; !le[0] && le.length > 1; le.splice(0, 1)); - } - return function (le, Me, de, ve, De) { - var me, - _e, - Ye, - Ee, - Be, - kt, - Ve, - We, - er, - Ue, - Y, - W, - j, - ce, - ze, - we, - xe, - Ft = le.s == Me.s ? 1 : -1, - Ke = le.c, - pe = Me.c; - if (!Ke || !Ke[0] || !pe || !pe[0]) - return new B( - !le.s || !Me.s || (Ke ? pe && Ke[0] == pe[0] : !pe) - ? NaN - : (Ke && Ke[0] == 0) || !pe - ? Ft * 0 - : Ft / 0 - ); - for ( - We = new B(Ft), - er = We.c = [], - _e = le.e - Me.e, - Ft = de + _e + 1, - De || - ((De = s), - (_e = O(le.e / c) - O(Me.e / c)), - (Ft = (Ft / c) | 0)), - Ye = 0; - pe[Ye] == (Ke[Ye] || 0); - Ye++ - ); - if ((pe[Ye] > (Ke[Ye] || 0) && _e--, Ft < 0)) - er.push(1), (Ee = !0); - else { - for ( - ce = Ke.length, - we = pe.length, - Ye = 0, - Ft += 2, - Be = i(De / (pe[0] + 1)), - Be > 1 && - ((pe = V(pe, Be, De)), - (Ke = V(Ke, Be, De)), - (we = pe.length), - (ce = Ke.length)), - j = we, - Ue = Ke.slice(0, we), - Y = Ue.length; - Y < we; - Ue[Y++] = 0 - ); - (xe = pe.slice()), - (xe = [0].concat(xe)), - (ze = pe[0]), - pe[1] >= De / 2 && ze++; - do { - if (((Be = 0), (me = ye(pe, Ue, we, Y)), me < 0)) { - if ( - ((W = Ue[0]), - we != Y && (W = W * De + (Ue[1] || 0)), - (Be = i(W / ze)), - Be > 1) - ) - for ( - Be >= De && (Be = De - 1), - kt = V(pe, Be, De), - Ve = kt.length, - Y = Ue.length; - ye(kt, Ue, Ve, Y) == 1; - - ) - Be--, - ae(kt, we < Ve ? xe : pe, Ve, De), - (Ve = kt.length), - (me = 1); - else - Be == 0 && (me = Be = 1), - (kt = pe.slice()), - (Ve = kt.length); - if ( - (Ve < Y && (kt = [0].concat(kt)), - ae(Ue, kt, Y, De), - (Y = Ue.length), - me == -1) - ) - for (; ye(pe, Ue, we, Y) < 1; ) - Be++, ae(Ue, we < Y ? xe : pe, Y, De), (Y = Ue.length); - } else me === 0 && (Be++, (Ue = [0])); - (er[Ye++] = Be), - Ue[0] ? (Ue[Y++] = Ke[j] || 0) : ((Ue = [Ke[j]]), (Y = 1)); - } while ((j++ < ce || Ue[0] != null) && Ft--); - (Ee = Ue[0] != null), er[0] || er.splice(0, 1); - } - if (De == s) { - for (Ye = 1, Ft = er[0]; Ft >= 10; Ft /= 10, Ye++); - ge(We, de + (We.e = Ye + _e * c - 1) + 1, ve, Ee); - } else (We.e = _e), (We.r = +Ee); - return We; - }; - })()); - function G(V, ye, ae, le) { - var Me, de, ve, De, me; - if ((ae == null ? (ae = p) : N(ae, 0, 8), !V.c)) return V.toString(); - if (((Me = V.c[0]), (ve = V.e), ye == null)) - (me = D(V.c)), - (me = - le == 1 || (le == 2 && (ve <= y || ve >= d)) - ? z(me, ve) - : H(me, ve, "0")); - else if ( - ((V = ge(new B(V), ye, ae)), - (de = V.e), - (me = D(V.c)), - (De = me.length), - le == 1 || (le == 2 && (ye <= de || de <= y))) - ) { - for (; De < ye; me += "0", De++); - me = z(me, de); - } else if (((ye -= ve), (me = H(me, de, "0")), de + 1 > De)) { - if (--ye > 0) for (me += "."; ye--; me += "0"); - } else if (((ye += de - De), ye > 0)) - for (de + 1 == De && (me += "."); ye--; me += "0"); - return V.s < 0 && Me ? "-" + me : me; - } - function L(V, ye) { - for (var ae, le = 1, Me = new B(V[0]); le < V.length; le++) - if (((ae = new B(V[le])), ae.s)) ye.call(Me, ae) && (Me = ae); - else { - Me = ae; - break; - } - return Me; - } - function ee(V, ye, ae) { - for (var le = 1, Me = ye.length; !ye[--Me]; ye.pop()); - for (Me = ye[0]; Me >= 10; Me /= 10, le++); - return ( - (ae = le + ae * c - 1) > _ - ? (V.c = V.e = null) - : ae < v - ? (V.c = [(V.e = 0)]) - : ((V.e = ae), (V.c = ye)), - V - ); - } - te = (function () { - var V = /^(-?)0([xbo])(?=\w[\w.]*$)/i, - ye = /^([^.]+)\.$/, - ae = /^\.([^.]+)$/, - le = /^-?(Infinity|NaN)$/, - Me = /^\s*\+(?=[\w.])|^\s+|\s+$/g; - return function (de, ve, De, me) { - var _e, - Ye = De ? ve : ve.replace(Me, ""); - if (le.test(Ye)) de.s = isNaN(Ye) ? null : Ye < 0 ? -1 : 1; - else { - if ( - !De && - ((Ye = Ye.replace(V, function (Ee, Be, kt) { - return ( - (_e = - (kt = kt.toLowerCase()) == "x" ? 16 : kt == "b" ? 2 : 8), - !me || me == _e ? Be : Ee - ); - })), - me && - ((_e = me), (Ye = Ye.replace(ye, "$1").replace(ae, "0.$1"))), - ve != Ye) - ) - return new B(Ye, _e); - if (B.DEBUG) - throw Error( - o + "Not a" + (me ? " base " + me : "") + " number: " + ve - ); - de.s = null; - } - de.c = de.e = null; - }; - })(); - function ge(V, ye, ae, le) { - var Me, - de, - ve, - De, - me, - _e, - Ye, - Ee = V.c, - Be = h; - if (Ee) { - e: { - for (Me = 1, De = Ee[0]; De >= 10; De /= 10, Me++); - if (((de = ye - Me), de < 0)) - (de += c), - (ve = ye), - (me = Ee[(_e = 0)]), - (Ye = (me / Be[Me - ve - 1]) % 10 | 0); - else if (((_e = n((de + 1) / c)), _e >= Ee.length)) - if (le) { - for (; Ee.length <= _e; Ee.push(0)); - (me = Ye = 0), (Me = 1), (de %= c), (ve = de - c + 1); - } else break e; - else { - for (me = De = Ee[_e], Me = 1; De >= 10; De /= 10, Me++); - (de %= c), - (ve = de - c + Me), - (Ye = ve < 0 ? 0 : (me / Be[Me - ve - 1]) % 10 | 0); - } - if ( - ((le = - le || - ye < 0 || - Ee[_e + 1] != null || - (ve < 0 ? me : me % Be[Me - ve - 1])), - (le = - ae < 4 - ? (Ye || le) && (ae == 0 || ae == (V.s < 0 ? 3 : 2)) - : Ye > 5 || - (Ye == 5 && - (ae == 4 || - le || - (ae == 6 && - (de > 0 - ? ve > 0 - ? me / Be[Me - ve] - : 0 - : Ee[_e - 1]) % - 10 & - 1) || - ae == (V.s < 0 ? 8 : 7)))), - ye < 1 || !Ee[0]) - ) - return ( - (Ee.length = 0), - le - ? ((ye -= V.e + 1), - (Ee[0] = Be[(c - (ye % c)) % c]), - (V.e = -ye || 0)) - : (Ee[0] = V.e = 0), - V - ); - if ( - (de == 0 - ? ((Ee.length = _e), (De = 1), _e--) - : ((Ee.length = _e + 1), - (De = Be[c - de]), - (Ee[_e] = - ve > 0 ? i((me / Be[Me - ve]) % Be[ve]) * De : 0)), - le) - ) - for (;;) - if (_e == 0) { - for (de = 1, ve = Ee[0]; ve >= 10; ve /= 10, de++); - for (ve = Ee[0] += De, De = 1; ve >= 10; ve /= 10, De++); - de != De && (V.e++, Ee[0] == s && (Ee[0] = 1)); - break; - } else { - if (((Ee[_e] += De), Ee[_e] != s)) break; - (Ee[_e--] = 0), (De = 1); - } - for (de = Ee.length; Ee[--de] === 0; Ee.pop()); - } - V.e > _ ? (V.c = V.e = null) : V.e < v && (V.c = [(V.e = 0)]); - } - return V; - } - function fe(V) { - var ye, - ae = V.e; - return ae === null - ? V.toString() - : ((ye = D(V.c)), - (ye = ae <= y || ae >= d ? z(ye, ae) : H(ye, ae, "0")), - V.s < 0 ? "-" + ye : ye); - } - return ( - (ne.absoluteValue = ne.abs = - function () { - var V = new B(this); - return V.s < 0 && (V.s = 1), V; - }), - (ne.comparedTo = function (V, ye) { - return F(this, new B(V, ye)); - }), - (ne.decimalPlaces = ne.dp = - function (V, ye) { - var ae, - le, - Me, - de = this; - if (V != null) - return ( - N(V, 0, M), - ye == null ? (ye = p) : N(ye, 0, 8), - ge(new B(de), V + de.e + 1, ye) - ); - if (!(ae = de.c)) return null; - if ( - ((le = ((Me = ae.length - 1) - O(this.e / c)) * c), - (Me = ae[Me])) - ) - for (; Me % 10 == 0; Me /= 10, le--); - return le < 0 && (le = 0), le; - }), - (ne.dividedBy = ne.div = - function (V, ye) { - return $(this, new B(V, ye), l, p); - }), - (ne.dividedToIntegerBy = ne.idiv = - function (V, ye) { - return $(this, new B(V, ye), 0, 1); - }), - (ne.exponentiatedBy = ne.pow = - function (V, ye) { - var ae, - le, - Me, - de, - ve, - De, - me, - _e, - Ye, - Ee = this; - if (((V = new B(V)), V.c && !V.isInteger())) - throw Error(o + "Exponent not an integer: " + fe(V)); - if ( - (ye != null && (ye = new B(ye)), - (De = V.e > 14), - !Ee.c || - !Ee.c[0] || - (Ee.c[0] == 1 && !Ee.e && Ee.c.length == 1) || - !V.c || - !V.c[0]) - ) - return ( - (Ye = new B(Math.pow(+fe(Ee), De ? 2 - q(V) : +fe(V)))), - ye ? Ye.mod(ye) : Ye - ); - if (((me = V.s < 0), ye)) { - if (ye.c ? !ye.c[0] : !ye.s) return new B(NaN); - (le = !me && Ee.isInteger() && ye.isInteger()), - le && (Ee = Ee.mod(ye)); - } else { - if ( - V.e > 9 && - (Ee.e > 0 || - Ee.e < -1 || - (Ee.e == 0 - ? Ee.c[0] > 1 || (De && Ee.c[1] >= 24e7) - : Ee.c[0] < 8e13 || (De && Ee.c[0] <= 9999975e7))) - ) - return ( - (de = Ee.s < 0 && q(V) ? -0 : 0), - Ee.e > -1 && (de = 1 / de), - new B(me ? 1 / de : de) - ); - f && (de = n(f / c + 2)); - } - for ( - De - ? ((ae = new B(0.5)), me && (V.s = 1), (_e = q(V))) - : ((Me = Math.abs(+fe(V))), (_e = Me % 2)), - Ye = new B(A); - ; - - ) { - if (_e) { - if (((Ye = Ye.times(Ee)), !Ye.c)) break; - de - ? Ye.c.length > de && (Ye.c.length = de) - : le && (Ye = Ye.mod(ye)); - } - if (Me) { - if (((Me = i(Me / 2)), Me === 0)) break; - _e = Me % 2; - } else if (((V = V.times(ae)), ge(V, V.e + 1, 1), V.e > 14)) - _e = q(V); - else { - if (((Me = +fe(V)), Me === 0)) break; - _e = Me % 2; - } - (Ee = Ee.times(Ee)), - de - ? Ee.c && Ee.c.length > de && (Ee.c.length = de) - : le && (Ee = Ee.mod(ye)); - } - return le - ? Ye - : (me && (Ye = A.div(Ye)), - ye ? Ye.mod(ye) : de ? ge(Ye, f, p, ve) : Ye); - }), - (ne.integerValue = function (V) { - var ye = new B(this); - return V == null ? (V = p) : N(V, 0, 8), ge(ye, ye.e + 1, V); - }), - (ne.isEqualTo = ne.eq = - function (V, ye) { - return F(this, new B(V, ye)) === 0; - }), - (ne.isFinite = function () { - return !!this.c; - }), - (ne.isGreaterThan = ne.gt = - function (V, ye) { - return F(this, new B(V, ye)) > 0; - }), - (ne.isGreaterThanOrEqualTo = ne.gte = - function (V, ye) { - return (ye = F(this, new B(V, ye))) === 1 || ye === 0; - }), - (ne.isInteger = function () { - return !!this.c && O(this.e / c) > this.c.length - 2; - }), - (ne.isLessThan = ne.lt = - function (V, ye) { - return F(this, new B(V, ye)) < 0; - }), - (ne.isLessThanOrEqualTo = ne.lte = - function (V, ye) { - return (ye = F(this, new B(V, ye))) === -1 || ye === 0; - }), - (ne.isNaN = function () { - return !this.s; - }), - (ne.isNegative = function () { - return this.s < 0; - }), - (ne.isPositive = function () { - return this.s > 0; - }), - (ne.isZero = function () { - return !!this.c && this.c[0] == 0; - }), - (ne.minus = function (V, ye) { - var ae, - le, - Me, - de, - ve = this, - De = ve.s; - if (((V = new B(V, ye)), (ye = V.s), !De || !ye)) return new B(NaN); - if (De != ye) return (V.s = -ye), ve.plus(V); - var me = ve.e / c, - _e = V.e / c, - Ye = ve.c, - Ee = V.c; - if (!me || !_e) { - if (!Ye || !Ee) - return Ye ? ((V.s = -ye), V) : new B(Ee ? ve : NaN); - if (!Ye[0] || !Ee[0]) - return Ee[0] - ? ((V.s = -ye), V) - : new B(Ye[0] ? ve : p == 3 ? -0 : 0); - } - if ( - ((me = O(me)), (_e = O(_e)), (Ye = Ye.slice()), (De = me - _e)) - ) { - for ( - (de = De < 0) - ? ((De = -De), (Me = Ye)) - : ((_e = me), (Me = Ee)), - Me.reverse(), - ye = De; - ye--; - Me.push(0) - ); - Me.reverse(); - } else - for ( - le = (de = (De = Ye.length) < (ye = Ee.length)) ? De : ye, - De = ye = 0; - ye < le; - ye++ - ) - if (Ye[ye] != Ee[ye]) { - de = Ye[ye] < Ee[ye]; - break; - } - if ( - (de && ((Me = Ye), (Ye = Ee), (Ee = Me), (V.s = -V.s)), - (ye = (le = Ee.length) - (ae = Ye.length)), - ye > 0) - ) - for (; ye--; Ye[ae++] = 0); - for (ye = s - 1; le > De; ) { - if (Ye[--le] < Ee[le]) { - for (ae = le; ae && !Ye[--ae]; Ye[ae] = ye); - --Ye[ae], (Ye[le] += s); - } - Ye[le] -= Ee[le]; - } - for (; Ye[0] == 0; Ye.splice(0, 1), --_e); - return Ye[0] - ? ee(V, Ye, _e) - : ((V.s = p == 3 ? -1 : 1), (V.c = [(V.e = 0)]), V); - }), - (ne.modulo = ne.mod = - function (V, ye) { - var ae, - le, - Me = this; - return ( - (V = new B(V, ye)), - !Me.c || !V.s || (V.c && !V.c[0]) - ? new B(NaN) - : !V.c || (Me.c && !Me.c[0]) - ? new B(Me) - : (b == 9 - ? ((le = V.s), - (V.s = 1), - (ae = $(Me, V, 0, 3)), - (V.s = le), - (ae.s *= le)) - : (ae = $(Me, V, 0, b)), - (V = Me.minus(ae.times(V))), - !V.c[0] && b == 1 && (V.s = Me.s), - V) - ); - }), - (ne.multipliedBy = ne.times = - function (V, ye) { - var ae, - le, - Me, - de, - ve, - De, - me, - _e, - Ye, - Ee, - Be, - kt, - Ve, - We, - er, - Ue = this, - Y = Ue.c, - W = (V = new B(V, ye)).c; - if (!Y || !W || !Y[0] || !W[0]) - return ( - !Ue.s || !V.s || (Y && !Y[0] && !W) || (W && !W[0] && !Y) - ? (V.c = V.e = V.s = null) - : ((V.s *= Ue.s), - !Y || !W ? (V.c = V.e = null) : ((V.c = [0]), (V.e = 0))), - V - ); - for ( - le = O(Ue.e / c) + O(V.e / c), - V.s *= Ue.s, - me = Y.length, - Ee = W.length, - me < Ee && - ((Ve = Y), - (Y = W), - (W = Ve), - (Me = me), - (me = Ee), - (Ee = Me)), - Me = me + Ee, - Ve = []; - Me--; - Ve.push(0) - ); - for (We = s, er = w, Me = Ee; --Me >= 0; ) { - for ( - ae = 0, - Be = W[Me] % er, - kt = (W[Me] / er) | 0, - ve = me, - de = Me + ve; - de > Me; - - ) - (_e = Y[--ve] % er), - (Ye = (Y[ve] / er) | 0), - (De = kt * _e + Ye * Be), - (_e = Be * _e + (De % er) * er + Ve[de] + ae), - (ae = ((_e / We) | 0) + ((De / er) | 0) + kt * Ye), - (Ve[de--] = _e % We); - Ve[de] = ae; - } - return ae ? ++le : Ve.splice(0, 1), ee(V, Ve, le); - }), - (ne.negated = function () { - var V = new B(this); - return (V.s = -V.s || null), V; - }), - (ne.plus = function (V, ye) { - var ae, - le = this, - Me = le.s; - if (((V = new B(V, ye)), (ye = V.s), !Me || !ye)) return new B(NaN); - if (Me != ye) return (V.s = -ye), le.minus(V); - var de = le.e / c, - ve = V.e / c, - De = le.c, - me = V.c; - if (!de || !ve) { - if (!De || !me) return new B(Me / 0); - if (!De[0] || !me[0]) - return me[0] ? V : new B(De[0] ? le : Me * 0); - } - if ( - ((de = O(de)), (ve = O(ve)), (De = De.slice()), (Me = de - ve)) - ) { - for ( - Me > 0 ? ((ve = de), (ae = me)) : ((Me = -Me), (ae = De)), - ae.reverse(); - Me--; - ae.push(0) - ); - ae.reverse(); - } - for ( - Me = De.length, - ye = me.length, - Me - ye < 0 && ((ae = me), (me = De), (De = ae), (ye = Me)), - Me = 0; - ye; - - ) - (Me = ((De[--ye] = De[ye] + me[ye] + Me) / s) | 0), - (De[ye] = s === De[ye] ? 0 : De[ye] % s); - return Me && ((De = [Me].concat(De)), ++ve), ee(V, De, ve); - }), - (ne.precision = ne.sd = - function (V, ye) { - var ae, - le, - Me, - de = this; - if (V != null && V !== !!V) - return ( - N(V, 1, M), - ye == null ? (ye = p) : N(ye, 0, 8), - ge(new B(de), V, ye) - ); - if (!(ae = de.c)) return null; - if (((Me = ae.length - 1), (le = Me * c + 1), (Me = ae[Me]))) { - for (; Me % 10 == 0; Me /= 10, le--); - for (Me = ae[0]; Me >= 10; Me /= 10, le++); - } - return V && de.e + 1 > le && (le = de.e + 1), le; - }), - (ne.shiftedBy = function (V) { - return N(V, -u, u), this.times("1e" + V); - }), - (ne.squareRoot = ne.sqrt = - function () { - var V, - ye, - ae, - le, - Me, - de = this, - ve = de.c, - De = de.s, - me = de.e, - _e = l + 4, - Ye = new B("0.5"); - if (De !== 1 || !ve || !ve[0]) - return new B( - !De || (De < 0 && (!ve || ve[0])) ? NaN : ve ? de : 1 / 0 - ); - if ( - ((De = Math.sqrt(+fe(de))), - De == 0 || De == 1 / 0 - ? ((ye = D(ve)), - (ye.length + me) % 2 == 0 && (ye += "0"), - (De = Math.sqrt(+ye)), - (me = O((me + 1) / 2) - (me < 0 || me % 2)), - De == 1 / 0 - ? (ye = "5e" + me) - : ((ye = De.toExponential()), - (ye = ye.slice(0, ye.indexOf("e") + 1) + me)), - (ae = new B(ye))) - : (ae = new B(De + "")), - ae.c[0]) - ) { - for (me = ae.e, De = me + _e, De < 3 && (De = 0); ; ) - if ( - ((Me = ae), - (ae = Ye.times(Me.plus($(de, Me, _e, 1)))), - D(Me.c).slice(0, De) === (ye = D(ae.c)).slice(0, De)) - ) - if ( - (ae.e < me && --De, - (ye = ye.slice(De - 3, De + 1)), - ye == "9999" || (!le && ye == "4999")) - ) { - if ( - !le && - (ge(Me, Me.e + l + 2, 0), Me.times(Me).eq(de)) - ) { - ae = Me; - break; - } - (_e += 4), (De += 4), (le = 1); - } else { - (!+ye || (!+ye.slice(1) && ye.charAt(0) == "5")) && - (ge(ae, ae.e + l + 2, 1), (V = !ae.times(ae).eq(de))); - break; - } - } - return ge(ae, ae.e + l + 1, p, V); - }), - (ne.toExponential = function (V, ye) { - return V != null && (N(V, 0, M), V++), G(this, V, ye, 1); - }), - (ne.toFixed = function (V, ye) { - return ( - V != null && (N(V, 0, M), (V = V + this.e + 1)), G(this, V, ye) - ); - }), - (ne.toFormat = function (V, ye, ae) { - var le, - Me = this; - if (ae == null) - V != null && ye && typeof ye == "object" - ? ((ae = ye), (ye = null)) - : V && typeof V == "object" - ? ((ae = V), (V = ye = null)) - : (ae = x); - else if (typeof ae != "object") - throw Error(o + "Argument not an object: " + ae); - if (((le = Me.toFixed(V, ye)), Me.c)) { - var de, - ve = le.split("."), - De = +ae.groupSize, - me = +ae.secondaryGroupSize, - _e = ae.groupSeparator || "", - Ye = ve[0], - Ee = ve[1], - Be = Me.s < 0, - kt = Be ? Ye.slice(1) : Ye, - Ve = kt.length; - if ( - (me && ((de = De), (De = me), (me = de), (Ve -= de)), - De > 0 && Ve > 0) - ) { - for ( - de = Ve % De || De, Ye = kt.substr(0, de); - de < Ve; - de += De - ) - Ye += _e + kt.substr(de, De); - me > 0 && (Ye += _e + kt.slice(de)), Be && (Ye = "-" + Ye); - } - le = Ee - ? Ye + - (ae.decimalSeparator || "") + - ((me = +ae.fractionGroupSize) - ? Ee.replace( - new RegExp("\\d{" + me + "}\\B", "g"), - "$&" + (ae.fractionGroupSeparator || "") - ) - : Ee) - : Ye; - } - return (ae.prefix || "") + le + (ae.suffix || ""); - }), - (ne.toFraction = function (V) { - var ye, - ae, - le, - Me, - de, - ve, - De, - me, - _e, - Ye, - Ee, - Be, - kt = this, - Ve = kt.c; - if ( - V != null && - ((De = new B(V)), - (!De.isInteger() && (De.c || De.s !== 1)) || De.lt(A)) - ) - throw Error( - o + - "Argument " + - (De.isInteger() ? "out of range: " : "not an integer: ") + - fe(De) - ); - if (!Ve) return new B(kt); - for ( - ye = new B(A), - _e = ae = new B(A), - le = me = new B(A), - Be = D(Ve), - de = ye.e = Be.length - kt.e - 1, - ye.c[0] = h[(ve = de % c) < 0 ? c + ve : ve], - V = !V || De.comparedTo(ye) > 0 ? (de > 0 ? ye : _e) : De, - ve = _, - _ = 1 / 0, - De = new B(Be), - me.c[0] = 0; - (Ye = $(De, ye, 0, 1)), - (Me = ae.plus(Ye.times(le))), - Me.comparedTo(V) != 1; - - ) - (ae = le), - (le = Me), - (_e = me.plus(Ye.times((Me = _e)))), - (me = Me), - (ye = De.minus(Ye.times((Me = ye)))), - (De = Me); - return ( - (Me = $(V.minus(ae), le, 0, 1)), - (me = me.plus(Me.times(_e))), - (ae = ae.plus(Me.times(le))), - (me.s = _e.s = kt.s), - (de = de * 2), - (Ee = - $(_e, le, de, p) - .minus(kt) - .abs() - .comparedTo($(me, ae, de, p).minus(kt).abs()) < 1 - ? [_e, le] - : [me, ae]), - (_ = ve), - Ee - ); - }), - (ne.toNumber = function () { - return +fe(this); - }), - (ne.toPrecision = function (V, ye) { - return V != null && N(V, 1, M), G(this, V, ye, 2); - }), - (ne.toString = function (V) { - var ye, - ae = this, - le = ae.s, - Me = ae.e; - return ( - Me === null - ? le - ? ((ye = "Infinity"), le < 0 && (ye = "-" + ye)) - : (ye = "NaN") - : (V == null - ? (ye = - Me <= y || Me >= d - ? z(D(ae.c), Me) - : H(D(ae.c), Me, "0")) - : V === 10 && E - ? ((ae = ge(new B(ae), l + Me + 1, p)), - (ye = H(D(ae.c), ae.e, "0"))) - : (N(V, 2, C.length, "Base"), - (ye = ue(H(D(ae.c), Me, "0"), 10, V, le, !0))), - le < 0 && ae.c[0] && (ye = "-" + ye)), - ye - ); - }), - (ne.valueOf = ne.toJSON = - function () { - return fe(this); - }), - (ne._isBigNumber = !0), - Z != null && B.set(Z), - B - ); - } - function O(Z) { - var $ = Z | 0; - return Z > 0 || Z === $ ? $ : $ - 1; - } - function D(Z) { - for (var $, ue, te = 1, ne = Z.length, A = Z[0] + ""; te < ne; ) { - for ($ = Z[te++] + "", ue = c - $.length; ue--; $ = "0" + $); - A += $; - } - for (ne = A.length; A.charCodeAt(--ne) === 48; ); - return A.slice(0, ne + 1 || 1); - } - function F(Z, $) { - var ue, - te, - ne = Z.c, - A = $.c, - l = Z.s, - p = $.s, - y = Z.e, - d = $.e; - if (!l || !p) return null; - if (((ue = ne && !ne[0]), (te = A && !A[0]), ue || te)) - return ue ? (te ? 0 : -p) : l; - if (l != p) return l; - if (((ue = l < 0), (te = y == d), !ne || !A)) - return te ? 0 : !ne ^ ue ? 1 : -1; - if (!te) return (y > d) ^ ue ? 1 : -1; - for (p = (y = ne.length) < (d = A.length) ? y : d, l = 0; l < p; l++) - if (ne[l] != A[l]) return (ne[l] > A[l]) ^ ue ? 1 : -1; - return y == d ? 0 : (y > d) ^ ue ? 1 : -1; - } - function N(Z, $, ue, te) { - if (Z < $ || Z > ue || Z !== i(Z)) - throw Error( - o + - (te || "Argument") + - (typeof Z == "number" - ? Z < $ || Z > ue - ? " out of range: " - : " not an integer: " - : " not a primitive number: ") + - String(Z) - ); - } - function q(Z) { - var $ = Z.c.length - 1; - return O(Z.e / c) == $ && Z.c[$] % 2 != 0; - } - function z(Z, $) { - return ( - (Z.length > 1 ? Z.charAt(0) + "." + Z.slice(1) : Z) + - ($ < 0 ? "e" : "e+") + - $ - ); - } - function H(Z, $, ue) { - var te, ne; - if ($ < 0) { - for (ne = ue + "."; ++$; ne += ue); - Z = ne + Z; - } else if (((te = Z.length), ++$ > te)) { - for (ne = ue, $ -= te; --$; ne += ue); - Z += ne; - } else $ < te && (Z = Z.slice(0, $) + "." + Z.slice($)); - return Z; - } - (e = k()), - (e.default = e.BigNumber = e), - typeof define == "function" && define.amd - ? define(function () { - return e; - }) - : typeof jee < "u" && jee.exports - ? (jee.exports = e) - : (t || (t = typeof self < "u" && self ? self : window), - (t.BigNumber = e)); - })(Mrt); - }); - var Trt = I((Lxe) => { - "use strict"; - m(); - g(); - Object.defineProperty(Lxe, "__esModule", { value: !0 }); - var chr = Sy(), - Fxe = class { - constructor() { - this.BigNum = (e, r) => { - let n = chr.BigNumber.clone({ DECIMAL_PLACES: r }); - return new n(e); - }; - } - winstonToAr( - e, - { formatted: r = !1, decimals: n = 12, trim: i = !0 } = {} - ) { - let o = this.stringToBigNum(e, n).shiftedBy(-12); - return r ? o.toFormat(n) : o.toFixed(n); - } - arToWinston(e, { formatted: r = !1 } = {}) { - let n = this.stringToBigNum(e).shiftedBy(12); - return r ? n.toFormat() : n.toFixed(0); - } - compare(e, r) { - let n = this.stringToBigNum(e), - i = this.stringToBigNum(r); - return n.comparedTo(i); - } - isEqual(e, r) { - return this.compare(e, r) === 0; - } - isLessThan(e, r) { - let n = this.stringToBigNum(e), - i = this.stringToBigNum(r); - return n.isLessThan(i); - } - isGreaterThan(e, r) { - let n = this.stringToBigNum(e), - i = this.stringToBigNum(r); - return n.isGreaterThan(i); - } - add(e, r) { - let n = this.stringToBigNum(e), - i = this.stringToBigNum(r); - return n.plus(r).toFixed(0); - } - sub(e, r) { - let n = this.stringToBigNum(e), - i = this.stringToBigNum(r); - return n.minus(r).toFixed(0); - } - stringToBigNum(e, r = 12) { - return this.BigNum(e, r); - } - }; - Lxe.default = Fxe; - }); - var qxe = I((_0n, krt) => { - "use strict"; - m(); - g(); - krt.exports = function (e, r) { - return function () { - for (var i = new Array(arguments.length), o = 0; o < i.length; o++) - i[o] = arguments[o]; - return e.apply(r, i); - }; - }; - }); - var Tu = I((x0n, Brt) => { - "use strict"; - m(); - g(); - var lhr = qxe(), - jxe = Object.prototype.toString, - Uxe = (function (t) { - return function (e) { - var r = jxe.call(e); - return t[r] || (t[r] = r.slice(8, -1).toLowerCase()); - }; - })(Object.create(null)); - function mT(t) { - return ( - (t = t.toLowerCase()), - function (r) { - return Uxe(r) === t; - } - ); - } - function Kxe(t) { - return Array.isArray(t); - } - function Kee(t) { - return typeof t > "u"; - } - function fhr(t) { - return ( - t !== null && - !Kee(t) && - t.constructor !== null && - !Kee(t.constructor) && - typeof t.constructor.isBuffer == "function" && - t.constructor.isBuffer(t) - ); - } - var Prt = mT("ArrayBuffer"); - function dhr(t) { - var e; - return ( - typeof ArrayBuffer < "u" && ArrayBuffer.isView - ? (e = ArrayBuffer.isView(t)) - : (e = t && t.buffer && Prt(t.buffer)), - e - ); - } - function hhr(t) { - return typeof t == "string"; - } - function phr(t) { - return typeof t == "number"; - } - function Ort(t) { - return t !== null && typeof t == "object"; - } - function Uee(t) { - if (Uxe(t) !== "object") return !1; - var e = Object.getPrototypeOf(t); - return e === null || e === Object.prototype; - } - var yhr = mT("Date"), - mhr = mT("File"), - ghr = mT("Blob"), - vhr = mT("FileList"); - function Hxe(t) { - return jxe.call(t) === "[object Function]"; - } - function bhr(t) { - return Ort(t) && Hxe(t.pipe); - } - function whr(t) { - var e = "[object FormData]"; - return ( - t && - ((typeof FormData == "function" && t instanceof FormData) || - jxe.call(t) === e || - (Hxe(t.toString) && t.toString() === e)) - ); - } - var _hr = mT("URLSearchParams"); - function xhr(t) { - return t.trim ? t.trim() : t.replace(/^\s+|\s+$/g, ""); - } - function Shr() { - return typeof navigator < "u" && - (navigator.product === "ReactNative" || - navigator.product === "NativeScript" || - navigator.product === "NS") - ? !1 - : typeof window < "u" && typeof document < "u"; - } - function Vxe(t, e) { - if (!(t === null || typeof t > "u")) - if ((typeof t != "object" && (t = [t]), Kxe(t))) - for (var r = 0, n = t.length; r < n; r++) e.call(null, t[r], r, t); - else - for (var i in t) - Object.prototype.hasOwnProperty.call(t, i) && - e.call(null, t[i], i, t); - } - function zxe() { - var t = {}; - function e(i, o) { - Uee(t[o]) && Uee(i) - ? (t[o] = zxe(t[o], i)) - : Uee(i) - ? (t[o] = zxe({}, i)) - : Kxe(i) - ? (t[o] = i.slice()) - : (t[o] = i); - } - for (var r = 0, n = arguments.length; r < n; r++) Vxe(arguments[r], e); - return t; - } - function Ahr(t, e, r) { - return ( - Vxe(e, function (i, o) { - r && typeof i == "function" ? (t[o] = lhr(i, r)) : (t[o] = i); - }), - t - ); - } - function Ehr(t) { - return t.charCodeAt(0) === 65279 && (t = t.slice(1)), t; - } - function Mhr(t, e, r, n) { - (t.prototype = Object.create(e.prototype, n)), - (t.prototype.constructor = t), - r && Object.assign(t.prototype, r); - } - function Thr(t, e, r) { - var n, - i, - o, - a = {}; - e = e || {}; - do { - for (n = Object.getOwnPropertyNames(t), i = n.length; i-- > 0; ) - (o = n[i]), a[o] || ((e[o] = t[o]), (a[o] = !0)); - t = Object.getPrototypeOf(t); - } while (t && (!r || r(t, e)) && t !== Object.prototype); - return e; - } - function khr(t, e, r) { - (t = String(t)), - (r === void 0 || r > t.length) && (r = t.length), - (r -= e.length); - var n = t.indexOf(e, r); - return n !== -1 && n === r; - } - function Phr(t) { - if (!t) return null; - var e = t.length; - if (Kee(e)) return null; - for (var r = new Array(e); e-- > 0; ) r[e] = t[e]; - return r; - } - var Ohr = (function (t) { - return function (e) { - return t && e instanceof t; - }; - })(typeof Uint8Array < "u" && Object.getPrototypeOf(Uint8Array)); - Brt.exports = { - isArray: Kxe, - isArrayBuffer: Prt, - isBuffer: fhr, - isFormData: whr, - isArrayBufferView: dhr, - isString: hhr, - isNumber: phr, - isObject: Ort, - isPlainObject: Uee, - isUndefined: Kee, - isDate: yhr, - isFile: mhr, - isBlob: ghr, - isFunction: Hxe, - isStream: bhr, - isURLSearchParams: _hr, - isStandardBrowserEnv: Shr, - forEach: Vxe, - merge: zxe, - extend: Ahr, - trim: xhr, - stripBOM: Ehr, - inherits: Mhr, - toFlatObject: Thr, - kindOf: Uxe, - kindOfTest: mT, - endsWith: khr, - toArray: Phr, - isTypedArray: Ohr, - isFileList: vhr, - }; - }); - var Wxe = I((S0n, Crt) => { - "use strict"; - m(); - g(); - var WC = Tu(); - function Irt(t) { - return encodeURIComponent(t) - .replace(/%3A/gi, ":") - .replace(/%24/g, "$") - .replace(/%2C/gi, ",") - .replace(/%20/g, "+") - .replace(/%5B/gi, "[") - .replace(/%5D/gi, "]"); - } - Crt.exports = function (e, r, n) { - if (!r) return e; - var i; - if (n) i = n(r); - else if (WC.isURLSearchParams(r)) i = r.toString(); - else { - var o = []; - WC.forEach(r, function (c, u) { - c === null || - typeof c > "u" || - (WC.isArray(c) ? (u = u + "[]") : (c = [c]), - WC.forEach(c, function (w) { - WC.isDate(w) - ? (w = w.toISOString()) - : WC.isObject(w) && (w = JSON.stringify(w)), - o.push(Irt(u) + "=" + Irt(w)); - })); - }), - (i = o.join("&")); - } - if (i) { - var a = e.indexOf("#"); - a !== -1 && (e = e.slice(0, a)), - (e += (e.indexOf("?") === -1 ? "?" : "&") + i); - } - return e; - }; - }); - var Nrt = I((A0n, Rrt) => { - "use strict"; - m(); - g(); - var Bhr = Tu(); - function Hee() { - this.handlers = []; - } - Hee.prototype.use = function (e, r, n) { - return ( - this.handlers.push({ - fulfilled: e, - rejected: r, - synchronous: n ? n.synchronous : !1, - runWhen: n ? n.runWhen : null, - }), - this.handlers.length - 1 - ); - }; - Hee.prototype.eject = function (e) { - this.handlers[e] && (this.handlers[e] = null); - }; - Hee.prototype.forEach = function (e) { - Bhr.forEach(this.handlers, function (n) { - n !== null && e(n); - }); - }; - Rrt.exports = Hee; - }); - var Frt = I((E0n, Drt) => { - "use strict"; - m(); - g(); - var Ihr = Tu(); - Drt.exports = function (e, r) { - Ihr.forEach(e, function (i, o) { - o !== r && - o.toUpperCase() === r.toUpperCase() && - ((e[r] = i), delete e[o]); - }); - }; - }); - var gT = I((M0n, jrt) => { - "use strict"; - m(); - g(); - var Lrt = Tu(); - function GC(t, e, r, n, i) { - Error.call(this), - (this.message = t), - (this.name = "AxiosError"), - e && (this.code = e), - r && (this.config = r), - n && (this.request = n), - i && (this.response = i); - } - Lrt.inherits(GC, Error, { - toJSON: function () { - return { - message: this.message, - name: this.name, - description: this.description, - number: this.number, - fileName: this.fileName, - lineNumber: this.lineNumber, - columnNumber: this.columnNumber, - stack: this.stack, - config: this.config, - code: this.code, - status: - this.response && this.response.status ? this.response.status : null, - }; - }, - }); - var qrt = GC.prototype, - zrt = {}; - [ - "ERR_BAD_OPTION_VALUE", - "ERR_BAD_OPTION", - "ECONNABORTED", - "ETIMEDOUT", - "ERR_NETWORK", - "ERR_FR_TOO_MANY_REDIRECTS", - "ERR_DEPRECATED", - "ERR_BAD_RESPONSE", - "ERR_BAD_REQUEST", - "ERR_CANCELED", - ].forEach(function (t) { - zrt[t] = { value: t }; - }); - Object.defineProperties(GC, zrt); - Object.defineProperty(qrt, "isAxiosError", { value: !0 }); - GC.from = function (t, e, r, n, i, o) { - var a = Object.create(qrt); - return ( - Lrt.toFlatObject(t, a, function (c) { - return c !== Error.prototype; - }), - GC.call(a, t.message, e, r, n, i), - (a.name = t.name), - o && Object.assign(a, o), - a - ); - }; - jrt.exports = GC; - }); - var Gxe = I((T0n, Urt) => { - "use strict"; - m(); - g(); - Urt.exports = { - silentJSONParsing: !0, - forcedJSONParsing: !0, - clarifyTimeoutError: !1, - }; - }); - var Jxe = I((k0n, Krt) => { - "use strict"; - m(); - g(); - var tg = Tu(); - function Chr(t, e) { - e = e || new FormData(); - var r = []; - function n(o) { - return o === null - ? "" - : tg.isDate(o) - ? o.toISOString() - : tg.isArrayBuffer(o) || tg.isTypedArray(o) - ? typeof Blob == "function" - ? new Blob([o]) - : Buffer.from(o) - : o; - } - function i(o, a) { - if (tg.isPlainObject(o) || tg.isArray(o)) { - if (r.indexOf(o) !== -1) - throw Error("Circular reference detected in " + a); - r.push(o), - tg.forEach(o, function (c, u) { - if (!tg.isUndefined(c)) { - var h = a ? a + "." + u : u, - w; - if (c && !a && typeof c == "object") { - if (tg.endsWith(u, "{}")) c = JSON.stringify(c); - else if (tg.endsWith(u, "[]") && (w = tg.toArray(c))) { - w.forEach(function (M) { - !tg.isUndefined(M) && e.append(h, n(M)); - }); - return; - } - } - i(c, h); - } - }), - r.pop(); - } else e.append(a, n(o)); - } - return i(t), e; - } - Krt.exports = Chr; - }); - var Vrt = I((P0n, Hrt) => { - "use strict"; - m(); - g(); - var $xe = gT(); - Hrt.exports = function (e, r, n) { - var i = n.config.validateStatus; - !n.status || !i || i(n.status) - ? e(n) - : r( - new $xe( - "Request failed with status code " + n.status, - [$xe.ERR_BAD_REQUEST, $xe.ERR_BAD_RESPONSE][ - Math.floor(n.status / 100) - 4 - ], - n.config, - n.request, - n - ) - ); - }; - }); - var Grt = I((O0n, Wrt) => { - "use strict"; - m(); - g(); - var Vee = Tu(); - Wrt.exports = Vee.isStandardBrowserEnv() - ? (function () { - return { - write: function (r, n, i, o, a, s) { - var c = []; - c.push(r + "=" + encodeURIComponent(n)), - Vee.isNumber(i) && - c.push("expires=" + new Date(i).toGMTString()), - Vee.isString(o) && c.push("path=" + o), - Vee.isString(a) && c.push("domain=" + a), - s === !0 && c.push("secure"), - (document.cookie = c.join("; ")); - }, - read: function (r) { - var n = document.cookie.match( - new RegExp("(^|;\\s*)(" + r + ")=([^;]*)") - ); - return n ? decodeURIComponent(n[3]) : null; - }, - remove: function (r) { - this.write(r, "", Date.now() - 864e5); - }, - }; - })() - : (function () { - return { - write: function () {}, - read: function () { - return null; - }, - remove: function () {}, - }; - })(); - }); - var $rt = I((B0n, Jrt) => { - "use strict"; - m(); - g(); - Jrt.exports = function (e) { - return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(e); - }; - }); - var Xrt = I((I0n, Zrt) => { - "use strict"; - m(); - g(); - Zrt.exports = function (e, r) { - return r ? e.replace(/\/+$/, "") + "/" + r.replace(/^\/+/, "") : e; - }; - }); - var Zxe = I((C0n, Yrt) => { - "use strict"; - m(); - g(); - var Rhr = $rt(), - Nhr = Xrt(); - Yrt.exports = function (e, r) { - return e && !Rhr(r) ? Nhr(e, r) : r; - }; - }); - var ent = I((R0n, Qrt) => { - "use strict"; - m(); - g(); - var Xxe = Tu(), - Dhr = [ - "age", - "authorization", - "content-length", - "content-type", - "etag", - "expires", - "from", - "host", - "if-modified-since", - "if-unmodified-since", - "last-modified", - "location", - "max-forwards", - "proxy-authorization", - "referer", - "retry-after", - "user-agent", - ]; - Qrt.exports = function (e) { - var r = {}, - n, - i, - o; - return ( - e && - Xxe.forEach( - e.split(` -`), - function (s) { - if ( - ((o = s.indexOf(":")), - (n = Xxe.trim(s.substr(0, o)).toLowerCase()), - (i = Xxe.trim(s.substr(o + 1))), - n) - ) { - if (r[n] && Dhr.indexOf(n) >= 0) return; - n === "set-cookie" - ? (r[n] = (r[n] ? r[n] : []).concat([i])) - : (r[n] = r[n] ? r[n] + ", " + i : i); - } - } - ), - r - ); - }; - }); - var nnt = I((N0n, rnt) => { - "use strict"; - m(); - g(); - var tnt = Tu(); - rnt.exports = tnt.isStandardBrowserEnv() - ? (function () { - var e = /(msie|trident)/i.test(navigator.userAgent), - r = document.createElement("a"), - n; - function i(o) { - var a = o; - return ( - e && (r.setAttribute("href", a), (a = r.href)), - r.setAttribute("href", a), - { - href: r.href, - protocol: r.protocol ? r.protocol.replace(/:$/, "") : "", - host: r.host, - search: r.search ? r.search.replace(/^\?/, "") : "", - hash: r.hash ? r.hash.replace(/^#/, "") : "", - hostname: r.hostname, - port: r.port, - pathname: - r.pathname.charAt(0) === "/" ? r.pathname : "/" + r.pathname, - } - ); - } - return ( - (n = i(window.location.href)), - function (a) { - var s = tnt.isString(a) ? i(a) : a; - return s.protocol === n.protocol && s.host === n.host; - } - ); - })() - : (function () { - return function () { - return !0; - }; - })(); - }); - var Uj = I((D0n, ont) => { - "use strict"; - m(); - g(); - var Yxe = gT(), - Fhr = Tu(); - function int(t) { - Yxe.call(this, t ?? "canceled", Yxe.ERR_CANCELED), - (this.name = "CanceledError"); - } - Fhr.inherits(int, Yxe, { __CANCEL__: !0 }); - ont.exports = int; - }); - var snt = I((F0n, ant) => { - "use strict"; - m(); - g(); - ant.exports = function (e) { - var r = /^([-+\w]{1,25})(:?\/\/|:)/.exec(e); - return (r && r[1]) || ""; - }; - }); - var Qxe = I((L0n, unt) => { - "use strict"; - m(); - g(); - var Kj = Tu(), - Lhr = Vrt(), - qhr = Grt(), - zhr = Wxe(), - jhr = Zxe(), - Uhr = ent(), - Khr = nnt(), - Hhr = Gxe(), - ox = gT(), - Vhr = Uj(), - Whr = snt(); - unt.exports = function (e) { - return new Promise(function (n, i) { - var o = e.data, - a = e.headers, - s = e.responseType, - c; - function u() { - e.cancelToken && e.cancelToken.unsubscribe(c), - e.signal && e.signal.removeEventListener("abort", c); - } - Kj.isFormData(o) && - Kj.isStandardBrowserEnv() && - delete a["Content-Type"]; - var h = new XMLHttpRequest(); - if (e.auth) { - var w = e.auth.username || "", - M = e.auth.password - ? unescape(encodeURIComponent(e.auth.password)) - : ""; - a.Authorization = "Basic " + btoa(w + ":" + M); - } - var k = jhr(e.baseURL, e.url); - h.open( - e.method.toUpperCase(), - zhr(k, e.params, e.paramsSerializer), - !0 - ), - (h.timeout = e.timeout); - function O() { - if (!!h) { - var N = - "getAllResponseHeaders" in h - ? Uhr(h.getAllResponseHeaders()) - : null, - q = - !s || s === "text" || s === "json" - ? h.responseText - : h.response, - z = { - data: q, - status: h.status, - statusText: h.statusText, - headers: N, - config: e, - request: h, - }; - Lhr( - function (Z) { - n(Z), u(); - }, - function (Z) { - i(Z), u(); - }, - z - ), - (h = null); - } - } - if ( - ("onloadend" in h - ? (h.onloadend = O) - : (h.onreadystatechange = function () { - !h || - h.readyState !== 4 || - (h.status === 0 && - !(h.responseURL && h.responseURL.indexOf("file:") === 0)) || - setTimeout(O); - }), - (h.onabort = function () { - !h || - (i(new ox("Request aborted", ox.ECONNABORTED, e, h)), (h = null)); - }), - (h.onerror = function () { - i(new ox("Network Error", ox.ERR_NETWORK, e, h, h)), (h = null); - }), - (h.ontimeout = function () { - var q = e.timeout - ? "timeout of " + e.timeout + "ms exceeded" - : "timeout exceeded", - z = e.transitional || Hhr; - e.timeoutErrorMessage && (q = e.timeoutErrorMessage), - i( - new ox( - q, - z.clarifyTimeoutError ? ox.ETIMEDOUT : ox.ECONNABORTED, - e, - h - ) - ), - (h = null); - }), - Kj.isStandardBrowserEnv()) - ) { - var D = - (e.withCredentials || Khr(k)) && e.xsrfCookieName - ? qhr.read(e.xsrfCookieName) - : void 0; - D && (a[e.xsrfHeaderName] = D); - } - "setRequestHeader" in h && - Kj.forEach(a, function (q, z) { - typeof o > "u" && z.toLowerCase() === "content-type" - ? delete a[z] - : h.setRequestHeader(z, q); - }), - Kj.isUndefined(e.withCredentials) || - (h.withCredentials = !!e.withCredentials), - s && s !== "json" && (h.responseType = e.responseType), - typeof e.onDownloadProgress == "function" && - h.addEventListener("progress", e.onDownloadProgress), - typeof e.onUploadProgress == "function" && - h.upload && - h.upload.addEventListener("progress", e.onUploadProgress), - (e.cancelToken || e.signal) && - ((c = function (N) { - !h || - (i(!N || (N && N.type) ? new Vhr() : N), h.abort(), (h = null)); - }), - e.cancelToken && e.cancelToken.subscribe(c), - e.signal && - (e.signal.aborted ? c() : e.signal.addEventListener("abort", c))), - o || (o = null); - var F = Whr(k); - if (F && ["http", "https", "file"].indexOf(F) === -1) { - i(new ox("Unsupported protocol " + F + ":", ox.ERR_BAD_REQUEST, e)); - return; - } - h.send(o); - }); - }; - }); - var lnt = I((q0n, cnt) => { - m(); - g(); - cnt.exports = null; - }); - var Gee = I((z0n, pnt) => { - "use strict"; - m(); - g(); - var ku = Tu(), - fnt = Frt(), - dnt = gT(), - Ghr = Gxe(), - Jhr = Jxe(), - $hr = { "Content-Type": "application/x-www-form-urlencoded" }; - function hnt(t, e) { - !ku.isUndefined(t) && - ku.isUndefined(t["Content-Type"]) && - (t["Content-Type"] = e); - } - function Zhr() { - var t; - return ( - typeof XMLHttpRequest < "u" - ? (t = Qxe()) - : typeof process < "u" && - Object.prototype.toString.call(process) === "[object process]" && - (t = Qxe()), - t - ); - } - function Xhr(t, e, r) { - if (ku.isString(t)) - try { - return (e || JSON.parse)(t), ku.trim(t); - } catch (n) { - if (n.name !== "SyntaxError") throw n; - } - return (r || JSON.stringify)(t); - } - var Wee = { - transitional: Ghr, - adapter: Zhr(), - transformRequest: [ - function (e, r) { - if ( - (fnt(r, "Accept"), - fnt(r, "Content-Type"), - ku.isFormData(e) || - ku.isArrayBuffer(e) || - ku.isBuffer(e) || - ku.isStream(e) || - ku.isFile(e) || - ku.isBlob(e)) - ) - return e; - if (ku.isArrayBufferView(e)) return e.buffer; - if (ku.isURLSearchParams(e)) - return ( - hnt(r, "application/x-www-form-urlencoded;charset=utf-8"), - e.toString() - ); - var n = ku.isObject(e), - i = r && r["Content-Type"], - o; - if ((o = ku.isFileList(e)) || (n && i === "multipart/form-data")) { - var a = this.env && this.env.FormData; - return Jhr(o ? { "files[]": e } : e, a && new a()); - } else if (n || i === "application/json") - return hnt(r, "application/json"), Xhr(e); - return e; - }, - ], - transformResponse: [ - function (e) { - var r = this.transitional || Wee.transitional, - n = r && r.silentJSONParsing, - i = r && r.forcedJSONParsing, - o = !n && this.responseType === "json"; - if (o || (i && ku.isString(e) && e.length)) - try { - return JSON.parse(e); - } catch (a) { - if (o) - throw a.name === "SyntaxError" - ? dnt.from(a, dnt.ERR_BAD_RESPONSE, this, null, this.response) - : a; - } - return e; - }, - ], - timeout: 0, - xsrfCookieName: "XSRF-TOKEN", - xsrfHeaderName: "X-XSRF-TOKEN", - maxContentLength: -1, - maxBodyLength: -1, - env: { FormData: lnt() }, - validateStatus: function (e) { - return e >= 200 && e < 300; - }, - headers: { common: { Accept: "application/json, text/plain, */*" } }, - }; - ku.forEach(["delete", "get", "head"], function (e) { - Wee.headers[e] = {}; - }); - ku.forEach(["post", "put", "patch"], function (e) { - Wee.headers[e] = ku.merge($hr); - }); - pnt.exports = Wee; - }); - var mnt = I((j0n, ynt) => { - "use strict"; - m(); - g(); - var Yhr = Tu(), - Qhr = Gee(); - ynt.exports = function (e, r, n) { - var i = this || Qhr; - return ( - Yhr.forEach(n, function (a) { - e = a.call(i, e, r); - }), - e - ); - }; - }); - var eSe = I((U0n, gnt) => { - "use strict"; - m(); - g(); - gnt.exports = function (e) { - return !!(e && e.__CANCEL__); - }; - }); - var wnt = I((K0n, bnt) => { - "use strict"; - m(); - g(); - var vnt = Tu(), - tSe = mnt(), - epr = eSe(), - tpr = Gee(), - rpr = Uj(); - function rSe(t) { - if ( - (t.cancelToken && t.cancelToken.throwIfRequested(), - t.signal && t.signal.aborted) - ) - throw new rpr(); - } - bnt.exports = function (e) { - rSe(e), - (e.headers = e.headers || {}), - (e.data = tSe.call(e, e.data, e.headers, e.transformRequest)), - (e.headers = vnt.merge( - e.headers.common || {}, - e.headers[e.method] || {}, - e.headers - )), - vnt.forEach( - ["delete", "get", "head", "post", "put", "patch", "common"], - function (i) { - delete e.headers[i]; - } - ); - var r = e.adapter || tpr.adapter; - return r(e).then( - function (i) { - return ( - rSe(e), - (i.data = tSe.call(e, i.data, i.headers, e.transformResponse)), - i - ); - }, - function (i) { - return ( - epr(i) || - (rSe(e), - i && - i.response && - (i.response.data = tSe.call( - e, - i.response.data, - i.response.headers, - e.transformResponse - ))), - Promise.reject(i) - ); - } - ); - }; - }); - var nSe = I((H0n, _nt) => { - "use strict"; - m(); - g(); - var Wp = Tu(); - _nt.exports = function (e, r) { - r = r || {}; - var n = {}; - function i(h, w) { - return Wp.isPlainObject(h) && Wp.isPlainObject(w) - ? Wp.merge(h, w) - : Wp.isPlainObject(w) - ? Wp.merge({}, w) - : Wp.isArray(w) - ? w.slice() - : w; - } - function o(h) { - if (Wp.isUndefined(r[h])) { - if (!Wp.isUndefined(e[h])) return i(void 0, e[h]); - } else return i(e[h], r[h]); - } - function a(h) { - if (!Wp.isUndefined(r[h])) return i(void 0, r[h]); - } - function s(h) { - if (Wp.isUndefined(r[h])) { - if (!Wp.isUndefined(e[h])) return i(void 0, e[h]); - } else return i(void 0, r[h]); - } - function c(h) { - if (h in r) return i(e[h], r[h]); - if (h in e) return i(void 0, e[h]); - } - var u = { - url: a, - method: a, - data: a, - baseURL: s, - transformRequest: s, - transformResponse: s, - paramsSerializer: s, - timeout: s, - timeoutMessage: s, - withCredentials: s, - adapter: s, - responseType: s, - xsrfCookieName: s, - xsrfHeaderName: s, - onUploadProgress: s, - onDownloadProgress: s, - decompress: s, - maxContentLength: s, - maxBodyLength: s, - beforeRedirect: s, - transport: s, - httpAgent: s, - httpsAgent: s, - cancelToken: s, - socketPath: s, - responseEncoding: s, - validateStatus: c, - }; - return ( - Wp.forEach(Object.keys(e).concat(Object.keys(r)), function (w) { - var M = u[w] || o, - k = M(w); - (Wp.isUndefined(k) && M !== c) || (n[w] = k); - }), - n - ); - }; - }); - var iSe = I((V0n, xnt) => { - m(); - g(); - xnt.exports = { version: "0.27.2" }; - }); - var Ent = I((W0n, Ant) => { - "use strict"; - m(); - g(); - var npr = iSe().version, - aA = gT(), - oSe = {}; - ["object", "boolean", "number", "function", "string", "symbol"].forEach( - function (t, e) { - oSe[t] = function (n) { - return typeof n === t || "a" + (e < 1 ? "n " : " ") + t; - }; - } - ); - var Snt = {}; - oSe.transitional = function (e, r, n) { - function i(o, a) { - return ( - "[Axios v" + - npr + - "] Transitional option '" + - o + - "'" + - a + - (n ? ". " + n : "") - ); - } - return function (o, a, s) { - if (e === !1) - throw new aA( - i(a, " has been removed" + (r ? " in " + r : "")), - aA.ERR_DEPRECATED - ); - return ( - r && - !Snt[a] && - ((Snt[a] = !0), - console.warn( - i( - a, - " has been deprecated since v" + - r + - " and will be removed in the near future" - ) - )), - e ? e(o, a, s) : !0 - ); - }; - }; - function ipr(t, e, r) { - if (typeof t != "object") - throw new aA("options must be an object", aA.ERR_BAD_OPTION_VALUE); - for (var n = Object.keys(t), i = n.length; i-- > 0; ) { - var o = n[i], - a = e[o]; - if (a) { - var s = t[o], - c = s === void 0 || a(s, o, t); - if (c !== !0) - throw new aA( - "option " + o + " must be " + c, - aA.ERR_BAD_OPTION_VALUE - ); - continue; - } - if (r !== !0) throw new aA("Unknown option " + o, aA.ERR_BAD_OPTION); - } - } - Ant.exports = { assertOptions: ipr, validators: oSe }; - }); - var Bnt = I((G0n, Ont) => { - "use strict"; - m(); - g(); - var knt = Tu(), - opr = Wxe(), - Mnt = Nrt(), - Tnt = wnt(), - Jee = nSe(), - apr = Zxe(), - Pnt = Ent(), - JC = Pnt.validators; - function $C(t) { - (this.defaults = t), - (this.interceptors = { request: new Mnt(), response: new Mnt() }); - } - $C.prototype.request = function (e, r) { - typeof e == "string" ? ((r = r || {}), (r.url = e)) : (r = e || {}), - (r = Jee(this.defaults, r)), - r.method - ? (r.method = r.method.toLowerCase()) - : this.defaults.method - ? (r.method = this.defaults.method.toLowerCase()) - : (r.method = "get"); - var n = r.transitional; - n !== void 0 && - Pnt.assertOptions( - n, - { - silentJSONParsing: JC.transitional(JC.boolean), - forcedJSONParsing: JC.transitional(JC.boolean), - clarifyTimeoutError: JC.transitional(JC.boolean), - }, - !1 - ); - var i = [], - o = !0; - this.interceptors.request.forEach(function (k) { - (typeof k.runWhen == "function" && k.runWhen(r) === !1) || - ((o = o && k.synchronous), i.unshift(k.fulfilled, k.rejected)); - }); - var a = []; - this.interceptors.response.forEach(function (k) { - a.push(k.fulfilled, k.rejected); - }); - var s; - if (!o) { - var c = [Tnt, void 0]; - for ( - Array.prototype.unshift.apply(c, i), - c = c.concat(a), - s = Promise.resolve(r); - c.length; - - ) - s = s.then(c.shift(), c.shift()); - return s; - } - for (var u = r; i.length; ) { - var h = i.shift(), - w = i.shift(); - try { - u = h(u); - } catch (M) { - w(M); - break; - } - } - try { - s = Tnt(u); - } catch (M) { - return Promise.reject(M); - } - for (; a.length; ) s = s.then(a.shift(), a.shift()); - return s; - }; - $C.prototype.getUri = function (e) { - e = Jee(this.defaults, e); - var r = apr(e.baseURL, e.url); - return opr(r, e.params, e.paramsSerializer); - }; - knt.forEach(["delete", "get", "head", "options"], function (e) { - $C.prototype[e] = function (r, n) { - return this.request( - Jee(n || {}, { method: e, url: r, data: (n || {}).data }) - ); - }; - }); - knt.forEach(["post", "put", "patch"], function (e) { - function r(n) { - return function (o, a, s) { - return this.request( - Jee(s || {}, { - method: e, - headers: n ? { "Content-Type": "multipart/form-data" } : {}, - url: o, - data: a, - }) - ); - }; - } - ($C.prototype[e] = r()), ($C.prototype[e + "Form"] = r(!0)); - }); - Ont.exports = $C; - }); - var Cnt = I((J0n, Int) => { - "use strict"; - m(); - g(); - var spr = Uj(); - function ZC(t) { - if (typeof t != "function") - throw new TypeError("executor must be a function."); - var e; - this.promise = new Promise(function (i) { - e = i; - }); - var r = this; - this.promise.then(function (n) { - if (!!r._listeners) { - var i, - o = r._listeners.length; - for (i = 0; i < o; i++) r._listeners[i](n); - r._listeners = null; - } - }), - (this.promise.then = function (n) { - var i, - o = new Promise(function (a) { - r.subscribe(a), (i = a); - }).then(n); - return ( - (o.cancel = function () { - r.unsubscribe(i); - }), - o - ); - }), - t(function (i) { - r.reason || ((r.reason = new spr(i)), e(r.reason)); - }); - } - ZC.prototype.throwIfRequested = function () { - if (this.reason) throw this.reason; - }; - ZC.prototype.subscribe = function (e) { - if (this.reason) { - e(this.reason); - return; - } - this._listeners ? this._listeners.push(e) : (this._listeners = [e]); - }; - ZC.prototype.unsubscribe = function (e) { - if (!!this._listeners) { - var r = this._listeners.indexOf(e); - r !== -1 && this._listeners.splice(r, 1); - } - }; - ZC.source = function () { - var e, - r = new ZC(function (i) { - e = i; - }); - return { token: r, cancel: e }; - }; - Int.exports = ZC; - }); - var Nnt = I(($0n, Rnt) => { - "use strict"; - m(); - g(); - Rnt.exports = function (e) { - return function (n) { - return e.apply(null, n); - }; - }; - }); - var Fnt = I((Z0n, Dnt) => { - "use strict"; - m(); - g(); - var upr = Tu(); - Dnt.exports = function (e) { - return upr.isObject(e) && e.isAxiosError === !0; - }; - }); - var znt = I((X0n, aSe) => { - "use strict"; - m(); - g(); - var Lnt = Tu(), - cpr = qxe(), - $ee = Bnt(), - lpr = nSe(), - fpr = Gee(); - function qnt(t) { - var e = new $ee(t), - r = cpr($ee.prototype.request, e); - return ( - Lnt.extend(r, $ee.prototype, e), - Lnt.extend(r, e), - (r.create = function (i) { - return qnt(lpr(t, i)); - }), - r - ); - } - var Fh = qnt(fpr); - Fh.Axios = $ee; - Fh.CanceledError = Uj(); - Fh.CancelToken = Cnt(); - Fh.isCancel = eSe(); - Fh.VERSION = iSe().version; - Fh.toFormData = Jxe(); - Fh.AxiosError = gT(); - Fh.Cancel = Fh.CanceledError; - Fh.all = function (e) { - return Promise.all(e); - }; - Fh.spread = Nnt(); - Fh.isAxiosError = Fnt(); - aSe.exports = Fh; - aSe.exports.default = Fh; - }); - var Unt = I((Y0n, jnt) => { - m(); - g(); - jnt.exports = znt(); - }); - var Knt = I((uSe) => { - "use strict"; - m(); - g(); - Object.defineProperty(uSe, "__esModule", { value: !0 }); - var dpr = Unt(), - sSe = class { - constructor(e) { - (this.METHOD_GET = "GET"), - (this.METHOD_POST = "POST"), - this.applyConfig(e); - } - applyConfig(e) { - this.config = this.mergeDefaults(e); - } - getConfig() { - return this.config; - } - mergeDefaults(e) { - let r = e.protocol || "http", - n = e.port || (r === "https" ? 443 : 80); - return { - host: e.host || "127.0.0.1", - protocol: r, - port: n, - timeout: e.timeout || 2e4, - logging: e.logging || !1, - logger: e.logger || console.log, - network: e.network, - }; - } - async get(e, r) { - try { - return await this.request().get(e, r); - } catch (n) { - if (n.response && n.response.status) return n.response; - throw n; - } - } - async post(e, r, n) { - try { - return await this.request().post(e, r, n); - } catch (i) { - if (i.response && i.response.status) return i.response; - throw i; - } - } - request() { - let e = {}; - this.config.network && (e["x-network"] = this.config.network); - let r = dpr.default.create({ - baseURL: `${this.config.protocol}://${this.config.host}:${this.config.port}`, - timeout: this.config.timeout, - maxContentLength: 1024 * 1024 * 512, - headers: e, - }); - return ( - this.config.logging && - (r.interceptors.request.use( - (n) => ( - this.config.logger(`Requesting: ${n.baseURL}/${n.url}`), n - ) - ), - r.interceptors.response.use( - (n) => ( - this.config.logger( - `Response: ${n.config.url} - ${n.status}` - ), - n - ) - )), - r - ); - } - }; - uSe.default = sSe; - }); - var rg = I((Da) => { - "use strict"; - m(); - g(); - Object.defineProperty(Da, "__esModule", { value: !0 }); - Da.b64UrlDecode = - Da.b64UrlEncode = - Da.bufferTob64Url = - Da.bufferTob64 = - Da.b64UrlToBuffer = - Da.stringToB64Url = - Da.stringToBuffer = - Da.bufferToString = - Da.b64UrlToString = - Da.concatBuffers = - void 0; - var Hnt = QI(); - function hpr(t) { - let e = 0; - for (let i = 0; i < t.length; i++) e += t[i].byteLength; - let r = new Uint8Array(e), - n = 0; - r.set(new Uint8Array(t[0]), n), (n += t[0].byteLength); - for (let i = 1; i < t.length; i++) - r.set(new Uint8Array(t[i]), n), (n += t[i].byteLength); - return r; - } - Da.concatBuffers = hpr; - function ppr(t) { - let e = Gnt(t); - return Vnt(e); - } - Da.b64UrlToString = ppr; - function Vnt(t) { - if (typeof TextDecoder > "u") { - let e = es().TextDecoder; - return new e("utf-8", { fatal: !0 }).decode(t); - } - return new TextDecoder("utf-8", { fatal: !0 }).decode(t); - } - Da.bufferToString = Vnt; - function Wnt(t) { - if (typeof TextEncoder > "u") { - let e = es().TextEncoder; - return new e().encode(t); - } - return new TextEncoder().encode(t); - } - Da.stringToBuffer = Wnt; - function ypr(t) { - return $nt(Wnt(t)); - } - Da.stringToB64Url = ypr; - function Gnt(t) { - return new Uint8Array(Hnt.toByteArray(Xnt(t))); - } - Da.b64UrlToBuffer = Gnt; - function Jnt(t) { - return Hnt.fromByteArray(new Uint8Array(t)); - } - Da.bufferTob64 = Jnt; - function $nt(t) { - return Znt(Jnt(t)); - } - Da.bufferTob64Url = $nt; - function Znt(t) { - return t.replace(/\+/g, "-").replace(/\//g, "_").replace(/\=/g, ""); - } - Da.b64UrlEncode = Znt; - function Xnt(t) { - t = t.replace(/\-/g, "+").replace(/\_/g, "/"); - let e; - return ( - t.length % 4 == 0 ? (e = 0) : (e = 4 - (t.length % 4)), - t.concat("=".repeat(e)) - ); - } - Da.b64UrlDecode = Xnt; - }); - var Ynt = I((lSe) => { - "use strict"; - m(); - g(); - Object.defineProperty(lSe, "__esModule", { value: !0 }); - var sA = rg(), - cSe = class { - constructor() { - if ( - ((this.keyLength = 4096), - (this.publicExponent = 65537), - (this.hashAlgorithm = "sha256"), - !this.detectWebCrypto()) - ) - throw new Error("SubtleCrypto not available!"); - this.driver = crypto.subtle; - } - async generateJWK() { - let e = await this.driver.generateKey( - { - name: "RSA-PSS", - modulusLength: 4096, - publicExponent: new Uint8Array([1, 0, 1]), - hash: { name: "SHA-256" }, - }, - !0, - ["sign"] - ), - r = await this.driver.exportKey("jwk", e.privateKey); - return { - kty: r.kty, - e: r.e, - n: r.n, - d: r.d, - p: r.p, - q: r.q, - dp: r.dp, - dq: r.dq, - qi: r.qi, - }; - } - async sign(e, r, { saltLength: n } = {}) { - let i = await this.driver.sign( - { name: "RSA-PSS", saltLength: 32 }, - await this.jwkToCryptoKey(e), - r - ); - return new Uint8Array(i); - } - async hash(e, r = "SHA-256") { - let n = await this.driver.digest(r, e); - return new Uint8Array(n); - } - async verify(e, r, n) { - let i = { kty: "RSA", e: "AQAB", n: e }, - o = await this.jwkToPublicCryptoKey(i), - a = this.driver.verify( - { name: "RSA-PSS", saltLength: 32 }, - o, - n, - r - ), - s = this.driver.verify({ name: "RSA-PSS", saltLength: 0 }, o, n, r); - return a || s; - } - async jwkToCryptoKey(e) { - return this.driver.importKey( - "jwk", - e, - { name: "RSA-PSS", hash: { name: "SHA-256" } }, - !1, - ["sign"] - ); - } - async jwkToPublicCryptoKey(e) { - return this.driver.importKey( - "jwk", - e, - { name: "RSA-PSS", hash: { name: "SHA-256" } }, - !1, - ["verify"] - ); - } - detectWebCrypto() { - if (typeof crypto > "u") return !1; - let e = crypto == null ? void 0 : crypto.subtle; - return e === void 0 - ? !1 - : ["generateKey", "importKey", "exportKey", "digest", "sign"].every( - (n) => typeof e[n] == "function" - ); - } - async encrypt(e, r, n) { - let i = await this.driver.importKey( - "raw", - typeof r == "string" ? sA.stringToBuffer(r) : r, - { name: "PBKDF2", length: 32 }, - !1, - ["deriveKey"] - ), - o = await this.driver.deriveKey( - { - name: "PBKDF2", - salt: n ? sA.stringToBuffer(n) : sA.stringToBuffer("salt"), - iterations: 1e5, - hash: "SHA-256", - }, - i, - { name: "AES-CBC", length: 256 }, - !1, - ["encrypt", "decrypt"] - ), - a = new Uint8Array(16); - crypto.getRandomValues(a); - let s = await this.driver.encrypt({ name: "AES-CBC", iv: a }, o, e); - return sA.concatBuffers([a, s]); - } - async decrypt(e, r, n) { - let i = await this.driver.importKey( - "raw", - typeof r == "string" ? sA.stringToBuffer(r) : r, - { name: "PBKDF2", length: 32 }, - !1, - ["deriveKey"] - ), - o = await this.driver.deriveKey( - { - name: "PBKDF2", - salt: n ? sA.stringToBuffer(n) : sA.stringToBuffer("salt"), - iterations: 1e5, - hash: "SHA-256", - }, - i, - { name: "AES-CBC", length: 256 }, - !1, - ["encrypt", "decrypt"] - ), - a = e.slice(0, 16), - s = await this.driver.decrypt( - { name: "AES-CBC", iv: a }, - o, - e.slice(16) - ); - return sA.concatBuffers([s]); - } - }; - lSe.default = cSe; - }); - var Qnt = I((dSe) => { - "use strict"; - m(); - g(); - Object.defineProperty(dSe, "__esModule", { value: !0 }); - var fSe = class { - constructor(e) { - this.api = e; - } - getInfo() { - return this.api.get("info").then((e) => e.data); - } - getPeers() { - return this.api.get("peers").then((e) => e.data); - } - }; - dSe.default = fSe; - }); - var Vj = I((Hj) => { - "use strict"; - m(); - g(); - Object.defineProperty(Hj, "__esModule", { value: !0 }); - Hj.getError = void 0; - var hSe = class extends Error { - constructor(e, r = {}) { - r.message ? super(r.message) : super(), - (this.type = e), - (this.response = r.response); - } - getType() { - return this.type; - } - }; - Hj.default = hSe; - function mpr(t) { - let e = t.data; - if (typeof t.data == "string") - try { - e = JSON.parse(t.data); - } catch {} - if (t.data instanceof ArrayBuffer || t.data instanceof Uint8Array) - try { - e = JSON.parse(e.toString()); - } catch {} - return e ? e.error || e : t.statusText || "unknown"; - } - Hj.getError = mpr; - }); - var ySe = I((pSe) => { - "use strict"; - m(); - g(); - Object.defineProperty(pSe, "__esModule", { value: !0 }); - var Gp = Wj(); - async function eit(t) { - if (Array.isArray(t)) { - let n = Gp.default.utils.concatBuffers([ - Gp.default.utils.stringToBuffer("list"), - Gp.default.utils.stringToBuffer(t.length.toString()), - ]); - return await tit(t, await Gp.default.crypto.hash(n, "SHA-384")); - } - let e = Gp.default.utils.concatBuffers([ - Gp.default.utils.stringToBuffer("blob"), - Gp.default.utils.stringToBuffer(t.byteLength.toString()), - ]), - r = Gp.default.utils.concatBuffers([ - await Gp.default.crypto.hash(e, "SHA-384"), - await Gp.default.crypto.hash(t, "SHA-384"), - ]); - return await Gp.default.crypto.hash(r, "SHA-384"); - } - pSe.default = eit; - async function tit(t, e) { - if (t.length < 1) return e; - let r = Gp.default.utils.concatBuffers([e, await eit(t[0])]), - n = await Gp.default.crypto.hash(r, "SHA-384"); - return await tit(t.slice(1), n); - } - }); - var _Se = I((Dn) => { - "use strict"; - m(); - g(); - Object.defineProperty(Dn, "__esModule", { value: !0 }); - Dn.debug = - Dn.validatePath = - Dn.arrayCompare = - Dn.bufferToInt = - Dn.intToBuffer = - Dn.arrayFlatten = - Dn.generateProofs = - Dn.buildLayers = - Dn.generateTransactionChunks = - Dn.generateTree = - Dn.computeRootHash = - Dn.generateLeaves = - Dn.chunkData = - Dn.MIN_CHUNK_SIZE = - Dn.MAX_CHUNK_SIZE = - void 0; - var Zee = Wj(), - rit = rg(); - Dn.MAX_CHUNK_SIZE = 256 * 1024; - Dn.MIN_CHUNK_SIZE = 32 * 1024; - var Jj = 32, - XC = 32; - async function gSe(t) { - let e = [], - r = t, - n = 0; - for (; r.byteLength >= Dn.MAX_CHUNK_SIZE; ) { - let i = Dn.MAX_CHUNK_SIZE, - o = r.byteLength - Dn.MAX_CHUNK_SIZE; - o > 0 && o < Dn.MIN_CHUNK_SIZE && (i = Math.ceil(r.byteLength / 2)); - let a = r.slice(0, i), - s = await Zee.default.crypto.hash(a); - (n += a.byteLength), - e.push({ - dataHash: s, - minByteRange: n - a.byteLength, - maxByteRange: n, - }), - (r = r.slice(i)); - } - return ( - e.push({ - dataHash: await Zee.default.crypto.hash(r), - minByteRange: n, - maxByteRange: n + r.byteLength, - }), - e - ); - } - Dn.chunkData = gSe; - async function vSe(t) { - return Promise.all( - t.map(async ({ dataHash: e, minByteRange: r, maxByteRange: n }) => ({ - type: "leaf", - id: await Pu(await Promise.all([Pu(e), Pu($j(n))])), - dataHash: e, - minByteRange: r, - maxByteRange: n, - })) - ); - } - Dn.generateLeaves = vSe; - async function gpr(t) { - return (await nit(t)).id; - } - Dn.computeRootHash = gpr; - async function nit(t) { - return await Xee(await vSe(await gSe(t))); - } - Dn.generateTree = nit; - async function vpr(t) { - let e = await gSe(t), - r = await vSe(e), - n = await Xee(r), - i = await iit(n), - o = e.slice(-1)[0]; - return ( - o.maxByteRange - o.minByteRange === 0 && - (e.splice(e.length - 1, 1), i.splice(i.length - 1, 1)), - { data_root: n.id, chunks: e, proofs: i } - ); - } - Dn.generateTransactionChunks = vpr; - async function Xee(t, e = 0) { - if (t.length < 2) return t[0]; - let r = []; - for (let n = 0; n < t.length; n += 2) r.push(await bpr(t[n], t[n + 1])); - return Xee(r, e + 1); - } - Dn.buildLayers = Xee; - function iit(t) { - let e = mSe(t); - return Array.isArray(e) ? bSe(e) : [e]; - } - Dn.generateProofs = iit; - function mSe(t, e = new Uint8Array(), r = 0) { - if (t.type == "leaf") - return { - offset: t.maxByteRange - 1, - proof: (0, rit.concatBuffers)([e, t.dataHash, $j(t.maxByteRange)]), - }; - if (t.type == "branch") { - let n = (0, rit.concatBuffers)([ - e, - t.leftChild.id, - t.rightChild.id, - $j(t.byteRange), - ]); - return [mSe(t.leftChild, n, r + 1), mSe(t.rightChild, n, r + 1)]; - } - throw new Error("Unexpected node type"); - } - function bSe(t) { - let e = []; - return ( - t.forEach((r) => { - Array.isArray(r) ? e.push(...bSe(r)) : e.push(r); - }), - e - ); - } - Dn.arrayFlatten = bSe; - async function bpr(t, e) { - return e - ? { - type: "branch", - id: await Pu([ - await Pu(t.id), - await Pu(e.id), - await Pu($j(t.maxByteRange)), - ]), - byteRange: t.maxByteRange, - maxByteRange: e.maxByteRange, - leftChild: t, - rightChild: e, - } - : t; - } - async function Pu(t) { - return ( - Array.isArray(t) && (t = Zee.default.utils.concatBuffers(t)), - new Uint8Array(await Zee.default.crypto.hash(t)) - ); - } - function $j(t) { - let e = new Uint8Array(Jj); - for (var r = e.length - 1; r >= 0; r--) { - var n = t % 256; - (e[r] = n), (t = (t - n) / 256); - } - return e; - } - Dn.intToBuffer = $j; - function wSe(t) { - let e = 0; - for (var r = 0; r < t.length; r++) (e *= 256), (e += t[r]); - return e; - } - Dn.bufferToInt = wSe; - var wpr = (t, e) => t.every((r, n) => e[n] === r); - Dn.arrayCompare = wpr; - async function Gj(t, e, r, n, i) { - if (n <= 0) return !1; - if (e >= n) return Gj(t, 0, n - 1, n, i); - if (e < 0) return Gj(t, 0, 0, n, i); - if (i.length == XC + Jj) { - let w = i.slice(0, XC), - M = i.slice(w.length, w.length + Jj), - k = await Pu([await Pu(w), await Pu(M)]); - return (0, Dn.arrayCompare)(t, k) - ? { offset: n - 1, leftBound: r, rightBound: n, chunkSize: n - r } - : !1; - } - let o = i.slice(0, XC), - a = i.slice(o.length, o.length + XC), - s = i.slice(o.length + a.length, o.length + a.length + Jj), - c = wSe(s), - u = i.slice(o.length + a.length + s.length), - h = await Pu([await Pu(o), await Pu(a), await Pu(s)]); - return (0, Dn.arrayCompare)(t, h) - ? e < c - ? await Gj(o, e, r, Math.min(n, c), u) - : await Gj(a, e, Math.max(r, c), n, u) - : !1; - } - Dn.validatePath = Gj; - async function oit(t, e = "") { - if (t.byteLength < 1) return e; - let r = t.slice(0, XC), - n = t.slice(r.length, r.length + XC), - i = t.slice(r.length + n.length, r.length + n.length + Jj), - o = wSe(i), - a = t.slice(r.length + n.length + i.length), - s = await Pu([await Pu(r), await Pu(n), await Pu(i)]), - c = `${e} -${JSON.stringify(Buffer.from(r))},${JSON.stringify( - Buffer.from(n) - )},${o} => ${JSON.stringify(s)}`; - return oit(a, c); - } - Dn.debug = oit; - }); - var Qee = I((Xj) => { - "use strict"; - m(); - g(); - Object.defineProperty(Xj, "__esModule", { value: !0 }); - Xj.Tag = void 0; - var Xs = rg(), - _pr = ySe(), - xpr = _Se(), - Yee = class { - get(e, r) { - if (!Object.getOwnPropertyNames(this).includes(e)) - throw new Error( - `Field "${e}" is not a property of the Arweave Transaction class.` - ); - return this[e] instanceof Uint8Array - ? r && r.decode && r.string - ? Xs.bufferToString(this[e]) - : r && r.decode && !r.string - ? this[e] - : Xs.bufferTob64Url(this[e]) - : r && r.decode == !0 - ? r && r.string - ? Xs.b64UrlToString(this[e]) - : Xs.b64UrlToBuffer(this[e]) - : this[e]; - } - }, - Zj = class extends Yee { - constructor(e, r, n = !1) { - super(), (this.name = e), (this.value = r); - } - }; - Xj.Tag = Zj; - var xSe = class extends Yee { - constructor(e = {}) { - super(), - (this.format = 2), - (this.id = ""), - (this.last_tx = ""), - (this.owner = ""), - (this.tags = []), - (this.target = ""), - (this.quantity = "0"), - (this.data_size = "0"), - (this.data = new Uint8Array()), - (this.data_root = ""), - (this.reward = "0"), - (this.signature = ""), - Object.assign(this, e), - typeof this.data == "string" && - (this.data = Xs.b64UrlToBuffer(this.data)), - e.tags && (this.tags = e.tags.map((r) => new Zj(r.name, r.value))); - } - addTag(e, r) { - this.tags.push(new Zj(Xs.stringToB64Url(e), Xs.stringToB64Url(r))); - } - toJSON() { - return { - format: this.format, - id: this.id, - last_tx: this.last_tx, - owner: this.owner, - tags: this.tags, - target: this.target, - quantity: this.quantity, - data: Xs.bufferTob64Url(this.data), - data_size: this.data_size, - data_root: this.data_root, - data_tree: this.data_tree, - reward: this.reward, - signature: this.signature, - }; - } - setOwner(e) { - this.owner = e; - } - setSignature({ id: e, owner: r, reward: n, tags: i, signature: o }) { - (this.id = e), - (this.owner = r), - n && (this.reward = n), - i && (this.tags = i), - (this.signature = o); - } - async prepareChunks(e) { - !this.chunks && - e.byteLength > 0 && - ((this.chunks = await (0, xpr.generateTransactionChunks)(e)), - (this.data_root = Xs.bufferTob64Url(this.chunks.data_root))), - !this.chunks && - e.byteLength === 0 && - ((this.chunks = { - chunks: [], - data_root: new Uint8Array(), - proofs: [], - }), - (this.data_root = "")); - } - getChunk(e, r) { - if (!this.chunks) throw new Error("Chunks have not been prepared"); - let n = this.chunks.proofs[e], - i = this.chunks.chunks[e]; - return { - data_root: this.data_root, - data_size: this.data_size, - data_path: Xs.bufferTob64Url(n.proof), - offset: n.offset.toString(), - chunk: Xs.bufferTob64Url(r.slice(i.minByteRange, i.maxByteRange)), - }; - } - async getSignatureData() { - switch (this.format) { - case 1: - let e = this.tags.reduce( - (n, i) => - Xs.concatBuffers([ - n, - i.get("name", { decode: !0, string: !1 }), - i.get("value", { decode: !0, string: !1 }), - ]), - new Uint8Array() - ); - return Xs.concatBuffers([ - this.get("owner", { decode: !0, string: !1 }), - this.get("target", { decode: !0, string: !1 }), - this.get("data", { decode: !0, string: !1 }), - Xs.stringToBuffer(this.quantity), - Xs.stringToBuffer(this.reward), - this.get("last_tx", { decode: !0, string: !1 }), - e, - ]); - case 2: - this.data_root || (await this.prepareChunks(this.data)); - let r = this.tags.map((n) => [ - n.get("name", { decode: !0, string: !1 }), - n.get("value", { decode: !0, string: !1 }), - ]); - return await (0, _pr.default)([ - Xs.stringToBuffer(this.format.toString()), - this.get("owner", { decode: !0, string: !1 }), - this.get("target", { decode: !0, string: !1 }), - Xs.stringToBuffer(this.quantity), - Xs.stringToBuffer(this.reward), - this.get("last_tx", { decode: !0, string: !1 }), - r, - Xs.stringToBuffer(this.data_size), - this.get("data_root", { decode: !0, string: !1 }), - ]); - default: - throw new Error(`Unexpected transaction format: ${this.format}`); - } - } - }; - Xj.default = xSe; - }); - var cit = I((ete) => { - "use strict"; - m(); - g(); - Object.defineProperty(ete, "__esModule", { value: !0 }); - ete.TransactionUploader = void 0; - var ait = Qee(), - Spr = rg(), - SSe = Vj(), - Apr = _Se(), - sit = 1, - Epr = [ - "invalid_json", - "chunk_too_big", - "data_path_too_big", - "offset_too_big", - "data_size_too_big", - "chunk_proof_ratio_not_attractive", - "invalid_proof", - ], - uit = 1e3 * 40, - Yj = class { - constructor(e, r) { - if ( - ((this.api = e), - (this.chunkIndex = 0), - (this.txPosted = !1), - (this.lastRequestTimeEnd = 0), - (this.totalErrors = 0), - (this.lastResponseStatus = 0), - (this.lastResponseError = ""), - !r.id) - ) - throw new Error("Transaction is not signed"); - if (!r.chunks) throw new Error("Transaction chunks not prepared"); - (this.data = r.data), - (this.transaction = new ait.default( - Object.assign({}, r, { data: new Uint8Array(0) }) - )); - } - get isComplete() { - return ( - this.txPosted && - this.chunkIndex === this.transaction.chunks.chunks.length - ); - } - get totalChunks() { - return this.transaction.chunks.chunks.length; - } - get uploadedChunks() { - return this.chunkIndex; - } - get pctComplete() { - return Math.trunc((this.uploadedChunks / this.totalChunks) * 100); - } - async uploadChunk(e) { - if (this.isComplete) throw new Error("Upload is already complete"); - if ( - (this.lastResponseError !== "" - ? this.totalErrors++ - : (this.totalErrors = 0), - this.totalErrors === 100) - ) - throw new Error( - `Unable to complete upload: ${this.lastResponseStatus}: ${this.lastResponseError}` - ); - let r = - this.lastResponseError === "" - ? 0 - : Math.max(this.lastRequestTimeEnd + uit - Date.now(), uit); - if ( - (r > 0 && - ((r = r - r * Math.random() * 0.3), - await new Promise((a) => setTimeout(a, r))), - (this.lastResponseError = ""), - !this.txPosted) - ) { - await this.postTransaction(); - return; - } - e && (this.chunkIndex = e); - let n = this.transaction.getChunk(e || this.chunkIndex, this.data); - if ( - !(await (0, Apr.validatePath)( - this.transaction.chunks.data_root, - parseInt(n.offset), - 0, - parseInt(n.data_size), - Spr.b64UrlToBuffer(n.data_path) - )) - ) - throw new Error(`Unable to validate chunk ${this.chunkIndex}`); - let o = await this.api - .post( - "chunk", - this.transaction.getChunk(this.chunkIndex, this.data) - ) - .catch( - (a) => ( - console.error(a.message), - { status: -1, data: { error: a.message } } - ) - ); - if ( - ((this.lastRequestTimeEnd = Date.now()), - (this.lastResponseStatus = o.status), - this.lastResponseStatus == 200) - ) - this.chunkIndex++; - else if ( - ((this.lastResponseError = (0, SSe.getError)(o)), - Epr.includes(this.lastResponseError)) - ) - throw new Error( - `Fatal error uploading chunk ${this.chunkIndex}: ${this.lastResponseError}` - ); - } - static async fromSerialized(e, r, n) { - if ( - !r || - typeof r.chunkIndex != "number" || - typeof r.transaction != "object" - ) - throw new Error( - "Serialized object does not match expected format." - ); - var i = new ait.default(r.transaction); - i.chunks || (await i.prepareChunks(n)); - let o = new Yj(e, i); - if ( - ((o.chunkIndex = r.chunkIndex), - (o.lastRequestTimeEnd = r.lastRequestTimeEnd), - (o.lastResponseError = r.lastResponseError), - (o.lastResponseStatus = r.lastResponseStatus), - (o.txPosted = r.txPosted), - (o.data = n), - o.transaction.data_root !== r.transaction.data_root) - ) - throw new Error( - "Data mismatch: Uploader doesn't match provided data." - ); - return o; - } - static async fromTransactionId(e, r) { - let n = await e.get(`tx/${r}`); - if (n.status !== 200) - throw new Error(`Tx ${r} not found: ${n.status}`); - let i = n.data; - return ( - (i.data = new Uint8Array(0)), - { - txPosted: !0, - chunkIndex: 0, - lastResponseError: "", - lastRequestTimeEnd: 0, - lastResponseStatus: 0, - transaction: i, - } - ); - } - toJSON() { - return { - chunkIndex: this.chunkIndex, - transaction: this.transaction, - lastRequestTimeEnd: this.lastRequestTimeEnd, - lastResponseStatus: this.lastResponseStatus, - lastResponseError: this.lastResponseError, - txPosted: this.txPosted, - }; - } - async postTransaction() { - if (this.totalChunks <= sit) { - this.transaction.data = this.data; - let n = await this.api - .post("tx", this.transaction) - .catch( - (i) => ( - console.error(i), { status: -1, data: { error: i.message } } - ) - ); - if ( - ((this.lastRequestTimeEnd = Date.now()), - (this.lastResponseStatus = n.status), - (this.transaction.data = new Uint8Array(0)), - n.status >= 200 && n.status < 300) - ) { - (this.txPosted = !0), (this.chunkIndex = sit); - return; - } - throw ( - ((this.lastResponseError = (0, SSe.getError)(n)), - new Error( - `Unable to upload transaction: ${n.status}, ${this.lastResponseError}` - )) - ); - } - let r = await this.api.post("tx", this.transaction); - if ( - ((this.lastRequestTimeEnd = Date.now()), - (this.lastResponseStatus = r.status), - !(r.status >= 200 && r.status < 300)) - ) - throw ( - ((this.lastResponseError = (0, SSe.getError)(r)), - new Error( - `Unable to upload transaction: ${r.status}, ${this.lastResponseError}` - )) - ); - this.txPosted = !0; - } - }; - ete.TransactionUploader = Yj; - }); - var tte = I((uyn, lit) => { - m(); - g(); - lit.exports = {}; - }); - var fit = I((bT) => { - "use strict"; - m(); - g(); - var vT = - (bT && bT.__await) || - function (t) { - return this instanceof vT ? ((this.v = t), this) : new vT(t); - }, - Mpr = - (bT && bT.__asyncGenerator) || - function (t, e, r) { - if (!Symbol.asyncIterator) - throw new TypeError("Symbol.asyncIterator is not defined."); - var n = r.apply(t, e || []), - i, - o = []; - return ( - (i = {}), - a("next"), - a("throw"), - a("return"), - (i[Symbol.asyncIterator] = function () { - return this; - }), - i - ); - function a(M) { - n[M] && - (i[M] = function (k) { - return new Promise(function (O, D) { - o.push([M, k, O, D]) > 1 || s(M, k); - }); - }); - } - function s(M, k) { - try { - c(n[M](k)); - } catch (O) { - w(o[0][3], O); - } - } - function c(M) { - M.value instanceof vT - ? Promise.resolve(M.value.v).then(u, h) - : w(o[0][2], M); - } - function u(M) { - s("next", M); - } - function h(M) { - s("throw", M); - } - function w(M, k) { - M(k), o.shift(), o.length && s(o[0][0], o[0][1]); - } - }; - Object.defineProperty(bT, "__esModule", { value: !0 }); - var ASe = Vj(), - ax = Qee(), - Qj = rg(), - ESe = cit(); - tte(); - var MSe = class { - constructor(e, r, n) { - (this.api = e), (this.crypto = r), (this.chunks = n); - } - getTransactionAnchor() { - return this.api - .get("tx_anchor", { transformResponse: [] }) - .then((e) => e.data); - } - getPrice(e, r) { - let n = r ? `price/${e}/${r}` : `price/${e}`; - return this.api - .get(n, { - transformResponse: [ - function (i) { - return i; - }, - ], - }) - .then((i) => i.data); - } - async get(e) { - let r = await this.api.get(`tx/${e}`); - if (r.status == 200) { - let n = parseInt(r.data.data_size); - if (r.data.format >= 2 && n > 0 && n <= 1024 * 1024 * 12) { - let i = await this.getData(e); - return new ax.default( - Object.assign(Object.assign({}, r.data), { data: i }) - ); - } - return new ax.default( - Object.assign(Object.assign({}, r.data), { - format: r.data.format || 1, - }) - ); - } - throw r.status == 404 - ? new ASe.default("TX_NOT_FOUND") - : r.status == 410 - ? new ASe.default("TX_FAILED") - : new ASe.default("TX_INVALID"); - } - fromRaw(e) { - return new ax.default(e); - } - async search(e, r) { - return this.api - .post("arql", { op: "equals", expr1: e, expr2: r }) - .then((n) => (n.data ? n.data : [])); - } - getStatus(e) { - return this.api - .get(`tx/${e}/status`) - .then((r) => - r.status == 200 - ? { status: 200, confirmed: r.data } - : { status: r.status, confirmed: null } - ); - } - async getData(e, r) { - let n; - try { - n = await this.chunks.downloadChunkedData(e); - } catch (i) { - console.error(`Error while trying to download chunked data for ${e}`), - console.error(i); - } - if (!n) { - console.warn(`Falling back to gateway cache for ${e}`); - try { - n = (await this.api.get(`/${e}`)).data; - } catch (i) { - console.error( - `Error while trying to download contiguous data from gateway cache for ${e}` - ), - console.error(i); - } - } - if (!n) throw new Error(`${e} was not found!`); - return r && r.decode && !r.string - ? n - : r && r.decode && r.string - ? Qj.bufferToString(n) - : Qj.bufferTob64Url(n); - } - async sign(e, r, n) { - if (!r && (typeof window > "u" || !window.arweaveWallet)) - throw new Error( - "A new Arweave transaction must provide the jwk parameter." - ); - if (!r || r === "use_wallet") { - try { - (await window.arweaveWallet.getPermissions()).includes( - "SIGN_TRANSACTION" - ) || (await window.arweaveWallet.connect(["SIGN_TRANSACTION"])); - } catch {} - let i = await window.arweaveWallet.sign(e, n); - e.setSignature({ - id: i.id, - owner: i.owner, - reward: i.reward, - tags: i.tags, - signature: i.signature, - }); - } else { - e.setOwner(r.n); - let i = await e.getSignatureData(), - o = await this.crypto.sign(r, i, n), - a = await this.crypto.hash(o); - e.setSignature({ - id: Qj.bufferTob64Url(a), - owner: r.n, - signature: Qj.bufferTob64Url(o), - }); - } - } - async verify(e) { - let r = await e.getSignatureData(), - n = e.get("signature", { decode: !0, string: !1 }), - i = Qj.bufferTob64Url(await this.crypto.hash(n)); - if (e.id !== i) - throw new Error( - "Invalid transaction signature or ID! The transaction ID doesn't match the expected SHA-256 hash of the signature." - ); - return this.crypto.verify(e.owner, r, n); - } - async post(e) { - if ( - (typeof e == "string" - ? (e = new ax.default(JSON.parse(e))) - : typeof e.readInt32BE == "function" - ? (e = new ax.default(JSON.parse(e.toString()))) - : typeof e == "object" && - !(e instanceof ax.default) && - (e = new ax.default(e)), - !(e instanceof ax.default)) - ) - throw new Error("Must be Transaction object"); - e.chunks || (await e.prepareChunks(e.data)); - let r = await this.getUploader(e, e.data); - try { - for (; !r.isComplete; ) await r.uploadChunk(); - } catch (n) { - if (r.lastResponseStatus > 0) - return { - status: r.lastResponseStatus, - statusText: r.lastResponseError, - data: { error: r.lastResponseError }, - }; - throw n; - } - return { status: 200, statusText: "OK", data: {} }; - } - async getUploader(e, r) { - let n; - if ( - (r instanceof ArrayBuffer && (r = new Uint8Array(r)), - e instanceof ax.default) - ) { - if ((r || (r = e.data), !(r instanceof Uint8Array))) - throw new Error("Data format is invalid"); - e.chunks || (await e.prepareChunks(r)), - (n = new ESe.TransactionUploader(this.api, e)), - (!n.data || n.data.length === 0) && (n.data = r); - } else { - if ( - (typeof e == "string" && - (e = await ESe.TransactionUploader.fromTransactionId( - this.api, - e - )), - !r || !(r instanceof Uint8Array)) - ) - throw new Error("Must provide data when resuming upload"); - n = await ESe.TransactionUploader.fromSerialized(this.api, e, r); - } - return n; - } - upload(e, r) { - return Mpr(this, arguments, function* () { - let i = yield vT(this.getUploader(e, r)); - for (; !i.isComplete; ) yield vT(i.uploadChunk()), yield yield vT(i); - return yield vT(i); - }); - } - }; - bT.default = MSe; - }); - var hit = I((kSe) => { - "use strict"; - m(); - g(); - Object.defineProperty(kSe, "__esModule", { value: !0 }); - var dit = rg(); - tte(); - var TSe = class { - constructor(e, r) { - (this.api = e), (this.crypto = r); - } - getBalance(e) { - return this.api - .get(`wallet/${e}/balance`, { - transformResponse: [ - function (r) { - return r; - }, - ], - }) - .then((r) => r.data); - } - getLastTransactionID(e) { - return this.api.get(`wallet/${e}/last_tx`).then((r) => r.data); - } - generate() { - return this.crypto.generateJWK(); - } - async jwkToAddress(e) { - return !e || e === "use_wallet" - ? this.getAddress() - : this.getAddress(e); - } - async getAddress(e) { - if (!e || e === "use_wallet") { - try { - await window.arweaveWallet.connect(["ACCESS_ADDRESS"]); - } catch {} - return window.arweaveWallet.getActiveAddress(); - } else return this.ownerToAddress(e.n); - } - async ownerToAddress(e) { - return dit.bufferTob64Url( - await this.crypto.hash(dit.b64UrlToBuffer(e)) - ); - } - }; - kSe.default = TSe; - }); - var yit = I((eU) => { - "use strict"; - m(); - g(); - Object.defineProperty(eU, "__esModule", { value: !0 }); - eU.SiloResource = void 0; - var pit = rg(), - PSe = class { - constructor(e, r, n) { - (this.api = e), (this.crypto = r), (this.transactions = n); - } - async get(e) { - if (!e) throw new Error("No Silo URI specified"); - let r = await this.parseUri(e), - n = await this.transactions.search("Silo-Name", r.getAccessKey()); - if (n.length == 0) - throw new Error(`No data could be found for the Silo URI: ${e}`); - let i = await this.transactions.get(n[0]); - if (!i) - throw new Error(`No data could be found for the Silo URI: ${e}`); - let o = i.get("data", { decode: !0, string: !1 }); - return this.crypto.decrypt(o, r.getEncryptionKey()); - } - async readTransactionData(e, r) { - if (!r) throw new Error("No Silo URI specified"); - let n = await this.parseUri(r), - i = e.get("data", { decode: !0, string: !1 }); - return this.crypto.decrypt(i, n.getEncryptionKey()); - } - async parseUri(e) { - let r = e.match(/^([a-z0-9-_]+)\.([0-9]+)/i); - if (!r) - throw new Error( - "Invalid Silo name, must be a name in the format of [a-z0-9]+.[0-9]+, e.g. 'bubble.7'" - ); - let n = r[1], - i = Math.pow(2, parseInt(r[2])), - o = await this.hash(pit.stringToBuffer(n), i), - a = pit.bufferTob64(o.slice(0, 15)), - s = await this.hash(o.slice(16, 31), 1); - return new rte(e, a, s); - } - async hash(e, r) { - let n = await this.crypto.hash(e); - for (let i = 0; i < r - 1; i++) n = await this.crypto.hash(n); - return n; - } - }; - eU.default = PSe; - var rte = class { - constructor(e, r, n) { - (this.uri = e), (this.accessKey = r), (this.encryptionKey = n); - } - getUri() { - return this.uri; - } - getAccessKey() { - return this.accessKey; - } - getEncryptionKey() { - return this.encryptionKey; - } - }; - eU.SiloResource = rte; - }); - var git = I((BSe) => { - "use strict"; - m(); - g(); - Object.defineProperty(BSe, "__esModule", { value: !0 }); - var mit = Vj(), - Tpr = rg(), - OSe = class { - constructor(e) { - this.api = e; - } - async getTransactionOffset(e) { - let r = await this.api.get(`tx/${e}/offset`); - if (r.status === 200) return r.data; - throw new Error( - `Unable to get transaction offset: ${(0, mit.getError)(r)}` - ); - } - async getChunk(e) { - let r = await this.api.get(`chunk/${e}`); - if (r.status === 200) return r.data; - throw new Error(`Unable to get chunk: ${(0, mit.getError)(r)}`); - } - async getChunkData(e) { - let r = await this.getChunk(e); - return Tpr.b64UrlToBuffer(r.chunk); - } - firstChunkOffset(e) { - return parseInt(e.offset) - parseInt(e.size) + 1; - } - async downloadChunkedData(e) { - let r = await this.getTransactionOffset(e), - n = parseInt(r.size), - o = parseInt(r.offset) - n + 1, - a = new Uint8Array(n), - s = 0; - for (; s < n; ) { - this.api.config.logging && console.log(`[chunk] ${s}/${n}`); - let c; - try { - c = await this.getChunkData(o + s); - } catch { - console.error(`[chunk] Failed to fetch chunk at offset ${o + s}`), - console.error( - "[chunk] This could indicate that the chunk wasn't uploaded or hasn't yet seeded properly to a particular gateway/node" - ); - } - if (c) a.set(c, s), (s += c.length); - else - throw new Error(`Couldn't complete data download at ${s}/${n}`); - } - return a; - } - }; - BSe.default = OSe; - }); - var vit = I((ISe) => { - "use strict"; - m(); - g(); - Object.defineProperty(ISe, "__esModule", { value: !0 }); - var kpr = Vj(); - tte(); - var YC = class { - constructor(e, r) { - (this.api = e), (this.network = r); - } - async get(e) { - let r = await this.api.get(`${YC.ENDPOINT}${e}`); - if (r.status === 200) return r.data; - throw r.status === 404 - ? new kpr.default("BLOCK_NOT_FOUND") - : new Error(`Error while loading block data: ${r}`); - } - async getCurrent() { - let { current: e } = await this.network.getInfo(); - return await this.get(e); - } - }; - ISe.default = YC; - YC.ENDPOINT = "block/hash/"; - }); - var Wj = I((CSe) => { - "use strict"; - m(); - g(); - Object.defineProperty(CSe, "__esModule", { value: !0 }); - var Ppr = Trt(), - Opr = Knt(), - Bpr = Ynt(), - Ipr = Qnt(), - Cpr = fit(), - Rpr = hit(), - bit = Qee(), - tU = rg(), - Npr = yit(), - Dpr = git(), - Fpr = vit(), - Fv = class { - constructor(e) { - (this.api = new Opr.default(e)), - (this.wallets = new Rpr.default(this.api, Fv.crypto)), - (this.chunks = new Dpr.default(this.api)), - (this.transactions = new Cpr.default( - this.api, - Fv.crypto, - this.chunks - )), - (this.silo = new Npr.default( - this.api, - this.crypto, - this.transactions - )), - (this.network = new Ipr.default(this.api)), - (this.blocks = new Fpr.default(this.api, this.network)), - (this.ar = new Ppr.default()); - } - get crypto() { - return Fv.crypto; - } - get utils() { - return Fv.utils; - } - getConfig() { - return { api: this.api.getConfig(), crypto: null }; - } - async createTransaction(e, r) { - let n = {}; - if ((Object.assign(n, e), !e.data && !(e.target && e.quantity))) - throw new Error( - "A new Arweave transaction must have a 'data' value, or 'target' and 'quantity' values." - ); - if ( - (e.owner == null && r && r !== "use_wallet" && (n.owner = r.n), - e.last_tx == null && - (n.last_tx = await this.transactions.getTransactionAnchor()), - typeof e.data == "string" && (e.data = tU.stringToBuffer(e.data)), - e.data instanceof ArrayBuffer && (e.data = new Uint8Array(e.data)), - e.data && !(e.data instanceof Uint8Array)) - ) - throw new Error( - "Expected data to be a string, Uint8Array or ArrayBuffer" - ); - if (e.reward == null) { - let o = e.data ? e.data.byteLength : 0; - n.reward = await this.transactions.getPrice(o, n.target); - } - (n.data_root = ""), - (n.data_size = e.data ? e.data.byteLength.toString() : "0"), - (n.data = e.data || new Uint8Array(0)); - let i = new bit.default(n); - return await i.getSignatureData(), i; - } - async createSiloTransaction(e, r, n) { - let i = {}; - if ((Object.assign(i, e), !e.data)) - throw new Error("Silo transactions must have a 'data' value"); - if (!n) throw new Error("No Silo URI specified."); - if (e.target || e.quantity) - throw new Error( - "Silo transactions can only be used for storing data, sending AR to other wallets isn't supported." - ); - if (e.owner == null) { - if (!r || !r.n) - throw new Error( - "A new Arweave transaction must either have an 'owner' attribute, or you must provide the jwk parameter." - ); - i.owner = r.n; - } - e.last_tx == null && - (i.last_tx = await this.transactions.getTransactionAnchor()); - let o = await this.silo.parseUri(n); - if (typeof e.data == "string") { - let s = await this.crypto.encrypt( - tU.stringToBuffer(e.data), - o.getEncryptionKey() - ); - (i.reward = await this.transactions.getPrice(s.byteLength)), - (i.data = tU.bufferTob64Url(s)); - } - if (e.data instanceof Uint8Array) { - let s = await this.crypto.encrypt(e.data, o.getEncryptionKey()); - (i.reward = await this.transactions.getPrice(s.byteLength)), - (i.data = tU.bufferTob64Url(s)); - } - let a = new bit.default(i); - return ( - a.addTag("Silo-Name", o.getAccessKey()), - a.addTag("Silo-Version", "0.1.0"), - a - ); - } - arql(e) { - return this.api.post("/arql", e).then((r) => r.data || []); - } - }; - CSe.default = Fv; - Fv.crypto = new Bpr.default(); - Fv.utils = tU; - }); - var wT = I((uA) => { - "use strict"; - m(); - g(); - var Lpr = - (uA && uA.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - qpr = - (uA && uA.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - Lpr(e, t, r); - }; - Object.defineProperty(uA, "__esModule", { value: !0 }); - var nte = Wj(); - nte.default.init = function (t = {}) { - function e() { - let a = { host: "arweave.net", port: 443, protocol: "https" }; - if ( - !window || - !window.location || - !window.location.protocol || - !window.location.hostname - ) - return a; - let s = window.location.protocol.replace(":", ""), - c = window.location.hostname, - u = window.location.port - ? parseInt(window.location.port) - : s == "https" - ? 443 - : 80; - return ["localhost", "127.0.0.1"].includes(c) || s == "file" - ? a - : { host: c, port: u, protocol: s }; - } - let r = e(), - n = t.protocol || r.protocol, - i = t.host || r.host, - o = t.port || r.port; - return new nte.default( - Object.assign(Object.assign({}, t), { host: i, protocol: n, port: o }) - ); - }; - window.Arweave = nte.default; - qpr(Wj(), uA); - uA.default = nte.default; - }); - var NSe = I((Lv) => { - "use strict"; - m(); - g(); - var zpr = - (Lv && Lv.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Lv, "__esModule", { value: !0 }); - Lv.hashStream = Lv.deepHashChunks = Lv.deepHash = void 0; - var Ys = zpr(wT()), - wit = Rp(); - async function _it(t) { - if (typeof t[Symbol.asyncIterator] == "function") { - let i = t, - o = wit.createHash("sha384"), - a = 0; - for await (let u of i) (a += u.byteLength), o.update(u); - let s = Ys.default.utils.concatBuffers([ - Ys.default.utils.stringToBuffer("blob"), - Ys.default.utils.stringToBuffer(a.toString()), - ]), - c = Ys.default.utils.concatBuffers([ - await Ys.default.crypto.hash(s, "SHA-384"), - o.digest(), - ]); - return await Ys.default.crypto.hash(c, "SHA-384"); - } else if (Array.isArray(t)) { - let i = Ys.default.utils.concatBuffers([ - Ys.default.utils.stringToBuffer("list"), - Ys.default.utils.stringToBuffer(t.length.toString()), - ]); - return await RSe(t, await Ys.default.crypto.hash(i, "SHA-384")); - } - let e = t, - r = Ys.default.utils.concatBuffers([ - Ys.default.utils.stringToBuffer("blob"), - Ys.default.utils.stringToBuffer(e.byteLength.toString()), - ]), - n = Ys.default.utils.concatBuffers([ - await Ys.default.crypto.hash(r, "SHA-384"), - await Ys.default.crypto.hash(e, "SHA-384"), - ]); - return await Ys.default.crypto.hash(n, "SHA-384"); - } - Lv.deepHash = _it; - async function RSe(t, e) { - if (t.length < 1) return e; - let r = Ys.default.utils.concatBuffers([e, await _it(t[0])]), - n = await Ys.default.crypto.hash(r, "SHA-384"); - return await RSe(t.slice(1), n); - } - Lv.deepHashChunks = RSe; - async function jpr(t) { - let e = wit.createHash("sha384"); - for await (let r of t) e.update(r); - return e.digest(); - } - Lv.hashStream = jpr; - }); - var DSe = I((qv) => { - "use strict"; - m(); - g(); - var Upr = - (qv && qv.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Kpr = - (qv && qv.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Hpr = - (qv && qv.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - Upr(e, t, r); - return Kpr(e, t), e; - }; - Object.defineProperty(qv, "__esModule", { value: !0 }); - qv.getSignatureData = void 0; - var QC = Dxe(), - Vpr = VC(), - Wpr = NSe(); - async function Gpr(t) { - return Vpr.isBrowser - ? (await Promise.resolve().then(() => Hpr(ySe()))).default([ - QC.stringToBuffer("dataitem"), - QC.stringToBuffer("1"), - QC.stringToBuffer(t.signatureType.toString()), - t.rawOwner, - t.rawTarget, - t.rawAnchor, - t.rawTags, - t.rawData, - ]) - : Wpr.deepHash([ - QC.stringToBuffer("dataitem"), - QC.stringToBuffer("1"), - QC.stringToBuffer(t.signatureType.toString()), - t.rawOwner, - t.rawTarget, - t.rawAnchor, - t.rawTags, - t.rawData, - ]); - } - qv.getSignatureData = Gpr; - }); - var xit = I((FSe) => { - "use strict"; - m(); - g(); - Object.defineProperty(FSe, "__esModule", { value: !0 }); - function Jpr(t) { - var e = 4, - r = t.length, - n = r % e; - if (!n) return t; - var i = r, - o = e - n, - a = r + o, - s = Buffer.alloc(a); - for (s.write(t); o--; ) s.write("=", i++); - return s.toString(); - } - FSe.default = Jpr; - }); - var Ait = I((zSe) => { - "use strict"; - m(); - g(); - Object.defineProperty(zSe, "__esModule", { value: !0 }); - var $pr = xit(); - function Sit(t, e) { - return ( - e === void 0 && (e = "utf8"), - Buffer.isBuffer(t) - ? LSe(t.toString("base64")) - : LSe(Buffer.from(t, e).toString("base64")) - ); - } - function Zpr(t, e) { - return ( - e === void 0 && (e = "utf8"), Buffer.from(qSe(t), "base64").toString(e) - ); - } - function qSe(t) { - return ( - (t = t.toString()), - $pr.default(t).replace(/\-/g, "+").replace(/_/g, "/") - ); - } - function LSe(t) { - return t.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_"); - } - function Xpr(t) { - return Buffer.from(qSe(t), "base64"); - } - var eR = Sit; - eR.encode = Sit; - eR.decode = Zpr; - eR.toBase64 = qSe; - eR.fromBase64 = LSe; - eR.toBuffer = Xpr; - zSe.default = eR; - }); - var ng = I((wyn, ite) => { - m(); - g(); - ite.exports = Ait().default; - ite.exports.default = ite.exports; - }); - var xT = I((_yn, kit) => { - "use strict"; - m(); - g(); - var Ypr = Rp(), - Qpr = es(), - e0r = new Tit(4096); - function rU(t) { - return typeof Buffer.alloc == "function" - ? Buffer.alloc(t) - : new Buffer(t); - } - function Eit(t, e) { - return typeof Buffer.from == "function" - ? Buffer.from(t, e) - : new Buffer(t, e); - } - function Mit(t) { - return t.charAt(0).toUpperCase() + t.slice(1); - } - function t0r(t, e) { - return t === e ? 0 : t < e ? -1 : 1; - } - function r0r(t, e, r) { - var n = t[e]; - return n === void 0 ? r : n; - } - function n0r(t, e) { - e = e || "md5"; - var r = Ypr.createHash(e); - return r.end(t), r.read(); - } - function i0r(t, e) { - var r = -1, - n, - i; - if (!t) return -1; - for (n = 0, i = t.length; n < i; n++) - if (t[n] === e) { - if (r >= 0) return -2; - r = n; - } - return r; - } - function o0r(t, e) { - var r = {}, - n, - i; - for (n = 0; n < t.length; n++) (i = t[n]), (r[e(i)] = i); - return r; - } - function a0r(t) { - return Object.keys(t).map(function (e) { - return t[e]; - }); - } - function s0r(t, e) { - var r = {}, - n, - i, - o; - for (n = 0, i = t.length; n < i; n++) { - if (((o = t[n]), e && (o = e(o)), r[o])) return !0; - r[o] = !0; - } - return !1; - } - function u0r(t, e, r) { - var n = Object.getOwnPropertyNames(t), - i, - o, - a; - for (i = 0, o = n.length; i < o; i++) - if (((a = n[i]), !e.hasOwnProperty(a) || r)) { - var s = Object.getOwnPropertyDescriptor(t, a); - Object.defineProperty(e, a, s); - } - return e; - } - function c0r(t, e) { - e = e | 0; - var r = t.charAt(e++); - if (/[\d-]/.test(r)) { - for (; /[eE\d.+-]/.test(t.charAt(e)); ) e++; - return e; - } else { - if (/true|null/.test(t.slice(e - 1, e + 3))) return e + 3; - if (/false/.test(t.slice(e - 1, e + 4))) return e + 4; - } - var n = 0, - i = !1; - do - switch (r) { - case "{": - case "[": - i || n++; - break; - case "}": - case "]": - if (!i && !--n) return e; - break; - case '"': - if (((i = !i), !n && !i)) return e; - break; - case "\\": - e++; - } - while ((r = t.charAt(e++))); - return -1; - } - function l0r() { - throw new Error("abstract"); - } - function f0r(t, e) { - var r = t.prototype, - n, - i, - o, - a; - for (n = 0, i = e.length; n < i; n++) - (o = e[n]), - (a = "get" + Mit(o)), - (r[a] = Qpr.deprecate( - s(o), - "use `." + o + "` instead of `." + a + "()`" - )); - function s(c) { - return function () { - var u = this[c]; - return typeof u == "function" ? u.apply(this, arguments) : u; - }; - } - } - function Tit(t) { - (this._len = t | 0), (this._pos = 0), (this._slab = rU(this._len)); - } - Tit.prototype.alloc = function (t) { - var e = this._len; - return t > e - ? rU(t) - : (this._pos + t > e && ((this._slab = rU(e)), (this._pos = 0)), - this._slab.slice(this._pos, (this._pos += t))); - }; - function _T(t) { - var e = 1103515245, - r = 12345, - n = Math.pow(2, 31), - i = Math.floor(t || Math.random() * (n - 1)); - (this._max = n), - (this._nextInt = function () { - return (i = (e * i + r) % n); - }); - } - _T.prototype.nextBoolean = function () { - return !!(this._nextInt() % 2); - }; - _T.prototype.nextInt = function (t, e) { - return ( - e === void 0 && ((e = t), (t = 0)), - (e = e === void 0 ? this._max : e), - t + Math.floor(this.nextFloat() * (e - t)) - ); - }; - _T.prototype.nextFloat = function (t, e) { - return ( - e === void 0 && ((e = t), (t = 0)), - (e = e === void 0 ? 1 : e), - t + ((e - t) * this._nextInt()) / this._max - ); - }; - _T.prototype.nextString = function (t, e) { - (t |= 0), (e = e || "aA"); - var r = ""; - e.indexOf("a") > -1 && (r += "abcdefghijklmnopqrstuvwxyz"), - e.indexOf("A") > -1 && (r += "ABCDEFGHIJKLMNOPQRSTUVWXYZ"), - e.indexOf("#") > -1 && (r += "0123456789"), - e.indexOf("!") > -1 && (r += "~`!@#$%^&*()_+-={}[]:\";'<>?,./|\\"); - for (var n = [], i = 0; i < t; i++) n.push(this.choice(r)); - return n.join(""); - }; - _T.prototype.nextBuffer = function (t) { - var e = [], - r; - for (r = 0; r < t; r++) e.push(this.nextInt(256)); - return Eit(e); - }; - _T.prototype.choice = function (t) { - var e = t.length; - if (!e) throw new Error("choosing from empty array"); - return t[this.nextInt(e)]; - }; - function USe() { - (this._index = 0), (this._items = []); - } - USe.prototype.push = function (t) { - var e = this._items, - r = e.length | 0, - n; - for (e.push(t); r > 0 && e[r].index < e[(n = (r - 1) >> 1)].index; ) - (t = e[r]), (e[r] = e[n]), (e[n] = t), (r = n); - }; - USe.prototype.pop = function () { - var t = this._items, - e = (t.length - 1) | 0, - r = t[0]; - if (!r || r.index > this._index) return null; - if ((this._index++, !e)) return t.pop(), r; - t[0] = t.pop(); - for ( - var n = e >> 1, i = 0, o, a, s, c, u, h, w; - i < n && - ((c = t[i]), - (o = (i << 1) + 1), - (a = (i + 1) << 1), - (h = t[o]), - (w = t[a]), - !w || h.index <= w.index ? ((u = h), (s = o)) : ((u = w), (s = a)), - !(u.index >= c.index)); - - ) - (t[s] = c), (t[i] = u), (i = s); - return r; - }; - function hn(t, e) { - if (((this.buf = t), (this.pos = e | 0), this.pos < 0)) - throw new Error("negative offset"); - } - hn.prototype.isValid = function () { - return this.pos <= this.buf.length; - }; - hn.prototype.readBoolean = function () { - return !!this.buf[this.pos++]; - }; - hn.prototype.skipBoolean = function () { - this.pos++; - }; - hn.prototype.writeBoolean = function (t) { - this.buf[this.pos++] = !!t; - }; - hn.prototype.readInt = hn.prototype.readLong = function () { - var t = 0, - e = 0, - r = this.buf, - n, - i, - o, - a; - do (n = r[this.pos++]), (i = n & 128), (t |= (n & 127) << e), (e += 7); - while (i && e < 28); - if (i) { - (o = t), (a = 268435456); - do (n = r[this.pos++]), (o += (n & 127) * a), (a *= 128); - while (n & 128); - return (o % 2 ? -(o + 1) : o) / 2; - } - return (t >> 1) ^ -(t & 1); - }; - hn.prototype.skipInt = hn.prototype.skipLong = function () { - for (var t = this.buf; t[this.pos++] & 128; ); - }; - hn.prototype.writeInt = hn.prototype.writeLong = function (t) { - var e = this.buf, - r, - n; - if (t >= -1073741824 && t < 1073741824) { - n = t >= 0 ? t << 1 : (~t << 1) | 1; - do (e[this.pos] = n & 127), (n >>= 7); - while (n && (e[this.pos++] |= 128)); - } else { - r = t >= 0 ? t * 2 : -t * 2 - 1; - do (e[this.pos] = r & 127), (r /= 128); - while (r >= 1 && (e[this.pos++] |= 128)); - } - this.pos++; - }; - hn.prototype.readFloat = function () { - var t = this.buf, - e = this.pos; - if (((this.pos += 4), !(this.pos > t.length))) - return this.buf.readFloatLE(e); - }; - hn.prototype.skipFloat = function () { - this.pos += 4; - }; - hn.prototype.writeFloat = function (t) { - var e = this.buf, - r = this.pos; - if (((this.pos += 4), !(this.pos > e.length))) - return this.buf.writeFloatLE(t, r); - }; - hn.prototype.readDouble = function () { - var t = this.buf, - e = this.pos; - if (((this.pos += 8), !(this.pos > t.length))) - return this.buf.readDoubleLE(e); - }; - hn.prototype.skipDouble = function () { - this.pos += 8; - }; - hn.prototype.writeDouble = function (t) { - var e = this.buf, - r = this.pos; - if (((this.pos += 8), !(this.pos > e.length))) - return this.buf.writeDoubleLE(t, r); - }; - hn.prototype.readFixed = function (t) { - var e = this.pos; - if (((this.pos += t), !(this.pos > this.buf.length))) { - var r = e0r.alloc(t); - return this.buf.copy(r, 0, e, e + t), r; - } - }; - hn.prototype.skipFixed = function (t) { - this.pos += t; - }; - hn.prototype.writeFixed = function (t, e) { - e = e || t.length; - var r = this.pos; - (this.pos += e), - !(this.pos > this.buf.length) && t.copy(this.buf, r, 0, e); - }; - hn.prototype.readBytes = function () { - return this.readFixed(this.readLong()); - }; - hn.prototype.skipBytes = function () { - var t = this.readLong(); - this.pos += t; - }; - hn.prototype.writeBytes = function (t) { - var e = t.length; - this.writeLong(e), this.writeFixed(t, e); - }; - typeof Buffer.prototype.utf8Slice == "function" - ? (hn.prototype.readString = function () { - var t = this.readLong(), - e = this.pos, - r = this.buf; - if (((this.pos += t), !(this.pos > r.length))) - return this.buf.utf8Slice(e, e + t); - }) - : (hn.prototype.readString = function () { - var t = this.readLong(), - e = this.pos, - r = this.buf; - if (((this.pos += t), !(this.pos > r.length))) - return this.buf.slice(e, e + t).toString(); - }); - hn.prototype.skipString = function () { - var t = this.readLong(); - this.pos += t; - }; - hn.prototype.writeString = function (t) { - var e = Buffer.byteLength(t), - r = this.buf; - this.writeLong(e); - var n = this.pos; - if (((this.pos += e), !(this.pos > r.length))) - if (e > 64) this._writeUtf8(t, e); - else { - var i, o, a, s; - for (i = 0, o = e; i < o; i++) - (a = t.charCodeAt(i)), - a < 128 - ? (r[n++] = a) - : a < 2048 - ? ((r[n++] = (a >> 6) | 192), (r[n++] = (a & 63) | 128)) - : (a & 64512) === 55296 && - ((s = t.charCodeAt(i + 1)) & 64512) === 56320 - ? ((a = 65536 + ((a & 1023) << 10) + (s & 1023)), - i++, - (r[n++] = (a >> 18) | 240), - (r[n++] = ((a >> 12) & 63) | 128), - (r[n++] = ((a >> 6) & 63) | 128), - (r[n++] = (a & 63) | 128)) - : ((r[n++] = (a >> 12) | 224), - (r[n++] = ((a >> 6) & 63) | 128), - (r[n++] = (a & 63) | 128)); - } - }; - typeof Buffer.prototype.utf8Write == "function" - ? (hn.prototype._writeUtf8 = function (t, e) { - this.buf.utf8Write(t, this.pos - e, e); - }) - : (hn.prototype._writeUtf8 = function (t, e) { - this.buf.write(t, this.pos - e, e, "utf8"); - }); - typeof Buffer.prototype.latin1Write == "function" - ? (hn.prototype.writeBinary = function (t, e) { - var r = this.pos; - (this.pos += e), - !(this.pos > this.buf.length) && this.buf.latin1Write(t, r, e); - }) - : typeof Buffer.prototype.binaryWrite == "function" - ? (hn.prototype.writeBinary = function (t, e) { - var r = this.pos; - (this.pos += e), - !(this.pos > this.buf.length) && this.buf.binaryWrite(t, r, e); - }) - : (hn.prototype.writeBinary = function (t, e) { - var r = this.pos; - (this.pos += e), - !(this.pos > this.buf.length) && this.buf.write(t, r, e, "binary"); - }); - hn.prototype.matchBoolean = function (t) { - return this.buf[this.pos++] - t.buf[t.pos++]; - }; - hn.prototype.matchInt = hn.prototype.matchLong = function (t) { - var e = this.readLong(), - r = t.readLong(); - return e === r ? 0 : e < r ? -1 : 1; - }; - hn.prototype.matchFloat = function (t) { - var e = this.readFloat(), - r = t.readFloat(); - return e === r ? 0 : e < r ? -1 : 1; - }; - hn.prototype.matchDouble = function (t) { - var e = this.readDouble(), - r = t.readDouble(); - return e === r ? 0 : e < r ? -1 : 1; - }; - hn.prototype.matchFixed = function (t, e) { - return this.readFixed(e).compare(t.readFixed(e)); - }; - hn.prototype.matchBytes = hn.prototype.matchString = function (t) { - var e = this.readLong(), - r = this.pos; - this.pos += e; - var n = t.readLong(), - i = t.pos; - t.pos += n; - var o = this.buf.slice(r, this.pos), - a = t.buf.slice(i, t.pos); - return o.compare(a); - }; - hn.prototype.unpackLongBytes = function () { - var t = rU(8), - e = 0, - r = 0, - n = 6, - i = this.buf, - o, - a; - for ( - o = i[this.pos++], a = o & 1, t.fill(0), e |= (o & 127) >> 1; - o & 128; - - ) - (o = i[this.pos++]), - (e |= (o & 127) << n), - (n += 7), - n >= 8 && ((n -= 8), (t[r++] = e), (e >>= 8)); - return (t[r] = e), a && jSe(t, 8), t; - }; - hn.prototype.packLongBytes = function (t) { - var e = (t[7] & 128) >> 7, - r = this.buf, - n = 1, - i = 0, - o = 3, - a; - e ? (jSe(t, 8), (a = 1)) : (a = 0); - for ( - var s = [t.readUIntLE(0, 3), t.readUIntLE(3, 3), t.readUIntLE(6, 2)]; - o && !s[--o]; - - ); - for (; i < o; ) - for (a |= s[i++] << n, n += 24; n > 7; ) - (r[this.pos++] = (a & 127) | 128), (a >>= 7), (n -= 7); - a |= s[o] << n; - do (r[this.pos] = a & 127), (a >>= 7); - while (a && (r[this.pos++] |= 128)); - this.pos++, e && jSe(t, 8); - }; - function jSe(t, e) { - for (; e--; ) t[e] = ~t[e]; - } - kit.exports = { - abstractFunction: l0r, - addDeprecatedGetters: f0r, - bufferFrom: Eit, - capitalize: Mit, - copyOwnProperties: u0r, - getHash: n0r, - compare: t0r, - getOption: r0r, - jsonEnd: c0r, - newBuffer: rU, - objectValues: a0r, - toMap: o0r, - singleIndexOf: i0r, - hasDuplicates: s0r, - Lcg: _T, - OrderedQueue: USe, - Tap: hn, - }; - }); - var ute = I((xyn, Rit) => { - "use strict"; - m(); - g(); - var Yn = xT(), - Pit = Qr(), - La = es(), - AT = Yn.Tap, - KSe = La.debuglog("avsc:types"), - Fn = La.format, - ote = { - array: jh, - boolean: ux, - bytes: $p, - double: jv, - enum: qh, - error: Fa, - fixed: zh, - float: zv, - int: cx, - long: Jp, - map: Wd, - null: Ay, - record: Fa, - string: ig, - }, - d0r = /^[A-Za-z_][A-Za-z0-9_]*$/, - sc = new Yn.Lcg(), - ST = new AT(new Pit.SlowBuffer(1024)), - cA = null, - tR = []; - function xt(t, e) { - var r; - if ( - (cA ? ((r = cA), tR.push([cA, this]), (cA = null)) : (r = this), - (this._hash = new h0r()), - (this.name = void 0), - (this.aliases = void 0), - (this.doc = t && t.doc ? "" + t.doc : void 0), - t) - ) { - var n = t.name, - i = t.namespace === void 0 ? e && e.namespace : t.namespace; - if (n !== void 0) { - if (((n = ate(n, i)), rR(n))) - throw new Error(Fn("cannot rename primitive type: %j", n)); - var o = e && e.registry; - if (o) { - if (o[n] !== void 0) - throw new Error(Fn("duplicate type name: %s", n)); - o[n] = r; - } - } else if (e && e.noAnonymousTypes) - throw new Error(Fn("missing name property in schema: %j", t)); - (this.name = n), - (this.aliases = t.aliases - ? t.aliases.map(function (a) { - return ate(a, i); - }) - : []); - } - } - xt.forSchema = function (t, e) { - (e = e || {}), (e.registry = e.registry || {}); - var r = (function (c) { - switch ( - (c === !0 - ? (c = "always") - : c === !1 - ? (c = "never") - : c === void 0 - ? (c = "auto") - : typeof c == "string" && (c = c.toLowerCase()), - c) - ) { - case "always": - return Ey; - case "never": - return Lh; - case "auto": - return; - default: - throw new Error(Fn("invalid wrap unions option: %j", c)); - } - })(e.wrapUnions); - if (t === null) - throw new Error('invalid type: null (did you mean "null"?)'); - if (xt.isType(t)) return t; - var n; - if (e.typeHook && (n = e.typeHook(t, e))) { - if (!xt.isType(n)) - throw new Error(Fn("invalid typehook return value: %j", n)); - return n; - } - if (typeof t == "string") { - if (((t = ate(t, e.namespace)), (n = e.registry[t]), n)) return n; - if (rR(t)) return (e.registry[t] = xt.forSchema({ type: t }, e)); - throw new Error(Fn("undefined type name: %s", t)); - } - if (t.logicalType && e.logicalTypes && !cA) { - var i = e.logicalTypes[t.logicalType]; - if (i) { - var o = e.namespace, - a = {}; - Object.keys(e.registry).forEach(function (c) { - a[c] = e.registry[c]; - }); - try { - return ( - KSe("instantiating logical type for %s", t.logicalType), - new i(t, e) - ); - } catch (c) { - if ( - (KSe("failed to instantiate logical type for %s", t.logicalType), - e.assertLogicalTypes) - ) - throw c; - (cA = null), (e.namespace = o), (e.registry = a); - } - } - } - if (Array.isArray(t)) { - var s = t.map(function (c) { - return xt.forSchema(c, e); - }); - r || (r = p0r(s) ? Ey : Lh), (n = new r(s, e)); - } else - n = (function (c) { - var u = ote[c]; - if (u === void 0) throw new Error(Fn("unknown type: %j", c)); - return new u(t, e); - })(t.type); - return n; - }; - xt.forValue = function (t, e) { - if ( - ((e = e || {}), - (e.emptyArrayType = - e.emptyArrayType || xt.forSchema({ type: "array", items: "null" })), - e.valueHook) - ) { - var r = e.valueHook(t, e); - if (r !== void 0) { - if (!xt.isType(r)) - throw new Error(Fn("invalid value hook return value: %j", r)); - return r; - } - } - switch (typeof t) { - case "string": - return xt.forSchema("string", e); - case "boolean": - return xt.forSchema("boolean", e); - case "number": - return (t | 0) === t - ? xt.forSchema("int", e) - : Math.abs(t) < 9007199254740991 - ? xt.forSchema("float", e) - : xt.forSchema("double", e); - case "object": - if (t === null) return xt.forSchema("null", e); - if (Array.isArray(t)) - return t.length - ? xt.forSchema( - { - type: "array", - items: xt.forTypes( - t.map(function (i) { - return xt.forValue(i, e); - }) - ), - }, - e - ) - : e.emptyArrayType; - if (Buffer.isBuffer(t)) return xt.forSchema("bytes", e); - var n = Object.keys(t); - return n.some(function (i) { - return !iU(i); - }) - ? xt.forSchema( - { - type: "map", - values: xt.forTypes( - n.map(function (i) { - return xt.forValue(t[i], e); - }), - e - ), - }, - e - ) - : xt.forSchema( - { - type: "record", - fields: n.map(function (i) { - return { name: i, type: xt.forValue(t[i], e) }; - }), - }, - e - ); - default: - throw new Error(Fn("cannot infer type from: %j", t)); - } - }; - xt.forTypes = function (t, e) { - if (!t.length) throw new Error("no types to combine"); - if (t.length === 1) return t[0]; - e = e || {}; - var r = [], - n = 0, - i = !0; - if ( - (t.forEach(function (w) { - switch (w.typeName) { - case "union:unwrapped": - (i = !1), (r = r.concat(w.types)); - break; - case "union:wrapped": - n++, (r = r.concat(w.types)); - break; - case "null": - r.push(w); - break; - default: - (i = !1), r.push(w); - } - }), - n) - ) { - if (!i) throw new Error("cannot combine wrapped union"); - var o = {}; - r.forEach(function (w) { - var M = w.branchName, - k = o[M]; - if (!k) o[M] = w; - else if (!w.equals(k)) throw new Error("inconsistent branch type"); - }); - var a = e.wrapUnions, - s; - e.wrapUnions = !0; - try { - s = xt.forSchema( - Object.keys(o).map(function (w) { - return o[w]; - }), - e - ); - } catch (w) { - throw ((e.wrapUnions = a), w); - } - return (e.wrapUnions = a), s; - } - var c = {}; - r.forEach(function (w) { - var M = ste(w), - k = c[M]; - k || (c[M] = k = []), k.push(w); - }); - var u = Object.keys(c), - h = u.map(function (w) { - var M = c[w]; - if (M.length === 1) return M[0]; - switch (w) { - case "null": - case "boolean": - return M[0]; - case "number": - return y0r(M); - case "string": - return m0r(M, e); - case "buffer": - return g0r(M, e); - case "array": - return ( - (M = M.filter(function (k) { - return k !== e.emptyArrayType; - })), - M.length - ? xt.forSchema( - { - type: "array", - items: xt.forTypes( - M.map(function (k) { - return k.itemsType; - }) - ), - }, - e - ) - : e.emptyArrayType - ); - default: - return v0r(M, e); - } - }); - return h.length === 1 ? h[0] : xt.forSchema(h, e); - }; - xt.isType = function () { - var t = arguments.length; - if (!t) return !1; - var e = arguments[0]; - if ( - !e || - typeof e._update != "function" || - typeof e.fingerprint != "function" - ) - return !1; - if (t === 1) return !0; - var r = e.typeName, - n; - for (n = 1; n < t; n++) if (r.indexOf(arguments[n]) === 0) return !0; - return !1; - }; - xt.__reset = function (t) { - KSe("resetting type buffer to %d", t), (ST.buf = new Pit.SlowBuffer(t)); - }; - Object.defineProperty(xt.prototype, "branchName", { - enumerable: !0, - get: function () { - if (this.name) return this.name; - var t = xt.isType(this, "logical") ? this.underlyingType : this; - return xt.isType(t, "abstract") - ? t._concreteTypeName - : xt.isType(t, "union") - ? void 0 - : t.typeName; - }, - }); - xt.prototype.clone = function (t, e) { - return e - ? ((e = { - coerce: !!e.coerceBuffers | 0, - fieldHook: e.fieldHook, - qualifyNames: !!e.qualifyNames, - skip: !!e.skipMissingFields, - wrap: !!e.wrapUnions | 0, - }), - this._copy(t, e)) - : this.fromBuffer(this.toBuffer(t)); - }; - xt.prototype.compare = Yn.abstractFunction; - xt.prototype.compareBuffers = function (t, e) { - return this._match(new AT(t), new AT(e)); - }; - xt.prototype.createResolver = function (t, e) { - if (!xt.isType(t)) throw new Error(Fn("not a type: %j", t)); - if (!xt.isType(this, "union", "logical") && xt.isType(t, "logical")) - return this.createResolver(t.underlyingType, e); - (e = e || {}), (e.registry = e.registry || {}); - var r, n; - if ( - xt.isType(this, "record", "error") && - xt.isType(t, "record", "error") && - ((n = this.name + ":" + t.name), (r = e.registry[n]), r) - ) - return r; - if ( - ((r = new VSe(this)), n && (e.registry[n] = r), xt.isType(t, "union")) - ) { - var i = t.types.map(function (o) { - return this.createResolver(o, e); - }, this); - r._read = function (o) { - var a = o.readLong(), - s = i[a]; - if (s === void 0) throw new Error(Fn("invalid union index: %s", a)); - return i[a]._read(o); - }; - } else this._update(r, t, e); - if (!r._read) throw new Error(Fn("cannot read %s as %s", t, this)); - return Object.freeze(r); - }; - xt.prototype.decode = function (t, e, r) { - var n = new AT(t, e), - i = Oit(this, n, r); - return n.isValid() - ? { value: i, offset: n.pos } - : { value: void 0, offset: -1 }; - }; - xt.prototype.encode = function (t, e, r) { - var n = new AT(e, r); - return this._write(n, t), n.isValid() ? n.pos : e.length - n.pos; - }; - xt.prototype.equals = function (t) { - return xt.isType(t) && this.fingerprint().equals(t.fingerprint()); - }; - xt.prototype.fingerprint = function (t) { - if (t) return Yn.getHash(JSON.stringify(this.schema()), t); - if (!this._hash.str) { - var e = JSON.stringify(this.schema()); - this._hash.str = Yn.getHash(e).toString("binary"); - } - return Yn.bufferFrom(this._hash.str, "binary"); - }; - xt.prototype.fromBuffer = function (t, e, r) { - var n = new AT(t), - i = Oit(this, n, e, r); - if (!n.isValid()) throw new Error("truncated buffer"); - if (!r && n.pos < t.length) throw new Error("trailing data"); - return i; - }; - xt.prototype.fromString = function (t) { - return this._copy(JSON.parse(t), { coerce: 2 }); - }; - xt.prototype.inspect = function () { - var t = this.typeName, - e = Bit(t); - if (rR(t)) return Fn("<%s>", e); - var r = this.schema({ exportAttrs: !0, noDeref: !0 }); - return ( - typeof r == "object" && - !xt.isType(this, "logical") && - (r.type = void 0), - Fn("<%s %j>", e, r) - ); - }; - xt.prototype.isValid = function (t, e) { - var r = (e && e.noUndeclaredFields) | 0, - n = e && e.errorHook, - i, - o; - return ( - n && - ((o = []), - (i = function (a, s) { - n.call(this, o.slice(), a, s, t); - })), - this._check(t, r, i, o) - ); - }; - xt.prototype.random = Yn.abstractFunction; - xt.prototype.schema = function (t) { - return this._attrs({ - exportAttrs: !!(t && t.exportAttrs), - noDeref: !!(t && t.noDeref), - }); - }; - xt.prototype.toBuffer = function (t) { - (ST.pos = 0), this._write(ST, t); - var e = Yn.newBuffer(ST.pos); - return ( - ST.isValid() ? ST.buf.copy(e, 0, 0, ST.pos) : this._write(new AT(e), t), - e - ); - }; - xt.prototype.toJSON = function () { - return this.schema({ exportAttrs: !0 }); - }; - xt.prototype.toString = function (t) { - return t === void 0 - ? JSON.stringify(this.schema({ noDeref: !0 })) - : JSON.stringify(this._copy(t, { coerce: 3 })); - }; - xt.prototype.wrap = function (t) { - var e = this._branchConstructor; - return e === null ? null : new e(t); - }; - xt.prototype._attrs = function (t) { - t.derefed = t.derefed || {}; - var e = this.name; - if (e !== void 0) { - if (t.noDeref || t.derefed[e]) return e; - t.derefed[e] = !0; - } - var r = {}; - this.name !== void 0 && (r.name = e), (r.type = this.typeName); - var n = this._deref(r, t); - return ( - n !== void 0 && (r = n), - t.exportAttrs && - (this.aliases && this.aliases.length && (r.aliases = this.aliases), - this.doc !== void 0 && (r.doc = this.doc)), - r - ); - }; - xt.prototype._createBranchConstructor = function () { - var t = this.branchName; - if (t === "null") return null; - function e() { - return function (i) { - ~t.indexOf(".") ? (this[`${t}`] = i) : (this[t] = i); - }; - } - var r = e(); - return ( - (r.type = this), - (r.prototype.unwrap = function () { - return this[`${t}`]; - }), - (r.prototype.unwrapped = r.prototype.unwrap), - r - ); - }; - xt.prototype._peek = function (t) { - var e = t.pos, - r = this._read(t); - return (t.pos = e), r; - }; - xt.prototype._check = Yn.abstractFunction; - xt.prototype._copy = Yn.abstractFunction; - xt.prototype._deref = Yn.abstractFunction; - xt.prototype._match = Yn.abstractFunction; - xt.prototype._read = Yn.abstractFunction; - xt.prototype._skip = Yn.abstractFunction; - xt.prototype._update = Yn.abstractFunction; - xt.prototype._write = Yn.abstractFunction; - xt.prototype.getAliases = function () { - return this.aliases; - }; - xt.prototype.getFingerprint = xt.prototype.fingerprint; - xt.prototype.getName = function (t) { - return this.name || !t ? this.name : this.branchName; - }; - xt.prototype.getSchema = xt.prototype.schema; - xt.prototype.getTypeName = function () { - return this.typeName; - }; - function wa(t) { - xt.call(this), - (this._branchConstructor = this._createBranchConstructor()), - t || Object.freeze(this); - } - La.inherits(wa, xt); - wa.prototype._update = function (t, e) { - e.typeName === this.typeName && (t._read = this._read); - }; - wa.prototype._copy = function (t) { - return this._check(t, void 0, lo), t; - }; - wa.prototype._deref = function () { - return this.typeName; - }; - wa.prototype.compare = Yn.compare; - function Ay() { - wa.call(this); - } - La.inherits(Ay, wa); - Ay.prototype._check = function (t, e, r) { - var n = t === null; - return !n && r && r(t, this), n; - }; - Ay.prototype._read = function () { - return null; - }; - Ay.prototype._skip = function () {}; - Ay.prototype._write = function (t, e) { - e !== null && lo(e, this); - }; - Ay.prototype._match = function () { - return 0; - }; - Ay.prototype.compare = Ay.prototype._match; - Ay.prototype.typeName = "null"; - Ay.prototype.random = Ay.prototype._read; - function ux() { - wa.call(this); - } - La.inherits(ux, wa); - ux.prototype._check = function (t, e, r) { - var n = typeof t == "boolean"; - return !n && r && r(t, this), n; - }; - ux.prototype._read = function (t) { - return t.readBoolean(); - }; - ux.prototype._skip = function (t) { - t.skipBoolean(); - }; - ux.prototype._write = function (t, e) { - typeof e != "boolean" && lo(e, this), t.writeBoolean(e); - }; - ux.prototype._match = function (t, e) { - return t.matchBoolean(e); - }; - ux.prototype.typeName = "boolean"; - ux.prototype.random = function () { - return sc.nextBoolean(); - }; - function cx() { - wa.call(this); - } - La.inherits(cx, wa); - cx.prototype._check = function (t, e, r) { - var n = t === (t | 0); - return !n && r && r(t, this), n; - }; - cx.prototype._read = function (t) { - return t.readInt(); - }; - cx.prototype._skip = function (t) { - t.skipInt(); - }; - cx.prototype._write = function (t, e) { - e !== (e | 0) && lo(e, this), t.writeInt(e); - }; - cx.prototype._match = function (t, e) { - return t.matchInt(e); - }; - cx.prototype.typeName = "int"; - cx.prototype.random = function () { - return sc.nextInt(1e3) | 0; - }; - function Jp() { - wa.call(this); - } - La.inherits(Jp, wa); - Jp.prototype._check = function (t, e, r) { - var n = typeof t == "number" && t % 1 === 0 && GSe(t); - return !n && r && r(t, this), n; - }; - Jp.prototype._read = function (t) { - var e = t.readLong(); - if (!GSe(e)) throw new Error("potential precision loss"); - return e; - }; - Jp.prototype._skip = function (t) { - t.skipLong(); - }; - Jp.prototype._write = function (t, e) { - (typeof e != "number" || e % 1 || !GSe(e)) && lo(e, this), t.writeLong(e); - }; - Jp.prototype._match = function (t, e) { - return t.matchLong(e); - }; - Jp.prototype._update = function (t, e) { - switch (e.typeName) { - case "int": - t._read = e._read; - break; - case "abstract:long": - case "long": - t._read = this._read; - } - }; - Jp.prototype.typeName = "long"; - Jp.prototype.random = function () { - return sc.nextInt(); - }; - Jp.__with = function (t, e) { - t = t || {}; - var r = { - toBuffer: "_toBuffer", - fromBuffer: "_fromBuffer", - fromJSON: "_fromJSON", - toJSON: "_toJSON", - isValid: "_isValid", - compare: "compare", - }, - n = new Jc(e); - return ( - Object.keys(r).forEach(function (i) { - if (t[i] === void 0) - throw new Error(Fn("missing method implementation: %s", i)); - n[r[i]] = t[i]; - }), - Object.freeze(n) - ); - }; - function zv() { - wa.call(this); - } - La.inherits(zv, wa); - zv.prototype._check = function (t, e, r) { - var n = typeof t == "number"; - return !n && r && r(t, this), n; - }; - zv.prototype._read = function (t) { - return t.readFloat(); - }; - zv.prototype._skip = function (t) { - t.skipFloat(); - }; - zv.prototype._write = function (t, e) { - typeof e != "number" && lo(e, this), t.writeFloat(e); - }; - zv.prototype._match = function (t, e) { - return t.matchFloat(e); - }; - zv.prototype._update = function (t, e) { - switch (e.typeName) { - case "float": - case "int": - t._read = e._read; - break; - case "abstract:long": - case "long": - t._read = function (r) { - return r.readLong(); - }; - } - }; - zv.prototype.typeName = "float"; - zv.prototype.random = function () { - return sc.nextFloat(1e3); - }; - function jv() { - wa.call(this); - } - La.inherits(jv, wa); - jv.prototype._check = function (t, e, r) { - var n = typeof t == "number"; - return !n && r && r(t, this), n; - }; - jv.prototype._read = function (t) { - return t.readDouble(); - }; - jv.prototype._skip = function (t) { - t.skipDouble(); - }; - jv.prototype._write = function (t, e) { - typeof e != "number" && lo(e, this), t.writeDouble(e); - }; - jv.prototype._match = function (t, e) { - return t.matchDouble(e); - }; - jv.prototype._update = function (t, e) { - switch (e.typeName) { - case "double": - case "float": - case "int": - t._read = e._read; - break; - case "abstract:long": - case "long": - t._read = function (r) { - return r.readLong(); - }; - } - }; - jv.prototype.typeName = "double"; - jv.prototype.random = function () { - return sc.nextFloat(); - }; - function ig() { - wa.call(this); - } - La.inherits(ig, wa); - ig.prototype._check = function (t, e, r) { - var n = typeof t == "string"; - return !n && r && r(t, this), n; - }; - ig.prototype._read = function (t) { - return t.readString(); - }; - ig.prototype._skip = function (t) { - t.skipString(); - }; - ig.prototype._write = function (t, e) { - typeof e != "string" && lo(e, this), t.writeString(e); - }; - ig.prototype._match = function (t, e) { - return t.matchString(e); - }; - ig.prototype._update = function (t, e) { - switch (e.typeName) { - case "bytes": - case "string": - t._read = this._read; - } - }; - ig.prototype.typeName = "string"; - ig.prototype.random = function () { - return sc.nextString(sc.nextInt(32)); - }; - function $p() { - wa.call(this); - } - La.inherits($p, wa); - $p.prototype._check = function (t, e, r) { - var n = Buffer.isBuffer(t); - return !n && r && r(t, this), n; - }; - $p.prototype._read = function (t) { - return t.readBytes(); - }; - $p.prototype._skip = function (t) { - t.skipBytes(); - }; - $p.prototype._write = function (t, e) { - Buffer.isBuffer(e) || lo(e, this), t.writeBytes(e); - }; - $p.prototype._match = function (t, e) { - return t.matchBytes(e); - }; - $p.prototype._update = ig.prototype._update; - $p.prototype._copy = function (t, e) { - var r; - switch ((e && e.coerce) | 0) { - case 3: - return this._check(t, void 0, lo), t.toString("binary"); - case 2: - if (typeof t != "string") - throw new Error(Fn("cannot coerce to buffer: %j", t)); - return ( - (r = Yn.bufferFrom(t, "binary")), this._check(r, void 0, lo), r - ); - case 1: - if (!Iit(t)) throw new Error(Fn("cannot coerce to buffer: %j", t)); - return (r = Yn.bufferFrom(t.data)), this._check(r, void 0, lo), r; - default: - return this._check(t, void 0, lo), Yn.bufferFrom(t); - } - }; - $p.prototype.compare = Buffer.compare; - $p.prototype.typeName = "bytes"; - $p.prototype.random = function () { - return sc.nextBuffer(sc.nextInt(32)); - }; - function Uv(t, e) { - if ((xt.call(this), !Array.isArray(t))) - throw new Error(Fn("non-array union schema: %j", t)); - if (!t.length) throw new Error("empty union"); - (this.types = Object.freeze( - t.map(function (r) { - return xt.forSchema(r, e); - }) - )), - (this._branchIndices = {}), - this.types.forEach(function (r, n) { - if (xt.isType(r, "union")) - throw new Error("unions cannot be directly nested"); - var i = r.branchName; - if (this._branchIndices[i] !== void 0) - throw new Error(Fn("duplicate union branch name: %j", i)); - this._branchIndices[i] = n; - }, this); - } - La.inherits(Uv, xt); - Uv.prototype._branchConstructor = function () { - throw new Error("unions cannot be directly wrapped"); - }; - Uv.prototype._skip = function (t) { - this.types[t.readLong()]._skip(t); - }; - Uv.prototype._match = function (t, e) { - var r = t.readLong(), - n = e.readLong(); - return r === n ? this.types[r]._match(t, e) : r < n ? -1 : 1; - }; - Uv.prototype._deref = function (t, e) { - return this.types.map(function (r) { - return r._attrs(e); - }); - }; - Uv.prototype.getTypes = function () { - return this.types; - }; - function Lh(t, e) { - Uv.call(this, t, e), - (this._dynamicBranches = null), - (this._bucketIndices = {}), - this.types.forEach(function (r, n) { - if (xt.isType(r, "abstract", "logical")) - this._dynamicBranches || (this._dynamicBranches = []), - this._dynamicBranches.push({ index: n, type: r }); - else { - var i = ste(r); - if (this._bucketIndices[i] !== void 0) - throw new Error(Fn("ambiguous unwrapped union: %j", this)); - this._bucketIndices[i] = n; - } - }, this), - Object.freeze(this); - } - La.inherits(Lh, Uv); - Lh.prototype._getIndex = function (t) { - var e = this._bucketIndices[Cit(t)]; - return this._dynamicBranches && (e = this._getBranchIndex(t, e)), e; - }; - Lh.prototype._getBranchIndex = function (t, e) { - var r = this._dynamicBranches, - n, - i, - o; - for (n = 0, i = r.length; n < i; n++) - if (((o = r[n]), o.type._check(t))) - if (e === void 0) e = o.index; - else throw new Error("ambiguous conversion"); - return e; - }; - Lh.prototype._check = function (t, e, r, n) { - var i = this._getIndex(t), - o = i !== void 0; - return o ? this.types[i]._check(t, e, r, n) : (r && r(t, this), o); - }; - Lh.prototype._read = function (t) { - var e = t.readLong(), - r = this.types[e]; - if (r) return r._read(t); - throw new Error(Fn("invalid union index: %s", e)); - }; - Lh.prototype._write = function (t, e) { - var r = this._getIndex(e); - r === void 0 && lo(e, this), - t.writeLong(r), - e !== null && this.types[r]._write(t, e); - }; - Lh.prototype._update = function (t, e, r) { - var n, i, o; - for (n = 0, i = this.types.length; n < i; n++) { - try { - o = this.types[n].createResolver(e, r); - } catch { - continue; - } - t._read = function (a) { - return o._read(a); - }; - return; - } - }; - Lh.prototype._copy = function (t, e) { - var r = e && e.coerce | 0, - n = e && e.wrap | 0, - i; - if (n === 2) i = 0; - else { - switch (r) { - case 1: - Iit(t) && this._bucketIndices.buffer !== void 0 - ? (i = this._bucketIndices.buffer) - : (i = this._getIndex(t)); - break; - case 2: - if (t === null) i = this._bucketIndices.null; - else if (typeof t == "object") { - var o = Object.keys(t); - o.length === 1 && - ((i = this._branchIndices[o[0]]), (t = t[o[0]])); - } - break; - default: - i = this._getIndex(t); - } - i === void 0 && lo(t, this); - } - var a = this.types[i]; - if (t === null || n === 3) return a._copy(t, e); - switch (r) { - case 3: - var s = {}; - return (s[a.branchName] = a._copy(t, e)), s; - default: - return a._copy(t, e); - } - }; - Lh.prototype.compare = function (t, e) { - var r = this._getIndex(t), - n = this._getIndex(e); - if (r === void 0) lo(t, this); - else if (n === void 0) lo(e, this); - else return r === n ? this.types[r].compare(t, e) : Yn.compare(r, n); - }; - Lh.prototype.typeName = "union:unwrapped"; - Lh.prototype.random = function () { - var t = sc.nextInt(this.types.length); - return this.types[t].random(); - }; - function Ey(t, e) { - Uv.call(this, t, e), Object.freeze(this); - } - La.inherits(Ey, Uv); - Ey.prototype._check = function (t, e, r, n) { - var i = !1; - if (t === null) i = this._branchIndices.null !== void 0; - else if (typeof t == "object") { - var o = Object.keys(t); - if (o.length === 1) { - var a = o[0], - s = this._branchIndices[a]; - if (s !== void 0) - return r - ? (n.push(a), - (i = this.types[s]._check(t[a], e, r, n)), - n.pop(), - i) - : this.types[s]._check(t[a], e); - } - } - return !i && r && r(t, this), i; - }; - Ey.prototype._read = function (t) { - var e = this.types[t.readLong()]; - if (!e) throw new Error(Fn("invalid union index")); - var r = e._branchConstructor; - return r === null ? null : new r(e._read(t)); - }; - Ey.prototype._write = function (t, e) { - var r, n, i; - e === null - ? ((r = this._branchIndices.null), - r === void 0 && lo(e, this), - t.writeLong(r)) - : ((n = Object.keys(e)), - n.length === 1 && ((i = n[0]), (r = this._branchIndices[i])), - r === void 0 && lo(e, this), - t.writeLong(r), - this.types[r]._write(t, e[i])); - }; - Ey.prototype._update = function (t, e, r) { - var n, i, o, a; - for (n = 0, i = this.types.length; n < i; n++) { - try { - o = this.types[n].createResolver(e, r); - } catch { - continue; - } - (a = this.types[n]._branchConstructor), - a - ? (t._read = function (s) { - return new a(o._read(s)); - }) - : (t._read = function () { - return null; - }); - return; - } - }; - Ey.prototype._copy = function (t, e) { - var r = e && e.wrap | 0; - if (r === 2) { - var n = this.types[0]; - return t === null && n.typeName === "null" - ? null - : new n._branchConstructor(n._copy(t, e)); - } - if (t === null && this._branchIndices.null !== void 0) return null; - var i, o, a; - if (typeof t == "object") { - var s = Object.keys(t); - if (s.length === 1) { - var c = s[0]; - if (((i = this._branchIndices[c]), i === void 0 && e.qualifyNames)) { - var u, h; - for (u = 0, o = this.types.length; u < o; u++) - if (((h = this.types[u]), h.name && c === WSe(h.name))) { - i = u; - break; - } - } - i !== void 0 && (a = this.types[i]._copy(t[c], e)); - } - } - if (r === 1 && a === void 0) - for (i = 0, o = this.types.length; i < o && a === void 0; ) - try { - a = this.types[i]._copy(t, e); - } catch { - i++; - } - if (a !== void 0) - return r === 3 ? a : new this.types[i]._branchConstructor(a); - lo(t, this); - }; - Ey.prototype.compare = function (t, e) { - var r = t === null ? "null" : Object.keys(t)[0], - n = e === null ? "null" : Object.keys(e)[0], - i = this._branchIndices[r]; - return r === n - ? r === "null" - ? 0 - : this.types[i].compare(t[r], e[r]) - : Yn.compare(i, this._branchIndices[n]); - }; - Ey.prototype.typeName = "union:wrapped"; - Ey.prototype.random = function () { - var t = sc.nextInt(this.types.length), - e = this.types[t], - r = e._branchConstructor; - return r ? new r(e.random()) : null; - }; - function qh(t, e) { - if ((xt.call(this, t, e), !Array.isArray(t.symbols) || !t.symbols.length)) - throw new Error(Fn("invalid enum symbols: %j", t.symbols)); - (this.symbols = Object.freeze(t.symbols.slice())), - (this._indices = {}), - this.symbols.forEach(function (r, n) { - if (!iU(r)) throw new Error(Fn("invalid %s symbol: %j", this, r)); - if (this._indices[r] !== void 0) - throw new Error(Fn("duplicate %s symbol: %j", this, r)); - this._indices[r] = n; - }, this), - (this._branchConstructor = this._createBranchConstructor()), - Object.freeze(this); - } - La.inherits(qh, xt); - qh.prototype._check = function (t, e, r) { - var n = this._indices[t] !== void 0; - return !n && r && r(t, this), n; - }; - qh.prototype._read = function (t) { - var e = t.readLong(), - r = this.symbols[e]; - if (r === void 0) - throw new Error(Fn("invalid %s enum index: %s", this.name, e)); - return r; - }; - qh.prototype._skip = function (t) { - t.skipLong(); - }; - qh.prototype._write = function (t, e) { - var r = this._indices[e]; - r === void 0 && lo(e, this), t.writeLong(r); - }; - qh.prototype._match = function (t, e) { - return t.matchLong(e); - }; - qh.prototype.compare = function (t, e) { - return Yn.compare(this._indices[t], this._indices[e]); - }; - qh.prototype._update = function (t, e) { - var r = this.symbols; - e.typeName === "enum" && - (!e.name || ~nU(this).indexOf(e.name)) && - e.symbols.every(function (n) { - return ~r.indexOf(n); - }) && - ((t.symbols = e.symbols), (t._read = e._read)); - }; - qh.prototype._copy = function (t) { - return this._check(t, void 0, lo), t; - }; - qh.prototype._deref = function (t) { - t.symbols = this.symbols; - }; - qh.prototype.getSymbols = function () { - return this.symbols; - }; - qh.prototype.typeName = "enum"; - qh.prototype.random = function () { - return sc.choice(this.symbols); - }; - function zh(t, e) { - if ((xt.call(this, t, e), t.size !== (t.size | 0) || t.size < 1)) - throw new Error(Fn("invalid %s size", this.branchName)); - (this.size = t.size | 0), - (this._branchConstructor = this._createBranchConstructor()), - Object.freeze(this); - } - La.inherits(zh, xt); - zh.prototype._check = function (t, e, r) { - var n = Buffer.isBuffer(t) && t.length === this.size; - return !n && r && r(t, this), n; - }; - zh.prototype._read = function (t) { - return t.readFixed(this.size); - }; - zh.prototype._skip = function (t) { - t.skipFixed(this.size); - }; - zh.prototype._write = function (t, e) { - (!Buffer.isBuffer(e) || e.length !== this.size) && lo(e, this), - t.writeFixed(e, this.size); - }; - zh.prototype._match = function (t, e) { - return t.matchFixed(e, this.size); - }; - zh.prototype.compare = Buffer.compare; - zh.prototype._update = function (t, e) { - e.typeName === "fixed" && - this.size === e.size && - (!e.name || ~nU(this).indexOf(e.name)) && - ((t.size = this.size), (t._read = this._read)); - }; - zh.prototype._copy = $p.prototype._copy; - zh.prototype._deref = function (t) { - t.size = this.size; - }; - zh.prototype.getSize = function () { - return this.size; - }; - zh.prototype.typeName = "fixed"; - zh.prototype.random = function () { - return sc.nextBuffer(this.size); - }; - function Wd(t, e) { - if ((xt.call(this), !t.values)) - throw new Error(Fn("missing map values: %j", t)); - (this.valuesType = xt.forSchema(t.values, e)), - (this._branchConstructor = this._createBranchConstructor()), - Object.freeze(this); - } - La.inherits(Wd, xt); - Wd.prototype._check = function (t, e, r, n) { - if (!t || typeof t != "object" || Array.isArray(t)) - return r && r(t, this), !1; - var i = Object.keys(t), - o = !0, - a, - s, - c, - u; - if (r) { - for (c = n.length, n.push(""), a = 0, s = i.length; a < s; a++) - (u = n[c] = i[a]), this.valuesType._check(t[u], e, r, n) || (o = !1); - n.pop(); - } else - for (a = 0, s = i.length; a < s; a++) - if (!this.valuesType._check(t[i[a]], e)) return !1; - return o; - }; - Wd.prototype._read = function (t) { - for (var e = this.valuesType, r = {}, n; (n = HSe(t)); ) - for (; n--; ) { - var i = t.readString(); - r[i] = e._read(t); - } - return r; - }; - Wd.prototype._skip = function (t) { - for (var e = this.valuesType, r, n; (n = t.readLong()); ) - if (n < 0) (r = t.readLong()), (t.pos += r); - else for (; n--; ) t.skipString(), e._skip(t); - }; - Wd.prototype._write = function (t, e) { - (!e || typeof e != "object" || Array.isArray(e)) && lo(e, this); - var r = this.valuesType, - n = Object.keys(e), - i = n.length, - o, - a; - if (i) - for (t.writeLong(i), o = 0; o < i; o++) - (a = n[o]), t.writeString(a), r._write(t, e[a]); - t.writeLong(0); - }; - Wd.prototype._match = function () { - throw new Error("maps cannot be compared"); - }; - Wd.prototype._update = function (t, e, r) { - e.typeName === "map" && - ((t.valuesType = this.valuesType.createResolver(e.valuesType, r)), - (t._read = this._read)); - }; - Wd.prototype._copy = function (t, e) { - if (t && typeof t == "object" && !Array.isArray(t)) { - var r = this.valuesType, - n = Object.keys(t), - i, - o, - a, - s = {}; - for (i = 0, o = n.length; i < o; i++) - (a = n[i]), (s[a] = r._copy(t[a], e)); - return s; - } - lo(t, this); - }; - Wd.prototype.compare = Wd.prototype._match; - Wd.prototype.typeName = "map"; - Wd.prototype.getValuesType = function () { - return this.valuesType; - }; - Wd.prototype.random = function () { - var t = {}, - e, - r; - for (e = 0, r = sc.nextInt(10); e < r; e++) - t[sc.nextString(sc.nextInt(20))] = this.valuesType.random(); - return t; - }; - Wd.prototype._deref = function (t, e) { - t.values = this.valuesType._attrs(e); - }; - function jh(t, e) { - if ((xt.call(this), !t.items)) - throw new Error(Fn("missing array items: %j", t)); - (this.itemsType = xt.forSchema(t.items, e)), - (this._branchConstructor = this._createBranchConstructor()), - Object.freeze(this); - } - La.inherits(jh, xt); - jh.prototype._check = function (t, e, r, n) { - if (!Array.isArray(t)) return r && r(t, this), !1; - var i = !0, - o, - a, - s; - if (r) { - for (s = n.length, n.push(""), o = 0, a = t.length; o < a; o++) - (n[s] = "" + o), this.itemsType._check(t[o], e, r, n) || (i = !1); - n.pop(); - } else - for (o = 0, a = t.length; o < a; o++) - if (!this.itemsType._check(t[o], e)) return !1; - return i; - }; - jh.prototype._read = function (t) { - for (var e = this.itemsType, r = [], n; (n = t.readLong()); ) - for (n < 0 && ((n = -n), t.skipLong()); n--; ) r.push(e._read(t)); - return r; - }; - jh.prototype._skip = function (t) { - for (var e, r; (r = t.readLong()); ) - if (r < 0) (e = t.readLong()), (t.pos += e); - else for (; r--; ) this.itemsType._skip(t); - }; - jh.prototype._write = function (t, e) { - Array.isArray(e) || lo(e, this); - var r = e.length, - n; - if (r) - for (t.writeLong(r), n = 0; n < r; n++) this.itemsType._write(t, e[n]); - t.writeLong(0); - }; - jh.prototype._match = function (t, e) { - for (var r = t.readLong(), n = e.readLong(), i; r && n; ) { - if (((i = this.itemsType._match(t, e)), i)) return i; - --r || (r = HSe(t)), --n || (n = HSe(e)); - } - return Yn.compare(r, n); - }; - jh.prototype._update = function (t, e, r) { - e.typeName === "array" && - ((t.itemsType = this.itemsType.createResolver(e.itemsType, r)), - (t._read = this._read)); - }; - jh.prototype._copy = function (t, e) { - Array.isArray(t) || lo(t, this); - var r = new Array(t.length), - n, - i; - for (n = 0, i = t.length; n < i; n++) - r[n] = this.itemsType._copy(t[n], e); - return r; - }; - jh.prototype._deref = function (t, e) { - t.items = this.itemsType._attrs(e); - }; - jh.prototype.compare = function (t, e) { - var r = t.length, - n = e.length, - i, - o, - a; - for (i = 0, o = Math.min(r, n); i < o; i++) - if ((a = this.itemsType.compare(t[i], e[i]))) return a; - return Yn.compare(r, n); - }; - jh.prototype.getItemsType = function () { - return this.itemsType; - }; - jh.prototype.typeName = "array"; - jh.prototype.random = function () { - var t = [], - e, - r; - for (e = 0, r = sc.nextInt(10); e < r; e++) - t.push(this.itemsType.random()); - return t; - }; - function Fa(t, e) { - e = e || {}; - var r = e.namespace; - if (t.namespace !== void 0) e.namespace = t.namespace; - else if (t.name) { - var n = /^(.*)\.[^.]+$/.exec(t.name); - n && (e.namespace = n[1]); - } - if ((xt.call(this, t, e), !Array.isArray(t.fields))) - throw new Error(Fn("non-array record fields: %j", t.fields)); - if ( - Yn.hasDuplicates(t.fields, function (i) { - return i.name; - }) - ) - throw new Error(Fn("duplicate field name: %j", t.fields)); - (this._fieldsByName = {}), - (this.fields = Object.freeze( - t.fields.map(function (i) { - var o = new sx(i, e); - return (this._fieldsByName[o.name] = o), o; - }, this) - )), - (this._branchConstructor = this._createBranchConstructor()), - (this._isError = t.type === "error"), - (this.recordConstructor = this._createConstructor(e.errorStackTraces)), - (this._read = this._createReader()), - (this._skip = this._createSkipper()), - (this._write = this._createWriter()), - (this._check = this._createChecker()), - (e.namespace = r), - Object.freeze(this); - } - La.inherits(Fa, xt); - Fa.prototype._getConstructorName = function () { - return this.name ? WSe(this.name) : this._isError ? "Error$" : "Record$"; - }; - Fa.prototype._createConstructor = function (t) { - var e = {}, - r, - n, - i, - o, - a, - s, - c; - for (r = 0, n = this.fields.length; r < n; r++) - (i = this.fields[r]), - (a = i.defaultValue), - (s = a() !== void 0), - (o = i.name), - t && - this._isError && - o === "stack" && - xt.isType(i.type, "string") && - !s && - (c = i), - s && (e[r] = a); - var u = this; - function h(M) { - let k = u._getConstructorName(); - var O = { - [k]: function (...D) { - for (var F = 0, N = u.fields.length; F < N; F++) { - let q = u.fields[F]; - q.defaultValue() === void 0 - ? (this[q.name] = D[F]) - : D[F] === void 0 - ? (this[q.name] = M[F]()) - : (this[q.name] = D[F]); - } - c && - this.stack === void 0 && - (typeof Error.captureStackTrace == "function" - ? Error.captureStackTrace(this, this.constructor) - : (this.stack = Error().stack)); - }, - }[k]; - return O; - } - var w = h(e); - return ( - (w.getType = function () { - return u; - }), - (w.type = u), - this._isError && - (La.inherits(w, Error), - (w.prototype.name = this._getConstructorName())), - (w.prototype.clone = function (M) { - return u.clone(this, M); - }), - (w.prototype.compare = function (M) { - return u.compare(this, M); - }), - (w.prototype.isValid = function (M) { - return u.isValid(this, M); - }), - (w.prototype.toBuffer = function () { - return u.toBuffer(this); - }), - (w.prototype.toString = function () { - return u.toString(this); - }), - (w.prototype.wrap = function () { - return u.wrap(this); - }), - (w.prototype.wrapped = w.prototype.wrap), - w - ); - }; - Fa.prototype._createChecker = function () { - let t = []; - this.fields.forEach((n) => { - t.push(n.type); - }); - var e = this; - function r(n) { - var i = e._getConstructorName(), - o = { - [i]: function (a, s, c, u) { - if ( - a === null || - typeof a != "object" || - (s && !this._checkFields(a)) - ) - return c && c(a, this), !1; - let h = []; - if (e.fields.length) - for (var w = 0, M = e.fields.length; w < M; w++) { - let D = e.fields[w]; - D.defaultValue() !== void 0 && h.push(a[D.name]); - } - else return !0; - if (c) { - var k = 1, - O = u.length; - u.push(""); - for (var w = 0, M = e.fields.length; w < M; w++) { - let N = e.fields[w]; - (u[O] = N.name), - (k &= - N.defaultValue() === void 0 - ? n[w]._check(a[N.name], N, c, u) - : h[w] === void 0 || n[w]._check(h[w], N, c, u)); - } - return u.pop(), !!k; - } else - return e.fields.reduce( - (D, F, N) => - D && - (F.defaultValue() === void 0 - ? n[N]._check(a[F.name]) - : h[N] === void 0 || n[N]._check(h[N], s)), - !0 - ); - }, - }[i]; - return o; - } - return r(t); - }; - Fa.prototype._createReader = function () { - var t = [this.recordConstructor], - e, - r; - for (e = 0, r = this.fields.length; e < r; e++) - t.push(this.fields[e].type); - var n = this; - function i(o) { - var a = n._getConstructorName(), - s = { - [a]: function (c) { - return new o[0](...o.slice(1).map((u) => u._read(c))); - }, - }[a]; - return s; - } - return i(t); - }; - Fa.prototype._createSkipper = function () { - var t = []; - this.fields.forEach((n) => { - t.push(n.type); - }); - var e = this; - function r(n) { - var i = e._getConstructorName(), - o = { - [i]: function (a) { - n.forEach((s) => s._skip(a)); - }, - }[i]; - return o; - } - return r(t); - }; - Fa.prototype._createWriter = function () { - var t = [], - e = {}; - this.fields.forEach((i, o) => { - t.push(i.type), - i.defaultValue() !== void 0 && - (e[o] = i.type.toBuffer(i.defaultValue()).toString("binary")); - }); - var r = this; - function n(i, o) { - var a = r._getConstructorName(), - s = { - [a]: function (c, u) { - for (var h = 0, w = r.fields.length; h < w; h++) { - let M = r.fields[h]; - M.defaultValue() === void 0 - ? i[h]._write(c, u[M.name]) - : u[M.name] === void 0 - ? c.writeBinary(o[h], o[h].length) - : i[h]._write(c, u[M.name]); - } - }, - }[a]; - return s; - } - return n(t, e); - }; - Fa.prototype._update = function (t, e, r) { - if (e.name && !~nU(this).indexOf(e.name)) - throw new Error(Fn("no alias found for %s", e.name)); - var n = this.fields, - i = e.fields, - o = Yn.toMap(i, function (F) { - return F.name; - }), - a = {}, - s, - c, - u, - h, - w, - M, - k; - for (s = 0; s < n.length; s++) { - for (u = n[s], w = nU(u), M = [], c = 0; c < w.length; c++) - (h = w[c]), o[h] && M.push(h); - if (M.length > 1) - throw new Error( - Fn("ambiguous aliasing for %s.%s (%s)", e.name, u.name, M) - ); - if (M.length) - (h = M[0]), - (k = { - resolver: u.type.createResolver(o[h].type, r), - name: "_" + u.name, - }), - a[h] ? a[h].push(k) : (a[h] = [k]); - else if (u.defaultValue() === void 0) - throw new Error( - Fn("no matching field for default-less %s.%s", e.name, u.name) - ); - } - var O = this; - function D() { - var F = O._getConstructorName(), - N = { - [F]: function (q, z) { - if (!z) { - var H = []; - for (Z = 0; Z < n.length; Z++) { - for (u = n[Z], w = nU(u), M = [], $ = 0; $ < w.length; $++) - (h = w[$]), o[h] && M.push(h); - M.length || H.push(void 0); - } - for (var Z = 0; Z < i.length; Z++) { - let ue = e.fields[Z]; - if (((h = ue.name), a[h] === void 0)) ue.type._skip(q); - else - for (var $ = a[h].length; $--; ) - H.unshift( - $ - ? a[h][$].resolver._peek(q) - : a[h][$].resolver._read(q) - ); - } - return new O.recordConstructor(...H); - } - }, - }[F]; - return N; - } - t._read = D(); - }; - Fa.prototype._match = function (t, e) { - var r = this.fields, - n, - i, - o, - a, - s; - for (n = 0, i = r.length; n < i; n++) - if (((o = r[n]), (a = o._order), (s = o.type), a)) { - if (((a *= s._match(t, e)), a)) return a; - } else s._skip(t), s._skip(e); - return 0; - }; - Fa.prototype._checkFields = function (t) { - var e = Object.keys(t), - r, - n; - for (r = 0, n = e.length; r < n; r++) - if (!this._fieldsByName[e[r]]) return !1; - return !0; - }; - Fa.prototype._copy = function (t, e) { - var r = e && e.fieldHook, - n = [void 0], - i, - o, - a, - s; - for (i = 0, o = this.fields.length; i < o; i++) - (a = this.fields[i]), - (s = t[a.name]), - s === void 0 && - a.hasOwnProperty("defaultValue") && - (s = a.defaultValue()), - ((e && !e.skip) || s !== void 0) && (s = a.type._copy(s, e)), - r && (s = r(a, s, this)), - n.push(s); - var c = this.recordConstructor; - return new (c.bind.apply(c, n))(); - }; - Fa.prototype._deref = function (t, e) { - t.fields = this.fields.map(function (r) { - var n = r.type, - i = { name: r.name, type: n._attrs(e) }; - if (e.exportAttrs) { - var o = r.defaultValue(); - o !== void 0 && (i.default = n._copy(o, { coerce: 3, wrap: 3 })); - var a = r.order; - a !== "ascending" && (i.order = a); - var s = r.aliases; - s.length && (i.aliases = s); - var c = r.doc; - c !== void 0 && (i.doc = c); - } - return i; - }); - }; - Fa.prototype.compare = function (t, e) { - var r = this.fields, - n, - i, - o, - a, - s, - c; - for (n = 0, i = r.length; n < i; n++) - if ( - ((o = r[n]), - (a = o.name), - (s = o._order), - (c = o.type), - s && ((s *= c.compare(t[a], e[a])), s)) - ) - return s; - return 0; - }; - Fa.prototype.random = function () { - var t = this.fields.map(function (r) { - return r.type.random(); - }); - t.unshift(void 0); - var e = this.recordConstructor; - return new (e.bind.apply(e, t))(); - }; - Fa.prototype.field = function (t) { - return this._fieldsByName[t]; - }; - Fa.prototype.getField = Fa.prototype.field; - Fa.prototype.getFields = function () { - return this.fields; - }; - Fa.prototype.getRecordConstructor = function () { - return this.recordConstructor; - }; - Object.defineProperty(Fa.prototype, "typeName", { - enumerable: !0, - get: function () { - return this._isError ? "error" : "record"; - }, - }); - function Ou(t, e) { - (this._logicalTypeName = t.logicalType), xt.call(this), (cA = this); - try { - this._underlyingType = xt.forSchema(t, e); - } finally { - cA = null; - var r = tR.length; - r && tR[r - 1][0] === this && tR.pop(); - } - xt.isType(this.underlyingType, "union") - ? (this._branchConstructor = this.underlyingType._branchConstructor) - : (this._branchConstructor = - this.underlyingType._createBranchConstructor()); - } - La.inherits(Ou, xt); - Object.defineProperty(Ou.prototype, "typeName", { - enumerable: !0, - get: function () { - return "logical:" + this._logicalTypeName; - }, - }); - Object.defineProperty(Ou.prototype, "underlyingType", { - enumerable: !0, - get: function () { - if (this._underlyingType) return this._underlyingType; - var t, e, r; - for (t = 0, e = tR.length; t < e; t++) - if (((r = tR[t]), r[0] === this)) return r[1]; - }, - }); - Ou.prototype.getUnderlyingType = function () { - return this.underlyingType; - }; - Ou.prototype._read = function (t) { - return this._fromValue(this.underlyingType._read(t)); - }; - Ou.prototype._write = function (t, e) { - this.underlyingType._write(t, this._toValue(e)); - }; - Ou.prototype._check = function (t, e, r, n) { - try { - var i = this._toValue(t); - } catch {} - return i === void 0 - ? (r && r(t, this), !1) - : this.underlyingType._check(i, e, r, n); - }; - Ou.prototype._copy = function (t, e) { - var r = this.underlyingType; - switch (e && e.coerce) { - case 3: - return r._copy(this._toValue(t), e); - case 2: - return this._fromValue(r._copy(t, e)); - default: - return this._fromValue(r._copy(this._toValue(t), e)); - } - }; - Ou.prototype._update = function (t, e, r) { - var n = this._resolve(e, r); - n && - (t._read = function (i) { - return n(e._read(i)); - }); - }; - Ou.prototype.compare = function (t, e) { - var r = this._toValue(t), - n = this._toValue(e); - return this.underlyingType.compare(r, n); - }; - Ou.prototype.random = function () { - return this._fromValue(this.underlyingType.random()); - }; - Ou.prototype._deref = function (t, e) { - var r = this.underlyingType, - n = r.name !== void 0 && e.derefed[r.name]; - return ( - (t = r._attrs(e)), - !n && - e.exportAttrs && - (typeof t == "string" && (t = { type: t }), - (t.logicalType = this._logicalTypeName), - this._export(t)), - t - ); - }; - Ou.prototype._skip = function (t) { - this.underlyingType._skip(t); - }; - Ou.prototype._export = function () {}; - Ou.prototype._fromValue = Yn.abstractFunction; - Ou.prototype._toValue = Yn.abstractFunction; - Ou.prototype._resolve = Yn.abstractFunction; - function Jc(t) { - (this._concreteTypeName = "long"), - wa.call(this, !0), - (this._noUnpack = !!t); - } - La.inherits(Jc, Jp); - Jc.prototype.typeName = "abstract:long"; - Jc.prototype._check = function (t, e, r) { - var n = this._isValid(t); - return !n && r && r(t, this), n; - }; - Jc.prototype._read = function (t) { - var e, r; - if ( - (this._noUnpack - ? ((r = t.pos), t.skipLong(), (e = t.buf.slice(r, t.pos))) - : (e = t.unpackLongBytes(t)), - t.isValid()) - ) - return this._fromBuffer(e); - }; - Jc.prototype._write = function (t, e) { - this._isValid(e) || lo(e, this); - var r = this._toBuffer(e); - this._noUnpack ? t.writeFixed(r) : t.packLongBytes(r); - }; - Jc.prototype._copy = function (t, e) { - switch (e && e.coerce) { - case 3: - return this._toJSON(t); - case 2: - return this._fromJSON(t); - default: - return this._fromJSON(this._toJSON(t)); - } - }; - Jc.prototype._deref = function () { - return "long"; - }; - Jc.prototype._update = function (t, e) { - var r = this; - switch (e.typeName) { - case "int": - t._read = function (n) { - return r._fromJSON(e._read(n)); - }; - break; - case "long": - t._read = function (n) { - return r._read(n); - }; - } - }; - Jc.prototype.random = function () { - return this._fromJSON(Jp.prototype.random()); - }; - Jc.prototype._fromBuffer = Yn.abstractFunction; - Jc.prototype._toBuffer = Yn.abstractFunction; - Jc.prototype._fromJSON = Yn.abstractFunction; - Jc.prototype._toJSON = Yn.abstractFunction; - Jc.prototype._isValid = Yn.abstractFunction; - Jc.prototype.compare = Yn.abstractFunction; - function sx(t, e) { - var r = t.name; - if (typeof r != "string" || !iU(r)) - throw new Error(Fn("invalid field name: %s", r)); - (this.name = r), - (this.type = xt.forSchema(t.type, e)), - (this.aliases = t.aliases || []), - (this.doc = t.doc !== void 0 ? "" + t.doc : void 0), - (this._order = (function (a) { - switch (a) { - case "ascending": - return 1; - case "descending": - return -1; - case "ignore": - return 0; - default: - throw new Error(Fn("invalid order: %j", a)); - } - })(t.order === void 0 ? "ascending" : t.order)); - var n = t.default; - if (n !== void 0) { - var i = this.type, - o = i._copy(n, { coerce: 2, wrap: 2 }); - rR(i.typeName) && i.typeName !== "bytes" - ? (this.defaultValue = function () { - return o; - }) - : (this.defaultValue = function () { - return i._copy(o); - }); - } - Object.freeze(this); - } - sx.prototype.defaultValue = function () {}; - Object.defineProperty(sx.prototype, "order", { - enumerable: !0, - get: function () { - return ["descending", "ignore", "ascending"][this._order + 1]; - }, - }); - sx.prototype.getAliases = function () { - return this.aliases; - }; - sx.prototype.getDefault = sx.prototype.defaultValue; - sx.prototype.getName = function () { - return this.name; - }; - sx.prototype.getOrder = function () { - return this.order; - }; - sx.prototype.getType = function () { - return this.type; - }; - function VSe(t) { - (this._readerType = t), - (this._read = null), - (this.itemsType = null), - (this.size = 0), - (this.symbols = null), - (this.valuesType = null); - } - VSe.prototype._peek = xt.prototype._peek; - VSe.prototype.inspect = function () { - return ""; - }; - function h0r() { - this.str = void 0; - } - function Oit(t, e, r, n) { - if (r) { - if (r._readerType !== t) throw new Error("invalid resolver"); - return r._read(e, n); - } else return t._read(e); - } - function WSe(t) { - var e = t.split("."); - return e[e.length - 1]; - } - function ate(t, e) { - ~t.indexOf(".") ? (t = t.replace(/^\./, "")) : e && (t = e + "." + t), - t.split(".").forEach(function (n) { - if (!iU(n)) throw new Error(Fn("invalid name: %j", t)); - }); - var r = WSe(t); - return rR(r) ? r : t; - } - function nU(t) { - var e = {}; - t.name && (e[t.name] = !0); - var r = t.aliases, - n, - i; - for (n = 0, i = r.length; n < i; n++) e[r[n]] = !0; - return Object.keys(e); - } - function rR(t) { - var e = ote[t]; - return e && e.prototype instanceof wa; - } - function Bit(t) { - if (t === "error") t = "record"; - else { - var e = /^([^:]+):(.*)$/.exec(t); - e && (e[1] === "union" ? (t = e[2] + "Union") : (t = e[1])); - } - return Yn.capitalize(t) + "Type"; - } - function HSe(t) { - var e = t.readLong(); - return e < 0 && ((e = -e), t.skipLong()), e; - } - function GSe(t) { - return t >= -9007199254740990 && t <= 9007199254740990; - } - function Iit(t) { - return t && t.type === "Buffer" && Array.isArray(t.data); - } - function iU(t) { - return d0r.test(t); - } - function lo(t, e) { - throw new Error(Fn("invalid %s: %j", e, t)); - } - function ste(t) { - var e = t.typeName; - switch (e) { - case "double": - case "float": - case "int": - case "long": - return "number"; - case "bytes": - case "fixed": - return "buffer"; - case "enum": - return "string"; - case "map": - case "error": - case "record": - return "object"; - default: - return e; - } - } - function Cit(t) { - if (t === null) return "null"; - var e = typeof t; - if (e === "object") { - if (Array.isArray(t)) return "array"; - if (Buffer.isBuffer(t)) return "buffer"; - } - return e; - } - function p0r(t) { - var e = {}, - r, - n, - i, - o; - for (r = 0, n = t.length; r < n; r++) - if (((o = t[r]), !xt.isType(o, "logical"))) { - if (((i = ste(o)), e[i])) return !0; - e[i] = !0; - } - return !1; - } - function y0r(t) { - var e = ["int", "long", "float", "double"], - r = -1, - n = null, - i, - o, - a, - s; - for (i = 0, o = t.length; i < o; i++) - (a = t[i]), (s = e.indexOf(a.typeName)), s > r && ((r = s), (n = a)); - return n; - } - function m0r(t, e) { - var r = {}, - n, - i, - o, - a; - for (n = 0, i = t.length; n < i; n++) { - if (((o = t[n]), o.typeName === "string")) return o; - a = o.symbols; - var s, c; - for (s = 0, c = a.length; s < c; s++) r[a[s]] = !0; - } - return xt.forSchema({ type: "enum", symbols: Object.keys(r) }, e); - } - function g0r(t, e) { - var r = -1, - n, - i, - o; - for (n = 0, i = t.length; n < i; n++) { - if (((o = t[n]), o.typeName === "bytes")) return o; - r === -1 ? (r = o.size) : o.size !== r && (r = -2); - } - return r < 0 ? xt.forSchema("bytes", e) : t[0]; - } - function v0r(t, e) { - var r = [], - n = {}, - i = {}, - o = !0, - a, - s, - c, - u; - for (a = 0, s = t.length; a < s; a++) - if (((c = t[a]), c.typeName === "map")) (o = !1), r.push(c.valuesType); - else { - u = c.fields; - var h, w, M, k, O, D; - for (h = 0, w = u.length; h < w; h++) - (M = u[h]), - (O = M.name), - (D = M.type), - r.push(D), - o && - (n[O] || (n[O] = []), - n[O].push(D), - (k = M.defaultValue()), - k !== void 0 && (i[O] = k)); - } - if (o) { - var F = Object.keys(n); - for (a = 0, s = F.length; a < s; a++) - (O = F[a]), - n[O].length < t.length && - i[O] === void 0 && - (e && e.strictDefaults - ? (o = !1) - : (n[O].unshift(xt.forSchema("null", e)), (i[O] = null))); - } - var N; - return ( - o - ? (N = { - type: "record", - fields: F.map(function (q) { - var z = xt.forTypes(n[q], e), - H = i[q]; - if (H !== void 0 && ~z.typeName.indexOf("union")) { - var Z = z.types.slice(), - $, - ue; - for ($ = 0, ue = Z.length; $ < ue && !Z[$].isValid(H); $++); - if ($ > 0) { - var te = Z[0]; - (Z[0] = Z[$]), (Z[$] = te), (z = xt.forSchema(Z, e)); - } - } - return { name: q, type: z, default: i[q] }; - }), - }) - : (N = { type: "map", values: xt.forTypes(r, e) }), - xt.forSchema(N, e) - ); - } - Rit.exports = { - Type: xt, - getTypeBucket: ste, - getValueBucket: Cit, - isPrimitive: rR, - isValidName: iU, - qualify: ate, - builtins: (function () { - var t = { - LogicalType: Ou, - UnwrappedUnionType: Lh, - WrappedUnionType: Ey, - }, - e = Object.keys(ote), - r, - n, - i; - for (r = 0, n = e.length; r < n; r++) (i = e[r]), (t[Bit(i)] = ote[i]); - return t; - })(), - }; - }); - var Dit = I((Syn, Nit) => { - "use strict"; - m(); - g(); - var oU = ute(); - function b0r(t, e) { - var r; - if (typeof t == "string") - try { - r = JSON.parse(t); - } catch { - r = t; - } - else r = t; - return oU.Type.forSchema(r, e); - } - Nit.exports = { - Type: oU.Type, - parse: b0r, - types: oU.builtins, - combine: oU.Type.forTypes, - infer: oU.Type.forValue, - }; - }); - var $it = I((Ayn, Jit) => { - "use strict"; - m(); - g(); - var XSe = ute(), - fo = xT(), - fA = o5(), - Hv = vM(), - no = es(), - YSe = fo.Tap, - Qs = XSe.Type, - ns = no.debuglog("avsc:services"), - Bu = no.format, - Kv = { namespace: "org.apache.avro.ipc" }, - Fit = Qs.forSchema("boolean", Kv), - Vv = Qs.forSchema({ type: "map", values: "bytes" }, Kv), - QSe = Qs.forSchema("string", Kv), - aU = Qs.forSchema( - { - name: "HandshakeRequest", - type: "record", - fields: [ - { - name: "clientHash", - type: { name: "MD5", type: "fixed", size: 16 }, - }, - { name: "clientProtocol", type: ["null", "string"], default: null }, - { name: "serverHash", type: "MD5" }, - { name: "meta", type: ["null", Vv], default: null }, - ], - }, - Kv - ), - sU = Qs.forSchema( - { - name: "HandshakeResponse", - type: "record", - fields: [ - { - name: "match", - type: { - name: "HandshakeMatch", - type: "enum", - symbols: ["BOTH", "CLIENT", "NONE"], - }, - }, - { name: "serverProtocol", type: ["null", "string"], default: null }, - { name: "serverHash", type: ["null", "MD5"], default: null }, - { name: "meta", type: ["null", Vv], default: null }, - ], - }, - Kv - ), - e2e = 16, - t2e = new lx( - "", - Qs.forSchema({ name: "PingRequest", type: "record", fields: [] }, Kv), - Qs.forSchema(["string"], Kv), - Qs.forSchema("null", Kv) - ); - function lx(t, e, r, n, i, o) { - if (((this.name = t), !Qs.isType(e, "record"))) - throw new Error("invalid request type"); - if ( - ((this.requestType = e), - !Qs.isType(r, "union") || !Qs.isType(r.getTypes()[0], "string")) - ) - throw new Error("invalid error type"); - if ( - ((this.errorType = r), - i && (!Qs.isType(n, "null") || r.getTypes().length > 1)) - ) - throw new Error("inapplicable one-way parameter"); - (this.responseType = n), - (this.oneWay = !!i), - (this.doc = o !== void 0 ? "" + o : void 0), - Object.freeze(this); - } - lx.forSchema = function (t, e, r) { - if (((r = r || {}), !XSe.isValidName(t))) - throw new Error(Bu("invalid message name: %s", t)); - if (!Array.isArray(e.request)) - throw new Error(Bu("invalid message request: %s", t)); - var n = Bu("%s.%sRequest", Kv.namespace, fo.capitalize(t)), - i = Qs.forSchema( - { - name: n, - type: "record", - namespace: r.namespace || "", - fields: e.request, - }, - r - ); - if ((delete r.registry[n], !e.response)) - throw new Error(Bu("invalid message response: %s", t)); - var o = Qs.forSchema(e.response, r); - if (e.errors !== void 0 && !Array.isArray(e.errors)) - throw new Error(Bu("invalid message errors: %s", t)); - var a = Qs.forSchema(["string"].concat(e.errors || []), r), - s = !!e["one-way"]; - return new lx(t, i, a, o, s, e.doc); - }; - lx.prototype.schema = Qs.prototype.getSchema; - lx.prototype._attrs = function (t) { - var e = this.requestType._attrs(t), - r = { request: e.fields, response: this.responseType._attrs(t) }, - n = this.doc; - n !== void 0 && (r.doc = n); - var i = this.errorType._attrs(t); - return ( - i.length > 1 && (r.errors = i.slice(1)), - this.oneWay && (r["one-way"] = !0), - r - ); - }; - fo.addDeprecatedGetters(lx, [ - "name", - "errorType", - "requestType", - "responseType", - ]); - lx.prototype.isOneWay = no.deprecate(function () { - return this.oneWay; - }, "use `.oneWay` directly instead of `.isOneWay()`"); - function Hi(t, e, r, n, i) { - if (typeof t != "string") return Hi.forProtocol(t, e); - (this.name = t), - (this._messagesByName = e || {}), - (this.messages = Object.freeze(fo.objectValues(this._messagesByName))), - (this._typesByName = r || {}), - (this.types = Object.freeze(fo.objectValues(this._typesByName))), - (this.protocol = n), - (this._hashStr = fo.getHash(JSON.stringify(n)).toString("binary")), - (this.doc = n.doc ? "" + n.doc : void 0), - (this._server = i || this.createServer({ silent: !0 })), - Object.freeze(this); - } - Hi.Client = Zp; - Hi.Server = og; - Hi.compatible = function (t, e) { - try { - zit(t, e); - } catch { - return !1; - } - return !0; - }; - Hi.forProtocol = function (t, e) { - e = e || {}; - var r = t.protocol; - if (!r) throw new Error("missing protocol name"); - if (t.namespace !== void 0) e.namespace = t.namespace; - else { - var n = /^(.*)\.[^.]+$/.exec(r); - n && (e.namespace = n[1]); - } - (r = XSe.qualify(r, e.namespace)), - t.types && - t.types.forEach(function (o) { - Qs.forSchema(o, e); - }); - var i; - return ( - t.messages && - ((i = {}), - Object.keys(t.messages).forEach(function (o) { - i[o] = lx.forSchema(o, t.messages[o], e); - })), - new Hi(r, i, e.registry, t) - ); - }; - Hi.isService = function (t) { - return !!t && t.hasOwnProperty("_hashStr"); - }; - Hi.prototype.createClient = function (t) { - var e = new Zp(this, t); - return ( - process.nextTick(function () { - if (t && t.server) { - var r = { objectMode: !0 }, - n = [new Hv.PassThrough(r), new Hv.PassThrough(r)]; - t.server.createChannel({ readable: n[0], writable: n[1] }, r), - e.createChannel({ readable: n[1], writable: n[0] }, r); - } else t && t.transport && e.createChannel(t.transport); - }), - e - ); - }; - Hi.prototype.createServer = function (t) { - return new og(this, t); - }; - Object.defineProperty(Hi.prototype, "hash", { - enumerable: !0, - get: function () { - return fo.bufferFrom(this._hashStr, "binary"); - }, - }); - Hi.prototype.message = function (t) { - return this._messagesByName[t]; - }; - Hi.prototype.type = function (t) { - return this._typesByName[t]; - }; - Hi.prototype.inspect = function () { - return Bu("", this.name); - }; - fo.addDeprecatedGetters(Hi, [ - "message", - "messages", - "name", - "type", - "types", - ]); - Hi.prototype.createEmitter = no.deprecate(function (t, e) { - e = e || {}; - var r = this.createClient({ - cache: e.cache, - buffering: !1, - strictTypes: e.strictErrors, - timeout: e.timeout, - }), - n = r.createChannel(t, e); - return _0r(r, n), n; - }, "use `.createClient()` instead of `.createEmitter()`"); - Hi.prototype.createListener = no.deprecate(function (t, e) { - if (e && e.strictErrors) - throw new Error("use `.createServer()` to support strict errors"); - return this._server.createChannel(t, e); - }, "use `.createServer().createChannel()` instead of `.createListener()`"); - Hi.prototype.emit = no.deprecate(function (t, e, r, n) { - if (!r || !this.equals(r.client._svc$)) - throw new Error("invalid emitter"); - var i = r.client; - return ( - Zp.prototype.emitMessage.call(i, t, e, n && n.bind(this)), - r.getPending() - ); - }, "create a client via `.createClient()` to emit messages instead of `.emit()`"); - Hi.prototype.equals = no.deprecate(function (t) { - return ( - Hi.isService(t) && this.getFingerprint().equals(t.getFingerprint()) - ); - }, "equality testing is deprecated, compare the `.protocol`s instead"); - Hi.prototype.getFingerprint = no.deprecate(function (t) { - return fo.getHash(JSON.stringify(this.protocol), t); - }, "use `.hash` instead of `.getFingerprint()`"); - Hi.prototype.getSchema = no.deprecate( - Qs.prototype.getSchema, - "use `.protocol` instead of `.getSchema()`" - ); - Hi.prototype.on = no.deprecate(function (t, e) { - var r = this; - return ( - this._server.onMessage(t, function (n, i) { - return e.call(r, n, this.channel, i); - }), - this - ); - }, "use `.createServer().onMessage()` instead of `.on()`"); - Hi.prototype.subprotocol = no.deprecate(function () { - var t = this._server, - e = { strictTypes: t._strict, cache: t._cache }, - r = new og(t.service, e); - return ( - (r._handlers = Object.create(t._handlers)), - new Hi( - this.name, - this._messagesByName, - this._typesByName, - this.protocol, - r - ) - ); - }, "`.subprotocol()` will be removed in 5.1"); - Hi.prototype._attrs = function (t) { - var e = { protocol: this.name }, - r = []; - this.types.forEach(function (i) { - if (i.getName() !== void 0) { - var o = i._attrs(t); - typeof o != "string" && r.push(o); - } - }), - r.length && (e.types = r); - var n = Object.keys(this._messagesByName); - return ( - n.length && - ((e.messages = {}), - n.forEach(function (i) { - e.messages[i] = this._messagesByName[i]._attrs(t); - }, this)), - t && t.exportAttrs && this.doc !== void 0 && (e.doc = this.doc), - e - ); - }; - function w0r(t, e, r) { - r === void 0 && typeof e == "function" && ((r = e), (e = void 0)); - var n = new Hi({ protocol: "Empty" }, Kv), - i; - n.createClient({ timeout: e && e.timeout }) - .createChannel(t, { - scope: e && e.scope, - endWritable: typeof t == "function", - }) - .once("handshake", function (o, a) { - (i = a.serverProtocol), this.destroy(!0); - }) - .once("eot", function (o, a) { - a && !/interrupted/.test(a) ? r(a) : r(null, JSON.parse(i)); - }); - } - function Zp(t, e) { - (e = e || {}), - fA.EventEmitter.call(this), - (this._svc$ = t), - (this._channels$ = []), - (this._fns$ = []), - (this._buffering$ = !!e.buffering), - (this._cache$ = e.cache || {}), - (this._policy$ = e.channelPolicy), - (this._strict$ = !!e.strictTypes), - (this._timeout$ = fo.getOption(e, "timeout", 1e4)), - e.remoteProtocols && jit(this._cache$, e.remoteProtocols, t, !0), - this._svc$.messages.forEach(function (r) { - this[r.name] = this._createMessageHandler$(r); - }, this); - } - no.inherits(Zp, fA.EventEmitter); - Zp.prototype.activeChannels = function () { - return this._channels$.slice(); - }; - Zp.prototype.createChannel = function (t, e) { - var r = e && e.objectMode, - n; - if (typeof t == "function") { - var i; - r - ? (i = t) - : (i = function (h) { - var w = new cU(), - M = t(function (k, O) { - if (k) { - h(k); - return; - } - var D = new ET().once("error", function (F) { - n.destroy(F); - }); - h(null, O.pipe(D)); - }); - if (M) return w.pipe(M), w; - }), - (n = new r2e(this, i, e)); - } else { - var o, a; - if ((Vit(t) ? (o = a = t) : ((o = t.readable), (a = t.writable)), !r)) { - var s = new nR(); - o = o.pipe(s); - var c = new lU(); - c.pipe(a), (a = c); - } - (n = new lte(this, o, a, e)), - r || - (n.once("eot", function () { - o.unpipe(s), c.unpipe(a); - }), - s.once("error", function (h) { - n.destroy(h); - })); - } - var u = this._channels$; - return ( - u.push(n), - n.once("_drain", function () { - u.splice(u.indexOf(this), 1); - }), - (this._buffering$ = !1), - this.emit("channel", n), - n - ); - }; - Zp.prototype.destroyChannels = function (t) { - this._channels$.forEach(function (e) { - e.destroy(t && t.noWait); - }); - }; - Zp.prototype.emitMessage = function (t, e, r, n) { - var i = Wit(this._svc$, t), - o = new fte(i, {}, e); - this._emitMessage$(o, r, n); - }; - Zp.prototype.remoteProtocols = function () { - return Uit(this._cache$, !0); - }; - Object.defineProperty(Zp.prototype, "service", { - enumerable: !0, - get: function () { - return this._svc$; - }, - }); - Zp.prototype.use = function () { - var t, e, r; - for (t = 0, e = arguments.length; t < e; t++) - (r = arguments[t]), this._fns$.push(r.length < 3 ? r(this) : r); - return this; - }; - Zp.prototype._emitMessage$ = function (t, e, r) { - !r && typeof e == "function" && ((r = e), (e = void 0)); - var n = this, - i = this._channels$, - o = i.length; - if (!o) { - if (this._buffering$) - ns("no active client channels, buffering call"), - this.once("channel", function () { - this._emitMessage$(t, e, r); - }); - else { - var a = new Error("no active channels"); - process.nextTick(function () { - r ? r.call(new i2e(t._msg), a) : n.emit("error", a); - }); - } - return; - } - (e = e || {}), e.timeout === void 0 && (e.timeout = this._timeout$); - var s; - if (o === 1) s = i[0]; - else if (this._policy$) { - if (((s = this._policy$(this._channels$.slice())), !s)) { - ns("policy returned no channel, skipping call"); - return; - } - } else s = i[Math.floor(Math.random() * o)]; - s._emit(t, e, function (c, u) { - var h = this, - w = h.message.errorType; - if (c) { - n._strict$ && (c = w.clone(c.message, { wrapUnions: !0 })), M(c); - return; - } - if (!u) { - M(); - return; - } - (c = u.error), - n._strict$ || - (c === void 0 - ? (c = null) - : Qs.isType(w, "union:unwrapped") - ? typeof c == "string" && (c = new Error(c)) - : c && - c.string && - typeof c.string == "string" && - (c = new Error(c.string))), - M(c, u.response); - function M(k, O) { - r ? r.call(h, k, O) : k && n.emit("error", k); - } - }); - }; - Zp.prototype._createMessageHandler$ = function (t) { - var e = t.requestType.getFields(), - r = e.map(function (i) { - return i.getName(); - }), - n = "return function " + t.name + "("; - return ( - r.length && (n += r.join(", ") + ", "), - (n += `opts, cb) { -`), - (n += " var req = {"), - (n += r - .map(function (i) { - return i + ": " + i; - }) - .join(", ")), - (n += `}; -`), - (n += - " return this.emitMessage('" + - t.name + - `', req, opts, cb); -`), - (n += "};"), - new Function(n)() - ); - }; - function og(t, e) { - (e = e || {}), - fA.EventEmitter.call(this), - (this.service = t), - (this._handlers = {}), - (this._fns = []), - (this._channels = {}), - (this._nextChannelId = 1), - (this._cache = e.cache || {}), - (this._defaultHandler = e.defaultHandler), - (this._sysErrFormatter = e.systemErrorFormatter), - (this._silent = !!e.silent), - (this._strict = !!e.strictTypes), - e.remoteProtocols && jit(this._cache, e.remoteProtocols, t, !1), - t.messages.forEach(function (r) { - var n = r.name; - e.noCapitalize || (n = fo.capitalize(n)), - (this["on" + n] = this._createMessageHandler(r)); - }, this); - } - no.inherits(og, fA.EventEmitter); - og.prototype.activeChannels = function () { - return fo.objectValues(this._channels); - }; - og.prototype.createChannel = function (t, e) { - var r = e && e.objectMode, - n; - if (typeof t == "function") { - var i; - r - ? (i = t) - : (i = function (w) { - var M = new ET().once("error", function (k) { - n.destroy(k); - }); - return t(function (k, O) { - if (k) { - w(k); - return; - } - var D = new cU(); - D.pipe(O), w(null, D); - }).pipe(M); - }), - (n = new Lit(this, i, e)); - } else { - var o, a; - if ((Vit(t) ? (o = a = t) : ((o = t.readable), (a = t.writable)), !r)) { - var s = new nR(); - o = o.pipe(s); - var c = new lU(); - c.pipe(a), (a = c); - } - (n = new qit(this, o, a, e)), - r || - (n.once("eot", function () { - o.unpipe(s), c.unpipe(a); - }), - s.once("error", function (w) { - n.destroy(w); - })); - } - this.listeners("error").length || this.on("error", this._onError); - var u = this._nextChannelId++, - h = this._channels; - return ( - (h[u] = n.once("eot", function () { - delete h[u]; - })), - this.emit("channel", n), - n - ); - }; - og.prototype.onMessage = function (t, e) { - return Wit(this.service, t), (this._handlers[t] = e), this; - }; - og.prototype.remoteProtocols = function () { - return Uit(this._cache, !1); - }; - og.prototype.use = function () { - var t, e, r; - for (t = 0, e = arguments.length; t < e; t++) - (r = arguments[t]), this._fns.push(r.length < 3 ? r(this) : r); - return this; - }; - og.prototype._createMessageHandler = function (t) { - var e = t.name, - r = t.requestType.fields, - n = r.length, - i = r.length - ? ", " + - r - .map(function (a) { - return "req." + a.name; - }) - .join(", ") - : "", - o = `return function (handler) { -`; - return ( - (o += - " if (handler.length > " + - n + - `) { -`), - (o += - " return this.onMessage('" + - e + - `', function (req, cb) { -`), - (o += - " return handler.call(this" + - i + - `, cb); -`), - (o += ` }); -`), - (o += ` } else { -`), - (o += - " return this.onMessage('" + - e + - `', function (req) { -`), - (o += - " return handler.call(this" + - i + - `); -`), - (o += ` }); -`), - (o += ` } -`), - (o += `}; -`), - new Function(o)() - ); - }; - og.prototype._onError = function (t) { - !this._silent && - t.rpcCode !== "UNKNOWN_PROTOCOL" && - (console.error(), - t.rpcCode - ? (console.error(t.rpcCode), console.error(t.cause)) - : (console.error("INTERNAL_SERVER_ERROR"), console.error(t))); - }; - function uc(t, e) { - (e = e || {}), - fA.EventEmitter.call(this), - (this.client = t), - (this.timeout = fo.getOption(e, "timeout", t._timeout$)), - (this._endWritable = !!fo.getOption(e, "endWritable", !0)), - (this._prefix = Kit(e.scope)); - var r = t._cache$, - n = t._svc$, - i = e.serverHash; - i || (i = n.hash); - var o = r[i]; - o || ((i = n.hash), (o = r[i] = new dA(n, n, i))), - (this._adapter = o), - (this._registry = new uU(this, e2e)), - (this.pending = 0), - (this.destroyed = !1), - (this.draining = !1), - this.once("_eot", function (a, s) { - ns("client channel EOT"), - (this.destroyed = !0), - this.emit("eot", a, s); - }); - } - no.inherits(uc, fA.EventEmitter); - uc.prototype.destroy = function (t) { - ns("destroying client channel"), - this.draining || ((this.draining = !0), this.emit("_drain")); - var e = this._registry, - r = this.pending; - t && e.clear(), - t || !r - ? o2e(t) - ? (ns("fatal client channel error: %s", t), this.emit("_eot", r, t)) - : this.emit("_eot", r) - : ns("client channel entering drain mode (%s pending)", r); - }; - uc.prototype.ping = function (t, e) { - !e && typeof t == "function" && ((e = t), (t = void 0)); - var r = this, - n = new fte(t2e); - this._emit(n, { timeout: t }, function (i) { - e ? e.call(r, i) : i && r.destroy(i); - }); - }; - uc.prototype._createHandshakeRequest = function (t, e) { - var r = this.client._svc$; - return { - clientHash: r.hash, - clientProtocol: e ? null : JSON.stringify(r.protocol), - serverHash: t._hash, - }; - }; - uc.prototype._emit = function (t, e, r) { - var n = t._msg, - i = n.oneWay ? void 0 : new n2e(n, {}), - o = new i2e(n, this), - a = this; - this.pending++, - process.nextTick(function () { - if (!n.name) s(t, i, c); - else { - a.emit("outgoingCall", o, e); - var h = a.client._fns$; - ns("starting client middleware chain (%s middleware)", h.length), - Git({ - fns: h, - ctx: o, - wreq: t, - wres: i, - onTransition: s, - onCompletion: c, - onError: u, - }); - } - }); - function s(h, w, M) { - var k, O; - if (a.destroyed) k = new Error("channel destroyed"); - else - try { - O = h.toBuffer(); - } catch { - k = ZSe(Bu("invalid %j request", n.name), h, [ - { name: "headers", type: Vv }, - { name: "request", type: n.requestType }, - ]); - } - if (k) { - M(k); - return; - } - var D = e && e.timeout !== void 0 ? e.timeout : a.timeout, - F = a._registry.add(D, function (N, q, z) { - if (!N && !n.oneWay) - try { - z._decodeResponse(q, w, n); - } catch (H) { - N = H; - } - M(N); - }); - (F |= a._prefix), - ns("sending message %s", F), - a._send(F, O, !!n && n.oneWay); - } - function c(h) { - a.pending--, - r.call(o, h, i), - a.draining && !a.destroyed && !a.pending && a.destroy(); - } - function u(h) { - a.client.emit("error", h, a); - } - }; - uc.prototype._getAdapter = function (t) { - var e = t.serverHash, - r = this.client._cache$, - n = r[e]; - if (n) return n; - var i = JSON.parse(t.serverProtocol), - o = Hi.forProtocol(i); - return (n = new dA(this.client._svc$, o, e, !0)), (r[e] = n); - }; - uc.prototype._matchesPrefix = function (t) { - return Hit(t, this._prefix); - }; - uc.prototype._send = fo.abstractFunction; - fo.addDeprecatedGetters(uc, ["pending", "timeout"]); - uc.prototype.getCache = no.deprecate(function () { - return this.client._cache$; - }, "use `.remoteProtocols()` instead of `.getCache()`"); - uc.prototype.getProtocol = no.deprecate(function () { - return this.client._svc$; - }, "use `.service` instead or `.getProtocol()`"); - uc.prototype.isDestroyed = no.deprecate(function () { - return this.destroyed; - }, "use `.destroyed` instead of `.isDestroyed`"); - function r2e(t, e, r) { - uc.call(this, t, r), - (this._writableFactory = e), - (!r || !r.noPing) && (ns("emitting ping request"), this.ping()); - } - no.inherits(r2e, uc); - r2e.prototype._send = function (t, e) { - var r = this._registry.get(t), - n = this._adapter, - i = this; - return process.nextTick(o), !0; - function o(a) { - if (!i.destroyed) { - var s = i._createHandshakeRequest(n, !a), - c = i._writableFactory.call(i, function (u, h) { - if (u) { - r(u); - return; - } - h.on("data", function (w) { - ns("received response %s", w.id); - var M = Buffer.concat(w.payload); - try { - var k = dte(sU, M), - O = k.head; - O.serverHash && (n = i._getAdapter(O)); - } catch (F) { - r(F); - return; - } - var D = O.match; - ns("handshake match: %s", D), - i.emit("handshake", s, O), - D === "NONE" - ? process.nextTick(function () { - o(!0); - }) - : ((i._adapter = n), r(null, k.tail, n)); - }); - }); - if (!c) { - r(new Error("invalid writable stream")); - return; - } - c.write({ id: t, payload: [aU.toBuffer(s), e] }), - i._endWritable && c.end(); - } - } - }; - function lte(t, e, r, n) { - uc.call(this, t, n), - (this._readable = e), - (this._writable = r), - (this._connected = !!(n && n.noPing)), - this._readable.on("end", h), - this._writable.on("finish", w); - var i = this, - o = null; - this.once("eot", function () { - o && (clearTimeout(o), (o = null)), - i._connected || i.emit("_ready"), - this._writable.removeListener("finish", w), - this._endWritable && (ns("ending transport"), this._writable.end()), - this._readable - .removeListener("data", c) - .removeListener("data", u) - .removeListener("end", h); - }); - var a; - this._connected - ? this._readable.on("data", u) - : (this._readable.on("data", c), - process.nextTick(s), - i.timeout && - (o = setTimeout(function () { - i.destroy(new Error("timeout")); - }, i.timeout))); - function s(M) { - if (!i.destroyed) { - a = i._createHandshakeRequest(i._adapter, !M); - var k = [aU.toBuffer(a), fo.bufferFrom([0, 0])]; - i._writable.write({ id: i._prefix, payload: k }); - } - } - function c(M) { - if (!i._matchesPrefix(M.id)) { - ns("discarding unscoped response %s (still connecting)", M.id); - return; - } - var k = Buffer.concat(M.payload); - try { - var O = dte(sU, k).head; - O.serverHash && (i._adapter = i._getAdapter(O)); - } catch (F) { - i.destroy(F); - return; - } - var D = O.match; - ns("handshake match: %s", D), - i.emit("handshake", a, O), - D === "NONE" - ? process.nextTick(function () { - s(!0); - }) - : (ns("successfully connected"), - o && (clearTimeout(o), (o = null)), - i._readable.removeListener("data", c).on("data", u), - (i._connected = !0), - i.emit("_ready"), - (a = null)); - } - function u(M) { - var k = M.id; - if (!i._matchesPrefix(k)) { - ns("discarding unscoped message %s", k); - return; - } - var O = i._registry.get(k); - O && - process.nextTick(function () { - ns("received message %s", k), - O(null, Buffer.concat(M.payload), i._adapter); - }); - } - function h() { - i.destroy(!0); - } - function w() { - i.destroy(); - } - } - no.inherits(lte, uc); - lte.prototype._emit = function () { - if (this._connected || this.draining) - uc.prototype._emit.apply(this, arguments); - else { - ns("queuing request"); - var t = [], - e, - r; - for (e = 0, r = arguments.length; e < r; e++) t.push(arguments[e]); - this.once("_ready", function () { - this._emit.apply(this, t); - }); - } - }; - lte.prototype._send = function (t, e, r) { - if (r) { - var n = this; - process.nextTick(function () { - n._registry.get(t)(null, fo.bufferFrom([0, 0, 0]), n._adapter); - }); - } - return this._writable.write({ id: t, payload: [e] }); - }; - function Gd(t, e) { - (e = e || {}), - fA.EventEmitter.call(this), - (this.server = t), - (this._endWritable = !!fo.getOption(e, "endWritable", !0)), - (this._prefix = Kit(e.scope)); - var r = t._cache, - n = t.service, - i = n.hash; - r[i] || (r[i] = new dA(n, n, i)), - (this._adapter = null), - (this.destroyed = !1), - (this.draining = !1), - (this.pending = 0), - this.once("_eot", function (o, a) { - ns("server channel EOT"), this.emit("eot", o, a); - }); - } - no.inherits(Gd, fA.EventEmitter); - Gd.prototype.destroy = function (t) { - this.draining || ((this.draining = !0), this.emit("_drain")), - (t || !this.pending) && - ((this.destroyed = !0), - o2e(t) - ? (ns("fatal server channel error: %s", t), - this.emit("_eot", this.pending, t)) - : this.emit("_eot", this.pending)); - }; - Gd.prototype._createHandshakeResponse = function (t, e) { - var r = this.server.service, - n = r.hash, - i = e && e.serverHash.equals(n); - return { - match: t ? "NONE" : i ? "BOTH" : "CLIENT", - serverProtocol: i ? null : JSON.stringify(r.protocol), - serverHash: i ? null : n, - }; - }; - Gd.prototype._getAdapter = function (t) { - var e = t.clientHash, - r = this.server._cache[e]; - if (r) return r; - if (!t.clientProtocol) throw lA("UNKNOWN_PROTOCOL"); - var n = JSON.parse(t.clientProtocol), - i = Hi.forProtocol(n); - return ( - (r = new dA(i, this.server.service, e, !0)), (this.server._cache[e] = r) - ); - }; - Gd.prototype._matchesPrefix = function (t) { - return Hit(t, this._prefix); - }; - Gd.prototype._receive = function (t, e, r) { - var n = this, - i; - try { - i = e._decodeRequest(t); - } catch (M) { - r(n._encodeSystemError(lA("INVALID_REQUEST", M))); - return; - } - var o = i._msg, - a = new n2e(o, {}); - if (!o.name) { - (a.response = null), r(a.toBuffer(), !1); - return; - } - var s = new i2e(o, this); - n.emit("incomingCall", s); - var c = this.server._fns; - ns("starting server middleware chain (%s middleware)", c.length), - n.pending++, - Git({ - fns: c, - ctx: s, - wreq: i, - wres: a, - onTransition: u, - onCompletion: h, - onError: w, - }); - function u(M, k, O) { - var D = n.server._handlers[o.name]; - if (D) { - var q = !o.oneWay; - try { - q - ? D.call(s, M.request, function (z, H) { - (q = !1), (k.error = z), (k.response = H), O(); - }) - : (D.call(s, M.request), O()); - } catch (z) { - q ? ((q = !1), O(z)) : w(z); - } - } else { - var F = n.server._defaultHandler; - if (F) F.call(s, M, k, O); - else { - var N = new Error(Bu("no handler for %s", o.name)); - O(lA("NOT_IMPLEMENTED", N)); - } - } - } - function h(M) { - n.pending--; - var k = n.server, - O; - if (!M) { - var D = a.error, - F = k._strict; - F || - (o2e(D) - ? (a.error = o.errorType.clone(D.message, { wrapUnions: !0 })) - : D === null && (D = a.error = void 0), - D === void 0 && - a.response === void 0 && - o.responseType.isValid(null) && - (a.response = null)); - try { - O = a.toBuffer(); - } catch { - a.error !== void 0 - ? (M = ZSe(Bu("invalid %j error", o.name), a, [ - { name: "headers", type: Vv }, - { name: "error", type: o.errorType }, - ])) - : (M = ZSe(Bu("invalid %j response", o.name), a, [ - { name: "headers", type: Vv }, - { name: "response", type: o.responseType }, - ])); - } - } - O - ? D !== void 0 && k.emit("error", lA("APPLICATION_ERROR", D)) - : (O = n._encodeSystemError(M, a.headers)), - r(O, o.oneWay), - n.draining && !n.pending && n.destroy(); - } - function w(M) { - n.server.emit("error", M, n); - } - }; - fo.addDeprecatedGetters(Gd, ["pending"]); - Gd.prototype.getCache = no.deprecate(function () { - return this.server._cache; - }, "use `.remoteProtocols()` instead of `.getCache()`"); - Gd.prototype.getProtocol = no.deprecate(function () { - return this.server.service; - }, "use `.service` instead of `.getProtocol()`"); - Gd.prototype.isDestroyed = no.deprecate(function () { - return this.destroyed; - }, "use `.destroyed` instead of `.isDestroyed`"); - Gd.prototype._encodeSystemError = function (t, e) { - var r = this.server; - r.emit("error", t, this); - var n; - r._sysErrFormatter - ? (n = r._sysErrFormatter.call(this, t)) - : t.rpcCode && (n = t.message); - var i; - if (e) - try { - i = Vv.toBuffer(e); - } catch (o) { - r.emit("error", o, this); - } - return Buffer.concat([ - i || fo.bufferFrom([0]), - fo.bufferFrom([1, 0]), - QSe.toBuffer(n || "internal server error"), - ]); - }; - function Lit(t, e, r) { - Gd.call(this, t, r), (this._writable = void 0); - var n = this, - i; - process.nextTick(function () { - i = e - .call(n, function (c, u) { - process.nextTick(function () { - if (c) { - s(c); - return; - } - (n._writable = u.on("finish", s)), n.emit("_writable"); - }); - }) - .on("data", o) - .on("end", a); - }); - function o(c) { - var u = c.id, - h = Buffer.concat(c.payload), - w; - try { - var M = dte(aU, h), - k = M.head, - O = n._getAdapter(k); - } catch (N) { - w = lA("INVALID_HANDSHAKE_REQUEST", N); - } - var D = n._createHandshakeResponse(w, k); - n.emit("handshake", k, D), - w ? F(n._encodeSystemError(w)) : n._receive(M.tail, O, F); - function F(N) { - if (!n.destroyed) { - if (!n._writable) { - n.once("_writable", function () { - F(N); - }); - return; - } - n._writable.write({ id: u, payload: [sU.toBuffer(D), N] }); - } - n._writable && n._endWritable && n._writable.end(); - } - } - function a() { - n.destroy(); - } - function s(c) { - i.removeListener("data", o).removeListener("end", a), - n.destroy(c || !0); - } - } - no.inherits(Lit, Gd); - function qit(t, e, r, n) { - Gd.call(this, t, n), - (this._adapter = void 0), - (this._writable = r.on("finish", c)), - (this._readable = e.on("data", o).on("end", s)), - this.once("_drain", function () { - this._readable - .removeListener("data", o) - .removeListener("data", a) - .removeListener("end", s); - }).once("eot", function () { - this._writable.removeListener("finish", c), - this._endWritable && this._writable.end(); - }); - var i = this; - function o(u) { - var h = u.id; - if (!i._matchesPrefix(h)) return; - var w = Buffer.concat(u.payload), - M; - try { - var k = dte(aU, w), - O = k.head; - i._adapter = i._getAdapter(O); - } catch (N) { - M = lA("INVALID_HANDSHAKE_REQUEST", N); - } - var D = i._createHandshakeResponse(M, O); - i.emit("handshake", O, D), - M - ? F(i._encodeSystemError(M)) - : (i._readable.removeListener("data", o).on("data", a), - i._receive(k.tail, i._adapter, F)); - function F(N) { - i.destroyed || - i._writable.write({ id: h, payload: [sU.toBuffer(D), N] }); - } - } - function a(u) { - var h = u.id; - if (!!i._matchesPrefix(h)) { - var w = Buffer.concat(u.payload); - i._receive(w, i._adapter, function (M, k) { - i.destroyed || k || i._writable.write({ id: h, payload: [M] }); - }); - } - } - function s() { - i.destroy(); - } - function c() { - i.destroy(!0); - } - } - no.inherits(qit, Gd); - function fte(t, e, r) { - (this._msg = t), (this.headers = e || {}), (this.request = r || {}); - } - fte.prototype.toBuffer = function () { - var t = this._msg; - return Buffer.concat([ - Vv.toBuffer(this.headers), - QSe.toBuffer(t.name), - t.requestType.toBuffer(this.request), - ]); - }; - function n2e(t, e, r, n) { - (this._msg = t), - (this.headers = e), - (this.error = r), - (this.response = n); - } - n2e.prototype.toBuffer = function () { - var t = Vv.toBuffer(this.headers), - e = this.error !== void 0; - return Buffer.concat([ - t, - Fit.toBuffer(e), - e - ? this._msg.errorType.toBuffer(this.error) - : this._msg.responseType.toBuffer(this.response), - ]); - }; - function i2e(t, e) { - (this.channel = e), - (this.locals = {}), - (this.message = t), - Object.freeze(this); - } - function uU(t, e) { - (this._ctx = t), - (this._mask = -1 >>> (e | 0)), - (this._id = 0), - (this._n = 0), - (this._cbs = {}); - } - uU.prototype.get = function (t) { - return this._cbs[t & this._mask]; - }; - uU.prototype.add = function (t, e) { - this._id = (this._id + 1) & this._mask; - var r = this, - n = this._id, - i; - return ( - t > 0 && - (i = setTimeout(function () { - o(new Error("timeout")); - }, t)), - (this._cbs[n] = o), - this._n++, - n - ); - function o() { - !r._cbs[n] || - (delete r._cbs[n], - r._n--, - i && clearTimeout(i), - e.apply(r._ctx, arguments)); - } - }; - uU.prototype.clear = function () { - Object.keys(this._cbs).forEach(function (t) { - this._cbs[t](new Error("interrupted")); - }, this); - }; - function dA(t, e, r, n) { - (this._clientSvc = t), - (this._serverSvc = e), - (this._hash = r), - (this._isRemote = !!n), - (this._readers = zit(t, e)); - } - dA.prototype._decodeRequest = function (t) { - var e = new YSe(t), - r = Vv._read(e), - n = QSe._read(e), - i, - o; - if ( - (n - ? ((i = this._serverSvc.message(n)), - (o = this._readers[n + "?"]._read(e))) - : (i = t2e), - !e.isValid()) - ) - throw new Error(Bu("truncated %s request", n || "ping$")); - return new fte(i, r, o); - }; - dA.prototype._decodeResponse = function (t, e, r) { - var n = new YSe(t); - fo.copyOwnProperties(Vv._read(n), e.headers, !0); - var i = Fit._read(n), - o = r.name; - if (o) { - var a = this._readers[o + (i ? "*" : "!")]; - if ( - ((r = this._clientSvc.message(o)), - i ? (e.error = a._read(n)) : (e.response = a._read(n)), - !n.isValid()) - ) - throw new Error(Bu("truncated %s response", o)); - } else r = t2e; - }; - function ET() { - Hv.Transform.call(this, { readableObjectMode: !0 }), - (this._id = void 0), - (this._buf = fo.newBuffer(0)), - (this._bufs = []), - this.on("finish", function () { - this.push(null); - }); - } - no.inherits(ET, Hv.Transform); - ET.prototype._transform = function (t, e, r) { - t = Buffer.concat([this._buf, t]); - for (var n; t.length >= 4 && t.length >= (n = t.readInt32BE(0)) + 4; ) { - if (n) this._bufs.push(t.slice(4, n + 4)); - else { - var i = this._bufs; - (this._bufs = []), this.push({ id: null, payload: i }); - } - t = t.slice(n + 4); - } - (this._buf = t), r(); - }; - ET.prototype._flush = function () { - if (this._buf.length || this._bufs.length) { - var t = this._bufs.slice(); - t.unshift(this._buf); - var e = lA("TRAILING_DATA"); - (e.trailingData = Buffer.concat(t).toString()), this.emit("error", e); - } - }; - function cU() { - Hv.Transform.call(this, { writableObjectMode: !0 }), - this.on("finish", function () { - this.push(null); - }); - } - no.inherits(cU, Hv.Transform); - cU.prototype._transform = function (t, e, r) { - var n = t.payload, - i, - o, - a; - for (i = 0, o = n.length; i < o; i++) - (a = n[i]), this.push($Se(a.length)), this.push(a); - this.push($Se(0)), r(); - }; - function nR() { - Hv.Transform.call(this, { readableObjectMode: !0 }), - (this._id = void 0), - (this._frameCount = 0), - (this._buf = fo.newBuffer(0)), - (this._bufs = []), - this.on("finish", function () { - this.push(null); - }); - } - no.inherits(nR, Hv.Transform); - nR.prototype._transform = function (t, e, r) { - for (t = Buffer.concat([this._buf, t]); ; ) { - if (this._id === void 0) { - if (t.length < 8) { - (this._buf = t), r(); - return; - } - (this._id = t.readInt32BE(0)), - (this._frameCount = t.readInt32BE(4)), - (t = t.slice(8)); - } - for ( - var n; - this._frameCount && - t.length >= 4 && - t.length >= (n = t.readInt32BE(0)) + 4; - - ) - this._frameCount--, - this._bufs.push(t.slice(4, n + 4)), - (t = t.slice(n + 4)); - if (this._frameCount) { - (this._buf = t), r(); - return; - } else { - var i = { id: this._id, payload: this._bufs }; - (this._bufs = []), (this._id = void 0), this.push(i); - } - } - }; - nR.prototype._flush = ET.prototype._flush; - function lU() { - Hv.Transform.call(this, { writableObjectMode: !0 }), - this.on("finish", function () { - this.push(null); - }); - } - no.inherits(lU, Hv.Transform); - lU.prototype._transform = function (t, e, r) { - var n = t.payload, - i = n.length, - o; - (o = fo.newBuffer(8)), - o.writeInt32BE(t.id, 0), - o.writeInt32BE(i, 4), - this.push(o); - var a; - for (a = 0; a < i; a++) - (o = n[a]), this.push($Se(o.length)), this.push(o); - r(); - }; - function $Se(t) { - var e = fo.newBuffer(4); - return e.writeInt32BE(t), e; - } - function dte(t, e) { - var r = new YSe(e), - n = t._read(r); - if (!r.isValid()) throw new Error(Bu("truncated %s", t)); - return { head: n, tail: r.buf.slice(r.pos) }; - } - function JSe(t, e) { - return t.equals(e) ? t : t.createResolver(e); - } - function zit(t, e) { - var r = {}; - return ( - t.messages.forEach(function (n) { - var i = n.name, - o = e.message(i); - try { - if (!o) throw new Error(Bu("missing server message: %s", i)); - if (o.oneWay !== n.oneWay) - throw new Error(Bu("inconsistent one-way message: %s", i)); - (r[i + "?"] = JSe(o.requestType, n.requestType)), - (r[i + "*"] = JSe(n.errorType, o.errorType)), - (r[i + "!"] = JSe(n.responseType, o.responseType)); - } catch (a) { - throw lA("INCOMPATIBLE_PROTOCOL", a); - } - }), - r - ); - } - function jit(t, e, r, n) { - Object.keys(e).forEach(function (i) { - var o = e[i], - a, - s; - n - ? ((a = r), (s = Hi.forProtocol(o))) - : ((a = Hi.forProtocol(o)), (s = r)), - (t[i] = new dA(a, s, i, !0)); - }); - } - function Uit(t, e) { - var r = {}; - return ( - Object.keys(t).forEach(function (n) { - var i = t[n]; - if (i._isRemote) { - var o = e ? i._serverSvc : i._clientSvc; - r[n] = o.protocol; - } - }), - r - ); - } - function o2e(t) { - return !!t && Object.prototype.toString.call(t) === "[object Error]"; - } - function _0r(t, e) { - return t.on("error", function (r) { - e.emit("error", r, t); - }); - } - function cte(t, e) { - var r = new Error(t); - return (r.cause = e), r; - } - function lA(t, e) { - var r = cte(t.toLowerCase().replace(/_/g, " "), e); - return (r.rpcCode = e && e.rpcCode ? e.rpcCode : t), r; - } - function ZSe(t, e, r) { - var n = [], - i, - o, - a; - for (i = 0, o = r.length; i < o; i++) - (a = r[i]), a.type.isValid(e[a.name], { errorHook: u }); - var s = n - .map(function (h) { - return Bu("%s = %j but expected %s", h.path, h.value, h.type); - }) - .join(", "), - c = new Error(Bu("%s (%s)", t, s)); - return (c.details = n), c; - function u(h, w, M) { - var k = [], - O, - D, - F; - for (O = 0, D = h.length; O < D; O++) - (F = h[O]), isNaN(F) ? k.push("." + F) : k.push("[" + F + "]"); - n.push({ path: a.name + k.join(""), value: w, type: M }); - } - } - function Kit(t) { - return t ? fo.getHash(t).readInt16BE(0) << (32 - e2e) : 0; - } - function Hit(t, e) { - return (t ^ e) >> (32 - e2e) === 0; - } - function Vit(t) { - return !!(t && t.pipe); - } - function Wit(t, e) { - var r = t.message(e); - if (!r) throw new Error(Bu("unknown message: %s", e)); - return r; - } - function Git(t) { - var e = [t.wreq, t.wres], - r = [], - n; - i(0); - function i(a) { - var s = !1; - a < t.fns.length - ? t.fns[a].apply( - t.ctx, - e.concat(function (c, u) { - if (s) { - t.onError(cte("duplicate forward middleware call", c)); - return; - } - if ( - ((s = !0), - c || - (t.wres && - (t.wres.error !== void 0 || t.wres.response !== void 0))) - ) { - (n = c), o(); - return; - } - u && r.push(u), i(++a); - }) - ) - : t.onTransition.apply( - t.ctx, - e.concat(function (c) { - if (s) { - t.onError(cte("duplicate handler call", c)); - return; - } - (s = !0), (n = c), process.nextTick(o); - }) - ); - } - function o() { - var a = r.pop(); - if (a) { - var s = !1; - a.call(t.ctx, n, function (c) { - if (s) { - t.onError(cte("duplicate backward middleware call", c)); - return; - } - (n = c), (s = !0), o(); - }); - } else t.onCompletion.call(t.ctx, n); - } - } - Jit.exports = { - Adapter: dA, - HANDSHAKE_REQUEST_TYPE: aU, - HANDSHAKE_RESPONSE_TYPE: sU, - Message: lx, - Registry: uU, - Service: Hi, - discoverProtocol: w0r, - streams: { - FrameDecoder: ET, - FrameEncoder: cU, - NettyDecoder: nR, - NettyEncoder: lU, - }, - }; - }); - var Xit = I((Eyn, Zit) => { - "use strict"; - m(); - g(); - function a2e() { - return new Error("unsupported in the browser"); - } - function x0r() { - return function (t, e, r) { - r(a2e()); - }; - } - function S0r() { - return function () { - throw a2e(); - }; - } - Zit.exports = { - createImportHook: x0r, - createSyncImportHook: S0r, - existsSync: function () { - return !1; - }, - readFileSync: function () { - throw a2e(); - }, - }; - }); - var eot = I((Myn, Qit) => { - "use strict"; - m(); - g(); - function Wv(t) { - if (typeof t != "string") - throw new TypeError( - "Path must be a string. Received " + JSON.stringify(t) - ); - } - function Yit(t, e) { - for (var r = "", n = 0, i = -1, o = 0, a, s = 0; s <= t.length; ++s) { - if (s < t.length) a = t.charCodeAt(s); - else { - if (a === 47) break; - a = 47; - } - if (a === 47) { - if (!(i === s - 1 || o === 1)) - if (i !== s - 1 && o === 2) { - if ( - r.length < 2 || - n !== 2 || - r.charCodeAt(r.length - 1) !== 46 || - r.charCodeAt(r.length - 2) !== 46 - ) { - if (r.length > 2) { - var c = r.lastIndexOf("/"); - if (c !== r.length - 1) { - c === -1 - ? ((r = ""), (n = 0)) - : ((r = r.slice(0, c)), - (n = r.length - 1 - r.lastIndexOf("/"))), - (i = s), - (o = 0); - continue; - } - } else if (r.length === 2 || r.length === 1) { - (r = ""), (n = 0), (i = s), (o = 0); - continue; - } - } - e && (r.length > 0 ? (r += "/..") : (r = ".."), (n = 2)); - } else - r.length > 0 - ? (r += "/" + t.slice(i + 1, s)) - : (r = t.slice(i + 1, s)), - (n = s - i - 1); - (i = s), (o = 0); - } else a === 46 && o !== -1 ? ++o : (o = -1); - } - return r; - } - function A0r(t, e) { - var r = e.dir || e.root, - n = e.base || (e.name || "") + (e.ext || ""); - return r ? (r === e.root ? r + n : r + t + n) : n; - } - var iR = { - resolve: function () { - for ( - var e = "", r = !1, n, i = arguments.length - 1; - i >= -1 && !r; - i-- - ) { - var o; - i >= 0 - ? (o = arguments[i]) - : (n === void 0 && (n = process.cwd()), (o = n)), - Wv(o), - o.length !== 0 && ((e = o + "/" + e), (r = o.charCodeAt(0) === 47)); - } - return ( - (e = Yit(e, !r)), - r ? (e.length > 0 ? "/" + e : "/") : e.length > 0 ? e : "." - ); - }, - normalize: function (e) { - if ((Wv(e), e.length === 0)) return "."; - var r = e.charCodeAt(0) === 47, - n = e.charCodeAt(e.length - 1) === 47; - return ( - (e = Yit(e, !r)), - e.length === 0 && !r && (e = "."), - e.length > 0 && n && (e += "/"), - r ? "/" + e : e - ); - }, - isAbsolute: function (e) { - return Wv(e), e.length > 0 && e.charCodeAt(0) === 47; - }, - join: function () { - if (arguments.length === 0) return "."; - for (var e, r = 0; r < arguments.length; ++r) { - var n = arguments[r]; - Wv(n), n.length > 0 && (e === void 0 ? (e = n) : (e += "/" + n)); - } - return e === void 0 ? "." : iR.normalize(e); - }, - relative: function (e, r) { - if ( - (Wv(e), - Wv(r), - e === r || ((e = iR.resolve(e)), (r = iR.resolve(r)), e === r)) - ) - return ""; - for (var n = 1; n < e.length && e.charCodeAt(n) === 47; ++n); - for ( - var i = e.length, o = i - n, a = 1; - a < r.length && r.charCodeAt(a) === 47; - ++a - ); - for ( - var s = r.length, c = s - a, u = o < c ? o : c, h = -1, w = 0; - w <= u; - ++w - ) { - if (w === u) { - if (c > u) { - if (r.charCodeAt(a + w) === 47) return r.slice(a + w + 1); - if (w === 0) return r.slice(a + w); - } else - o > u && - (e.charCodeAt(n + w) === 47 ? (h = w) : w === 0 && (h = 0)); - break; - } - var M = e.charCodeAt(n + w), - k = r.charCodeAt(a + w); - if (M !== k) break; - M === 47 && (h = w); - } - var O = ""; - for (w = n + h + 1; w <= i; ++w) - (w === i || e.charCodeAt(w) === 47) && - (O.length === 0 ? (O += "..") : (O += "/..")); - return O.length > 0 - ? O + r.slice(a + h) - : ((a += h), r.charCodeAt(a) === 47 && ++a, r.slice(a)); - }, - _makeLong: function (e) { - return e; - }, - dirname: function (e) { - if ((Wv(e), e.length === 0)) return "."; - for ( - var r = e.charCodeAt(0), - n = r === 47, - i = -1, - o = !0, - a = e.length - 1; - a >= 1; - --a - ) - if (((r = e.charCodeAt(a)), r === 47)) { - if (!o) { - i = a; - break; - } - } else o = !1; - return i === -1 ? (n ? "/" : ".") : n && i === 1 ? "//" : e.slice(0, i); - }, - basename: function (e, r) { - if (r !== void 0 && typeof r != "string") - throw new TypeError('"ext" argument must be a string'); - Wv(e); - var n = 0, - i = -1, - o = !0, - a; - if (r !== void 0 && r.length > 0 && r.length <= e.length) { - if (r.length === e.length && r === e) return ""; - var s = r.length - 1, - c = -1; - for (a = e.length - 1; a >= 0; --a) { - var u = e.charCodeAt(a); - if (u === 47) { - if (!o) { - n = a + 1; - break; - } - } else - c === -1 && ((o = !1), (c = a + 1)), - s >= 0 && - (u === r.charCodeAt(s) - ? --s === -1 && (i = a) - : ((s = -1), (i = c))); - } - return n === i ? (i = c) : i === -1 && (i = e.length), e.slice(n, i); - } else { - for (a = e.length - 1; a >= 0; --a) - if (e.charCodeAt(a) === 47) { - if (!o) { - n = a + 1; - break; - } - } else i === -1 && ((o = !1), (i = a + 1)); - return i === -1 ? "" : e.slice(n, i); - } - }, - extname: function (e) { - Wv(e); - for ( - var r = -1, n = 0, i = -1, o = !0, a = 0, s = e.length - 1; - s >= 0; - --s - ) { - var c = e.charCodeAt(s); - if (c === 47) { - if (!o) { - n = s + 1; - break; - } - continue; - } - i === -1 && ((o = !1), (i = s + 1)), - c === 46 - ? r === -1 - ? (r = s) - : a !== 1 && (a = 1) - : r !== -1 && (a = -1); - } - return r === -1 || - i === -1 || - a === 0 || - (a === 1 && r === i - 1 && r === n + 1) - ? "" - : e.slice(r, i); - }, - format: function (e) { - if (e === null || typeof e != "object") - throw new TypeError( - 'The "pathObject" argument must be of type Object. Received type ' + - typeof e - ); - return A0r("/", e); - }, - parse: function (e) { - Wv(e); - var r = { root: "", dir: "", base: "", ext: "", name: "" }; - if (e.length === 0) return r; - var n = e.charCodeAt(0), - i = n === 47, - o; - i ? ((r.root = "/"), (o = 1)) : (o = 0); - for ( - var a = -1, s = 0, c = -1, u = !0, h = e.length - 1, w = 0; - h >= o; - --h - ) { - if (((n = e.charCodeAt(h)), n === 47)) { - if (!u) { - s = h + 1; - break; - } - continue; - } - c === -1 && ((u = !1), (c = h + 1)), - n === 46 - ? a === -1 - ? (a = h) - : w !== 1 && (w = 1) - : a !== -1 && (w = -1); - } - return ( - a === -1 || - c === -1 || - w === 0 || - (w === 1 && a === c - 1 && a === s + 1) - ? c !== -1 && - (s === 0 && i - ? (r.base = r.name = e.slice(1, c)) - : (r.base = r.name = e.slice(s, c))) - : (s === 0 && i - ? ((r.name = e.slice(1, a)), (r.base = e.slice(1, c))) - : ((r.name = e.slice(s, a)), (r.base = e.slice(s, c))), - (r.ext = e.slice(a, c))), - s > 0 ? (r.dir = e.slice(0, s - 1)) : i && (r.dir = "/"), - r - ); - }, - sep: "/", - delimiter: ":", - win32: null, - posix: null, - }; - iR.posix = iR; - Qit.exports = iR; - }); - var not = I((Tyn, rot) => { - "use strict"; - m(); - g(); - var hte = Xit(), - tot = xT(), - s2e = eot(), - E0r = es(), - oR = E0r.format, - M0r = { - date: { type: "int", logicalType: "date" }, - decimal: { type: "bytes", logicalType: "decimal" }, - time_ms: { type: "long", logicalType: "time-millis" }, - timestamp_ms: { type: "long", logicalType: "timestamp-millis" }, - }; - function u2e(t, e, r) { - !r && typeof e == "function" && ((r = e), (e = void 0)), - (e = e || {}), - e.importHook || (e.importHook = hte.createImportHook()); - var n = [], - i, - o; - e.importHook(t, "idl", function (c, u) { - if (c) { - r(c); - return; - } - if (u === void 0) { - r(null, {}); - return; - } - try { - var h = new qa(u, e), - w = h._readProtocol(u, e); - } catch (M) { - (M.path = t), r(M); - return; - } - (i = w.protocol), (o = w.imports), a(); - }); - function a() { - var c = o.shift(); - if (!c) - n.length && (i.types = i.types ? n.concat(i.types) : n), r(null, i); - else { - var u = s2e.join(s2e.dirname(t), c.name); - c.kind === "idl" - ? u2e(u, e, s) - : e.importHook(u, c.kind, function (h, w) { - if (h) { - r(h); - return; - } - switch (c.kind) { - case "protocol": - case "schema": - if (w === void 0) { - s(null, {}); - return; - } - try { - var M = JSON.parse(w); - } catch (O) { - (O.path = u), r(O); - return; - } - var k = c.kind === "schema" ? { types: [M] } : M; - s(null, k); - break; - default: - r(new Error(oR("invalid import kind: %s", c.kind))); - } - }); - } - } - function s(c, u) { - if (c) { - r(c); - return; - } - (u.types || []).forEach(function (h) { - if (h.namespace === void 0) { - var w = u.namespace; - if (!w) { - var M = /^(.*)\.[^.]+$/.exec(u.protocol); - M && (w = M[1]); - } - h.namespace = w || ""; - } - n.push(h); - }); - try { - Object.keys(u.messages || {}).forEach(function (h) { - if ((i.messages || (i.messages = {}), i.messages[h])) - throw new Error(oR("duplicate message: %s", h)); - i.messages[h] = u.messages[h]; - }); - } catch (h) { - r(h); - return; - } - a(); - } - } - function T0r(t) { - var e; - if (typeof t == "string" && ~t.indexOf(s2e.sep) && hte.existsSync(t)) { - var r = hte.readFileSync(t, { encoding: "utf8" }); - try { - return JSON.parse(r); - } catch { - var n = { importHook: hte.createSyncImportHook() }; - u2e(t, n, function (o, a) { - e = o ? r : a; - }); - } - } else e = t; - if (typeof e != "string" || e === "null") return e; - try { - return JSON.parse(e); - } catch { - try { - return qa.readProtocol(e); - } catch { - try { - return qa.readSchema(e); - } catch { - return e; - } - } - } - } - function qa(t, e) { - (e = e || {}), - (this._tk = new hA(t)), - (this._ackVoidMessages = !!e.ackVoidMessages), - (this._implicitTags = !e.delimitedCollections), - (this._typeRefs = e.typeRefs || M0r); - } - qa.readProtocol = function (t, e) { - var r = new qa(t, e), - n = r._readProtocol(); - if (n.imports.length) throw new Error("unresolvable import"); - return n.protocol; - }; - qa.readSchema = function (t, e) { - var r = new qa(t, e), - n = r._readJavadoc(), - i = r._readType(n === void 0 ? {} : { doc: n }); - return r._tk.next({ id: "(eof)" }), i; - }; - qa.prototype._readProtocol = function () { - var t = this._tk, - e = [], - r = [], - n = {}, - i; - this._readImports(e); - var o = {}, - a = this._readJavadoc(); - for ( - a !== void 0 && (o.doc = a), - this._readAnnotations(o), - t.next({ val: "protocol" }), - t.next({ val: "{", silent: !0 }) || - ((o.protocol = t.next({ id: "name" }).val), t.next({ val: "{" })); - !t.next({ val: "}", silent: !0 }); - - ) - if (!this._readImports(e)) { - var s = this._readJavadoc(), - c = this._readType(), - u = this._readImports(e, !0), - h = void 0; - if (((i = t.pos), !u && (h = this._readMessage(c)))) { - s !== void 0 && h.schema.doc === void 0 && (h.schema.doc = s); - var w = !1; - if ( - ((h.schema.response === "void" || - h.schema.response.type === "void") && - ((w = !this._ackVoidMessages && !h.schema.errors), - h.schema.response === "void" - ? (h.schema.response = "null") - : (h.schema.response.type = "null")), - w && (h.schema["one-way"] = !0), - n[h.name]) - ) - throw new Error(oR("duplicate message: %s", h.name)); - n[h.name] = h.schema; - } else - s && - (typeof c == "string" - ? (c = { doc: s, type: c }) - : c.doc === void 0 && (c.doc = s)), - r.push(c), - (t.pos = i), - t.next({ val: ";", silent: !0 }); - s = void 0; - } - return ( - t.next({ id: "(eof)" }), - r.length && (o.types = r), - Object.keys(n).length && (o.messages = n), - { protocol: o, imports: e } - ); - }; - qa.prototype._readAnnotations = function (t) { - for (var e = this._tk; e.next({ val: "@", silent: !0 }); ) { - for (var r = []; !e.next({ val: "(", silent: !0 }); ) - r.push(e.next().val); - (t[r.join("")] = e.next({ id: "json" }).val), e.next({ val: ")" }); - } - }; - qa.prototype._readMessage = function (t) { - var e = this._tk, - r = { request: [], response: t }; - this._readAnnotations(r); - var n = e.next().val; - if (e.next().val === "(") { - if (!e.next({ val: ")", silent: !0 })) - do r.request.push(this._readField()); - while (!e.next({ val: ")", silent: !0 }) && e.next({ val: "," })); - var i = e.next(); - switch (i.val) { - case "throws": - r.errors = []; - do r.errors.push(this._readType()); - while (!e.next({ val: ";", silent: !0 }) && e.next({ val: "," })); - break; - case "oneway": - (r["one-way"] = !0), e.next({ val: ";" }); - break; - case ";": - break; - default: - throw e.error("invalid message suffix", i); - } - return { name: n, schema: r }; - } - }; - qa.prototype._readJavadoc = function () { - var t = this._tk.next({ id: "javadoc", emitJavadoc: !0, silent: !0 }); - if (t) return t.val; - }; - qa.prototype._readField = function () { - var t = this._tk, - e = this._readJavadoc(), - r = { type: this._readType() }; - return ( - e !== void 0 && r.doc === void 0 && (r.doc = e), - this._readAnnotations(r), - (r.name = t.next({ id: "name" }).val), - t.next({ val: "=", silent: !0 }) && - (r.default = t.next({ id: "json" }).val), - r - ); - }; - qa.prototype._readType = function (t) { - switch ( - ((t = t || {}), - this._readAnnotations(t), - (t.type = this._tk.next({ id: "name" }).val), - t.type) - ) { - case "record": - case "error": - return this._readRecord(t); - case "fixed": - return this._readFixed(t); - case "enum": - return this._readEnum(t); - case "map": - return this._readMap(t); - case "array": - return this._readArray(t); - case "union": - if (Object.keys(t).length > 1) - throw new Error("union annotations are not supported"); - return this._readUnion(); - default: - var e = this._typeRefs[t.type]; - return ( - e && (delete t.type, tot.copyOwnProperties(e, t)), - Object.keys(t).length > 1 ? t : t.type - ); - } - }; - qa.prototype._readFixed = function (t) { - var e = this._tk; - return ( - e.next({ val: "(", silent: !0 }) || - ((t.name = e.next({ id: "name" }).val), e.next({ val: "(" })), - (t.size = parseInt(e.next({ id: "number" }).val)), - e.next({ val: ")" }), - t - ); - }; - qa.prototype._readMap = function (t) { - var e = this._tk, - r = this._implicitTags, - n = e.next({ val: "<", silent: r }) === void 0; - return (t.values = this._readType()), e.next({ val: ">", silent: n }), t; - }; - qa.prototype._readArray = function (t) { - var e = this._tk, - r = this._implicitTags, - n = e.next({ val: "<", silent: r }) === void 0; - return (t.items = this._readType()), e.next({ val: ">", silent: n }), t; - }; - qa.prototype._readEnum = function (t) { - var e = this._tk; - e.next({ val: "{", silent: !0 }) || - ((t.name = e.next({ id: "name" }).val), e.next({ val: "{" })), - (t.symbols = []); - do t.symbols.push(e.next().val); - while (!e.next({ val: "}", silent: !0 }) && e.next({ val: "," })); - return t; - }; - qa.prototype._readUnion = function () { - var t = this._tk, - e = []; - t.next({ val: "{" }); - do e.push(this._readType()); - while (!t.next({ val: "}", silent: !0 }) && t.next({ val: "," })); - return e; - }; - qa.prototype._readRecord = function (t) { - var e = this._tk; - for ( - e.next({ val: "{", silent: !0 }) || - ((t.name = e.next({ id: "name" }).val), e.next({ val: "{" })), - t.fields = []; - !e.next({ val: "}", silent: !0 }); - - ) - t.fields.push(this._readField()), e.next({ val: ";" }); - return t; - }; - qa.prototype._readImports = function (t, e) { - for ( - var r = this._tk, n = 0, i = r.pos; - r.next({ val: "import", silent: !0 }); - - ) { - if (!n && e && r.next({ val: "(", silent: !0 })) { - r.pos = i; - return; - } - var o = r.next({ id: "name" }).val, - a = JSON.parse(r.next({ id: "string" }).val); - r.next({ val: ";" }), t.push({ kind: o, name: a }), n++; - } - return n; - }; - function hA(t) { - (this._str = t), (this.pos = 0); - } - hA.prototype.next = function (t) { - var e = { pos: this.pos, id: void 0, val: void 0 }, - r = this._skip(t && t.emitJavadoc); - if (r) (e.id = "javadoc"), (e.val = r); - else { - var n = this.pos, - i = this._str, - o = i.charAt(n); - if (!o) e.id = "(eof)"; - else if ( - (t && t.id === "json" - ? ((e.id = "json"), (this.pos = this._endOfJson())) - : o === '"' - ? ((e.id = "string"), (this.pos = this._endOfString())) - : /[0-9]/.test(o) - ? ((e.id = "number"), (this.pos = this._endOf(/[0-9]/))) - : /[`A-Za-z_.]/.test(o) - ? ((e.id = "name"), (this.pos = this._endOf(/[`A-Za-z0-9_.]/))) - : ((e.id = "operator"), (this.pos = n + 1)), - (e.val = i.slice(n, this.pos)), - e.id === "json") - ) - try { - e.val = JSON.parse(e.val); - } catch { - throw this.error("invalid JSON", e); - } - else e.id === "name" && (e.val = e.val.replace(/`/g, "")); - } - var a; - if ( - (t && t.id && t.id !== e.id - ? (a = this.error(oR("expected ID %s", t.id), e)) - : t && - t.val && - t.val !== e.val && - (a = this.error(oR("expected value %s", t.val), e)), - a) - ) - if (t && t.silent) { - this.pos = e.pos; - return; - } else throw a; - else return e; - }; - hA.prototype.error = function (t, e) { - var r = typeof e != "number", - n = r ? e.pos : e, - i = this._str, - o = 1, - a = 0, - s; - for (s = 0; s < n; s++) - i.charAt(s) === - ` -` && (o++, (a = s)); - var c = r ? oR("invalid token %j: %s", e, t) : t, - u = new Error(c); - return (u.token = r ? e : void 0), (u.lineNum = o), (u.colNum = n - a), u; - }; - hA.prototype._skip = function (t) { - for ( - var e = this._str, r = !1, n, i; - (i = e.charAt(this.pos)) && /\s/.test(i); - - ) - this.pos++; - if (((n = this.pos), i === "/")) - switch (e.charAt(this.pos + 1)) { - case "/": - for ( - this.pos += 2; - (i = e.charAt(this.pos)) && - i !== - ` -`; - - ) - this.pos++; - return this._skip(t); - case "*": - for ( - this.pos += 2, e.charAt(this.pos) === "*" && (r = !0); - (i = e.charAt(this.pos++)); - - ) - if (i === "*" && e.charAt(this.pos) === "/") - return ( - this.pos++, - r && t ? k0r(e.slice(n + 3, this.pos - 2)) : this._skip(t) - ); - throw this.error("unterminated comment", n); - } - }; - hA.prototype._endOf = function (t) { - for (var e = this.pos, r = this._str; t.test(r.charAt(e)); ) e++; - return e; - }; - hA.prototype._endOfString = function () { - for (var t = this.pos + 1, e = this._str, r; (r = e.charAt(t)); ) { - if (r === '"') return t + 1; - r === "\\" ? (t += 2) : t++; - } - throw this.error("unterminated string", t - 1); - }; - hA.prototype._endOfJson = function () { - var t = tot.jsonEnd(this._str, this.pos); - if (t < 0) throw this.error("invalid JSON", t); - return t; - }; - function k0r(t) { - for ( - var e = t - .replace(/^[ \t]+|[ \t]+$/g, "") - .split( - ` -` - ) - .map(function (r, n) { - return n ? r.replace(/^\s*\*\s?/, "") : r; - }); - !e[0]; - - ) - e.shift(); - for (; !e[e.length - 1]; ) e.pop(); - return e.join(` -`); - } - rot.exports = { - Tokenizer: hA, - assembleProtocol: u2e, - read: T0r, - readProtocol: qa.readProtocol, - readSchema: qa.readSchema, - }; - }); - var oot = I((kyn, l2e) => { - "use strict"; - m(); - g(); - var iot = Dit(), - c2e = $it(), - pte = not(), - P0r = xT(); - function O0r(t, e) { - var r = pte.read(t); - return r.protocol - ? c2e.Service.forProtocol(r, e) - : iot.Type.forSchema(r, e); - } - l2e.exports = { - Service: c2e.Service, - assembleProtocol: pte.assembleProtocol, - discoverProtocol: c2e.discoverProtocol, - parse: O0r, - readProtocol: pte.readProtocol, - readSchema: pte.readSchema, - }; - P0r.copyOwnProperties(iot, l2e.exports); - }); - var sot = I((Pyn, aot) => { - "use strict"; - m(); - g(); - function B0r() { - (this.input = null), - (this.next_in = 0), - (this.avail_in = 0), - (this.total_in = 0), - (this.output = null), - (this.next_out = 0), - (this.avail_out = 0), - (this.total_out = 0), - (this.msg = ""), - (this.state = null), - (this.data_type = 2), - (this.adler = 0); - } - aot.exports = B0r; - }); - var fU = I((Jd) => { - "use strict"; - m(); - g(); - var I0r = - typeof Uint8Array < "u" && - typeof Uint16Array < "u" && - typeof Int32Array < "u"; - function C0r(t, e) { - return Object.prototype.hasOwnProperty.call(t, e); - } - Jd.assign = function (t) { - for (var e = Array.prototype.slice.call(arguments, 1); e.length; ) { - var r = e.shift(); - if (!!r) { - if (typeof r != "object") - throw new TypeError(r + "must be non-object"); - for (var n in r) C0r(r, n) && (t[n] = r[n]); - } - } - return t; - }; - Jd.shrinkBuf = function (t, e) { - return t.length === e - ? t - : t.subarray - ? t.subarray(0, e) - : ((t.length = e), t); - }; - var R0r = { - arraySet: function (t, e, r, n, i) { - if (e.subarray && t.subarray) { - t.set(e.subarray(r, r + n), i); - return; - } - for (var o = 0; o < n; o++) t[i + o] = e[r + o]; - }, - flattenChunks: function (t) { - var e, r, n, i, o, a; - for (n = 0, e = 0, r = t.length; e < r; e++) n += t[e].length; - for (a = new Uint8Array(n), i = 0, e = 0, r = t.length; e < r; e++) - (o = t[e]), a.set(o, i), (i += o.length); - return a; - }, - }, - N0r = { - arraySet: function (t, e, r, n, i) { - for (var o = 0; o < n; o++) t[i + o] = e[r + o]; - }, - flattenChunks: function (t) { - return [].concat.apply([], t); - }, - }; - Jd.setTyped = function (t) { - t - ? ((Jd.Buf8 = Uint8Array), - (Jd.Buf16 = Uint16Array), - (Jd.Buf32 = Int32Array), - Jd.assign(Jd, R0r)) - : ((Jd.Buf8 = Array), - (Jd.Buf16 = Array), - (Jd.Buf32 = Array), - Jd.assign(Jd, N0r)); - }; - Jd.setTyped(I0r); - }); - var Oot = I((uR) => { - "use strict"; - m(); - g(); - var D0r = fU(), - F0r = 4, - uot = 0, - cot = 1, - L0r = 2; - function sR(t) { - for (var e = t.length; --e >= 0; ) t[e] = 0; - } - var q0r = 0, - yot = 1, - z0r = 2, - j0r = 3, - U0r = 258, - g2e = 29, - gU = 256, - hU = gU + 1 + g2e, - aR = 30, - v2e = 19, - mot = 2 * hU + 1, - MT = 15, - f2e = 16, - K0r = 7, - b2e = 256, - got = 16, - vot = 17, - bot = 18, - y2e = [ - 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, - 5, 5, 5, 5, 0, - ], - yte = [ - 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, - 10, 11, 11, 12, 12, 13, 13, - ], - H0r = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7], - wot = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15], - V0r = 512, - fx = new Array((hU + 2) * 2); - sR(fx); - var dU = new Array(aR * 2); - sR(dU); - var pU = new Array(V0r); - sR(pU); - var yU = new Array(U0r - j0r + 1); - sR(yU); - var w2e = new Array(g2e); - sR(w2e); - var mte = new Array(aR); - sR(mte); - function d2e(t, e, r, n, i) { - (this.static_tree = t), - (this.extra_bits = e), - (this.extra_base = r), - (this.elems = n), - (this.max_length = i), - (this.has_stree = t && t.length); - } - var _ot, xot, Sot; - function h2e(t, e) { - (this.dyn_tree = t), (this.max_code = 0), (this.stat_desc = e); - } - function Aot(t) { - return t < 256 ? pU[t] : pU[256 + (t >>> 7)]; - } - function mU(t, e) { - (t.pending_buf[t.pending++] = e & 255), - (t.pending_buf[t.pending++] = (e >>> 8) & 255); - } - function Uh(t, e, r) { - t.bi_valid > f2e - r - ? ((t.bi_buf |= (e << t.bi_valid) & 65535), - mU(t, t.bi_buf), - (t.bi_buf = e >> (f2e - t.bi_valid)), - (t.bi_valid += r - f2e)) - : ((t.bi_buf |= (e << t.bi_valid) & 65535), (t.bi_valid += r)); - } - function Gv(t, e, r) { - Uh(t, r[e * 2], r[e * 2 + 1]); - } - function Eot(t, e) { - var r = 0; - do (r |= t & 1), (t >>>= 1), (r <<= 1); - while (--e > 0); - return r >>> 1; - } - function W0r(t) { - t.bi_valid === 16 - ? (mU(t, t.bi_buf), (t.bi_buf = 0), (t.bi_valid = 0)) - : t.bi_valid >= 8 && - ((t.pending_buf[t.pending++] = t.bi_buf & 255), - (t.bi_buf >>= 8), - (t.bi_valid -= 8)); - } - function G0r(t, e) { - var r = e.dyn_tree, - n = e.max_code, - i = e.stat_desc.static_tree, - o = e.stat_desc.has_stree, - a = e.stat_desc.extra_bits, - s = e.stat_desc.extra_base, - c = e.stat_desc.max_length, - u, - h, - w, - M, - k, - O, - D = 0; - for (M = 0; M <= MT; M++) t.bl_count[M] = 0; - for (r[t.heap[t.heap_max] * 2 + 1] = 0, u = t.heap_max + 1; u < mot; u++) - (h = t.heap[u]), - (M = r[r[h * 2 + 1] * 2 + 1] + 1), - M > c && ((M = c), D++), - (r[h * 2 + 1] = M), - !(h > n) && - (t.bl_count[M]++, - (k = 0), - h >= s && (k = a[h - s]), - (O = r[h * 2]), - (t.opt_len += O * (M + k)), - o && (t.static_len += O * (i[h * 2 + 1] + k))); - if (D !== 0) { - do { - for (M = c - 1; t.bl_count[M] === 0; ) M--; - t.bl_count[M]--, (t.bl_count[M + 1] += 2), t.bl_count[c]--, (D -= 2); - } while (D > 0); - for (M = c; M !== 0; M--) - for (h = t.bl_count[M]; h !== 0; ) - (w = t.heap[--u]), - !(w > n) && - (r[w * 2 + 1] !== M && - ((t.opt_len += (M - r[w * 2 + 1]) * r[w * 2]), - (r[w * 2 + 1] = M)), - h--); - } - } - function Mot(t, e, r) { - var n = new Array(MT + 1), - i = 0, - o, - a; - for (o = 1; o <= MT; o++) n[o] = i = (i + r[o - 1]) << 1; - for (a = 0; a <= e; a++) { - var s = t[a * 2 + 1]; - s !== 0 && (t[a * 2] = Eot(n[s]++, s)); - } - } - function J0r() { - var t, - e, - r, - n, - i, - o = new Array(MT + 1); - for (r = 0, n = 0; n < g2e - 1; n++) - for (w2e[n] = r, t = 0; t < 1 << y2e[n]; t++) yU[r++] = n; - for (yU[r - 1] = n, i = 0, n = 0; n < 16; n++) - for (mte[n] = i, t = 0; t < 1 << yte[n]; t++) pU[i++] = n; - for (i >>= 7; n < aR; n++) - for (mte[n] = i << 7, t = 0; t < 1 << (yte[n] - 7); t++) - pU[256 + i++] = n; - for (e = 0; e <= MT; e++) o[e] = 0; - for (t = 0; t <= 143; ) (fx[t * 2 + 1] = 8), t++, o[8]++; - for (; t <= 255; ) (fx[t * 2 + 1] = 9), t++, o[9]++; - for (; t <= 279; ) (fx[t * 2 + 1] = 7), t++, o[7]++; - for (; t <= 287; ) (fx[t * 2 + 1] = 8), t++, o[8]++; - for (Mot(fx, hU + 1, o), t = 0; t < aR; t++) - (dU[t * 2 + 1] = 5), (dU[t * 2] = Eot(t, 5)); - (_ot = new d2e(fx, y2e, gU + 1, hU, MT)), - (xot = new d2e(dU, yte, 0, aR, MT)), - (Sot = new d2e(new Array(0), H0r, 0, v2e, K0r)); - } - function Tot(t) { - var e; - for (e = 0; e < hU; e++) t.dyn_ltree[e * 2] = 0; - for (e = 0; e < aR; e++) t.dyn_dtree[e * 2] = 0; - for (e = 0; e < v2e; e++) t.bl_tree[e * 2] = 0; - (t.dyn_ltree[b2e * 2] = 1), - (t.opt_len = t.static_len = 0), - (t.last_lit = t.matches = 0); - } - function kot(t) { - t.bi_valid > 8 - ? mU(t, t.bi_buf) - : t.bi_valid > 0 && (t.pending_buf[t.pending++] = t.bi_buf), - (t.bi_buf = 0), - (t.bi_valid = 0); - } - function $0r(t, e, r, n) { - kot(t), - n && (mU(t, r), mU(t, ~r)), - D0r.arraySet(t.pending_buf, t.window, e, r, t.pending), - (t.pending += r); - } - function lot(t, e, r, n) { - var i = e * 2, - o = r * 2; - return t[i] < t[o] || (t[i] === t[o] && n[e] <= n[r]); - } - function p2e(t, e, r) { - for ( - var n = t.heap[r], i = r << 1; - i <= t.heap_len && - (i < t.heap_len && lot(e, t.heap[i + 1], t.heap[i], t.depth) && i++, - !lot(e, n, t.heap[i], t.depth)); - - ) - (t.heap[r] = t.heap[i]), (r = i), (i <<= 1); - t.heap[r] = n; - } - function fot(t, e, r) { - var n, - i, - o = 0, - a, - s; - if (t.last_lit !== 0) - do - (n = - (t.pending_buf[t.d_buf + o * 2] << 8) | - t.pending_buf[t.d_buf + o * 2 + 1]), - (i = t.pending_buf[t.l_buf + o]), - o++, - n === 0 - ? Gv(t, i, e) - : ((a = yU[i]), - Gv(t, a + gU + 1, e), - (s = y2e[a]), - s !== 0 && ((i -= w2e[a]), Uh(t, i, s)), - n--, - (a = Aot(n)), - Gv(t, a, r), - (s = yte[a]), - s !== 0 && ((n -= mte[a]), Uh(t, n, s))); - while (o < t.last_lit); - Gv(t, b2e, e); - } - function m2e(t, e) { - var r = e.dyn_tree, - n = e.stat_desc.static_tree, - i = e.stat_desc.has_stree, - o = e.stat_desc.elems, - a, - s, - c = -1, - u; - for (t.heap_len = 0, t.heap_max = mot, a = 0; a < o; a++) - r[a * 2] !== 0 - ? ((t.heap[++t.heap_len] = c = a), (t.depth[a] = 0)) - : (r[a * 2 + 1] = 0); - for (; t.heap_len < 2; ) - (u = t.heap[++t.heap_len] = c < 2 ? ++c : 0), - (r[u * 2] = 1), - (t.depth[u] = 0), - t.opt_len--, - i && (t.static_len -= n[u * 2 + 1]); - for (e.max_code = c, a = t.heap_len >> 1; a >= 1; a--) p2e(t, r, a); - u = o; - do - (a = t.heap[1]), - (t.heap[1] = t.heap[t.heap_len--]), - p2e(t, r, 1), - (s = t.heap[1]), - (t.heap[--t.heap_max] = a), - (t.heap[--t.heap_max] = s), - (r[u * 2] = r[a * 2] + r[s * 2]), - (t.depth[u] = - (t.depth[a] >= t.depth[s] ? t.depth[a] : t.depth[s]) + 1), - (r[a * 2 + 1] = r[s * 2 + 1] = u), - (t.heap[1] = u++), - p2e(t, r, 1); - while (t.heap_len >= 2); - (t.heap[--t.heap_max] = t.heap[1]), G0r(t, e), Mot(r, c, t.bl_count); - } - function dot(t, e, r) { - var n, - i = -1, - o, - a = e[0 * 2 + 1], - s = 0, - c = 7, - u = 4; - for ( - a === 0 && ((c = 138), (u = 3)), e[(r + 1) * 2 + 1] = 65535, n = 0; - n <= r; - n++ - ) - (o = a), - (a = e[(n + 1) * 2 + 1]), - !(++s < c && o === a) && - (s < u - ? (t.bl_tree[o * 2] += s) - : o !== 0 - ? (o !== i && t.bl_tree[o * 2]++, t.bl_tree[got * 2]++) - : s <= 10 - ? t.bl_tree[vot * 2]++ - : t.bl_tree[bot * 2]++, - (s = 0), - (i = o), - a === 0 - ? ((c = 138), (u = 3)) - : o === a - ? ((c = 6), (u = 3)) - : ((c = 7), (u = 4))); - } - function hot(t, e, r) { - var n, - i = -1, - o, - a = e[0 * 2 + 1], - s = 0, - c = 7, - u = 4; - for (a === 0 && ((c = 138), (u = 3)), n = 0; n <= r; n++) - if (((o = a), (a = e[(n + 1) * 2 + 1]), !(++s < c && o === a))) { - if (s < u) - do Gv(t, o, t.bl_tree); - while (--s !== 0); - else - o !== 0 - ? (o !== i && (Gv(t, o, t.bl_tree), s--), - Gv(t, got, t.bl_tree), - Uh(t, s - 3, 2)) - : s <= 10 - ? (Gv(t, vot, t.bl_tree), Uh(t, s - 3, 3)) - : (Gv(t, bot, t.bl_tree), Uh(t, s - 11, 7)); - (s = 0), - (i = o), - a === 0 - ? ((c = 138), (u = 3)) - : o === a - ? ((c = 6), (u = 3)) - : ((c = 7), (u = 4)); - } - } - function Z0r(t) { - var e; - for ( - dot(t, t.dyn_ltree, t.l_desc.max_code), - dot(t, t.dyn_dtree, t.d_desc.max_code), - m2e(t, t.bl_desc), - e = v2e - 1; - e >= 3 && t.bl_tree[wot[e] * 2 + 1] === 0; - e-- - ); - return (t.opt_len += 3 * (e + 1) + 5 + 5 + 4), e; - } - function X0r(t, e, r, n) { - var i; - for ( - Uh(t, e - 257, 5), Uh(t, r - 1, 5), Uh(t, n - 4, 4), i = 0; - i < n; - i++ - ) - Uh(t, t.bl_tree[wot[i] * 2 + 1], 3); - hot(t, t.dyn_ltree, e - 1), hot(t, t.dyn_dtree, r - 1); - } - function Y0r(t) { - var e = 4093624447, - r; - for (r = 0; r <= 31; r++, e >>>= 1) - if (e & 1 && t.dyn_ltree[r * 2] !== 0) return uot; - if ( - t.dyn_ltree[9 * 2] !== 0 || - t.dyn_ltree[10 * 2] !== 0 || - t.dyn_ltree[13 * 2] !== 0 - ) - return cot; - for (r = 32; r < gU; r++) if (t.dyn_ltree[r * 2] !== 0) return cot; - return uot; - } - var pot = !1; - function Q0r(t) { - pot || (J0r(), (pot = !0)), - (t.l_desc = new h2e(t.dyn_ltree, _ot)), - (t.d_desc = new h2e(t.dyn_dtree, xot)), - (t.bl_desc = new h2e(t.bl_tree, Sot)), - (t.bi_buf = 0), - (t.bi_valid = 0), - Tot(t); - } - function Pot(t, e, r, n) { - Uh(t, (q0r << 1) + (n ? 1 : 0), 3), $0r(t, e, r, !0); - } - function eyr(t) { - Uh(t, yot << 1, 3), Gv(t, b2e, fx), W0r(t); - } - function tyr(t, e, r, n) { - var i, - o, - a = 0; - t.level > 0 - ? (t.strm.data_type === L0r && (t.strm.data_type = Y0r(t)), - m2e(t, t.l_desc), - m2e(t, t.d_desc), - (a = Z0r(t)), - (i = (t.opt_len + 3 + 7) >>> 3), - (o = (t.static_len + 3 + 7) >>> 3), - o <= i && (i = o)) - : (i = o = r + 5), - r + 4 <= i && e !== -1 - ? Pot(t, e, r, n) - : t.strategy === F0r || o === i - ? (Uh(t, (yot << 1) + (n ? 1 : 0), 3), fot(t, fx, dU)) - : (Uh(t, (z0r << 1) + (n ? 1 : 0), 3), - X0r(t, t.l_desc.max_code + 1, t.d_desc.max_code + 1, a + 1), - fot(t, t.dyn_ltree, t.dyn_dtree)), - Tot(t), - n && kot(t); - } - function ryr(t, e, r) { - return ( - (t.pending_buf[t.d_buf + t.last_lit * 2] = (e >>> 8) & 255), - (t.pending_buf[t.d_buf + t.last_lit * 2 + 1] = e & 255), - (t.pending_buf[t.l_buf + t.last_lit] = r & 255), - t.last_lit++, - e === 0 - ? t.dyn_ltree[r * 2]++ - : (t.matches++, - e--, - t.dyn_ltree[(yU[r] + gU + 1) * 2]++, - t.dyn_dtree[Aot(e) * 2]++), - t.last_lit === t.lit_bufsize - 1 - ); - } - uR._tr_init = Q0r; - uR._tr_stored_block = Pot; - uR._tr_flush_block = tyr; - uR._tr_tally = ryr; - uR._tr_align = eyr; - }); - var _2e = I((Iyn, Bot) => { - "use strict"; - m(); - g(); - function nyr(t, e, r, n) { - for ( - var i = (t & 65535) | 0, o = ((t >>> 16) & 65535) | 0, a = 0; - r !== 0; - - ) { - (a = r > 2e3 ? 2e3 : r), (r -= a); - do (i = (i + e[n++]) | 0), (o = (o + i) | 0); - while (--a); - (i %= 65521), (o %= 65521); - } - return i | (o << 16) | 0; - } - Bot.exports = nyr; - }); - var x2e = I((Cyn, Iot) => { - "use strict"; - m(); - g(); - function iyr() { - for (var t, e = [], r = 0; r < 256; r++) { - t = r; - for (var n = 0; n < 8; n++) - t = t & 1 ? 3988292384 ^ (t >>> 1) : t >>> 1; - e[r] = t; - } - return e; - } - var oyr = iyr(); - function ayr(t, e, r, n) { - var i = oyr, - o = n + r; - t ^= -1; - for (var a = n; a < o; a++) t = (t >>> 8) ^ i[(t ^ e[a]) & 255]; - return t ^ -1; - } - Iot.exports = ayr; - }); - var Rot = I((Ryn, Cot) => { - "use strict"; - m(); - g(); - Cot.exports = { - 2: "need dictionary", - 1: "stream end", - 0: "", - "-1": "file error", - "-2": "stream error", - "-3": "data error", - "-4": "insufficient memory", - "-5": "buffer error", - "-6": "incompatible version", - }; - }); - var Kot = I((Zv) => { - "use strict"; - m(); - g(); - var $d = fU(), - My = Oot(), - Lot = _2e(), - pA = x2e(), - syr = Rot(), - OT = 0, - uyr = 1, - cyr = 3, - bA = 4, - Not = 5, - $v = 0, - Dot = 1, - Ty = -2, - lyr = -3, - S2e = -5, - fyr = -1, - dyr = 1, - gte = 2, - hyr = 3, - pyr = 4, - yyr = 0, - myr = 2, - _te = 8, - gyr = 9, - vyr = 15, - byr = 8, - wyr = 29, - _yr = 256, - E2e = _yr + 1 + wyr, - xyr = 30, - Syr = 19, - Ayr = 2 * E2e + 1, - Eyr = 15, - li = 3, - gA = 258, - ag = gA + li + 1, - Myr = 32, - xte = 42, - M2e = 69, - vte = 73, - bte = 91, - wte = 103, - TT = 113, - bU = 666, - eu = 1, - wU = 2, - kT = 3, - fR = 4, - Tyr = 3; - function vA(t, e) { - return (t.msg = syr[e]), e; - } - function Fot(t) { - return (t << 1) - (t > 4 ? 9 : 0); - } - function mA(t) { - for (var e = t.length; --e >= 0; ) t[e] = 0; - } - function yA(t) { - var e = t.state, - r = e.pending; - r > t.avail_out && (r = t.avail_out), - r !== 0 && - ($d.arraySet(t.output, e.pending_buf, e.pending_out, r, t.next_out), - (t.next_out += r), - (e.pending_out += r), - (t.total_out += r), - (t.avail_out -= r), - (e.pending -= r), - e.pending === 0 && (e.pending_out = 0)); - } - function cc(t, e) { - My._tr_flush_block( - t, - t.block_start >= 0 ? t.block_start : -1, - t.strstart - t.block_start, - e - ), - (t.block_start = t.strstart), - yA(t.strm); - } - function Ri(t, e) { - t.pending_buf[t.pending++] = e; - } - function vU(t, e) { - (t.pending_buf[t.pending++] = (e >>> 8) & 255), - (t.pending_buf[t.pending++] = e & 255); - } - function kyr(t, e, r, n) { - var i = t.avail_in; - return ( - i > n && (i = n), - i === 0 - ? 0 - : ((t.avail_in -= i), - $d.arraySet(e, t.input, t.next_in, i, r), - t.state.wrap === 1 - ? (t.adler = Lot(t.adler, e, i, r)) - : t.state.wrap === 2 && (t.adler = pA(t.adler, e, i, r)), - (t.next_in += i), - (t.total_in += i), - i) - ); - } - function qot(t, e) { - var r = t.max_chain_length, - n = t.strstart, - i, - o, - a = t.prev_length, - s = t.nice_match, - c = t.strstart > t.w_size - ag ? t.strstart - (t.w_size - ag) : 0, - u = t.window, - h = t.w_mask, - w = t.prev, - M = t.strstart + gA, - k = u[n + a - 1], - O = u[n + a]; - t.prev_length >= t.good_match && (r >>= 2), - s > t.lookahead && (s = t.lookahead); - do - if ( - ((i = e), - !( - u[i + a] !== O || - u[i + a - 1] !== k || - u[i] !== u[n] || - u[++i] !== u[n + 1] - )) - ) { - (n += 2), i++; - do; - while ( - u[++n] === u[++i] && - u[++n] === u[++i] && - u[++n] === u[++i] && - u[++n] === u[++i] && - u[++n] === u[++i] && - u[++n] === u[++i] && - u[++n] === u[++i] && - u[++n] === u[++i] && - n < M - ); - if (((o = gA - (M - n)), (n = M - gA), o > a)) { - if (((t.match_start = e), (a = o), o >= s)) break; - (k = u[n + a - 1]), (O = u[n + a]); - } - } - while ((e = w[e & h]) > c && --r !== 0); - return a <= t.lookahead ? a : t.lookahead; - } - function PT(t) { - var e = t.w_size, - r, - n, - i, - o, - a; - do { - if ( - ((o = t.window_size - t.lookahead - t.strstart), - t.strstart >= e + (e - ag)) - ) { - $d.arraySet(t.window, t.window, e, e, 0), - (t.match_start -= e), - (t.strstart -= e), - (t.block_start -= e), - (n = t.hash_size), - (r = n); - do (i = t.head[--r]), (t.head[r] = i >= e ? i - e : 0); - while (--n); - (n = e), (r = n); - do (i = t.prev[--r]), (t.prev[r] = i >= e ? i - e : 0); - while (--n); - o += e; - } - if (t.strm.avail_in === 0) break; - if ( - ((n = kyr(t.strm, t.window, t.strstart + t.lookahead, o)), - (t.lookahead += n), - t.lookahead + t.insert >= li) - ) - for ( - a = t.strstart - t.insert, - t.ins_h = t.window[a], - t.ins_h = - ((t.ins_h << t.hash_shift) ^ t.window[a + 1]) & t.hash_mask; - t.insert && - ((t.ins_h = - ((t.ins_h << t.hash_shift) ^ t.window[a + li - 1]) & t.hash_mask), - (t.prev[a & t.w_mask] = t.head[t.ins_h]), - (t.head[t.ins_h] = a), - a++, - t.insert--, - !(t.lookahead + t.insert < li)); - - ); - } while (t.lookahead < ag && t.strm.avail_in !== 0); - } - function Pyr(t, e) { - var r = 65535; - for (r > t.pending_buf_size - 5 && (r = t.pending_buf_size - 5); ; ) { - if (t.lookahead <= 1) { - if ((PT(t), t.lookahead === 0 && e === OT)) return eu; - if (t.lookahead === 0) break; - } - (t.strstart += t.lookahead), (t.lookahead = 0); - var n = t.block_start + r; - if ( - ((t.strstart === 0 || t.strstart >= n) && - ((t.lookahead = t.strstart - n), - (t.strstart = n), - cc(t, !1), - t.strm.avail_out === 0)) || - (t.strstart - t.block_start >= t.w_size - ag && - (cc(t, !1), t.strm.avail_out === 0)) - ) - return eu; - } - return ( - (t.insert = 0), - e === bA - ? (cc(t, !0), t.strm.avail_out === 0 ? kT : fR) - : (t.strstart > t.block_start && (cc(t, !1), t.strm.avail_out === 0), - eu) - ); - } - function A2e(t, e) { - for (var r, n; ; ) { - if (t.lookahead < ag) { - if ((PT(t), t.lookahead < ag && e === OT)) return eu; - if (t.lookahead === 0) break; - } - if ( - ((r = 0), - t.lookahead >= li && - ((t.ins_h = - ((t.ins_h << t.hash_shift) ^ t.window[t.strstart + li - 1]) & - t.hash_mask), - (r = t.prev[t.strstart & t.w_mask] = t.head[t.ins_h]), - (t.head[t.ins_h] = t.strstart)), - r !== 0 && - t.strstart - r <= t.w_size - ag && - (t.match_length = qot(t, r)), - t.match_length >= li) - ) - if ( - ((n = My._tr_tally( - t, - t.strstart - t.match_start, - t.match_length - li - )), - (t.lookahead -= t.match_length), - t.match_length <= t.max_lazy_match && t.lookahead >= li) - ) { - t.match_length--; - do - t.strstart++, - (t.ins_h = - ((t.ins_h << t.hash_shift) ^ t.window[t.strstart + li - 1]) & - t.hash_mask), - (r = t.prev[t.strstart & t.w_mask] = t.head[t.ins_h]), - (t.head[t.ins_h] = t.strstart); - while (--t.match_length !== 0); - t.strstart++; - } else - (t.strstart += t.match_length), - (t.match_length = 0), - (t.ins_h = t.window[t.strstart]), - (t.ins_h = - ((t.ins_h << t.hash_shift) ^ t.window[t.strstart + 1]) & - t.hash_mask); - else - (n = My._tr_tally(t, 0, t.window[t.strstart])), - t.lookahead--, - t.strstart++; - if (n && (cc(t, !1), t.strm.avail_out === 0)) return eu; - } - return ( - (t.insert = t.strstart < li - 1 ? t.strstart : li - 1), - e === bA - ? (cc(t, !0), t.strm.avail_out === 0 ? kT : fR) - : t.last_lit && (cc(t, !1), t.strm.avail_out === 0) - ? eu - : wU - ); - } - function cR(t, e) { - for (var r, n, i; ; ) { - if (t.lookahead < ag) { - if ((PT(t), t.lookahead < ag && e === OT)) return eu; - if (t.lookahead === 0) break; - } - if ( - ((r = 0), - t.lookahead >= li && - ((t.ins_h = - ((t.ins_h << t.hash_shift) ^ t.window[t.strstart + li - 1]) & - t.hash_mask), - (r = t.prev[t.strstart & t.w_mask] = t.head[t.ins_h]), - (t.head[t.ins_h] = t.strstart)), - (t.prev_length = t.match_length), - (t.prev_match = t.match_start), - (t.match_length = li - 1), - r !== 0 && - t.prev_length < t.max_lazy_match && - t.strstart - r <= t.w_size - ag && - ((t.match_length = qot(t, r)), - t.match_length <= 5 && - (t.strategy === dyr || - (t.match_length === li && t.strstart - t.match_start > 4096)) && - (t.match_length = li - 1)), - t.prev_length >= li && t.match_length <= t.prev_length) - ) { - (i = t.strstart + t.lookahead - li), - (n = My._tr_tally( - t, - t.strstart - 1 - t.prev_match, - t.prev_length - li - )), - (t.lookahead -= t.prev_length - 1), - (t.prev_length -= 2); - do - ++t.strstart <= i && - ((t.ins_h = - ((t.ins_h << t.hash_shift) ^ t.window[t.strstart + li - 1]) & - t.hash_mask), - (r = t.prev[t.strstart & t.w_mask] = t.head[t.ins_h]), - (t.head[t.ins_h] = t.strstart)); - while (--t.prev_length !== 0); - if ( - ((t.match_available = 0), - (t.match_length = li - 1), - t.strstart++, - n && (cc(t, !1), t.strm.avail_out === 0)) - ) - return eu; - } else if (t.match_available) { - if ( - ((n = My._tr_tally(t, 0, t.window[t.strstart - 1])), - n && cc(t, !1), - t.strstart++, - t.lookahead--, - t.strm.avail_out === 0) - ) - return eu; - } else (t.match_available = 1), t.strstart++, t.lookahead--; - } - return ( - t.match_available && - ((n = My._tr_tally(t, 0, t.window[t.strstart - 1])), - (t.match_available = 0)), - (t.insert = t.strstart < li - 1 ? t.strstart : li - 1), - e === bA - ? (cc(t, !0), t.strm.avail_out === 0 ? kT : fR) - : t.last_lit && (cc(t, !1), t.strm.avail_out === 0) - ? eu - : wU - ); - } - function Oyr(t, e) { - for (var r, n, i, o, a = t.window; ; ) { - if (t.lookahead <= gA) { - if ((PT(t), t.lookahead <= gA && e === OT)) return eu; - if (t.lookahead === 0) break; - } - if ( - ((t.match_length = 0), - t.lookahead >= li && - t.strstart > 0 && - ((i = t.strstart - 1), - (n = a[i]), - n === a[++i] && n === a[++i] && n === a[++i])) - ) { - o = t.strstart + gA; - do; - while ( - n === a[++i] && - n === a[++i] && - n === a[++i] && - n === a[++i] && - n === a[++i] && - n === a[++i] && - n === a[++i] && - n === a[++i] && - i < o - ); - (t.match_length = gA - (o - i)), - t.match_length > t.lookahead && (t.match_length = t.lookahead); - } - if ( - (t.match_length >= li - ? ((r = My._tr_tally(t, 1, t.match_length - li)), - (t.lookahead -= t.match_length), - (t.strstart += t.match_length), - (t.match_length = 0)) - : ((r = My._tr_tally(t, 0, t.window[t.strstart])), - t.lookahead--, - t.strstart++), - r && (cc(t, !1), t.strm.avail_out === 0)) - ) - return eu; - } - return ( - (t.insert = 0), - e === bA - ? (cc(t, !0), t.strm.avail_out === 0 ? kT : fR) - : t.last_lit && (cc(t, !1), t.strm.avail_out === 0) - ? eu - : wU - ); - } - function Byr(t, e) { - for (var r; ; ) { - if (t.lookahead === 0 && (PT(t), t.lookahead === 0)) { - if (e === OT) return eu; - break; - } - if ( - ((t.match_length = 0), - (r = My._tr_tally(t, 0, t.window[t.strstart])), - t.lookahead--, - t.strstart++, - r && (cc(t, !1), t.strm.avail_out === 0)) - ) - return eu; - } - return ( - (t.insert = 0), - e === bA - ? (cc(t, !0), t.strm.avail_out === 0 ? kT : fR) - : t.last_lit && (cc(t, !1), t.strm.avail_out === 0) - ? eu - : wU - ); - } - function Jv(t, e, r, n, i) { - (this.good_length = t), - (this.max_lazy = e), - (this.nice_length = r), - (this.max_chain = n), - (this.func = i); - } - var lR; - lR = [ - new Jv(0, 0, 0, 0, Pyr), - new Jv(4, 4, 8, 4, A2e), - new Jv(4, 5, 16, 8, A2e), - new Jv(4, 6, 32, 32, A2e), - new Jv(4, 4, 16, 16, cR), - new Jv(8, 16, 32, 32, cR), - new Jv(8, 16, 128, 128, cR), - new Jv(8, 32, 128, 256, cR), - new Jv(32, 128, 258, 1024, cR), - new Jv(32, 258, 258, 4096, cR), - ]; - function Iyr(t) { - (t.window_size = 2 * t.w_size), - mA(t.head), - (t.max_lazy_match = lR[t.level].max_lazy), - (t.good_match = lR[t.level].good_length), - (t.nice_match = lR[t.level].nice_length), - (t.max_chain_length = lR[t.level].max_chain), - (t.strstart = 0), - (t.block_start = 0), - (t.lookahead = 0), - (t.insert = 0), - (t.match_length = t.prev_length = li - 1), - (t.match_available = 0), - (t.ins_h = 0); - } - function Cyr() { - (this.strm = null), - (this.status = 0), - (this.pending_buf = null), - (this.pending_buf_size = 0), - (this.pending_out = 0), - (this.pending = 0), - (this.wrap = 0), - (this.gzhead = null), - (this.gzindex = 0), - (this.method = _te), - (this.last_flush = -1), - (this.w_size = 0), - (this.w_bits = 0), - (this.w_mask = 0), - (this.window = null), - (this.window_size = 0), - (this.prev = null), - (this.head = null), - (this.ins_h = 0), - (this.hash_size = 0), - (this.hash_bits = 0), - (this.hash_mask = 0), - (this.hash_shift = 0), - (this.block_start = 0), - (this.match_length = 0), - (this.prev_match = 0), - (this.match_available = 0), - (this.strstart = 0), - (this.match_start = 0), - (this.lookahead = 0), - (this.prev_length = 0), - (this.max_chain_length = 0), - (this.max_lazy_match = 0), - (this.level = 0), - (this.strategy = 0), - (this.good_match = 0), - (this.nice_match = 0), - (this.dyn_ltree = new $d.Buf16(Ayr * 2)), - (this.dyn_dtree = new $d.Buf16((2 * xyr + 1) * 2)), - (this.bl_tree = new $d.Buf16((2 * Syr + 1) * 2)), - mA(this.dyn_ltree), - mA(this.dyn_dtree), - mA(this.bl_tree), - (this.l_desc = null), - (this.d_desc = null), - (this.bl_desc = null), - (this.bl_count = new $d.Buf16(Eyr + 1)), - (this.heap = new $d.Buf16(2 * E2e + 1)), - mA(this.heap), - (this.heap_len = 0), - (this.heap_max = 0), - (this.depth = new $d.Buf16(2 * E2e + 1)), - mA(this.depth), - (this.l_buf = 0), - (this.lit_bufsize = 0), - (this.last_lit = 0), - (this.d_buf = 0), - (this.opt_len = 0), - (this.static_len = 0), - (this.matches = 0), - (this.insert = 0), - (this.bi_buf = 0), - (this.bi_valid = 0); - } - function zot(t) { - var e; - return !t || !t.state - ? vA(t, Ty) - : ((t.total_in = t.total_out = 0), - (t.data_type = myr), - (e = t.state), - (e.pending = 0), - (e.pending_out = 0), - e.wrap < 0 && (e.wrap = -e.wrap), - (e.status = e.wrap ? xte : TT), - (t.adler = e.wrap === 2 ? 0 : 1), - (e.last_flush = OT), - My._tr_init(e), - $v); - } - function jot(t) { - var e = zot(t); - return e === $v && Iyr(t.state), e; - } - function Ryr(t, e) { - return !t || !t.state || t.state.wrap !== 2 - ? Ty - : ((t.state.gzhead = e), $v); - } - function Uot(t, e, r, n, i, o) { - if (!t) return Ty; - var a = 1; - if ( - (e === fyr && (e = 6), - n < 0 ? ((a = 0), (n = -n)) : n > 15 && ((a = 2), (n -= 16)), - i < 1 || - i > gyr || - r !== _te || - n < 8 || - n > 15 || - e < 0 || - e > 9 || - o < 0 || - o > pyr) - ) - return vA(t, Ty); - n === 8 && (n = 9); - var s = new Cyr(); - return ( - (t.state = s), - (s.strm = t), - (s.wrap = a), - (s.gzhead = null), - (s.w_bits = n), - (s.w_size = 1 << s.w_bits), - (s.w_mask = s.w_size - 1), - (s.hash_bits = i + 7), - (s.hash_size = 1 << s.hash_bits), - (s.hash_mask = s.hash_size - 1), - (s.hash_shift = ~~((s.hash_bits + li - 1) / li)), - (s.window = new $d.Buf8(s.w_size * 2)), - (s.head = new $d.Buf16(s.hash_size)), - (s.prev = new $d.Buf16(s.w_size)), - (s.lit_bufsize = 1 << (i + 6)), - (s.pending_buf_size = s.lit_bufsize * 4), - (s.pending_buf = new $d.Buf8(s.pending_buf_size)), - (s.d_buf = 1 * s.lit_bufsize), - (s.l_buf = (1 + 2) * s.lit_bufsize), - (s.level = e), - (s.strategy = o), - (s.method = r), - jot(t) - ); - } - function Nyr(t, e) { - return Uot(t, e, _te, vyr, byr, yyr); - } - function Dyr(t, e) { - var r, n, i, o; - if (!t || !t.state || e > Not || e < 0) return t ? vA(t, Ty) : Ty; - if ( - ((n = t.state), - !t.output || - (!t.input && t.avail_in !== 0) || - (n.status === bU && e !== bA)) - ) - return vA(t, t.avail_out === 0 ? S2e : Ty); - if ( - ((n.strm = t), (r = n.last_flush), (n.last_flush = e), n.status === xte) - ) - if (n.wrap === 2) - (t.adler = 0), - Ri(n, 31), - Ri(n, 139), - Ri(n, 8), - n.gzhead - ? (Ri( - n, - (n.gzhead.text ? 1 : 0) + - (n.gzhead.hcrc ? 2 : 0) + - (n.gzhead.extra ? 4 : 0) + - (n.gzhead.name ? 8 : 0) + - (n.gzhead.comment ? 16 : 0) - ), - Ri(n, n.gzhead.time & 255), - Ri(n, (n.gzhead.time >> 8) & 255), - Ri(n, (n.gzhead.time >> 16) & 255), - Ri(n, (n.gzhead.time >> 24) & 255), - Ri( - n, - n.level === 9 ? 2 : n.strategy >= gte || n.level < 2 ? 4 : 0 - ), - Ri(n, n.gzhead.os & 255), - n.gzhead.extra && - n.gzhead.extra.length && - (Ri(n, n.gzhead.extra.length & 255), - Ri(n, (n.gzhead.extra.length >> 8) & 255)), - n.gzhead.hcrc && - (t.adler = pA(t.adler, n.pending_buf, n.pending, 0)), - (n.gzindex = 0), - (n.status = M2e)) - : (Ri(n, 0), - Ri(n, 0), - Ri(n, 0), - Ri(n, 0), - Ri(n, 0), - Ri( - n, - n.level === 9 ? 2 : n.strategy >= gte || n.level < 2 ? 4 : 0 - ), - Ri(n, Tyr), - (n.status = TT)); - else { - var a = (_te + ((n.w_bits - 8) << 4)) << 8, - s = -1; - n.strategy >= gte || n.level < 2 - ? (s = 0) - : n.level < 6 - ? (s = 1) - : n.level === 6 - ? (s = 2) - : (s = 3), - (a |= s << 6), - n.strstart !== 0 && (a |= Myr), - (a += 31 - (a % 31)), - (n.status = TT), - vU(n, a), - n.strstart !== 0 && (vU(n, t.adler >>> 16), vU(n, t.adler & 65535)), - (t.adler = 1); - } - if (n.status === M2e) - if (n.gzhead.extra) { - for ( - i = n.pending; - n.gzindex < (n.gzhead.extra.length & 65535) && - !( - n.pending === n.pending_buf_size && - (n.gzhead.hcrc && - n.pending > i && - (t.adler = pA(t.adler, n.pending_buf, n.pending - i, i)), - yA(t), - (i = n.pending), - n.pending === n.pending_buf_size) - ); - - ) - Ri(n, n.gzhead.extra[n.gzindex] & 255), n.gzindex++; - n.gzhead.hcrc && - n.pending > i && - (t.adler = pA(t.adler, n.pending_buf, n.pending - i, i)), - n.gzindex === n.gzhead.extra.length && - ((n.gzindex = 0), (n.status = vte)); - } else n.status = vte; - if (n.status === vte) - if (n.gzhead.name) { - i = n.pending; - do { - if ( - n.pending === n.pending_buf_size && - (n.gzhead.hcrc && - n.pending > i && - (t.adler = pA(t.adler, n.pending_buf, n.pending - i, i)), - yA(t), - (i = n.pending), - n.pending === n.pending_buf_size) - ) { - o = 1; - break; - } - n.gzindex < n.gzhead.name.length - ? (o = n.gzhead.name.charCodeAt(n.gzindex++) & 255) - : (o = 0), - Ri(n, o); - } while (o !== 0); - n.gzhead.hcrc && - n.pending > i && - (t.adler = pA(t.adler, n.pending_buf, n.pending - i, i)), - o === 0 && ((n.gzindex = 0), (n.status = bte)); - } else n.status = bte; - if (n.status === bte) - if (n.gzhead.comment) { - i = n.pending; - do { - if ( - n.pending === n.pending_buf_size && - (n.gzhead.hcrc && - n.pending > i && - (t.adler = pA(t.adler, n.pending_buf, n.pending - i, i)), - yA(t), - (i = n.pending), - n.pending === n.pending_buf_size) - ) { - o = 1; - break; - } - n.gzindex < n.gzhead.comment.length - ? (o = n.gzhead.comment.charCodeAt(n.gzindex++) & 255) - : (o = 0), - Ri(n, o); - } while (o !== 0); - n.gzhead.hcrc && - n.pending > i && - (t.adler = pA(t.adler, n.pending_buf, n.pending - i, i)), - o === 0 && (n.status = wte); - } else n.status = wte; - if ( - (n.status === wte && - (n.gzhead.hcrc - ? (n.pending + 2 > n.pending_buf_size && yA(t), - n.pending + 2 <= n.pending_buf_size && - (Ri(n, t.adler & 255), - Ri(n, (t.adler >> 8) & 255), - (t.adler = 0), - (n.status = TT))) - : (n.status = TT)), - n.pending !== 0) - ) { - if ((yA(t), t.avail_out === 0)) return (n.last_flush = -1), $v; - } else if (t.avail_in === 0 && Fot(e) <= Fot(r) && e !== bA) - return vA(t, S2e); - if (n.status === bU && t.avail_in !== 0) return vA(t, S2e); - if ( - t.avail_in !== 0 || - n.lookahead !== 0 || - (e !== OT && n.status !== bU) - ) { - var c = - n.strategy === gte - ? Byr(n, e) - : n.strategy === hyr - ? Oyr(n, e) - : lR[n.level].func(n, e); - if (((c === kT || c === fR) && (n.status = bU), c === eu || c === kT)) - return t.avail_out === 0 && (n.last_flush = -1), $v; - if ( - c === wU && - (e === uyr - ? My._tr_align(n) - : e !== Not && - (My._tr_stored_block(n, 0, 0, !1), - e === cyr && - (mA(n.head), - n.lookahead === 0 && - ((n.strstart = 0), (n.block_start = 0), (n.insert = 0)))), - yA(t), - t.avail_out === 0) - ) - return (n.last_flush = -1), $v; - } - return e !== bA - ? $v - : n.wrap <= 0 - ? Dot - : (n.wrap === 2 - ? (Ri(n, t.adler & 255), - Ri(n, (t.adler >> 8) & 255), - Ri(n, (t.adler >> 16) & 255), - Ri(n, (t.adler >> 24) & 255), - Ri(n, t.total_in & 255), - Ri(n, (t.total_in >> 8) & 255), - Ri(n, (t.total_in >> 16) & 255), - Ri(n, (t.total_in >> 24) & 255)) - : (vU(n, t.adler >>> 16), vU(n, t.adler & 65535)), - yA(t), - n.wrap > 0 && (n.wrap = -n.wrap), - n.pending !== 0 ? $v : Dot); - } - function Fyr(t) { - var e; - return !t || !t.state - ? Ty - : ((e = t.state.status), - e !== xte && - e !== M2e && - e !== vte && - e !== bte && - e !== wte && - e !== TT && - e !== bU - ? vA(t, Ty) - : ((t.state = null), e === TT ? vA(t, lyr) : $v)); - } - function Lyr(t, e) { - var r = e.length, - n, - i, - o, - a, - s, - c, - u, - h; - if ( - !t || - !t.state || - ((n = t.state), - (a = n.wrap), - a === 2 || (a === 1 && n.status !== xte) || n.lookahead) - ) - return Ty; - for ( - a === 1 && (t.adler = Lot(t.adler, e, r, 0)), - n.wrap = 0, - r >= n.w_size && - (a === 0 && - (mA(n.head), - (n.strstart = 0), - (n.block_start = 0), - (n.insert = 0)), - (h = new $d.Buf8(n.w_size)), - $d.arraySet(h, e, r - n.w_size, n.w_size, 0), - (e = h), - (r = n.w_size)), - s = t.avail_in, - c = t.next_in, - u = t.input, - t.avail_in = r, - t.next_in = 0, - t.input = e, - PT(n); - n.lookahead >= li; - - ) { - (i = n.strstart), (o = n.lookahead - (li - 1)); - do - (n.ins_h = - ((n.ins_h << n.hash_shift) ^ n.window[i + li - 1]) & n.hash_mask), - (n.prev[i & n.w_mask] = n.head[n.ins_h]), - (n.head[n.ins_h] = i), - i++; - while (--o); - (n.strstart = i), (n.lookahead = li - 1), PT(n); - } - return ( - (n.strstart += n.lookahead), - (n.block_start = n.strstart), - (n.insert = n.lookahead), - (n.lookahead = 0), - (n.match_length = n.prev_length = li - 1), - (n.match_available = 0), - (t.next_in = c), - (t.input = u), - (t.avail_in = s), - (n.wrap = a), - $v - ); - } - Zv.deflateInit = Nyr; - Zv.deflateInit2 = Uot; - Zv.deflateReset = jot; - Zv.deflateResetKeep = zot; - Zv.deflateSetHeader = Ryr; - Zv.deflate = Dyr; - Zv.deflateEnd = Fyr; - Zv.deflateSetDictionary = Lyr; - Zv.deflateInfo = "pako deflate (from Nodeca project)"; - }); - var Vot = I((Dyn, Hot) => { - "use strict"; - m(); - g(); - var Ste = 30, - qyr = 12; - Hot.exports = function (e, r) { - var n, - i, - o, - a, - s, - c, - u, - h, - w, - M, - k, - O, - D, - F, - N, - q, - z, - H, - Z, - $, - ue, - te, - ne, - A, - l; - (n = e.state), - (i = e.next_in), - (A = e.input), - (o = i + (e.avail_in - 5)), - (a = e.next_out), - (l = e.output), - (s = a - (r - e.avail_out)), - (c = a + (e.avail_out - 257)), - (u = n.dmax), - (h = n.wsize), - (w = n.whave), - (M = n.wnext), - (k = n.window), - (O = n.hold), - (D = n.bits), - (F = n.lencode), - (N = n.distcode), - (q = (1 << n.lenbits) - 1), - (z = (1 << n.distbits) - 1); - e: do { - D < 15 && ((O += A[i++] << D), (D += 8), (O += A[i++] << D), (D += 8)), - (H = F[O & q]); - t: for (;;) { - if ( - ((Z = H >>> 24), - (O >>>= Z), - (D -= Z), - (Z = (H >>> 16) & 255), - Z === 0) - ) - l[a++] = H & 65535; - else if (Z & 16) { - ($ = H & 65535), - (Z &= 15), - Z && - (D < Z && ((O += A[i++] << D), (D += 8)), - ($ += O & ((1 << Z) - 1)), - (O >>>= Z), - (D -= Z)), - D < 15 && - ((O += A[i++] << D), (D += 8), (O += A[i++] << D), (D += 8)), - (H = N[O & z]); - r: for (;;) { - if ( - ((Z = H >>> 24), - (O >>>= Z), - (D -= Z), - (Z = (H >>> 16) & 255), - Z & 16) - ) { - if ( - ((ue = H & 65535), - (Z &= 15), - D < Z && - ((O += A[i++] << D), - (D += 8), - D < Z && ((O += A[i++] << D), (D += 8))), - (ue += O & ((1 << Z) - 1)), - ue > u) - ) { - (e.msg = "invalid distance too far back"), (n.mode = Ste); - break e; - } - if (((O >>>= Z), (D -= Z), (Z = a - s), ue > Z)) { - if (((Z = ue - Z), Z > w && n.sane)) { - (e.msg = "invalid distance too far back"), (n.mode = Ste); - break e; - } - if (((te = 0), (ne = k), M === 0)) { - if (((te += h - Z), Z < $)) { - $ -= Z; - do l[a++] = k[te++]; - while (--Z); - (te = a - ue), (ne = l); - } - } else if (M < Z) { - if (((te += h + M - Z), (Z -= M), Z < $)) { - $ -= Z; - do l[a++] = k[te++]; - while (--Z); - if (((te = 0), M < $)) { - (Z = M), ($ -= Z); - do l[a++] = k[te++]; - while (--Z); - (te = a - ue), (ne = l); - } - } - } else if (((te += M - Z), Z < $)) { - $ -= Z; - do l[a++] = k[te++]; - while (--Z); - (te = a - ue), (ne = l); - } - for (; $ > 2; ) - (l[a++] = ne[te++]), - (l[a++] = ne[te++]), - (l[a++] = ne[te++]), - ($ -= 3); - $ && ((l[a++] = ne[te++]), $ > 1 && (l[a++] = ne[te++])); - } else { - te = a - ue; - do - (l[a++] = l[te++]), - (l[a++] = l[te++]), - (l[a++] = l[te++]), - ($ -= 3); - while ($ > 2); - $ && ((l[a++] = l[te++]), $ > 1 && (l[a++] = l[te++])); - } - } else if ((Z & 64) === 0) { - H = N[(H & 65535) + (O & ((1 << Z) - 1))]; - continue r; - } else { - (e.msg = "invalid distance code"), (n.mode = Ste); - break e; - } - break; - } - } else if ((Z & 64) === 0) { - H = F[(H & 65535) + (O & ((1 << Z) - 1))]; - continue t; - } else if (Z & 32) { - n.mode = qyr; - break e; - } else { - (e.msg = "invalid literal/length code"), (n.mode = Ste); - break e; - } - break; - } - } while (i < o && a < c); - ($ = D >> 3), - (i -= $), - (D -= $ << 3), - (O &= (1 << D) - 1), - (e.next_in = i), - (e.next_out = a), - (e.avail_in = i < o ? 5 + (o - i) : 5 - (i - o)), - (e.avail_out = a < c ? 257 + (c - a) : 257 - (a - c)), - (n.hold = O), - (n.bits = D); - }; - }); - var Yot = I((Fyn, Xot) => { - "use strict"; - m(); - g(); - var Wot = fU(), - dR = 15, - Got = 852, - Jot = 592, - $ot = 0, - T2e = 1, - Zot = 2, - zyr = [ - 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, - 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0, - ], - jyr = [ - 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, - 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78, - ], - Uyr = [ - 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, - 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, - 0, 0, - ], - Kyr = [ - 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, - 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 64, 64, - ]; - Xot.exports = function (e, r, n, i, o, a, s, c) { - var u = c.bits, - h = 0, - w = 0, - M = 0, - k = 0, - O = 0, - D = 0, - F = 0, - N = 0, - q = 0, - z = 0, - H, - Z, - $, - ue, - te, - ne = null, - A = 0, - l, - p = new Wot.Buf16(dR + 1), - y = new Wot.Buf16(dR + 1), - d = null, - v = 0, - _, - S, - b; - for (h = 0; h <= dR; h++) p[h] = 0; - for (w = 0; w < i; w++) p[r[n + w]]++; - for (O = u, k = dR; k >= 1 && p[k] === 0; k--); - if ((O > k && (O = k), k === 0)) - return ( - (o[a++] = (1 << 24) | (64 << 16) | 0), - (o[a++] = (1 << 24) | (64 << 16) | 0), - (c.bits = 1), - 0 - ); - for (M = 1; M < k && p[M] === 0; M++); - for (O < M && (O = M), N = 1, h = 1; h <= dR; h++) - if (((N <<= 1), (N -= p[h]), N < 0)) return -1; - if (N > 0 && (e === $ot || k !== 1)) return -1; - for (y[1] = 0, h = 1; h < dR; h++) y[h + 1] = y[h] + p[h]; - for (w = 0; w < i; w++) r[n + w] !== 0 && (s[y[r[n + w]]++] = w); - if ( - (e === $ot - ? ((ne = d = s), (l = 19)) - : e === T2e - ? ((ne = zyr), (A -= 257), (d = jyr), (v -= 257), (l = 256)) - : ((ne = Uyr), (d = Kyr), (l = -1)), - (z = 0), - (w = 0), - (h = M), - (te = a), - (D = O), - (F = 0), - ($ = -1), - (q = 1 << O), - (ue = q - 1), - (e === T2e && q > Got) || (e === Zot && q > Jot)) - ) - return 1; - for (;;) { - (_ = h - F), - s[w] < l - ? ((S = 0), (b = s[w])) - : s[w] > l - ? ((S = d[v + s[w]]), (b = ne[A + s[w]])) - : ((S = 32 + 64), (b = 0)), - (H = 1 << (h - F)), - (Z = 1 << D), - (M = Z); - do (Z -= H), (o[te + (z >> F) + Z] = (_ << 24) | (S << 16) | b | 0); - while (Z !== 0); - for (H = 1 << (h - 1); z & H; ) H >>= 1; - if ((H !== 0 ? ((z &= H - 1), (z += H)) : (z = 0), w++, --p[h] === 0)) { - if (h === k) break; - h = r[n + s[w]]; - } - if (h > O && (z & ue) !== $) { - for ( - F === 0 && (F = O), te += M, D = h - F, N = 1 << D; - D + F < k && ((N -= p[D + F]), !(N <= 0)); - - ) - D++, (N <<= 1); - if (((q += 1 << D), (e === T2e && q > Got) || (e === Zot && q > Jot))) - return 1; - ($ = z & ue), (o[$] = (O << 24) | (D << 16) | (te - a) | 0); - } - } - return ( - z !== 0 && (o[te + z] = ((h - F) << 24) | (64 << 16) | 0), - (c.bits = O), - 0 - ); - }; - }); - var Cat = I((sg) => { - "use strict"; - m(); - g(); - var Xp = fU(), - C2e = _2e(), - Xv = x2e(), - Hyr = Vot(), - _U = Yot(), - Vyr = 0, - Aat = 1, - Eat = 2, - Qot = 4, - Wyr = 5, - Ate = 6, - BT = 0, - Gyr = 1, - Jyr = 2, - ky = -2, - Mat = -3, - R2e = -4, - $yr = -5, - eat = 8, - Tat = 1, - tat = 2, - rat = 3, - nat = 4, - iat = 5, - oat = 6, - aat = 7, - sat = 8, - uat = 9, - cat = 10, - Tte = 11, - dx = 12, - k2e = 13, - lat = 14, - P2e = 15, - fat = 16, - dat = 17, - hat = 18, - pat = 19, - Ete = 20, - Mte = 21, - yat = 22, - mat = 23, - gat = 24, - vat = 25, - bat = 26, - O2e = 27, - wat = 28, - _at = 29, - sa = 30, - N2e = 31, - Zyr = 32, - Xyr = 852, - Yyr = 592, - Qyr = 15, - emr = Qyr; - function xat(t) { - return ( - ((t >>> 24) & 255) + - ((t >>> 8) & 65280) + - ((t & 65280) << 8) + - ((t & 255) << 24) - ); - } - function tmr() { - (this.mode = 0), - (this.last = !1), - (this.wrap = 0), - (this.havedict = !1), - (this.flags = 0), - (this.dmax = 0), - (this.check = 0), - (this.total = 0), - (this.head = null), - (this.wbits = 0), - (this.wsize = 0), - (this.whave = 0), - (this.wnext = 0), - (this.window = null), - (this.hold = 0), - (this.bits = 0), - (this.length = 0), - (this.offset = 0), - (this.extra = 0), - (this.lencode = null), - (this.distcode = null), - (this.lenbits = 0), - (this.distbits = 0), - (this.ncode = 0), - (this.nlen = 0), - (this.ndist = 0), - (this.have = 0), - (this.next = null), - (this.lens = new Xp.Buf16(320)), - (this.work = new Xp.Buf16(288)), - (this.lendyn = null), - (this.distdyn = null), - (this.sane = 0), - (this.back = 0), - (this.was = 0); - } - function kat(t) { - var e; - return !t || !t.state - ? ky - : ((e = t.state), - (t.total_in = t.total_out = e.total = 0), - (t.msg = ""), - e.wrap && (t.adler = e.wrap & 1), - (e.mode = Tat), - (e.last = 0), - (e.havedict = 0), - (e.dmax = 32768), - (e.head = null), - (e.hold = 0), - (e.bits = 0), - (e.lencode = e.lendyn = new Xp.Buf32(Xyr)), - (e.distcode = e.distdyn = new Xp.Buf32(Yyr)), - (e.sane = 1), - (e.back = -1), - BT); - } - function Pat(t) { - var e; - return !t || !t.state - ? ky - : ((e = t.state), (e.wsize = 0), (e.whave = 0), (e.wnext = 0), kat(t)); - } - function Oat(t, e) { - var r, n; - return !t || - !t.state || - ((n = t.state), - e < 0 ? ((r = 0), (e = -e)) : ((r = (e >> 4) + 1), e < 48 && (e &= 15)), - e && (e < 8 || e > 15)) - ? ky - : (n.window !== null && n.wbits !== e && (n.window = null), - (n.wrap = r), - (n.wbits = e), - Pat(t)); - } - function Bat(t, e) { - var r, n; - return t - ? ((n = new tmr()), - (t.state = n), - (n.window = null), - (r = Oat(t, e)), - r !== BT && (t.state = null), - r) - : ky; - } - function rmr(t) { - return Bat(t, emr); - } - var Sat = !0, - B2e, - I2e; - function nmr(t) { - if (Sat) { - var e; - for (B2e = new Xp.Buf32(512), I2e = new Xp.Buf32(32), e = 0; e < 144; ) - t.lens[e++] = 8; - for (; e < 256; ) t.lens[e++] = 9; - for (; e < 280; ) t.lens[e++] = 7; - for (; e < 288; ) t.lens[e++] = 8; - for ( - _U(Aat, t.lens, 0, 288, B2e, 0, t.work, { bits: 9 }), e = 0; - e < 32; - - ) - t.lens[e++] = 5; - _U(Eat, t.lens, 0, 32, I2e, 0, t.work, { bits: 5 }), (Sat = !1); - } - (t.lencode = B2e), (t.lenbits = 9), (t.distcode = I2e), (t.distbits = 5); - } - function Iat(t, e, r, n) { - var i, - o = t.state; - return ( - o.window === null && - ((o.wsize = 1 << o.wbits), - (o.wnext = 0), - (o.whave = 0), - (o.window = new Xp.Buf8(o.wsize))), - n >= o.wsize - ? (Xp.arraySet(o.window, e, r - o.wsize, o.wsize, 0), - (o.wnext = 0), - (o.whave = o.wsize)) - : ((i = o.wsize - o.wnext), - i > n && (i = n), - Xp.arraySet(o.window, e, r - n, i, o.wnext), - (n -= i), - n - ? (Xp.arraySet(o.window, e, r - n, n, 0), - (o.wnext = n), - (o.whave = o.wsize)) - : ((o.wnext += i), - o.wnext === o.wsize && (o.wnext = 0), - o.whave < o.wsize && (o.whave += i))), - 0 - ); - } - function imr(t, e) { - var r, - n, - i, - o, - a, - s, - c, - u, - h, - w, - M, - k, - O, - D, - F = 0, - N, - q, - z, - H, - Z, - $, - ue, - te, - ne = new Xp.Buf8(4), - A, - l, - p = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]; - if (!t || !t.state || !t.output || (!t.input && t.avail_in !== 0)) - return ky; - (r = t.state), - r.mode === dx && (r.mode = k2e), - (a = t.next_out), - (i = t.output), - (c = t.avail_out), - (o = t.next_in), - (n = t.input), - (s = t.avail_in), - (u = r.hold), - (h = r.bits), - (w = s), - (M = c), - (te = BT); - e: for (;;) - switch (r.mode) { - case Tat: - if (r.wrap === 0) { - r.mode = k2e; - break; - } - for (; h < 16; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - if (r.wrap & 2 && u === 35615) { - (r.check = 0), - (ne[0] = u & 255), - (ne[1] = (u >>> 8) & 255), - (r.check = Xv(r.check, ne, 2, 0)), - (u = 0), - (h = 0), - (r.mode = tat); - break; - } - if ( - ((r.flags = 0), - r.head && (r.head.done = !1), - !(r.wrap & 1) || (((u & 255) << 8) + (u >> 8)) % 31) - ) { - (t.msg = "incorrect header check"), (r.mode = sa); - break; - } - if ((u & 15) !== eat) { - (t.msg = "unknown compression method"), (r.mode = sa); - break; - } - if (((u >>>= 4), (h -= 4), (ue = (u & 15) + 8), r.wbits === 0)) - r.wbits = ue; - else if (ue > r.wbits) { - (t.msg = "invalid window size"), (r.mode = sa); - break; - } - (r.dmax = 1 << ue), - (t.adler = r.check = 1), - (r.mode = u & 512 ? cat : dx), - (u = 0), - (h = 0); - break; - case tat: - for (; h < 16; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - if (((r.flags = u), (r.flags & 255) !== eat)) { - (t.msg = "unknown compression method"), (r.mode = sa); - break; - } - if (r.flags & 57344) { - (t.msg = "unknown header flags set"), (r.mode = sa); - break; - } - r.head && (r.head.text = (u >> 8) & 1), - r.flags & 512 && - ((ne[0] = u & 255), - (ne[1] = (u >>> 8) & 255), - (r.check = Xv(r.check, ne, 2, 0))), - (u = 0), - (h = 0), - (r.mode = rat); - case rat: - for (; h < 32; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - r.head && (r.head.time = u), - r.flags & 512 && - ((ne[0] = u & 255), - (ne[1] = (u >>> 8) & 255), - (ne[2] = (u >>> 16) & 255), - (ne[3] = (u >>> 24) & 255), - (r.check = Xv(r.check, ne, 4, 0))), - (u = 0), - (h = 0), - (r.mode = nat); - case nat: - for (; h < 16; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - r.head && ((r.head.xflags = u & 255), (r.head.os = u >> 8)), - r.flags & 512 && - ((ne[0] = u & 255), - (ne[1] = (u >>> 8) & 255), - (r.check = Xv(r.check, ne, 2, 0))), - (u = 0), - (h = 0), - (r.mode = iat); - case iat: - if (r.flags & 1024) { - for (; h < 16; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - (r.length = u), - r.head && (r.head.extra_len = u), - r.flags & 512 && - ((ne[0] = u & 255), - (ne[1] = (u >>> 8) & 255), - (r.check = Xv(r.check, ne, 2, 0))), - (u = 0), - (h = 0); - } else r.head && (r.head.extra = null); - r.mode = oat; - case oat: - if ( - r.flags & 1024 && - ((k = r.length), - k > s && (k = s), - k && - (r.head && - ((ue = r.head.extra_len - r.length), - r.head.extra || (r.head.extra = new Array(r.head.extra_len)), - Xp.arraySet(r.head.extra, n, o, k, ue)), - r.flags & 512 && (r.check = Xv(r.check, n, k, o)), - (s -= k), - (o += k), - (r.length -= k)), - r.length) - ) - break e; - (r.length = 0), (r.mode = aat); - case aat: - if (r.flags & 2048) { - if (s === 0) break e; - k = 0; - do - (ue = n[o + k++]), - r.head && - ue && - r.length < 65536 && - (r.head.name += String.fromCharCode(ue)); - while (ue && k < s); - if ( - (r.flags & 512 && (r.check = Xv(r.check, n, k, o)), - (s -= k), - (o += k), - ue) - ) - break e; - } else r.head && (r.head.name = null); - (r.length = 0), (r.mode = sat); - case sat: - if (r.flags & 4096) { - if (s === 0) break e; - k = 0; - do - (ue = n[o + k++]), - r.head && - ue && - r.length < 65536 && - (r.head.comment += String.fromCharCode(ue)); - while (ue && k < s); - if ( - (r.flags & 512 && (r.check = Xv(r.check, n, k, o)), - (s -= k), - (o += k), - ue) - ) - break e; - } else r.head && (r.head.comment = null); - r.mode = uat; - case uat: - if (r.flags & 512) { - for (; h < 16; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - if (u !== (r.check & 65535)) { - (t.msg = "header crc mismatch"), (r.mode = sa); - break; - } - (u = 0), (h = 0); - } - r.head && ((r.head.hcrc = (r.flags >> 9) & 1), (r.head.done = !0)), - (t.adler = r.check = 0), - (r.mode = dx); - break; - case cat: - for (; h < 32; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - (t.adler = r.check = xat(u)), (u = 0), (h = 0), (r.mode = Tte); - case Tte: - if (r.havedict === 0) - return ( - (t.next_out = a), - (t.avail_out = c), - (t.next_in = o), - (t.avail_in = s), - (r.hold = u), - (r.bits = h), - Jyr - ); - (t.adler = r.check = 1), (r.mode = dx); - case dx: - if (e === Wyr || e === Ate) break e; - case k2e: - if (r.last) { - (u >>>= h & 7), (h -= h & 7), (r.mode = O2e); - break; - } - for (; h < 3; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - switch (((r.last = u & 1), (u >>>= 1), (h -= 1), u & 3)) { - case 0: - r.mode = lat; - break; - case 1: - if ((nmr(r), (r.mode = Ete), e === Ate)) { - (u >>>= 2), (h -= 2); - break e; - } - break; - case 2: - r.mode = dat; - break; - case 3: - (t.msg = "invalid block type"), (r.mode = sa); - } - (u >>>= 2), (h -= 2); - break; - case lat: - for (u >>>= h & 7, h -= h & 7; h < 32; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - if ((u & 65535) !== ((u >>> 16) ^ 65535)) { - (t.msg = "invalid stored block lengths"), (r.mode = sa); - break; - } - if ( - ((r.length = u & 65535), - (u = 0), - (h = 0), - (r.mode = P2e), - e === Ate) - ) - break e; - case P2e: - r.mode = fat; - case fat: - if (((k = r.length), k)) { - if ((k > s && (k = s), k > c && (k = c), k === 0)) break e; - Xp.arraySet(i, n, o, k, a), - (s -= k), - (o += k), - (c -= k), - (a += k), - (r.length -= k); - break; - } - r.mode = dx; - break; - case dat: - for (; h < 14; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - if ( - ((r.nlen = (u & 31) + 257), - (u >>>= 5), - (h -= 5), - (r.ndist = (u & 31) + 1), - (u >>>= 5), - (h -= 5), - (r.ncode = (u & 15) + 4), - (u >>>= 4), - (h -= 4), - r.nlen > 286 || r.ndist > 30) - ) { - (t.msg = "too many length or distance symbols"), (r.mode = sa); - break; - } - (r.have = 0), (r.mode = hat); - case hat: - for (; r.have < r.ncode; ) { - for (; h < 3; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - (r.lens[p[r.have++]] = u & 7), (u >>>= 3), (h -= 3); - } - for (; r.have < 19; ) r.lens[p[r.have++]] = 0; - if ( - ((r.lencode = r.lendyn), - (r.lenbits = 7), - (A = { bits: r.lenbits }), - (te = _U(Vyr, r.lens, 0, 19, r.lencode, 0, r.work, A)), - (r.lenbits = A.bits), - te) - ) { - (t.msg = "invalid code lengths set"), (r.mode = sa); - break; - } - (r.have = 0), (r.mode = pat); - case pat: - for (; r.have < r.nlen + r.ndist; ) { - for ( - ; - (F = r.lencode[u & ((1 << r.lenbits) - 1)]), - (N = F >>> 24), - (q = (F >>> 16) & 255), - (z = F & 65535), - !(N <= h); - - ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - if (z < 16) (u >>>= N), (h -= N), (r.lens[r.have++] = z); - else { - if (z === 16) { - for (l = N + 2; h < l; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - if (((u >>>= N), (h -= N), r.have === 0)) { - (t.msg = "invalid bit length repeat"), (r.mode = sa); - break; - } - (ue = r.lens[r.have - 1]), - (k = 3 + (u & 3)), - (u >>>= 2), - (h -= 2); - } else if (z === 17) { - for (l = N + 3; h < l; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - (u >>>= N), - (h -= N), - (ue = 0), - (k = 3 + (u & 7)), - (u >>>= 3), - (h -= 3); - } else { - for (l = N + 7; h < l; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - (u >>>= N), - (h -= N), - (ue = 0), - (k = 11 + (u & 127)), - (u >>>= 7), - (h -= 7); - } - if (r.have + k > r.nlen + r.ndist) { - (t.msg = "invalid bit length repeat"), (r.mode = sa); - break; - } - for (; k--; ) r.lens[r.have++] = ue; - } - } - if (r.mode === sa) break; - if (r.lens[256] === 0) { - (t.msg = "invalid code -- missing end-of-block"), (r.mode = sa); - break; - } - if ( - ((r.lenbits = 9), - (A = { bits: r.lenbits }), - (te = _U(Aat, r.lens, 0, r.nlen, r.lencode, 0, r.work, A)), - (r.lenbits = A.bits), - te) - ) { - (t.msg = "invalid literal/lengths set"), (r.mode = sa); - break; - } - if ( - ((r.distbits = 6), - (r.distcode = r.distdyn), - (A = { bits: r.distbits }), - (te = _U(Eat, r.lens, r.nlen, r.ndist, r.distcode, 0, r.work, A)), - (r.distbits = A.bits), - te) - ) { - (t.msg = "invalid distances set"), (r.mode = sa); - break; - } - if (((r.mode = Ete), e === Ate)) break e; - case Ete: - r.mode = Mte; - case Mte: - if (s >= 6 && c >= 258) { - (t.next_out = a), - (t.avail_out = c), - (t.next_in = o), - (t.avail_in = s), - (r.hold = u), - (r.bits = h), - Hyr(t, M), - (a = t.next_out), - (i = t.output), - (c = t.avail_out), - (o = t.next_in), - (n = t.input), - (s = t.avail_in), - (u = r.hold), - (h = r.bits), - r.mode === dx && (r.back = -1); - break; - } - for ( - r.back = 0; - (F = r.lencode[u & ((1 << r.lenbits) - 1)]), - (N = F >>> 24), - (q = (F >>> 16) & 255), - (z = F & 65535), - !(N <= h); - - ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - if (q && (q & 240) === 0) { - for ( - H = N, Z = q, $ = z; - (F = r.lencode[$ + ((u & ((1 << (H + Z)) - 1)) >> H)]), - (N = F >>> 24), - (q = (F >>> 16) & 255), - (z = F & 65535), - !(H + N <= h); - - ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - (u >>>= H), (h -= H), (r.back += H); - } - if ( - ((u >>>= N), (h -= N), (r.back += N), (r.length = z), q === 0) - ) { - r.mode = bat; - break; - } - if (q & 32) { - (r.back = -1), (r.mode = dx); - break; - } - if (q & 64) { - (t.msg = "invalid literal/length code"), (r.mode = sa); - break; - } - (r.extra = q & 15), (r.mode = yat); - case yat: - if (r.extra) { - for (l = r.extra; h < l; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - (r.length += u & ((1 << r.extra) - 1)), - (u >>>= r.extra), - (h -= r.extra), - (r.back += r.extra); - } - (r.was = r.length), (r.mode = mat); - case mat: - for ( - ; - (F = r.distcode[u & ((1 << r.distbits) - 1)]), - (N = F >>> 24), - (q = (F >>> 16) & 255), - (z = F & 65535), - !(N <= h); - - ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - if ((q & 240) === 0) { - for ( - H = N, Z = q, $ = z; - (F = r.distcode[$ + ((u & ((1 << (H + Z)) - 1)) >> H)]), - (N = F >>> 24), - (q = (F >>> 16) & 255), - (z = F & 65535), - !(H + N <= h); - - ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - (u >>>= H), (h -= H), (r.back += H); - } - if (((u >>>= N), (h -= N), (r.back += N), q & 64)) { - (t.msg = "invalid distance code"), (r.mode = sa); - break; - } - (r.offset = z), (r.extra = q & 15), (r.mode = gat); - case gat: - if (r.extra) { - for (l = r.extra; h < l; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - (r.offset += u & ((1 << r.extra) - 1)), - (u >>>= r.extra), - (h -= r.extra), - (r.back += r.extra); - } - if (r.offset > r.dmax) { - (t.msg = "invalid distance too far back"), (r.mode = sa); - break; - } - r.mode = vat; - case vat: - if (c === 0) break e; - if (((k = M - c), r.offset > k)) { - if (((k = r.offset - k), k > r.whave && r.sane)) { - (t.msg = "invalid distance too far back"), (r.mode = sa); - break; - } - k > r.wnext - ? ((k -= r.wnext), (O = r.wsize - k)) - : (O = r.wnext - k), - k > r.length && (k = r.length), - (D = r.window); - } else (D = i), (O = a - r.offset), (k = r.length); - k > c && (k = c), (c -= k), (r.length -= k); - do i[a++] = D[O++]; - while (--k); - r.length === 0 && (r.mode = Mte); - break; - case bat: - if (c === 0) break e; - (i[a++] = r.length), c--, (r.mode = Mte); - break; - case O2e: - if (r.wrap) { - for (; h < 32; ) { - if (s === 0) break e; - s--, (u |= n[o++] << h), (h += 8); - } - if ( - ((M -= c), - (t.total_out += M), - (r.total += M), - M && - (t.adler = r.check = - r.flags - ? Xv(r.check, i, M, a - M) - : C2e(r.check, i, M, a - M)), - (M = c), - (r.flags ? u : xat(u)) !== r.check) - ) { - (t.msg = "incorrect data check"), (r.mode = sa); - break; - } - (u = 0), (h = 0); - } - r.mode = wat; - case wat: - if (r.wrap && r.flags) { - for (; h < 32; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - if (u !== (r.total & 4294967295)) { - (t.msg = "incorrect length check"), (r.mode = sa); - break; - } - (u = 0), (h = 0); - } - r.mode = _at; - case _at: - te = Gyr; - break e; - case sa: - te = Mat; - break e; - case N2e: - return R2e; - case Zyr: - default: - return ky; - } - return ( - (t.next_out = a), - (t.avail_out = c), - (t.next_in = o), - (t.avail_in = s), - (r.hold = u), - (r.bits = h), - (r.wsize || - (M !== t.avail_out && r.mode < sa && (r.mode < O2e || e !== Qot))) && - Iat(t, t.output, t.next_out, M - t.avail_out) - ? ((r.mode = N2e), R2e) - : ((w -= t.avail_in), - (M -= t.avail_out), - (t.total_in += w), - (t.total_out += M), - (r.total += M), - r.wrap && - M && - (t.adler = r.check = - r.flags - ? Xv(r.check, i, M, t.next_out - M) - : C2e(r.check, i, M, t.next_out - M)), - (t.data_type = - r.bits + - (r.last ? 64 : 0) + - (r.mode === dx ? 128 : 0) + - (r.mode === Ete || r.mode === P2e ? 256 : 0)), - ((w === 0 && M === 0) || e === Qot) && te === BT && (te = $yr), - te) - ); - } - function omr(t) { - if (!t || !t.state) return ky; - var e = t.state; - return e.window && (e.window = null), (t.state = null), BT; - } - function amr(t, e) { - var r; - return !t || !t.state || ((r = t.state), (r.wrap & 2) === 0) - ? ky - : ((r.head = e), (e.done = !1), BT); - } - function smr(t, e) { - var r = e.length, - n, - i, - o; - return !t || !t.state || ((n = t.state), n.wrap !== 0 && n.mode !== Tte) - ? ky - : n.mode === Tte && ((i = 1), (i = C2e(i, e, r, 0)), i !== n.check) - ? Mat - : ((o = Iat(t, e, r, r)), - o ? ((n.mode = N2e), R2e) : ((n.havedict = 1), BT)); - } - sg.inflateReset = Pat; - sg.inflateReset2 = Oat; - sg.inflateResetKeep = kat; - sg.inflateInit = rmr; - sg.inflateInit2 = Bat; - sg.inflate = imr; - sg.inflateEnd = omr; - sg.inflateGetHeader = amr; - sg.inflateSetDictionary = smr; - sg.inflateInfo = "pako inflate (from Nodeca project)"; - }); - var Nat = I((qyn, Rat) => { - "use strict"; - m(); - g(); - Rat.exports = { - Z_NO_FLUSH: 0, - Z_PARTIAL_FLUSH: 1, - Z_SYNC_FLUSH: 2, - Z_FULL_FLUSH: 3, - Z_FINISH: 4, - Z_BLOCK: 5, - Z_TREES: 6, - Z_OK: 0, - Z_STREAM_END: 1, - Z_NEED_DICT: 2, - Z_ERRNO: -1, - Z_STREAM_ERROR: -2, - Z_DATA_ERROR: -3, - Z_BUF_ERROR: -5, - Z_NO_COMPRESSION: 0, - Z_BEST_SPEED: 1, - Z_BEST_COMPRESSION: 9, - Z_DEFAULT_COMPRESSION: -1, - Z_FILTERED: 1, - Z_HUFFMAN_ONLY: 2, - Z_RLE: 3, - Z_FIXED: 4, - Z_DEFAULT_STRATEGY: 0, - Z_BINARY: 0, - Z_TEXT: 1, - Z_UNKNOWN: 2, - Z_DEFLATED: 8, - }; - }); - var Fat = I((Zt) => { - "use strict"; - m(); - g(); - var Yp = Dr(), - umr = sot(), - xU = Kot(), - IT = Cat(), - Dat = Nat(); - for (D2e in Dat) Zt[D2e] = Dat[D2e]; - var D2e; - Zt.NONE = 0; - Zt.DEFLATE = 1; - Zt.INFLATE = 2; - Zt.GZIP = 3; - Zt.GUNZIP = 4; - Zt.DEFLATERAW = 5; - Zt.INFLATERAW = 6; - Zt.UNZIP = 7; - var cmr = 31, - lmr = 139; - function $c(t) { - if (typeof t != "number" || t < Zt.DEFLATE || t > Zt.UNZIP) - throw new TypeError("Bad argument"); - (this.dictionary = null), - (this.err = 0), - (this.flush = 0), - (this.init_done = !1), - (this.level = 0), - (this.memLevel = 0), - (this.mode = t), - (this.strategy = 0), - (this.windowBits = 0), - (this.write_in_progress = !1), - (this.pending_close = !1), - (this.gzip_id_bytes_read = 0); - } - $c.prototype.close = function () { - if (this.write_in_progress) { - this.pending_close = !0; - return; - } - (this.pending_close = !1), - Yp(this.init_done, "close before init"), - Yp(this.mode <= Zt.UNZIP), - this.mode === Zt.DEFLATE || - this.mode === Zt.GZIP || - this.mode === Zt.DEFLATERAW - ? xU.deflateEnd(this.strm) - : (this.mode === Zt.INFLATE || - this.mode === Zt.GUNZIP || - this.mode === Zt.INFLATERAW || - this.mode === Zt.UNZIP) && - IT.inflateEnd(this.strm), - (this.mode = Zt.NONE), - (this.dictionary = null); - }; - $c.prototype.write = function (t, e, r, n, i, o, a) { - return this._write(!0, t, e, r, n, i, o, a); - }; - $c.prototype.writeSync = function (t, e, r, n, i, o, a) { - return this._write(!1, t, e, r, n, i, o, a); - }; - $c.prototype._write = function (t, e, r, n, i, o, a, s) { - if ( - (Yp.equal(arguments.length, 8), - Yp(this.init_done, "write before init"), - Yp(this.mode !== Zt.NONE, "already finalized"), - Yp.equal(!1, this.write_in_progress, "write already in progress"), - Yp.equal(!1, this.pending_close, "close is pending"), - (this.write_in_progress = !0), - Yp.equal(!1, e === void 0, "must provide flush value"), - (this.write_in_progress = !0), - e !== Zt.Z_NO_FLUSH && - e !== Zt.Z_PARTIAL_FLUSH && - e !== Zt.Z_SYNC_FLUSH && - e !== Zt.Z_FULL_FLUSH && - e !== Zt.Z_FINISH && - e !== Zt.Z_BLOCK) - ) - throw new Error("Invalid flush value"); - if ( - (r == null && ((r = Buffer.alloc(0)), (i = 0), (n = 0)), - (this.strm.avail_in = i), - (this.strm.input = r), - (this.strm.next_in = n), - (this.strm.avail_out = s), - (this.strm.output = o), - (this.strm.next_out = a), - (this.flush = e), - !t) - ) - return this._process(), this._checkError() ? this._afterSync() : void 0; - var c = this; - return ( - process.nextTick(function () { - c._process(), c._after(); - }), - this - ); - }; - $c.prototype._afterSync = function () { - var t = this.strm.avail_out, - e = this.strm.avail_in; - return (this.write_in_progress = !1), [e, t]; - }; - $c.prototype._process = function () { - var t = null; - switch (this.mode) { - case Zt.DEFLATE: - case Zt.GZIP: - case Zt.DEFLATERAW: - this.err = xU.deflate(this.strm, this.flush); - break; - case Zt.UNZIP: - switch ( - (this.strm.avail_in > 0 && (t = this.strm.next_in), - this.gzip_id_bytes_read) - ) { - case 0: - if (t === null) break; - if (this.strm.input[t] === cmr) { - if ( - ((this.gzip_id_bytes_read = 1), t++, this.strm.avail_in === 1) - ) - break; - } else { - this.mode = Zt.INFLATE; - break; - } - case 1: - if (t === null) break; - this.strm.input[t] === lmr - ? ((this.gzip_id_bytes_read = 2), (this.mode = Zt.GUNZIP)) - : (this.mode = Zt.INFLATE); - break; - default: - throw new Error("invalid number of gzip magic number bytes read"); - } - case Zt.INFLATE: - case Zt.GUNZIP: - case Zt.INFLATERAW: - for ( - this.err = IT.inflate(this.strm, this.flush), - this.err === Zt.Z_NEED_DICT && - this.dictionary && - ((this.err = IT.inflateSetDictionary( - this.strm, - this.dictionary - )), - this.err === Zt.Z_OK - ? (this.err = IT.inflate(this.strm, this.flush)) - : this.err === Zt.Z_DATA_ERROR && - (this.err = Zt.Z_NEED_DICT)); - this.strm.avail_in > 0 && - this.mode === Zt.GUNZIP && - this.err === Zt.Z_STREAM_END && - this.strm.next_in[0] !== 0; - - ) - this.reset(), (this.err = IT.inflate(this.strm, this.flush)); - break; - default: - throw new Error("Unknown mode " + this.mode); - } - }; - $c.prototype._checkError = function () { - switch (this.err) { - case Zt.Z_OK: - case Zt.Z_BUF_ERROR: - if (this.strm.avail_out !== 0 && this.flush === Zt.Z_FINISH) - return this._error("unexpected end of file"), !1; - break; - case Zt.Z_STREAM_END: - break; - case Zt.Z_NEED_DICT: - return ( - this.dictionary == null - ? this._error("Missing dictionary") - : this._error("Bad dictionary"), - !1 - ); - default: - return this._error("Zlib error"), !1; - } - return !0; - }; - $c.prototype._after = function () { - if (!!this._checkError()) { - var t = this.strm.avail_out, - e = this.strm.avail_in; - (this.write_in_progress = !1), - this.callback(e, t), - this.pending_close && this.close(); - } - }; - $c.prototype._error = function (t) { - this.strm.msg && (t = this.strm.msg), - this.onerror(t, this.err), - (this.write_in_progress = !1), - this.pending_close && this.close(); - }; - $c.prototype.init = function (t, e, r, n, i) { - Yp( - arguments.length === 4 || arguments.length === 5, - "init(windowBits, level, memLevel, strategy, [dictionary])" - ), - Yp(t >= 8 && t <= 15, "invalid windowBits"), - Yp(e >= -1 && e <= 9, "invalid compression level"), - Yp(r >= 1 && r <= 9, "invalid memlevel"), - Yp( - n === Zt.Z_FILTERED || - n === Zt.Z_HUFFMAN_ONLY || - n === Zt.Z_RLE || - n === Zt.Z_FIXED || - n === Zt.Z_DEFAULT_STRATEGY, - "invalid strategy" - ), - this._init(e, t, r, n, i), - this._setDictionary(); - }; - $c.prototype.params = function () { - throw new Error("deflateParams Not supported"); - }; - $c.prototype.reset = function () { - this._reset(), this._setDictionary(); - }; - $c.prototype._init = function (t, e, r, n, i) { - switch ( - ((this.level = t), - (this.windowBits = e), - (this.memLevel = r), - (this.strategy = n), - (this.flush = Zt.Z_NO_FLUSH), - (this.err = Zt.Z_OK), - (this.mode === Zt.GZIP || this.mode === Zt.GUNZIP) && - (this.windowBits += 16), - this.mode === Zt.UNZIP && (this.windowBits += 32), - (this.mode === Zt.DEFLATERAW || this.mode === Zt.INFLATERAW) && - (this.windowBits = -1 * this.windowBits), - (this.strm = new umr()), - this.mode) - ) { - case Zt.DEFLATE: - case Zt.GZIP: - case Zt.DEFLATERAW: - this.err = xU.deflateInit2( - this.strm, - this.level, - Zt.Z_DEFLATED, - this.windowBits, - this.memLevel, - this.strategy - ); - break; - case Zt.INFLATE: - case Zt.GUNZIP: - case Zt.INFLATERAW: - case Zt.UNZIP: - this.err = IT.inflateInit2(this.strm, this.windowBits); - break; - default: - throw new Error("Unknown mode " + this.mode); - } - this.err !== Zt.Z_OK && this._error("Init error"), - (this.dictionary = i), - (this.write_in_progress = !1), - (this.init_done = !0); - }; - $c.prototype._setDictionary = function () { - if (this.dictionary != null) { - switch (((this.err = Zt.Z_OK), this.mode)) { - case Zt.DEFLATE: - case Zt.DEFLATERAW: - this.err = xU.deflateSetDictionary(this.strm, this.dictionary); - break; - default: - break; - } - this.err !== Zt.Z_OK && this._error("Failed to set dictionary"); - } - }; - $c.prototype._reset = function () { - switch (((this.err = Zt.Z_OK), this.mode)) { - case Zt.DEFLATE: - case Zt.DEFLATERAW: - case Zt.GZIP: - this.err = xU.deflateReset(this.strm); - break; - case Zt.INFLATE: - case Zt.INFLATERAW: - case Zt.GUNZIP: - this.err = IT.inflateReset(this.strm); - break; - default: - break; - } - this.err !== Zt.Z_OK && this._error("Failed to reset stream"); - }; - Zt.Zlib = $c; - }); - var Kat = I((yr) => { - "use strict"; - m(); - g(); - var Yv = Qr().Buffer, - jat = vM().Transform, - ln = Fat(), - wA = es(), - SU = Dr().ok, - L2e = Qr().kMaxLength, - Uat = - "Cannot create final Buffer. It would be larger than 0x" + - L2e.toString(16) + - " bytes"; - ln.Z_MIN_WINDOWBITS = 8; - ln.Z_MAX_WINDOWBITS = 15; - ln.Z_DEFAULT_WINDOWBITS = 15; - ln.Z_MIN_CHUNK = 64; - ln.Z_MAX_CHUNK = 1 / 0; - ln.Z_DEFAULT_CHUNK = 16 * 1024; - ln.Z_MIN_MEMLEVEL = 1; - ln.Z_MAX_MEMLEVEL = 9; - ln.Z_DEFAULT_MEMLEVEL = 8; - ln.Z_MIN_LEVEL = -1; - ln.Z_MAX_LEVEL = 9; - ln.Z_DEFAULT_LEVEL = ln.Z_DEFAULT_COMPRESSION; - var Lat = Object.keys(ln); - for (kte = 0; kte < Lat.length; kte++) - (Pte = Lat[kte]), - Pte.match(/^Z/) && - Object.defineProperty(yr, Pte, { - enumerable: !0, - value: ln[Pte], - writable: !1, - }); - var Pte, - kte, - Bte = { - Z_OK: ln.Z_OK, - Z_STREAM_END: ln.Z_STREAM_END, - Z_NEED_DICT: ln.Z_NEED_DICT, - Z_ERRNO: ln.Z_ERRNO, - Z_STREAM_ERROR: ln.Z_STREAM_ERROR, - Z_DATA_ERROR: ln.Z_DATA_ERROR, - Z_MEM_ERROR: ln.Z_MEM_ERROR, - Z_BUF_ERROR: ln.Z_BUF_ERROR, - Z_VERSION_ERROR: ln.Z_VERSION_ERROR, - }, - qat = Object.keys(Bte); - for (Ote = 0; Ote < qat.length; Ote++) - (F2e = qat[Ote]), (Bte[Bte[F2e]] = F2e); - var F2e, Ote; - Object.defineProperty(yr, "codes", { - enumerable: !0, - value: Object.freeze(Bte), - writable: !1, - }); - yr.Deflate = CT; - yr.Inflate = RT; - yr.Gzip = NT; - yr.Gunzip = DT; - yr.DeflateRaw = FT; - yr.InflateRaw = LT; - yr.Unzip = qT; - yr.createDeflate = function (t) { - return new CT(t); - }; - yr.createInflate = function (t) { - return new RT(t); - }; - yr.createDeflateRaw = function (t) { - return new FT(t); - }; - yr.createInflateRaw = function (t) { - return new LT(t); - }; - yr.createGzip = function (t) { - return new NT(t); - }; - yr.createGunzip = function (t) { - return new DT(t); - }; - yr.createUnzip = function (t) { - return new qT(t); - }; - yr.deflate = function (t, e, r) { - return typeof e == "function" && ((r = e), (e = {})), zT(new CT(e), t, r); - }; - yr.deflateSync = function (t, e) { - return jT(new CT(e), t); - }; - yr.gzip = function (t, e, r) { - return typeof e == "function" && ((r = e), (e = {})), zT(new NT(e), t, r); - }; - yr.gzipSync = function (t, e) { - return jT(new NT(e), t); - }; - yr.deflateRaw = function (t, e, r) { - return typeof e == "function" && ((r = e), (e = {})), zT(new FT(e), t, r); - }; - yr.deflateRawSync = function (t, e) { - return jT(new FT(e), t); - }; - yr.unzip = function (t, e, r) { - return typeof e == "function" && ((r = e), (e = {})), zT(new qT(e), t, r); - }; - yr.unzipSync = function (t, e) { - return jT(new qT(e), t); - }; - yr.inflate = function (t, e, r) { - return typeof e == "function" && ((r = e), (e = {})), zT(new RT(e), t, r); - }; - yr.inflateSync = function (t, e) { - return jT(new RT(e), t); - }; - yr.gunzip = function (t, e, r) { - return typeof e == "function" && ((r = e), (e = {})), zT(new DT(e), t, r); - }; - yr.gunzipSync = function (t, e) { - return jT(new DT(e), t); - }; - yr.inflateRaw = function (t, e, r) { - return typeof e == "function" && ((r = e), (e = {})), zT(new LT(e), t, r); - }; - yr.inflateRawSync = function (t, e) { - return jT(new LT(e), t); - }; - function zT(t, e, r) { - var n = [], - i = 0; - t.on("error", a), t.on("end", s), t.end(e), o(); - function o() { - for (var c; (c = t.read()) !== null; ) n.push(c), (i += c.length); - t.once("readable", o); - } - function a(c) { - t.removeListener("end", s), t.removeListener("readable", o), r(c); - } - function s() { - var c, - u = null; - i >= L2e ? (u = new RangeError(Uat)) : (c = Yv.concat(n, i)), - (n = []), - t.close(), - r(u, c); - } - } - function jT(t, e) { - if ((typeof e == "string" && (e = Yv.from(e)), !Yv.isBuffer(e))) - throw new TypeError("Not a string or buffer"); - var r = t._finishFlushFlag; - return t._processChunk(e, r); - } - function CT(t) { - if (!(this instanceof CT)) return new CT(t); - za.call(this, t, ln.DEFLATE); - } - function RT(t) { - if (!(this instanceof RT)) return new RT(t); - za.call(this, t, ln.INFLATE); - } - function NT(t) { - if (!(this instanceof NT)) return new NT(t); - za.call(this, t, ln.GZIP); - } - function DT(t) { - if (!(this instanceof DT)) return new DT(t); - za.call(this, t, ln.GUNZIP); - } - function FT(t) { - if (!(this instanceof FT)) return new FT(t); - za.call(this, t, ln.DEFLATERAW); - } - function LT(t) { - if (!(this instanceof LT)) return new LT(t); - za.call(this, t, ln.INFLATERAW); - } - function qT(t) { - if (!(this instanceof qT)) return new qT(t); - za.call(this, t, ln.UNZIP); - } - function zat(t) { - return ( - t === ln.Z_NO_FLUSH || - t === ln.Z_PARTIAL_FLUSH || - t === ln.Z_SYNC_FLUSH || - t === ln.Z_FULL_FLUSH || - t === ln.Z_FINISH || - t === ln.Z_BLOCK - ); - } - function za(t, e) { - var r = this; - if ( - ((this._opts = t = t || {}), - (this._chunkSize = t.chunkSize || yr.Z_DEFAULT_CHUNK), - jat.call(this, t), - t.flush && !zat(t.flush)) - ) - throw new Error("Invalid flush flag: " + t.flush); - if (t.finishFlush && !zat(t.finishFlush)) - throw new Error("Invalid flush flag: " + t.finishFlush); - if ( - ((this._flushFlag = t.flush || ln.Z_NO_FLUSH), - (this._finishFlushFlag = - typeof t.finishFlush < "u" ? t.finishFlush : ln.Z_FINISH), - t.chunkSize && - (t.chunkSize < yr.Z_MIN_CHUNK || t.chunkSize > yr.Z_MAX_CHUNK)) - ) - throw new Error("Invalid chunk size: " + t.chunkSize); - if ( - t.windowBits && - (t.windowBits < yr.Z_MIN_WINDOWBITS || - t.windowBits > yr.Z_MAX_WINDOWBITS) - ) - throw new Error("Invalid windowBits: " + t.windowBits); - if (t.level && (t.level < yr.Z_MIN_LEVEL || t.level > yr.Z_MAX_LEVEL)) - throw new Error("Invalid compression level: " + t.level); - if ( - t.memLevel && - (t.memLevel < yr.Z_MIN_MEMLEVEL || t.memLevel > yr.Z_MAX_MEMLEVEL) - ) - throw new Error("Invalid memLevel: " + t.memLevel); - if ( - t.strategy && - t.strategy != yr.Z_FILTERED && - t.strategy != yr.Z_HUFFMAN_ONLY && - t.strategy != yr.Z_RLE && - t.strategy != yr.Z_FIXED && - t.strategy != yr.Z_DEFAULT_STRATEGY - ) - throw new Error("Invalid strategy: " + t.strategy); - if (t.dictionary && !Yv.isBuffer(t.dictionary)) - throw new Error("Invalid dictionary: it should be a Buffer instance"); - this._handle = new ln.Zlib(e); - var n = this; - (this._hadError = !1), - (this._handle.onerror = function (a, s) { - Ite(n), (n._hadError = !0); - var c = new Error(a); - (c.errno = s), (c.code = yr.codes[s]), n.emit("error", c); - }); - var i = yr.Z_DEFAULT_COMPRESSION; - typeof t.level == "number" && (i = t.level); - var o = yr.Z_DEFAULT_STRATEGY; - typeof t.strategy == "number" && (o = t.strategy), - this._handle.init( - t.windowBits || yr.Z_DEFAULT_WINDOWBITS, - i, - t.memLevel || yr.Z_DEFAULT_MEMLEVEL, - o, - t.dictionary - ), - (this._buffer = Yv.allocUnsafe(this._chunkSize)), - (this._offset = 0), - (this._level = i), - (this._strategy = o), - this.once("end", this.close), - Object.defineProperty(this, "_closed", { - get: function () { - return !r._handle; - }, - configurable: !0, - enumerable: !0, - }); - } - wA.inherits(za, jat); - za.prototype.params = function (t, e, r) { - if (t < yr.Z_MIN_LEVEL || t > yr.Z_MAX_LEVEL) - throw new RangeError("Invalid compression level: " + t); - if ( - e != yr.Z_FILTERED && - e != yr.Z_HUFFMAN_ONLY && - e != yr.Z_RLE && - e != yr.Z_FIXED && - e != yr.Z_DEFAULT_STRATEGY - ) - throw new TypeError("Invalid strategy: " + e); - if (this._level !== t || this._strategy !== e) { - var n = this; - this.flush(ln.Z_SYNC_FLUSH, function () { - SU(n._handle, "zlib binding closed"), - n._handle.params(t, e), - n._hadError || ((n._level = t), (n._strategy = e), r && r()); - }); - } else process.nextTick(r); - }; - za.prototype.reset = function () { - return SU(this._handle, "zlib binding closed"), this._handle.reset(); - }; - za.prototype._flush = function (t) { - this._transform(Yv.alloc(0), "", t); - }; - za.prototype.flush = function (t, e) { - var r = this, - n = this._writableState; - (typeof t == "function" || (t === void 0 && !e)) && - ((e = t), (t = ln.Z_FULL_FLUSH)), - n.ended - ? e && process.nextTick(e) - : n.ending - ? e && this.once("end", e) - : n.needDrain - ? e && - this.once("drain", function () { - return r.flush(t, e); - }) - : ((this._flushFlag = t), this.write(Yv.alloc(0), "", e)); - }; - za.prototype.close = function (t) { - Ite(this, t), process.nextTick(fmr, this); - }; - function Ite(t, e) { - e && process.nextTick(e), - t._handle && (t._handle.close(), (t._handle = null)); - } - function fmr(t) { - t.emit("close"); - } - za.prototype._transform = function (t, e, r) { - var n, - i = this._writableState, - o = i.ending || i.ended, - a = o && (!t || i.length === t.length); - if (t !== null && !Yv.isBuffer(t)) return r(new Error("invalid input")); - if (!this._handle) return r(new Error("zlib binding closed")); - a - ? (n = this._finishFlushFlag) - : ((n = this._flushFlag), - t.length >= i.length && - (this._flushFlag = this._opts.flush || ln.Z_NO_FLUSH)), - this._processChunk(t, n, r); - }; - za.prototype._processChunk = function (t, e, r) { - var n = t && t.length, - i = this._chunkSize - this._offset, - o = 0, - a = this, - s = typeof r == "function"; - if (!s) { - var c = [], - u = 0, - h; - this.on("error", function (D) { - h = D; - }), - SU(this._handle, "zlib binding closed"); - do - var w = this._handle.writeSync( - e, - t, - o, - n, - this._buffer, - this._offset, - i - ); - while (!this._hadError && O(w[0], w[1])); - if (this._hadError) throw h; - if (u >= L2e) throw (Ite(this), new RangeError(Uat)); - var M = Yv.concat(c, u); - return Ite(this), M; - } - SU(this._handle, "zlib binding closed"); - var k = this._handle.write(e, t, o, n, this._buffer, this._offset, i); - (k.buffer = t), (k.callback = O); - function O(D, F) { - if ( - (this && ((this.buffer = null), (this.callback = null)), !a._hadError) - ) { - var N = i - F; - if ((SU(N >= 0, "have should not go down"), N > 0)) { - var q = a._buffer.slice(a._offset, a._offset + N); - (a._offset += N), s ? a.push(q) : (c.push(q), (u += q.length)); - } - if ( - ((F === 0 || a._offset >= a._chunkSize) && - ((i = a._chunkSize), - (a._offset = 0), - (a._buffer = Yv.allocUnsafe(a._chunkSize))), - F === 0) - ) { - if (((o += n - D), (n = D), !s)) return !0; - var z = a._handle.write( - e, - t, - o, - n, - a._buffer, - a._offset, - a._chunkSize - ); - (z.callback = O), (z.buffer = t); - return; - } - if (!s) return !1; - r(); - } - } - }; - wA.inherits(CT, za); - wA.inherits(RT, za); - wA.inherits(NT, za); - wA.inherits(DT, za); - wA.inherits(FT, za); - wA.inherits(LT, za); - wA.inherits(qT, za); - }); - var Xat = I((Uyn, Zat) => { - "use strict"; - m(); - g(); - var Qv = ute(), - lc = xT(), - _A = vM(), - MU = es(), - Vat = Kat(), - Cte = { namespace: "org.apache.avro.file" }, - Hat = Qv.Type.forSchema("long", Cte), - Wat = Qv.Type.forSchema({ type: "map", values: "bytes" }, Cte), - q2e = Qv.Type.forSchema( - { - name: "Header", - type: "record", - fields: [ - { name: "magic", type: { type: "fixed", name: "Magic", size: 4 } }, - { name: "meta", type: Wat }, - { name: "sync", type: { type: "fixed", name: "Sync", size: 16 } }, - ], - }, - Cte - ), - Gat = Qv.Type.forSchema( - { - name: "Block", - type: "record", - fields: [ - { name: "count", type: "long" }, - { name: "data", type: "bytes" }, - { name: "sync", type: "Sync" }, - ], - }, - Cte - ), - AU = lc.bufferFrom("Obj"), - Rte = MU.format, - EU = lc.Tap; - function Nte(t, e) { - e = e || {}; - var r = !!e.noDecode; - _A.Duplex.call(this, { readableObjectMode: !r, allowHalfOpen: !1 }), - (this._type = Qv.Type.forSchema(t)), - (this._tap = new EU(lc.newBuffer(0))), - (this._writeCb = null), - (this._needPush = !1), - (this._readValue = $at(r, this._type)), - (this._finished = !1), - this.on("finish", function () { - (this._finished = !0), this._read(); - }); - } - MU.inherits(Nte, _A.Duplex); - Nte.prototype._write = function (t, e, r) { - this._writeCb = r; - var n = this._tap; - (n.buf = Buffer.concat([n.buf.slice(n.pos), t])), - (n.pos = 0), - this._needPush && ((this._needPush = !1), this._read()); - }; - Nte.prototype._read = function () { - this._needPush = !1; - var t = this._tap, - e = t.pos, - r = this._readValue(t); - t.isValid() - ? this.push(r) - : this._finished - ? this.push(null) - : ((t.pos = e), - (this._needPush = !0), - this._writeCb && this._writeCb()); - }; - function ug(t) { - t = t || {}; - var e = !!t.noDecode; - _A.Duplex.call(this, { allowHalfOpen: !0, readableObjectMode: !e }), - (this._rType = - t.readerSchema !== void 0 - ? Qv.Type.forSchema(t.readerSchema) - : void 0), - (this._wType = null), - (this._codecs = t.codecs), - (this._codec = void 0), - (this._parseHook = t.parseHook), - (this._tap = new EU(lc.newBuffer(0))), - (this._blockTap = new EU(lc.newBuffer(0))), - (this._syncMarker = null), - (this._readValue = null), - (this._noDecode = e), - (this._queue = new lc.OrderedQueue()), - (this._decompress = null), - (this._index = 0), - (this._remaining = void 0), - (this._needPush = !1), - (this._finished = !1), - this.on("finish", function () { - (this._finished = !0), this._needPush && this._read(); - }); - } - MU.inherits(ug, _A.Duplex); - ug.defaultCodecs = function () { - return { - null: function (t, e) { - e(null, t); - }, - deflate: Vat.inflateRaw, - }; - }; - ug.getDefaultCodecs = ug.defaultCodecs; - ug.prototype._decodeHeader = function () { - var t = this._tap; - if (t.buf.length < AU.length) return !1; - if (!AU.equals(t.buf.slice(0, AU.length))) - return this.emit("error", new Error("invalid magic bytes")), !1; - var e = q2e._read(t); - if (!t.isValid()) return !1; - this._codec = (e.meta["avro.codec"] || "null").toString(); - var r = this._codecs || ug.getDefaultCodecs(); - if (((this._decompress = r[this._codec]), !this._decompress)) { - this.emit("error", new Error(Rte("unknown codec: %s", this._codec))); - return; - } - try { - var n = JSON.parse(e.meta["avro.schema"].toString()); - this._parseHook && (n = this._parseHook(n)), - (this._wType = Qv.Type.forSchema(n)); - } catch (i) { - this.emit("error", i); - return; - } - return ( - (this._readValue = $at(this._noDecode, this._wType, this._rType)), - (this._syncMarker = e.sync), - this.emit("metadata", this._wType, this._codec, e), - !0 - ); - }; - ug.prototype._write = function (t, e, r) { - var n = this._tap; - if ( - ((n.buf = Buffer.concat([n.buf, t])), - (n.pos = 0), - !this._decodeHeader()) - ) { - process.nextTick(r); - return; - } - (this._write = this._writeChunk), this._write(lc.newBuffer(0), e, r); - }; - ug.prototype._writeChunk = function (t, e, r) { - var n = this._tap; - (n.buf = Buffer.concat([n.buf.slice(n.pos), t])), (n.pos = 0); - for (var i = 1, o; (o = dmr(n)); ) { - if (!this._syncMarker.equals(o.sync)) { - this.emit("error", new Error("invalid sync marker")); - return; - } - i++, this._decompress(o.data, this._createBlockCallback(o.count, a)); - } - a(); - function a() { - --i || r(); - } - }; - ug.prototype._createBlockCallback = function (t, e) { - var r = this, - n = this._index++; - return function (i, o) { - if (i) { - var a = new Error(Rte("%s codec decompression error", r._codec)); - (a.cause = i), r.emit("error", a), e(); - } else r._queue.push(new Jat(n, o, e, t)), r._needPush && r._read(); - }; - }; - ug.prototype._read = function () { - this._needPush = !1; - var t = this._blockTap; - if (!this._remaining) { - var e = this._queue.pop(); - if (!e || !e.count) { - this._finished ? this.push(null) : (this._needPush = !0), e && e.cb(); - return; - } - e.cb(), (this._remaining = e.count), (t.buf = e.buf), (t.pos = 0); - } - this._remaining--, this.push(this._readValue(t)); - }; - function Dte(t, e) { - (e = e || {}), - _A.Transform.call(this, { writableObjectMode: !0, allowHalfOpen: !1 }), - (this._type = Qv.Type.forSchema(t)), - (this._writeValue = function (r, n) { - try { - this._type._write(r, n); - } catch (i) { - this.emit("error", i); - } - }), - (this._tap = new EU(lc.newBuffer(e.batchSize || 65536))); - } - MU.inherits(Dte, _A.Transform); - Dte.prototype._transform = function (t, e, r) { - var n = this._tap, - i = n.buf, - o = n.pos; - if ((this._writeValue(n, t), !n.isValid())) { - o && this.push(hmr(n.buf, 0, o)); - var a = n.pos - o; - a > i.length && (n.buf = lc.newBuffer(2 * a)), - (n.pos = 0), - this._writeValue(n, t); - } - r(); - }; - Dte.prototype._flush = function (t) { - var e = this._tap, - r = e.pos; - r && this.push(e.buf.slice(0, r)), t(); - }; - function cg(t, e) { - (e = e || {}), - _A.Duplex.call(this, { allowHalfOpen: !0, writableObjectMode: !0 }); - var r; - if ( - (Qv.Type.isType(t) - ? ((r = t), (t = void 0)) - : (r = Qv.Type.forSchema(t)), - (this._schema = t), - (this._type = r), - (this._writeValue = function (i, o) { - try { - this._type._write(i, o); - } catch (a) { - this.emit("error", a); - } - }), - (this._blockSize = e.blockSize || 65536), - (this._tap = new EU(lc.newBuffer(this._blockSize))), - (this._codecs = e.codecs), - (this._codec = e.codec || "null"), - (this._blockCount = 0), - (this._syncMarker = e.syncMarker || new lc.Lcg().nextBuffer(16)), - (this._queue = new lc.OrderedQueue()), - (this._pending = 0), - (this._finished = !1), - (this._needHeader = !1), - (this._needPush = !1), - (this._metadata = e.metadata || {}), - !Wat.isValid(this._metadata)) - ) - throw new Error("invalid metadata"); - var n = this._codec; - if ( - ((this._compress = (this._codecs || cg.getDefaultCodecs())[n]), - !this._compress) - ) - throw new Error(Rte("unsupported codec: %s", n)); - switch ( - (e.omitHeader !== void 0 && - (e.writeHeader = e.omitHeader ? "never" : "auto"), - e.writeHeader) - ) { - case !1: - case "never": - break; - case void 0: - case "auto": - this._needHeader = !0; - break; - default: - this._writeHeader(); - } - this.on("finish", function () { - (this._finished = !0), - this._blockCount - ? this._flushChunk() - : this._finished && this._needPush && this.push(null); - }); - } - MU.inherits(cg, _A.Duplex); - cg.defaultCodecs = function () { - return { - null: function (t, e) { - e(null, t); - }, - deflate: Vat.deflateRaw, - }; - }; - cg.getDefaultCodecs = cg.defaultCodecs; - cg.prototype._writeHeader = function () { - var t = JSON.stringify( - this._schema - ? this._schema - : this._type.getSchema({ exportAttrs: !0 }) - ), - e = lc.copyOwnProperties( - this._metadata, - { - "avro.schema": lc.bufferFrom(t), - "avro.codec": lc.bufferFrom(this._codec), - }, - !0 - ), - r = q2e.getRecordConstructor(), - n = new r(AU, e, this._syncMarker); - this.push(n.toBuffer()); - }; - cg.prototype._write = function (t, e, r) { - this._needHeader && (this._writeHeader(), (this._needHeader = !1)); - var n = this._tap, - i = n.pos, - o = !1; - if ((this._writeValue(n, t), !n.isValid())) { - i && (this._flushChunk(i, r), (o = !0)); - var a = n.pos - i; - a > this._blockSize && (this._blockSize = a * 2), - (n.buf = lc.newBuffer(this._blockSize)), - (n.pos = 0), - this._writeValue(n, t); - } - this._blockCount++, o || r(); - }; - cg.prototype._flushChunk = function (t, e) { - var r = this._tap; - (t = t || r.pos), - this._compress(r.buf.slice(0, t), this._createBlockCallback(e)), - (this._blockCount = 0); - }; - cg.prototype._read = function () { - var t = this, - e = this._queue.pop(); - if (!e) { - this._finished && !this._pending - ? process.nextTick(function () { - t.push(null); - }) - : (this._needPush = !0); - return; - } - this.push(Hat.toBuffer(e.count, !0)), - this.push(Hat.toBuffer(e.buf.length, !0)), - this.push(e.buf), - this.push(this._syncMarker), - this._finished || e.cb(); - }; - cg.prototype._createBlockCallback = function (t) { - var e = this, - r = this._index++, - n = this._blockCount; - return ( - this._pending++, - function (i, o) { - if (i) { - var a = new Error(Rte("%s codec compression error", e._codec)); - (a.cause = i), e.emit("error", a); - return; - } - e._pending--, - e._queue.push(new Jat(r, o, t, n)), - e._needPush && ((e._needPush = !1), e._read()); - } - ); - }; - function Jat(t, e, r, n) { - (this.index = t), (this.buf = e), (this.cb = r), (this.count = n | 0); - } - function dmr(t) { - var e = t.pos, - r = Gat._read(t); - return t.isValid() ? r : ((t.pos = e), null); - } - function $at(t, e, r) { - if (t) - return (function (i) { - return function (o) { - var a = o.pos; - return i(o), o.buf.slice(a, o.pos); - }; - })(e._skip); - if (r) { - var n = r.createResolver(e); - return function (i) { - return n._read(i); - }; - } else - return function (i) { - return e._read(i); - }; - } - function hmr(t, e, r) { - var n = lc.newBuffer(r); - return t.copy(n, 0, e, e + r), n; - } - Zat.exports = { - BLOCK_TYPE: Gat, - HEADER_TYPE: q2e, - MAGIC_BYTES: AU, - streams: { - BlockDecoder: ug, - BlockEncoder: cg, - RawDecoder: Nte, - RawEncoder: Dte, - }, - }; - }); - var est = I((Kyn, U2e) => { - "use strict"; - m(); - g(); - var pmr = oot(), - z2e = Xat(), - Yat = xT(), - TU = vM(), - Qat = es(); - function j2e(t, e) { - TU.Readable.call(this), - (e = e || {}), - (this._batchSize = e.batchSize || 65536), - (this._blob = t), - (this._pos = 0); - } - Qat.inherits(j2e, TU.Readable); - j2e.prototype._read = function () { - var t = this._pos; - if (t >= this._blob.size) { - this.push(null); - return; - } - this._pos += this._batchSize; - var e = this._blob.slice(t, this._pos, this._blob.type), - r = new FileReader(), - n = this; - r.addEventListener( - "loadend", - function i(o) { - r.removeEventListener("loadend", i, !1), - o.error - ? n.emit("error", o.error) - : n.push(Yat.bufferFrom(r.result)); - }, - !1 - ), - r.readAsArrayBuffer(e); - }; - function Fte() { - TU.Transform.call(this, { readableObjectMode: !0 }), (this._bufs = []); - } - Qat.inherits(Fte, TU.Transform); - Fte.prototype._transform = function (t, e, r) { - this._bufs.push(t), r(); - }; - Fte.prototype._flush = function (t) { - this.push(new Blob(this._bufs, { type: "application/octet-binary" })), - t(); - }; - function ymr(t, e) { - return new j2e(t).pipe(new z2e.streams.BlockDecoder(e)); - } - function mmr(t, e) { - var r = new z2e.streams.BlockEncoder(t, e), - n = new Fte(); - return ( - r.pipe(n), - new TU.Duplex({ - objectMode: !0, - read: function () { - var i = n.read(); - i ? a(i) : n.once("readable", a); - var o = this; - function a(s) { - o.push(s || n.read()), o.push(null); - } - }, - write: function (i, o, a) { - return r.write(i, o, a); - }, - }).on("finish", function () { - r.end(); - }) - ); - } - U2e.exports = { - createBlobDecoder: ymr, - createBlobEncoder: mmr, - streams: z2e.streams, - }; - Yat.copyOwnProperties(pmr, U2e.exports); - }); - var K2e = I((Zc) => { - "use strict"; - m(); - g(); - var gmr = - (Zc && Zc.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - vmr = - (Zc && Zc.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - bmr = - (Zc && Zc.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - gmr(e, t, r); - return vmr(e, t), e; - }; - Object.defineProperty(Zc, "__esModule", { value: !0 }); - Zc.serializeTags = Zc.tagsParser = Zc.tagParser = void 0; - var tst = bmr(est()); - Zc.tagParser = tst.Type.forSchema({ - type: "record", - name: "Tag", - fields: [ - { name: "name", type: "string" }, - { name: "value", type: "string" }, - ], - }); - Zc.tagsParser = tst.Type.forSchema({ type: "array", items: Zc.tagParser }); - function wmr(t) { - if (t.length == 0) return new Uint8Array(0); - let e; - try { - e = Zc.tagsParser.toBuffer(t); - } catch { - throw new Error( - "Incorrect tag format used. Make sure your tags are { name: string!, value: string! }[]" - ); - } - return Uint8Array.from(e); - } - Zc.serializeTags = wmr; - }); - var rst = I((Lte) => { - "use strict"; - m(); - g(); - Object.defineProperty(Lte, "__esModule", { value: !0 }); - Lte.Signer = void 0; - var H2e = class { - static verify(e) { - throw new Error("You must implement verify method on child"); - } - }; - Lte.Signer = H2e; - }); - var KT = I((UT) => { - "use strict"; - m(); - g(); - Object.defineProperty(UT, "__esModule", { value: !0 }); - UT.SIG_CONFIG = UT.SignatureConfig = void 0; - var kU; - (function (t) { - (t[(t.ARWEAVE = 1)] = "ARWEAVE"), - (t[(t.ED25519 = 2)] = "ED25519"), - (t[(t.ETHEREUM = 3)] = "ETHEREUM"), - (t[(t.SOLANA = 4)] = "SOLANA"); - })((kU = UT.SignatureConfig || (UT.SignatureConfig = {}))); - UT.SIG_CONFIG = { - [kU.ARWEAVE]: { sigLength: 512, pubLength: 512, sigName: "arweave" }, - [kU.ED25519]: { sigLength: 64, pubLength: 32, sigName: "ed25519" }, - [kU.ETHEREUM]: { sigLength: 65, pubLength: 65, sigName: "ethereum" }, - [kU.SOLANA]: { sigLength: 64, pubLength: 32, sigName: "solana" }, - }; - }); - var qte = I((lg) => { - "use strict"; - m(); - g(); - var _mr = - (lg && lg.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - xmr = - (lg && lg.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Smr = - (lg && lg.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - _mr(e, t, r); - return xmr(e, t), e; - }, - Amr = - (lg && lg.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(lg, "__esModule", { value: !0 }); - var Emr = Amr(ng()), - nst = Smr(CX()), - ist = KT(), - V2e = class { - constructor(e, r) { - (this._key = e), - (this.pk = r), - (this.ownerLength = ist.SIG_CONFIG[2].pubLength), - (this.signatureLength = ist.SIG_CONFIG[2].sigLength), - (this.signatureType = 2); - } - get publicKey() { - return this._publicKey; - } - get key() { - return new Uint8Array(0); - } - sign(e) { - return nst.sign(Buffer.from(e), Buffer.from(this.key)); - } - static async verify(e, r, n) { - let i = e; - return ( - typeof e == "string" && (i = Emr.default.toBuffer(e)), - nst.verify(Buffer.from(n), Buffer.from(r), Buffer.from(i)) - ); - } - }; - lg.default = V2e; - }); - var ast = I((Jyn, ost) => { - m(); - g(); - var Ni = { - IMPOSSIBLE_CASE: "Impossible case. Please create issue.", - TWEAK_ADD: - "The tweak was out of range or the resulted private key is invalid", - TWEAK_MUL: "The tweak was out of range or equal to zero", - CONTEXT_RANDOMIZE_UNKNOW: "Unknow error on context randomization", - SECKEY_INVALID: "Private Key is invalid", - PUBKEY_PARSE: "Public Key could not be parsed", - PUBKEY_SERIALIZE: "Public Key serialization error", - PUBKEY_COMBINE: "The sum of the public keys is not valid", - SIG_PARSE: "Signature could not be parsed", - SIGN: "The nonce generation function failed, or the private key was invalid", - RECOVER: "Public key could not be recover", - ECDH: "Scalar was invalid (zero or overflow)", - }; - function Py(t, e) { - if (!t) throw new Error(e); - } - function wi(t, e, r) { - if ( - (Py(e instanceof Uint8Array, `Expected ${t} to be an Uint8Array`), - r !== void 0) - ) - if (Array.isArray(r)) { - let n = r.join(", "), - i = `Expected ${t} to be an Uint8Array with length [${n}]`; - Py(r.includes(e.length), i); - } else { - let n = `Expected ${t} to be an Uint8Array with length ${r}`; - Py(e.length === r, n); - } - } - function HT(t) { - Py(hR(t) === "Boolean", "Expected compressed to be a Boolean"); - } - function fg(t = (r) => new Uint8Array(r), e) { - return typeof t == "function" && (t = t(e)), wi("output", t, e), t; - } - function hR(t) { - return Object.prototype.toString.call(t).slice(8, -1); - } - ost.exports = (t) => ({ - contextRandomize(e) { - switch ( - (Py( - e === null || e instanceof Uint8Array, - "Expected seed to be an Uint8Array or null" - ), - e !== null && wi("seed", e, 32), - t.contextRandomize(e)) - ) { - case 1: - throw new Error(Ni.CONTEXT_RANDOMIZE_UNKNOW); - } - }, - privateKeyVerify(e) { - return wi("private key", e, 32), t.privateKeyVerify(e) === 0; - }, - privateKeyNegate(e) { - switch ((wi("private key", e, 32), t.privateKeyNegate(e))) { - case 0: - return e; - case 1: - throw new Error(Ni.IMPOSSIBLE_CASE); - } - }, - privateKeyTweakAdd(e, r) { - switch ( - (wi("private key", e, 32), - wi("tweak", r, 32), - t.privateKeyTweakAdd(e, r)) - ) { - case 0: - return e; - case 1: - throw new Error(Ni.TWEAK_ADD); - } - }, - privateKeyTweakMul(e, r) { - switch ( - (wi("private key", e, 32), - wi("tweak", r, 32), - t.privateKeyTweakMul(e, r)) - ) { - case 0: - return e; - case 1: - throw new Error(Ni.TWEAK_MUL); - } - }, - publicKeyVerify(e) { - return wi("public key", e, [33, 65]), t.publicKeyVerify(e) === 0; - }, - publicKeyCreate(e, r = !0, n) { - switch ( - (wi("private key", e, 32), - HT(r), - (n = fg(n, r ? 33 : 65)), - t.publicKeyCreate(n, e)) - ) { - case 0: - return n; - case 1: - throw new Error(Ni.SECKEY_INVALID); - case 2: - throw new Error(Ni.PUBKEY_SERIALIZE); - } - }, - publicKeyConvert(e, r = !0, n) { - switch ( - (wi("public key", e, [33, 65]), - HT(r), - (n = fg(n, r ? 33 : 65)), - t.publicKeyConvert(n, e)) - ) { - case 0: - return n; - case 1: - throw new Error(Ni.PUBKEY_PARSE); - case 2: - throw new Error(Ni.PUBKEY_SERIALIZE); - } - }, - publicKeyNegate(e, r = !0, n) { - switch ( - (wi("public key", e, [33, 65]), - HT(r), - (n = fg(n, r ? 33 : 65)), - t.publicKeyNegate(n, e)) - ) { - case 0: - return n; - case 1: - throw new Error(Ni.PUBKEY_PARSE); - case 2: - throw new Error(Ni.IMPOSSIBLE_CASE); - case 3: - throw new Error(Ni.PUBKEY_SERIALIZE); - } - }, - publicKeyCombine(e, r = !0, n) { - Py(Array.isArray(e), "Expected public keys to be an Array"), - Py( - e.length > 0, - "Expected public keys array will have more than zero items" - ); - for (let i of e) wi("public key", i, [33, 65]); - switch ((HT(r), (n = fg(n, r ? 33 : 65)), t.publicKeyCombine(n, e))) { - case 0: - return n; - case 1: - throw new Error(Ni.PUBKEY_PARSE); - case 2: - throw new Error(Ni.PUBKEY_COMBINE); - case 3: - throw new Error(Ni.PUBKEY_SERIALIZE); - } - }, - publicKeyTweakAdd(e, r, n = !0, i) { - switch ( - (wi("public key", e, [33, 65]), - wi("tweak", r, 32), - HT(n), - (i = fg(i, n ? 33 : 65)), - t.publicKeyTweakAdd(i, e, r)) - ) { - case 0: - return i; - case 1: - throw new Error(Ni.PUBKEY_PARSE); - case 2: - throw new Error(Ni.TWEAK_ADD); - } - }, - publicKeyTweakMul(e, r, n = !0, i) { - switch ( - (wi("public key", e, [33, 65]), - wi("tweak", r, 32), - HT(n), - (i = fg(i, n ? 33 : 65)), - t.publicKeyTweakMul(i, e, r)) - ) { - case 0: - return i; - case 1: - throw new Error(Ni.PUBKEY_PARSE); - case 2: - throw new Error(Ni.TWEAK_MUL); - } - }, - signatureNormalize(e) { - switch ((wi("signature", e, 64), t.signatureNormalize(e))) { - case 0: - return e; - case 1: - throw new Error(Ni.SIG_PARSE); - } - }, - signatureExport(e, r) { - wi("signature", e, 64), (r = fg(r, 72)); - let n = { output: r, outputlen: 72 }; - switch (t.signatureExport(n, e)) { - case 0: - return r.slice(0, n.outputlen); - case 1: - throw new Error(Ni.SIG_PARSE); - case 2: - throw new Error(Ni.IMPOSSIBLE_CASE); - } - }, - signatureImport(e, r) { - switch ( - (wi("signature", e), (r = fg(r, 64)), t.signatureImport(r, e)) - ) { - case 0: - return r; - case 1: - throw new Error(Ni.SIG_PARSE); - case 2: - throw new Error(Ni.IMPOSSIBLE_CASE); - } - }, - ecdsaSign(e, r, n = {}, i) { - wi("message", e, 32), - wi("private key", r, 32), - Py(hR(n) === "Object", "Expected options to be an Object"), - n.data !== void 0 && wi("options.data", n.data), - n.noncefn !== void 0 && - Py( - hR(n.noncefn) === "Function", - "Expected options.noncefn to be a Function" - ), - (i = fg(i, 64)); - let o = { signature: i, recid: null }; - switch (t.ecdsaSign(o, e, r, n.data, n.noncefn)) { - case 0: - return o; - case 1: - throw new Error(Ni.SIGN); - case 2: - throw new Error(Ni.IMPOSSIBLE_CASE); - } - }, - ecdsaVerify(e, r, n) { - switch ( - (wi("signature", e, 64), - wi("message", r, 32), - wi("public key", n, [33, 65]), - t.ecdsaVerify(e, r, n)) - ) { - case 0: - return !0; - case 3: - return !1; - case 1: - throw new Error(Ni.SIG_PARSE); - case 2: - throw new Error(Ni.PUBKEY_PARSE); - } - }, - ecdsaRecover(e, r, n, i = !0, o) { - switch ( - (wi("signature", e, 64), - Py( - hR(r) === "Number" && r >= 0 && r <= 3, - "Expected recovery id to be a Number within interval [0, 3]" - ), - wi("message", n, 32), - HT(i), - (o = fg(o, i ? 33 : 65)), - t.ecdsaRecover(o, e, r, n)) - ) { - case 0: - return o; - case 1: - throw new Error(Ni.SIG_PARSE); - case 2: - throw new Error(Ni.RECOVER); - case 3: - throw new Error(Ni.IMPOSSIBLE_CASE); - } - }, - ecdh(e, r, n = {}, i) { - switch ( - (wi("public key", e, [33, 65]), - wi("private key", r, 32), - Py(hR(n) === "Object", "Expected options to be an Object"), - n.data !== void 0 && wi("options.data", n.data), - n.hashfn !== void 0 - ? (Py( - hR(n.hashfn) === "Function", - "Expected options.hashfn to be a Function" - ), - n.xbuf !== void 0 && wi("options.xbuf", n.xbuf, 32), - n.ybuf !== void 0 && wi("options.ybuf", n.ybuf, 32), - wi("output", i)) - : (i = fg(i, 32)), - t.ecdh(i, e, r, n.data, n.hashfn, n.xbuf, n.ybuf)) - ) { - case 0: - return i; - case 1: - throw new Error(Ni.PUBKEY_PARSE); - case 2: - throw new Error(Ni.ECDH); - } - }, - }); - }); - var ust = I(($yn, sst) => { - m(); - g(); - var Mmr = F5().ec, - eb = new Mmr("secp256k1"), - fi = eb.curve, - Ao = fi.n.constructor; - function Tmr(t, e) { - let r = new Ao(e); - if (r.cmp(fi.p) >= 0) return null; - r = r.toRed(fi.red); - let n = r.redSqr().redIMul(r).redIAdd(fi.b).redSqrt(); - return ( - (t === 3) !== n.isOdd() && (n = n.redNeg()), - eb.keyPair({ pub: { x: r, y: n } }) - ); - } - function kmr(t, e, r) { - let n = new Ao(e), - i = new Ao(r); - if ( - n.cmp(fi.p) >= 0 || - i.cmp(fi.p) >= 0 || - ((n = n.toRed(fi.red)), - (i = i.toRed(fi.red)), - (t === 6 || t === 7) && i.isOdd() !== (t === 7)) - ) - return null; - let o = n.redSqr().redIMul(n); - return i.redSqr().redISub(o.redIAdd(fi.b)).isZero() - ? eb.keyPair({ pub: { x: n, y: i } }) - : null; - } - function xA(t) { - let e = t[0]; - switch (e) { - case 2: - case 3: - return t.length !== 33 ? null : Tmr(e, t.subarray(1, 33)); - case 4: - case 6: - case 7: - return t.length !== 65 - ? null - : kmr(e, t.subarray(1, 33), t.subarray(33, 65)); - default: - return null; - } - } - function VT(t, e) { - let r = e.encode(null, t.length === 33); - for (let n = 0; n < t.length; ++n) t[n] = r[n]; - } - sst.exports = { - contextRandomize() { - return 0; - }, - privateKeyVerify(t) { - let e = new Ao(t); - return e.cmp(fi.n) < 0 && !e.isZero() ? 0 : 1; - }, - privateKeyNegate(t) { - let e = new Ao(t), - r = fi.n.sub(e).umod(fi.n).toArrayLike(Uint8Array, "be", 32); - return t.set(r), 0; - }, - privateKeyTweakAdd(t, e) { - let r = new Ao(e); - if ( - r.cmp(fi.n) >= 0 || - (r.iadd(new Ao(t)), r.cmp(fi.n) >= 0 && r.isub(fi.n), r.isZero()) - ) - return 1; - let n = r.toArrayLike(Uint8Array, "be", 32); - return t.set(n), 0; - }, - privateKeyTweakMul(t, e) { - let r = new Ao(e); - if (r.cmp(fi.n) >= 0 || r.isZero()) return 1; - r.imul(new Ao(t)), r.cmp(fi.n) >= 0 && (r = r.umod(fi.n)); - let n = r.toArrayLike(Uint8Array, "be", 32); - return t.set(n), 0; - }, - publicKeyVerify(t) { - return xA(t) === null ? 1 : 0; - }, - publicKeyCreate(t, e) { - let r = new Ao(e); - if (r.cmp(fi.n) >= 0 || r.isZero()) return 1; - let n = eb.keyFromPrivate(e).getPublic(); - return VT(t, n), 0; - }, - publicKeyConvert(t, e) { - let r = xA(e); - if (r === null) return 1; - let n = r.getPublic(); - return VT(t, n), 0; - }, - publicKeyNegate(t, e) { - let r = xA(e); - if (r === null) return 1; - let n = r.getPublic(); - return (n.y = n.y.redNeg()), VT(t, n), 0; - }, - publicKeyCombine(t, e) { - let r = new Array(e.length); - for (let i = 0; i < e.length; ++i) - if (((r[i] = xA(e[i])), r[i] === null)) return 1; - let n = r[0].getPublic(); - for (let i = 1; i < r.length; ++i) n = n.add(r[i].pub); - return n.isInfinity() ? 2 : (VT(t, n), 0); - }, - publicKeyTweakAdd(t, e, r) { - let n = xA(e); - if (n === null) return 1; - if (((r = new Ao(r)), r.cmp(fi.n) >= 0)) return 2; - let i = n.getPublic().add(fi.g.mul(r)); - return i.isInfinity() ? 2 : (VT(t, i), 0); - }, - publicKeyTweakMul(t, e, r) { - let n = xA(e); - if (n === null) return 1; - if (((r = new Ao(r)), r.cmp(fi.n) >= 0 || r.isZero())) return 2; - let i = n.getPublic().mul(r); - return VT(t, i), 0; - }, - signatureNormalize(t) { - let e = new Ao(t.subarray(0, 32)), - r = new Ao(t.subarray(32, 64)); - return e.cmp(fi.n) >= 0 || r.cmp(fi.n) >= 0 - ? 1 - : (r.cmp(eb.nh) === 1 && - t.set(fi.n.sub(r).toArrayLike(Uint8Array, "be", 32), 32), - 0); - }, - signatureExport(t, e) { - let r = e.subarray(0, 32), - n = e.subarray(32, 64); - if (new Ao(r).cmp(fi.n) >= 0 || new Ao(n).cmp(fi.n) >= 0) return 1; - let { output: i } = t, - o = i.subarray(4, 4 + 33); - (o[0] = 0), o.set(r, 1); - let a = 33, - s = 0; - for (; a > 1 && o[s] === 0 && !(o[s + 1] & 128); --a, ++s); - if ( - ((o = o.subarray(s)), - o[0] & 128 || (a > 1 && o[0] === 0 && !(o[1] & 128))) - ) - return 1; - let c = i.subarray(6 + 33, 6 + 33 + 33); - (c[0] = 0), c.set(n, 1); - let u = 33, - h = 0; - for (; u > 1 && c[h] === 0 && !(c[h + 1] & 128); --u, ++h); - return ( - (c = c.subarray(h)), - c[0] & 128 || (u > 1 && c[0] === 0 && !(c[1] & 128)) - ? 1 - : ((t.outputlen = 6 + a + u), - (i[0] = 48), - (i[1] = t.outputlen - 2), - (i[2] = 2), - (i[3] = o.length), - i.set(o, 4), - (i[4 + a] = 2), - (i[5 + a] = c.length), - i.set(c, 6 + a), - 0) - ); - }, - signatureImport(t, e) { - if ( - e.length < 8 || - e.length > 72 || - e[0] !== 48 || - e[1] !== e.length - 2 || - e[2] !== 2 - ) - return 1; - let r = e[3]; - if (r === 0 || 5 + r >= e.length || e[4 + r] !== 2) return 1; - let n = e[5 + r]; - if ( - n === 0 || - 6 + r + n !== e.length || - e[4] & 128 || - (r > 1 && e[4] === 0 && !(e[5] & 128)) || - e[r + 6] & 128 || - (n > 1 && e[r + 6] === 0 && !(e[r + 7] & 128)) - ) - return 1; - let i = e.subarray(4, 4 + r); - if ( - (i.length === 33 && i[0] === 0 && (i = i.subarray(1)), i.length > 32) - ) - return 1; - let o = e.subarray(6 + r); - if ((o.length === 33 && o[0] === 0 && (o = o.slice(1)), o.length > 32)) - throw new Error("S length is too long"); - let a = new Ao(i); - a.cmp(fi.n) >= 0 && (a = new Ao(0)); - let s = new Ao(e.subarray(6 + r)); - return ( - s.cmp(fi.n) >= 0 && (s = new Ao(0)), - t.set(a.toArrayLike(Uint8Array, "be", 32), 0), - t.set(s.toArrayLike(Uint8Array, "be", 32), 32), - 0 - ); - }, - ecdsaSign(t, e, r, n, i) { - if (i) { - let s = i; - i = (c) => { - let u = s(e, r, null, n, c); - if (!(u instanceof Uint8Array && u.length === 32)) - throw new Error("This is the way"); - return new Ao(u); - }; - } - let o = new Ao(r); - if (o.cmp(fi.n) >= 0 || o.isZero()) return 1; - let a; - try { - a = eb.sign(e, r, { canonical: !0, k: i, pers: n }); - } catch { - return 1; - } - return ( - t.signature.set(a.r.toArrayLike(Uint8Array, "be", 32), 0), - t.signature.set(a.s.toArrayLike(Uint8Array, "be", 32), 32), - (t.recid = a.recoveryParam), - 0 - ); - }, - ecdsaVerify(t, e, r) { - let n = { r: t.subarray(0, 32), s: t.subarray(32, 64) }, - i = new Ao(n.r), - o = new Ao(n.s); - if (i.cmp(fi.n) >= 0 || o.cmp(fi.n) >= 0) return 1; - if (o.cmp(eb.nh) === 1 || i.isZero() || o.isZero()) return 3; - let a = xA(r); - if (a === null) return 2; - let s = a.getPublic(); - return eb.verify(e, n, s) ? 0 : 3; - }, - ecdsaRecover(t, e, r, n) { - let i = { r: e.slice(0, 32), s: e.slice(32, 64) }, - o = new Ao(i.r), - a = new Ao(i.s); - if (o.cmp(fi.n) >= 0 || a.cmp(fi.n) >= 0) return 1; - if (o.isZero() || a.isZero()) return 2; - let s; - try { - s = eb.recoverPubKey(n, i, r); - } catch { - return 2; - } - return VT(t, s), 0; - }, - ecdh(t, e, r, n, i, o, a) { - let s = xA(e); - if (s === null) return 1; - let c = new Ao(r); - if (c.cmp(fi.n) >= 0 || c.isZero()) return 2; - let u = s.getPublic().mul(c); - if (i === void 0) { - let h = u.encode(null, !0), - w = eb.hash().update(h).digest(); - for (let M = 0; M < 32; ++M) t[M] = w[M]; - } else { - o || (o = new Uint8Array(32)); - let h = u.getX().toArray("be", 32); - for (let O = 0; O < 32; ++O) o[O] = h[O]; - a || (a = new Uint8Array(32)); - let w = u.getY().toArray("be", 32); - for (let O = 0; O < 32; ++O) a[O] = w[O]; - let M = i(o, a, n); - if (!(M instanceof Uint8Array && M.length === t.length)) return 2; - t.set(M); - } - return 0; - }, - }; - }); - var W2e = I((Zyn, cst) => { - m(); - g(); - cst.exports = ast()(ust()); - }); - var dst = I((Xyn, fst) => { - m(); - g(); - var { Transform: Pmr } = mq(); - fst.exports = (t) => - class lst extends Pmr { - constructor(r, n, i, o, a) { - super(a), - (this._rate = r), - (this._capacity = n), - (this._delimitedSuffix = i), - (this._hashBitLength = o), - (this._options = a), - (this._state = new t()), - this._state.initialize(r, n), - (this._finalized = !1); - } - _transform(r, n, i) { - let o = null; - try { - this.update(r, n); - } catch (a) { - o = a; - } - i(o); - } - _flush(r) { - let n = null; - try { - this.push(this.digest()); - } catch (i) { - n = i; - } - r(n); - } - update(r, n) { - if (!Buffer.isBuffer(r) && typeof r != "string") - throw new TypeError("Data must be a string or a buffer"); - if (this._finalized) throw new Error("Digest already called"); - return ( - Buffer.isBuffer(r) || (r = Buffer.from(r, n)), - this._state.absorb(r), - this - ); - } - digest(r) { - if (this._finalized) throw new Error("Digest already called"); - (this._finalized = !0), - this._delimitedSuffix && - this._state.absorbLastFewBits(this._delimitedSuffix); - let n = this._state.squeeze(this._hashBitLength / 8); - return r !== void 0 && (n = n.toString(r)), this._resetState(), n; - } - _resetState() { - return this._state.initialize(this._rate, this._capacity), this; - } - _clone() { - let r = new lst( - this._rate, - this._capacity, - this._delimitedSuffix, - this._hashBitLength, - this._options - ); - return ( - this._state.copy(r._state), (r._finalized = this._finalized), r - ); - } - }; - }); - var yst = I((Yyn, pst) => { - m(); - g(); - var { Transform: Omr } = mq(); - pst.exports = (t) => - class hst extends Omr { - constructor(r, n, i, o) { - super(o), - (this._rate = r), - (this._capacity = n), - (this._delimitedSuffix = i), - (this._options = o), - (this._state = new t()), - this._state.initialize(r, n), - (this._finalized = !1); - } - _transform(r, n, i) { - let o = null; - try { - this.update(r, n); - } catch (a) { - o = a; - } - i(o); - } - _flush() {} - _read(r) { - this.push(this.squeeze(r)); - } - update(r, n) { - if (!Buffer.isBuffer(r) && typeof r != "string") - throw new TypeError("Data must be a string or a buffer"); - if (this._finalized) throw new Error("Squeeze already called"); - return ( - Buffer.isBuffer(r) || (r = Buffer.from(r, n)), - this._state.absorb(r), - this - ); - } - squeeze(r, n) { - this._finalized || - ((this._finalized = !0), - this._state.absorbLastFewBits(this._delimitedSuffix)); - let i = this._state.squeeze(r); - return n !== void 0 && (i = i.toString(n)), i; - } - _resetState() { - return this._state.initialize(this._rate, this._capacity), this; - } - _clone() { - let r = new hst( - this._rate, - this._capacity, - this._delimitedSuffix, - this._options - ); - return ( - this._state.copy(r._state), (r._finalized = this._finalized), r - ); - } - }; - }); - var gst = I((Qyn, mst) => { - m(); - g(); - var Bmr = dst(), - Imr = yst(); - mst.exports = function (t) { - let e = Bmr(t), - r = Imr(t); - return function (n, i) { - switch (typeof n == "string" ? n.toLowerCase() : n) { - case "keccak224": - return new e(1152, 448, null, 224, i); - case "keccak256": - return new e(1088, 512, null, 256, i); - case "keccak384": - return new e(832, 768, null, 384, i); - case "keccak512": - return new e(576, 1024, null, 512, i); - case "sha3-224": - return new e(1152, 448, 6, 224, i); - case "sha3-256": - return new e(1088, 512, 6, 256, i); - case "sha3-384": - return new e(832, 768, 6, 384, i); - case "sha3-512": - return new e(576, 1024, 6, 512, i); - case "shake128": - return new r(1344, 256, 31, i); - case "shake256": - return new r(1088, 512, 31, i); - default: - throw new Error("Invald algorithm: " + n); - } - }; - }; - }); - var wst = I((bst) => { - m(); - g(); - var vst = [ - 1, 0, 32898, 0, 32906, 2147483648, 2147516416, 2147483648, 32907, 0, - 2147483649, 0, 2147516545, 2147483648, 32777, 2147483648, 138, 0, 136, 0, - 2147516425, 0, 2147483658, 0, 2147516555, 0, 139, 2147483648, 32905, - 2147483648, 32771, 2147483648, 32770, 2147483648, 128, 2147483648, 32778, - 0, 2147483658, 2147483648, 2147516545, 2147483648, 32896, 2147483648, - 2147483649, 0, 2147516424, 2147483648, - ]; - bst.p1600 = function (t) { - for (let e = 0; e < 24; ++e) { - let r = t[0] ^ t[10] ^ t[20] ^ t[30] ^ t[40], - n = t[1] ^ t[11] ^ t[21] ^ t[31] ^ t[41], - i = t[2] ^ t[12] ^ t[22] ^ t[32] ^ t[42], - o = t[3] ^ t[13] ^ t[23] ^ t[33] ^ t[43], - a = t[4] ^ t[14] ^ t[24] ^ t[34] ^ t[44], - s = t[5] ^ t[15] ^ t[25] ^ t[35] ^ t[45], - c = t[6] ^ t[16] ^ t[26] ^ t[36] ^ t[46], - u = t[7] ^ t[17] ^ t[27] ^ t[37] ^ t[47], - h = t[8] ^ t[18] ^ t[28] ^ t[38] ^ t[48], - w = t[9] ^ t[19] ^ t[29] ^ t[39] ^ t[49], - M = h ^ ((i << 1) | (o >>> 31)), - k = w ^ ((o << 1) | (i >>> 31)), - O = t[0] ^ M, - D = t[1] ^ k, - F = t[10] ^ M, - N = t[11] ^ k, - q = t[20] ^ M, - z = t[21] ^ k, - H = t[30] ^ M, - Z = t[31] ^ k, - $ = t[40] ^ M, - ue = t[41] ^ k; - (M = r ^ ((a << 1) | (s >>> 31))), (k = n ^ ((s << 1) | (a >>> 31))); - let te = t[2] ^ M, - ne = t[3] ^ k, - A = t[12] ^ M, - l = t[13] ^ k, - p = t[22] ^ M, - y = t[23] ^ k, - d = t[32] ^ M, - v = t[33] ^ k, - _ = t[42] ^ M, - S = t[43] ^ k; - (M = i ^ ((c << 1) | (u >>> 31))), (k = o ^ ((u << 1) | (c >>> 31))); - let b = t[4] ^ M, - f = t[5] ^ k, - x = t[14] ^ M, - C = t[15] ^ k, - E = t[24] ^ M, - B = t[25] ^ k, - G = t[34] ^ M, - L = t[35] ^ k, - ee = t[44] ^ M, - ge = t[45] ^ k; - (M = a ^ ((h << 1) | (w >>> 31))), (k = s ^ ((w << 1) | (h >>> 31))); - let fe = t[6] ^ M, - V = t[7] ^ k, - ye = t[16] ^ M, - ae = t[17] ^ k, - le = t[26] ^ M, - Me = t[27] ^ k, - de = t[36] ^ M, - ve = t[37] ^ k, - De = t[46] ^ M, - me = t[47] ^ k; - (M = c ^ ((r << 1) | (n >>> 31))), (k = u ^ ((n << 1) | (r >>> 31))); - let _e = t[8] ^ M, - Ye = t[9] ^ k, - Ee = t[18] ^ M, - Be = t[19] ^ k, - kt = t[28] ^ M, - Ve = t[29] ^ k, - We = t[38] ^ M, - er = t[39] ^ k, - Ue = t[48] ^ M, - Y = t[49] ^ k, - W = O, - j = D, - ce = (N << 4) | (F >>> 28), - ze = (F << 4) | (N >>> 28), - we = (q << 3) | (z >>> 29), - xe = (z << 3) | (q >>> 29), - Ft = (Z << 9) | (H >>> 23), - Ke = (H << 9) | (Z >>> 23), - pe = ($ << 18) | (ue >>> 14), - Re = (ue << 18) | ($ >>> 14), - Se = (te << 1) | (ne >>> 31), - Pe = (ne << 1) | (te >>> 31), - At = (l << 12) | (A >>> 20), - Ie = (A << 12) | (l >>> 20), - je = (p << 10) | (y >>> 22), - qt = (y << 10) | (p >>> 22), - Fe = (v << 13) | (d >>> 19), - He = (d << 13) | (v >>> 19), - lr = (_ << 2) | (S >>> 30), - Xe = (S << 2) | (_ >>> 30), - Ze = (f << 30) | (b >>> 2), - Ir = (b << 30) | (f >>> 2), - $e = (x << 6) | (C >>> 26), - tt = (C << 6) | (x >>> 26), - oe = (B << 11) | (E >>> 21), - ie = (E << 11) | (B >>> 21), - re = (G << 15) | (L >>> 17), - U = (L << 15) | (G >>> 17), - se = (ge << 29) | (ee >>> 3), - be = (ee << 29) | (ge >>> 3), - Qe = (fe << 28) | (V >>> 4), - Ae = (V << 28) | (fe >>> 4), - ke = (ae << 23) | (ye >>> 9), - Ct = (ye << 23) | (ae >>> 9), - ut = (le << 25) | (Me >>> 7), - St = (Me << 25) | (le >>> 7), - wt = (de << 21) | (ve >>> 11), - zt = (ve << 21) | (de >>> 11), - jt = (me << 24) | (De >>> 8), - Ht = (De << 24) | (me >>> 8), - Ut = (_e << 27) | (Ye >>> 5), - Kt = (Ye << 27) | (_e >>> 5), - Ot = (Ee << 20) | (Be >>> 12), - Bt = (Be << 20) | (Ee >>> 12), - Et = (Ve << 7) | (kt >>> 25), - Mt = (kt << 7) | (Ve >>> 25), - gt = (We << 8) | (er >>> 24), - Pt = (er << 8) | (We >>> 24), - It = (Ue << 14) | (Y >>> 18), - yt = (Y << 14) | (Ue >>> 18); - (t[0] = W ^ (~At & oe)), - (t[1] = j ^ (~Ie & ie)), - (t[10] = Qe ^ (~Ot & we)), - (t[11] = Ae ^ (~Bt & xe)), - (t[20] = Se ^ (~$e & ut)), - (t[21] = Pe ^ (~tt & St)), - (t[30] = Ut ^ (~ce & je)), - (t[31] = Kt ^ (~ze & qt)), - (t[40] = Ze ^ (~ke & Et)), - (t[41] = Ir ^ (~Ct & Mt)), - (t[2] = At ^ (~oe & wt)), - (t[3] = Ie ^ (~ie & zt)), - (t[12] = Ot ^ (~we & Fe)), - (t[13] = Bt ^ (~xe & He)), - (t[22] = $e ^ (~ut & gt)), - (t[23] = tt ^ (~St & Pt)), - (t[32] = ce ^ (~je & re)), - (t[33] = ze ^ (~qt & U)), - (t[42] = ke ^ (~Et & Ft)), - (t[43] = Ct ^ (~Mt & Ke)), - (t[4] = oe ^ (~wt & It)), - (t[5] = ie ^ (~zt & yt)), - (t[14] = we ^ (~Fe & se)), - (t[15] = xe ^ (~He & be)), - (t[24] = ut ^ (~gt & pe)), - (t[25] = St ^ (~Pt & Re)), - (t[34] = je ^ (~re & jt)), - (t[35] = qt ^ (~U & Ht)), - (t[44] = Et ^ (~Ft & lr)), - (t[45] = Mt ^ (~Ke & Xe)), - (t[6] = wt ^ (~It & W)), - (t[7] = zt ^ (~yt & j)), - (t[16] = Fe ^ (~se & Qe)), - (t[17] = He ^ (~be & Ae)), - (t[26] = gt ^ (~pe & Se)), - (t[27] = Pt ^ (~Re & Pe)), - (t[36] = re ^ (~jt & Ut)), - (t[37] = U ^ (~Ht & Kt)), - (t[46] = Ft ^ (~lr & Ze)), - (t[47] = Ke ^ (~Xe & Ir)), - (t[8] = It ^ (~W & At)), - (t[9] = yt ^ (~j & Ie)), - (t[18] = se ^ (~Qe & Ot)), - (t[19] = be ^ (~Ae & Bt)), - (t[28] = pe ^ (~Se & $e)), - (t[29] = Re ^ (~Pe & tt)), - (t[38] = jt ^ (~Ut & ce)), - (t[39] = Ht ^ (~Kt & ze)), - (t[48] = lr ^ (~Ze & ke)), - (t[49] = Xe ^ (~Ir & Ct)), - (t[0] ^= vst[e * 2]), - (t[1] ^= vst[e * 2 + 1]); - } - }; - }); - var xst = I((tmn, _st) => { - m(); - g(); - var zte = wst(); - function pR() { - (this.state = [ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, - ]), - (this.blockSize = null), - (this.count = 0), - (this.squeezing = !1); - } - pR.prototype.initialize = function (t, e) { - for (let r = 0; r < 50; ++r) this.state[r] = 0; - (this.blockSize = t / 8), (this.count = 0), (this.squeezing = !1); - }; - pR.prototype.absorb = function (t) { - for (let e = 0; e < t.length; ++e) - (this.state[~~(this.count / 4)] ^= t[e] << (8 * (this.count % 4))), - (this.count += 1), - this.count === this.blockSize && - (zte.p1600(this.state), (this.count = 0)); - }; - pR.prototype.absorbLastFewBits = function (t) { - (this.state[~~(this.count / 4)] ^= t << (8 * (this.count % 4))), - (t & 128) !== 0 && - this.count === this.blockSize - 1 && - zte.p1600(this.state), - (this.state[~~((this.blockSize - 1) / 4)] ^= - 128 << (8 * ((this.blockSize - 1) % 4))), - zte.p1600(this.state), - (this.count = 0), - (this.squeezing = !0); - }; - pR.prototype.squeeze = function (t) { - this.squeezing || this.absorbLastFewBits(1); - let e = Buffer.alloc(t); - for (let r = 0; r < t; ++r) - (e[r] = - (this.state[~~(this.count / 4)] >>> (8 * (this.count % 4))) & 255), - (this.count += 1), - this.count === this.blockSize && - (zte.p1600(this.state), (this.count = 0)); - return e; - }; - pR.prototype.copy = function (t) { - for (let e = 0; e < 50; ++e) t.state[e] = this.state[e]; - (t.blockSize = this.blockSize), - (t.count = this.count), - (t.squeezing = this.squeezing); - }; - _st.exports = pR; - }); - var Ast = I((rmn, Sst) => { - m(); - g(); - Sst.exports = gst()(xst()); - }); - var J2e = I((G2e, kst) => { - "use strict"; - m(); - g(); - var Est = - (G2e && G2e.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }, - Cmr = Est(Ho()), - SA = Qr(), - Rmr = Est(Ast()); - function Mst(t) { - return (t = Nmr(t)), Rmr.default("keccak256").update(t).digest(); - } - function Nmr(t) { - if (!SA.Buffer.isBuffer(t)) - if (Array.isArray(t)) t = SA.Buffer.from(t); - else if (typeof t == "string") - Dmr(t) - ? (t = SA.Buffer.from(Tst(Fmr(t)), "hex")) - : (t = SA.Buffer.from(t)); - else if (typeof t == "number") t = qmr(t); - else if (t == null) t = SA.Buffer.allocUnsafe(0); - else if (Cmr.default.isBN(t)) t = t.toArrayLike(SA.Buffer); - else if (t.toArray) t = SA.Buffer.from(t.toArray()); - else throw new Error("invalid type"); - return t; - } - function Dmr(t, e) { - return !( - typeof t != "string" || - !t.match(/^0x[0-9A-Fa-f]*$/) || - (e && t.length !== 2 + 2 * e) - ); - } - function Tst(t) { - if (typeof t != "string") - throw new Error( - `while padding to even, value must be string, is currently ${typeof t}, while padToEven.` - ); - return t.length % 2 && (t = `0${t}`), t; - } - function Fmr(t) { - return typeof t != "string" ? t : Lmr(t) ? t.slice(2) : t; - } - function Lmr(t) { - if (typeof t != "string") - throw new Error( - "value must be type 'string', is currently type " + - typeof t + - ", while checking isHexPrefixed." - ); - return t.slice(0, 2) === "0x"; - } - function qmr(t) { - let e = zmr(t); - return SA.Buffer.from(Tst(e.slice(2)), "hex"); - } - function zmr(t) { - return `0x${t.toString(16)}`; - } - typeof window < "u" && (window.keccak256 = Mst); - kst.exports = Mst; - }); - var Bst = I((OU) => { - "use strict"; - m(); - g(); - var Z2e = - (OU && OU.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(OU, "__esModule", { value: !0 }); - var jmr = Z2e(ng()), - Pst = Z2e(W2e()), - PU = KT(), - Ost = Z2e(J2e()), - $2e = class { - constructor(e, r) { - (this._key = e), - (this.ownerLength = - PU.SIG_CONFIG[PU.SignatureConfig.ETHEREUM].pubLength), - (this.signatureLength = - PU.SIG_CONFIG[PU.SignatureConfig.ETHEREUM].sigLength), - (this.signatureType = PU.SignatureConfig.ETHEREUM), - (this.pk = r.toString("hex")); - } - get publicKey() { - return Buffer.alloc(0); - } - get key() { - return Buffer.from(this._key, "hex"); - } - static async verify(e, r, n) { - let i = e; - typeof e == "string" && (i = jmr.default.toBuffer(e)); - let o = !1; - try { - o = Pst.default.ecdsaVerify(n, Ost.default(Buffer.from(r)), i); - } catch {} - return o; - } - sign(e) { - return Pst.default.ecdsaSign( - Ost.default(Buffer.from(e)), - Buffer.from(this.key) - ).signature; - } - }; - OU.default = $2e; - }); - var Ist = I((jte) => { - "use strict"; - m(); - g(); - Object.defineProperty(jte, "__esModule", { value: !0 }); - jte.version = void 0; - jte.version = "logger/5.7.0"; - }); - var rr = I((rb) => { - "use strict"; - m(); - g(); - Object.defineProperty(rb, "__esModule", { value: !0 }); - rb.Logger = rb.ErrorCode = rb.LogLevel = void 0; - var Cst = !1, - Rst = !1, - Ute = { debug: 1, default: 2, info: 2, warning: 3, error: 4, off: 5 }, - Nst = Ute.default, - Umr = Ist(), - X2e = null; - function Kmr() { - try { - var t = []; - if ( - (["NFD", "NFC", "NFKD", "NFKC"].forEach(function (e) { - try { - if ("test".normalize(e) !== "test") - throw new Error("bad normalize"); - } catch { - t.push(e); - } - }), - t.length) - ) - throw new Error("missing " + t.join(", ")); - if ( - String.fromCharCode(233).normalize("NFD") !== - String.fromCharCode(101, 769) - ) - throw new Error("broken implementation"); - } catch (e) { - return e.message; - } - return null; - } - var Dst = Kmr(), - Lst; - (function (t) { - (t.DEBUG = "DEBUG"), - (t.INFO = "INFO"), - (t.WARNING = "WARNING"), - (t.ERROR = "ERROR"), - (t.OFF = "OFF"); - })((Lst = rb.LogLevel || (rb.LogLevel = {}))); - var tb; - (function (t) { - (t.UNKNOWN_ERROR = "UNKNOWN_ERROR"), - (t.NOT_IMPLEMENTED = "NOT_IMPLEMENTED"), - (t.UNSUPPORTED_OPERATION = "UNSUPPORTED_OPERATION"), - (t.NETWORK_ERROR = "NETWORK_ERROR"), - (t.SERVER_ERROR = "SERVER_ERROR"), - (t.TIMEOUT = "TIMEOUT"), - (t.BUFFER_OVERRUN = "BUFFER_OVERRUN"), - (t.NUMERIC_FAULT = "NUMERIC_FAULT"), - (t.MISSING_NEW = "MISSING_NEW"), - (t.INVALID_ARGUMENT = "INVALID_ARGUMENT"), - (t.MISSING_ARGUMENT = "MISSING_ARGUMENT"), - (t.UNEXPECTED_ARGUMENT = "UNEXPECTED_ARGUMENT"), - (t.CALL_EXCEPTION = "CALL_EXCEPTION"), - (t.INSUFFICIENT_FUNDS = "INSUFFICIENT_FUNDS"), - (t.NONCE_EXPIRED = "NONCE_EXPIRED"), - (t.REPLACEMENT_UNDERPRICED = "REPLACEMENT_UNDERPRICED"), - (t.UNPREDICTABLE_GAS_LIMIT = "UNPREDICTABLE_GAS_LIMIT"), - (t.TRANSACTION_REPLACED = "TRANSACTION_REPLACED"), - (t.ACTION_REJECTED = "ACTION_REJECTED"); - })((tb = rb.ErrorCode || (rb.ErrorCode = {}))); - var Fst = "0123456789abcdef", - Hmr = (function () { - function t(e) { - Object.defineProperty(this, "version", { - enumerable: !0, - value: e, - writable: !1, - }); - } - return ( - (t.prototype._log = function (e, r) { - var n = e.toLowerCase(); - Ute[n] == null && - this.throwArgumentError("invalid log level name", "logLevel", e), - !(Nst > Ute[n]) && console.log.apply(console, r); - }), - (t.prototype.debug = function () { - for (var e = [], r = 0; r < arguments.length; r++) - e[r] = arguments[r]; - this._log(t.levels.DEBUG, e); - }), - (t.prototype.info = function () { - for (var e = [], r = 0; r < arguments.length; r++) - e[r] = arguments[r]; - this._log(t.levels.INFO, e); - }), - (t.prototype.warn = function () { - for (var e = [], r = 0; r < arguments.length; r++) - e[r] = arguments[r]; - this._log(t.levels.WARNING, e); - }), - (t.prototype.makeError = function (e, r, n) { - if (Rst) return this.makeError("censored error", r, {}); - r || (r = t.errors.UNKNOWN_ERROR), n || (n = {}); - var i = []; - Object.keys(n).forEach(function (u) { - var h = n[u]; - try { - if (h instanceof Uint8Array) { - for (var w = "", M = 0; M < h.length; M++) - (w += Fst[h[M] >> 4]), (w += Fst[h[M] & 15]); - i.push(u + "=Uint8Array(0x" + w + ")"); - } else i.push(u + "=" + JSON.stringify(h)); - } catch { - i.push(u + "=" + JSON.stringify(n[u].toString())); - } - }), - i.push("code=" + r), - i.push("version=" + this.version); - var o = e, - a = ""; - switch (r) { - case tb.NUMERIC_FAULT: { - a = "NUMERIC_FAULT"; - var s = e; - switch (s) { - case "overflow": - case "underflow": - case "division-by-zero": - a += "-" + s; - break; - case "negative-power": - case "negative-width": - a += "-unsupported"; - break; - case "unbound-bitwise-result": - a += "-unbound-result"; - break; - } - break; - } - case tb.CALL_EXCEPTION: - case tb.INSUFFICIENT_FUNDS: - case tb.MISSING_NEW: - case tb.NONCE_EXPIRED: - case tb.REPLACEMENT_UNDERPRICED: - case tb.TRANSACTION_REPLACED: - case tb.UNPREDICTABLE_GAS_LIMIT: - a = r; - break; - } - a && - (e += " [ See: https://links.ethers.org/v5-errors-" + a + " ]"), - i.length && (e += " (" + i.join(", ") + ")"); - var c = new Error(e); - return ( - (c.reason = o), - (c.code = r), - Object.keys(n).forEach(function (u) { - c[u] = n[u]; - }), - c - ); - }), - (t.prototype.throwError = function (e, r, n) { - throw this.makeError(e, r, n); - }), - (t.prototype.throwArgumentError = function (e, r, n) { - return this.throwError(e, t.errors.INVALID_ARGUMENT, { - argument: r, - value: n, - }); - }), - (t.prototype.assert = function (e, r, n, i) { - e || this.throwError(r, n, i); - }), - (t.prototype.assertArgument = function (e, r, n, i) { - e || this.throwArgumentError(r, n, i); - }), - (t.prototype.checkNormalize = function (e) { - e == null && (e = "platform missing String.prototype.normalize"), - Dst && - this.throwError( - "platform missing String.prototype.normalize", - t.errors.UNSUPPORTED_OPERATION, - { operation: "String.prototype.normalize", form: Dst } - ); - }), - (t.prototype.checkSafeUint53 = function (e, r) { - typeof e == "number" && - (r == null && (r = "value not safe"), - (e < 0 || e >= 9007199254740991) && - this.throwError(r, t.errors.NUMERIC_FAULT, { - operation: "checkSafeInteger", - fault: "out-of-safe-range", - value: e, - }), - e % 1 && - this.throwError(r, t.errors.NUMERIC_FAULT, { - operation: "checkSafeInteger", - fault: "non-integer", - value: e, - })); - }), - (t.prototype.checkArgumentCount = function (e, r, n) { - n ? (n = ": " + n) : (n = ""), - e < r && - this.throwError( - "missing argument" + n, - t.errors.MISSING_ARGUMENT, - { count: e, expectedCount: r } - ), - e > r && - this.throwError( - "too many arguments" + n, - t.errors.UNEXPECTED_ARGUMENT, - { count: e, expectedCount: r } - ); - }), - (t.prototype.checkNew = function (e, r) { - (e === Object || e == null) && - this.throwError("missing new", t.errors.MISSING_NEW, { - name: r.name, - }); - }), - (t.prototype.checkAbstract = function (e, r) { - e === r - ? this.throwError( - "cannot instantiate abstract class " + - JSON.stringify(r.name) + - " directly; use a sub-class", - t.errors.UNSUPPORTED_OPERATION, - { name: e.name, operation: "new" } - ) - : (e === Object || e == null) && - this.throwError("missing new", t.errors.MISSING_NEW, { - name: r.name, - }); - }), - (t.globalLogger = function () { - return X2e || (X2e = new t(Umr.version)), X2e; - }), - (t.setCensorship = function (e, r) { - if ( - (!e && - r && - this.globalLogger().throwError( - "cannot permanently disable censorship", - t.errors.UNSUPPORTED_OPERATION, - { operation: "setCensorship" } - ), - Cst) - ) { - if (!e) return; - this.globalLogger().throwError( - "error censorship permanent", - t.errors.UNSUPPORTED_OPERATION, - { operation: "setCensorship" } - ); - } - (Rst = !!e), (Cst = !!r); - }), - (t.setLogLevel = function (e) { - var r = Ute[e.toLowerCase()]; - if (r == null) { - t.globalLogger().warn("invalid log level - " + e); - return; - } - Nst = r; - }), - (t.from = function (e) { - return new t(e); - }), - (t.errors = tb), - (t.levels = Lst), - t - ); - })(); - rb.Logger = Hmr; - }); - var qst = I((Kte) => { - "use strict"; - m(); - g(); - Object.defineProperty(Kte, "__esModule", { value: !0 }); - Kte.version = void 0; - Kte.version = "bytes/5.7.0"; - }); - var Ar = I((_i) => { - "use strict"; - m(); - g(); - Object.defineProperty(_i, "__esModule", { value: !0 }); - _i.joinSignature = - _i.splitSignature = - _i.hexZeroPad = - _i.hexStripZeros = - _i.hexValue = - _i.hexConcat = - _i.hexDataSlice = - _i.hexDataLength = - _i.hexlify = - _i.isHexString = - _i.zeroPad = - _i.stripZeros = - _i.concat = - _i.arrayify = - _i.isBytes = - _i.isBytesLike = - void 0; - var Vmr = rr(), - Wmr = qst(), - ja = new Vmr.Logger(Wmr.version); - function jst(t) { - return !!t.toHexString; - } - function yR(t) { - return ( - t.slice || - (t.slice = function () { - var e = Array.prototype.slice.call(arguments); - return yR(new Uint8Array(Array.prototype.slice.apply(t, e))); - }), - t - ); - } - function Ust(t) { - return (dg(t) && !(t.length % 2)) || Vte(t); - } - _i.isBytesLike = Ust; - function zst(t) { - return typeof t == "number" && t == t && t % 1 === 0; - } - function Vte(t) { - if (t == null) return !1; - if (t.constructor === Uint8Array) return !0; - if (typeof t == "string" || !zst(t.length) || t.length < 0) return !1; - for (var e = 0; e < t.length; e++) { - var r = t[e]; - if (!zst(r) || r < 0 || r >= 256) return !1; - } - return !0; - } - _i.isBytes = Vte; - function WT(t, e) { - if ((e || (e = {}), typeof t == "number")) { - ja.checkSafeUint53(t, "invalid arrayify value"); - for (var r = []; t; ) - r.unshift(t & 255), (t = parseInt(String(t / 256))); - return r.length === 0 && r.push(0), yR(new Uint8Array(r)); - } - if ( - (e.allowMissingPrefix && - typeof t == "string" && - t.substring(0, 2) !== "0x" && - (t = "0x" + t), - jst(t) && (t = t.toHexString()), - dg(t)) - ) { - var n = t.substring(2); - n.length % 2 && - (e.hexPad === "left" - ? (n = "0" + n) - : e.hexPad === "right" - ? (n += "0") - : ja.throwArgumentError("hex data is odd-length", "value", t)); - for (var r = [], i = 0; i < n.length; i += 2) - r.push(parseInt(n.substring(i, i + 2), 16)); - return yR(new Uint8Array(r)); - } - return Vte(t) - ? yR(new Uint8Array(t)) - : ja.throwArgumentError("invalid arrayify value", "value", t); - } - _i.arrayify = WT; - function Kst(t) { - var e = t.map(function (i) { - return WT(i); - }), - r = e.reduce(function (i, o) { - return i + o.length; - }, 0), - n = new Uint8Array(r); - return ( - e.reduce(function (i, o) { - return n.set(o, i), i + o.length; - }, 0), - yR(n) - ); - } - _i.concat = Kst; - function Gmr(t) { - var e = WT(t); - if (e.length === 0) return e; - for (var r = 0; r < e.length && e[r] === 0; ) r++; - return r && (e = e.slice(r)), e; - } - _i.stripZeros = Gmr; - function Hst(t, e) { - (t = WT(t)), - t.length > e && - ja.throwArgumentError("value out of range", "value", arguments[0]); - var r = new Uint8Array(e); - return r.set(t, e - t.length), yR(r); - } - _i.zeroPad = Hst; - function dg(t, e) { - return !( - typeof t != "string" || - !t.match(/^0x[0-9A-Fa-f]*$/) || - (e && t.length !== 2 + 2 * e) - ); - } - _i.isHexString = dg; - var Y2e = "0123456789abcdef"; - function Xc(t, e) { - if ((e || (e = {}), typeof t == "number")) { - ja.checkSafeUint53(t, "invalid hexlify value"); - for (var r = ""; t; ) (r = Y2e[t & 15] + r), (t = Math.floor(t / 16)); - return r.length ? (r.length % 2 && (r = "0" + r), "0x" + r) : "0x00"; - } - if (typeof t == "bigint") - return (t = t.toString(16)), t.length % 2 ? "0x0" + t : "0x" + t; - if ( - (e.allowMissingPrefix && - typeof t == "string" && - t.substring(0, 2) !== "0x" && - (t = "0x" + t), - jst(t)) - ) - return t.toHexString(); - if (dg(t)) - return ( - t.length % 2 && - (e.hexPad === "left" - ? (t = "0x0" + t.substring(2)) - : e.hexPad === "right" - ? (t += "0") - : ja.throwArgumentError("hex data is odd-length", "value", t)), - t.toLowerCase() - ); - if (Vte(t)) { - for (var n = "0x", i = 0; i < t.length; i++) { - var o = t[i]; - n += Y2e[(o & 240) >> 4] + Y2e[o & 15]; - } - return n; - } - return ja.throwArgumentError("invalid hexlify value", "value", t); - } - _i.hexlify = Xc; - function Jmr(t) { - if (typeof t != "string") t = Xc(t); - else if (!dg(t) || t.length % 2) return null; - return (t.length - 2) / 2; - } - _i.hexDataLength = Jmr; - function $mr(t, e, r) { - return ( - typeof t != "string" - ? (t = Xc(t)) - : (!dg(t) || t.length % 2) && - ja.throwArgumentError("invalid hexData", "value", t), - (e = 2 + 2 * e), - r != null ? "0x" + t.substring(e, 2 + 2 * r) : "0x" + t.substring(e) - ); - } - _i.hexDataSlice = $mr; - function Zmr(t) { - var e = "0x"; - return ( - t.forEach(function (r) { - e += Xc(r).substring(2); - }), - e - ); - } - _i.hexConcat = Zmr; - function Xmr(t) { - var e = Vst(Xc(t, { hexPad: "left" })); - return e === "0x" ? "0x0" : e; - } - _i.hexValue = Xmr; - function Vst(t) { - typeof t != "string" && (t = Xc(t)), - dg(t) || ja.throwArgumentError("invalid hex string", "value", t), - (t = t.substring(2)); - for (var e = 0; e < t.length && t[e] === "0"; ) e++; - return "0x" + t.substring(e); - } - _i.hexStripZeros = Vst; - function Hte(t, e) { - for ( - typeof t != "string" - ? (t = Xc(t)) - : dg(t) || ja.throwArgumentError("invalid hex string", "value", t), - t.length > 2 * e + 2 && - ja.throwArgumentError("value out of range", "value", arguments[1]); - t.length < 2 * e + 2; - - ) - t = "0x0" + t.substring(2); - return t; - } - _i.hexZeroPad = Hte; - function Wst(t) { - var e = { - r: "0x", - s: "0x", - _vs: "0x", - recoveryParam: 0, - v: 0, - yParityAndS: "0x", - compact: "0x", - }; - if (Ust(t)) { - var r = WT(t); - r.length === 64 - ? ((e.v = 27 + (r[32] >> 7)), - (r[32] &= 127), - (e.r = Xc(r.slice(0, 32))), - (e.s = Xc(r.slice(32, 64)))) - : r.length === 65 - ? ((e.r = Xc(r.slice(0, 32))), - (e.s = Xc(r.slice(32, 64))), - (e.v = r[64])) - : ja.throwArgumentError("invalid signature string", "signature", t), - e.v < 27 && - (e.v === 0 || e.v === 1 - ? (e.v += 27) - : ja.throwArgumentError( - "signature invalid v byte", - "signature", - t - )), - (e.recoveryParam = 1 - (e.v % 2)), - e.recoveryParam && (r[32] |= 128), - (e._vs = Xc(r.slice(32, 64))); - } else { - if ( - ((e.r = t.r), - (e.s = t.s), - (e.v = t.v), - (e.recoveryParam = t.recoveryParam), - (e._vs = t._vs), - e._vs != null) - ) { - var n = Hst(WT(e._vs), 32); - e._vs = Xc(n); - var i = n[0] >= 128 ? 1 : 0; - e.recoveryParam == null - ? (e.recoveryParam = i) - : e.recoveryParam !== i && - ja.throwArgumentError( - "signature recoveryParam mismatch _vs", - "signature", - t - ), - (n[0] &= 127); - var o = Xc(n); - e.s == null - ? (e.s = o) - : e.s !== o && - ja.throwArgumentError("signature v mismatch _vs", "signature", t); - } - if (e.recoveryParam == null) - e.v == null - ? ja.throwArgumentError( - "signature missing v and recoveryParam", - "signature", - t - ) - : e.v === 0 || e.v === 1 - ? (e.recoveryParam = e.v) - : (e.recoveryParam = 1 - (e.v % 2)); - else if (e.v == null) e.v = 27 + e.recoveryParam; - else { - var a = e.v === 0 || e.v === 1 ? e.v : 1 - (e.v % 2); - e.recoveryParam !== a && - ja.throwArgumentError( - "signature recoveryParam mismatch v", - "signature", - t - ); - } - e.r == null || !dg(e.r) - ? ja.throwArgumentError( - "signature missing or invalid r", - "signature", - t - ) - : (e.r = Hte(e.r, 32)), - e.s == null || !dg(e.s) - ? ja.throwArgumentError( - "signature missing or invalid s", - "signature", - t - ) - : (e.s = Hte(e.s, 32)); - var s = WT(e.s); - s[0] >= 128 && - ja.throwArgumentError("signature s out of range", "signature", t), - e.recoveryParam && (s[0] |= 128); - var c = Xc(s); - e._vs && - (dg(e._vs) || - ja.throwArgumentError("signature invalid _vs", "signature", t), - (e._vs = Hte(e._vs, 32))), - e._vs == null - ? (e._vs = c) - : e._vs !== c && - ja.throwArgumentError( - "signature _vs mismatch v and s", - "signature", - t - ); - } - return ( - (e.yParityAndS = e._vs), - (e.compact = e.r + e.yParityAndS.substring(2)), - e - ); - } - _i.splitSignature = Wst; - function Ymr(t) { - return ( - (t = Wst(t)), Xc(Kst([t.r, t.s, t.recoveryParam ? "0x1c" : "0x1b"])) - ); - } - _i.joinSignature = Ymr; - }); - var Q2e = I((Wte) => { - "use strict"; - m(); - g(); - Object.defineProperty(Wte, "__esModule", { value: !0 }); - Wte.version = void 0; - Wte.version = "bignumber/5.7.0"; - }); - var Jte = I((By) => { - "use strict"; - m(); - g(); - var Qmr = - (By && By.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(By, "__esModule", { value: !0 }); - By._base16To36 = By._base36To16 = By.BigNumber = By.isBigNumberish = void 0; - var egr = Qmr(Ho()), - BU = egr.default.BN, - mR = Ar(), - gR = rr(), - tgr = Q2e(), - hx = new gR.Logger(tgr.version), - eAe = {}, - Gst = 9007199254740991; - function rgr(t) { - return ( - t != null && - (Gte.isBigNumber(t) || - (typeof t == "number" && t % 1 === 0) || - (typeof t == "string" && !!t.match(/^-?[0-9]+$/)) || - (0, mR.isHexString)(t) || - typeof t == "bigint" || - (0, mR.isBytes)(t)) - ); - } - By.isBigNumberish = rgr; - var Jst = !1, - Gte = (function () { - function t(e, r) { - e !== eAe && - hx.throwError( - "cannot call constructor directly; use BigNumber.from", - gR.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "new (BigNumber)" } - ), - (this._hex = r), - (this._isBigNumber = !0), - Object.freeze(this); - } - return ( - (t.prototype.fromTwos = function (e) { - return Kh(ri(this).fromTwos(e)); - }), - (t.prototype.toTwos = function (e) { - return Kh(ri(this).toTwos(e)); - }), - (t.prototype.abs = function () { - return this._hex[0] === "-" ? t.from(this._hex.substring(1)) : this; - }), - (t.prototype.add = function (e) { - return Kh(ri(this).add(ri(e))); - }), - (t.prototype.sub = function (e) { - return Kh(ri(this).sub(ri(e))); - }), - (t.prototype.div = function (e) { - var r = t.from(e); - return ( - r.isZero() && Oy("division-by-zero", "div"), - Kh(ri(this).div(ri(e))) - ); - }), - (t.prototype.mul = function (e) { - return Kh(ri(this).mul(ri(e))); - }), - (t.prototype.mod = function (e) { - var r = ri(e); - return ( - r.isNeg() && Oy("division-by-zero", "mod"), Kh(ri(this).umod(r)) - ); - }), - (t.prototype.pow = function (e) { - var r = ri(e); - return ( - r.isNeg() && Oy("negative-power", "pow"), Kh(ri(this).pow(r)) - ); - }), - (t.prototype.and = function (e) { - var r = ri(e); - return ( - (this.isNegative() || r.isNeg()) && - Oy("unbound-bitwise-result", "and"), - Kh(ri(this).and(r)) - ); - }), - (t.prototype.or = function (e) { - var r = ri(e); - return ( - (this.isNegative() || r.isNeg()) && - Oy("unbound-bitwise-result", "or"), - Kh(ri(this).or(r)) - ); - }), - (t.prototype.xor = function (e) { - var r = ri(e); - return ( - (this.isNegative() || r.isNeg()) && - Oy("unbound-bitwise-result", "xor"), - Kh(ri(this).xor(r)) - ); - }), - (t.prototype.mask = function (e) { - return ( - (this.isNegative() || e < 0) && Oy("negative-width", "mask"), - Kh(ri(this).maskn(e)) - ); - }), - (t.prototype.shl = function (e) { - return ( - (this.isNegative() || e < 0) && Oy("negative-width", "shl"), - Kh(ri(this).shln(e)) - ); - }), - (t.prototype.shr = function (e) { - return ( - (this.isNegative() || e < 0) && Oy("negative-width", "shr"), - Kh(ri(this).shrn(e)) - ); - }), - (t.prototype.eq = function (e) { - return ri(this).eq(ri(e)); - }), - (t.prototype.lt = function (e) { - return ri(this).lt(ri(e)); - }), - (t.prototype.lte = function (e) { - return ri(this).lte(ri(e)); - }), - (t.prototype.gt = function (e) { - return ri(this).gt(ri(e)); - }), - (t.prototype.gte = function (e) { - return ri(this).gte(ri(e)); - }), - (t.prototype.isNegative = function () { - return this._hex[0] === "-"; - }), - (t.prototype.isZero = function () { - return ri(this).isZero(); - }), - (t.prototype.toNumber = function () { - try { - return ri(this).toNumber(); - } catch { - Oy("overflow", "toNumber", this.toString()); - } - return null; - }), - (t.prototype.toBigInt = function () { - try { - return BigInt(this.toString()); - } catch {} - return hx.throwError( - "this platform does not support BigInt", - gR.Logger.errors.UNSUPPORTED_OPERATION, - { value: this.toString() } - ); - }), - (t.prototype.toString = function () { - return ( - arguments.length > 0 && - (arguments[0] === 10 - ? Jst || - ((Jst = !0), - hx.warn( - "BigNumber.toString does not accept any parameters; base-10 is assumed" - )) - : arguments[0] === 16 - ? hx.throwError( - "BigNumber.toString does not accept any parameters; use bigNumber.toHexString()", - gR.Logger.errors.UNEXPECTED_ARGUMENT, - {} - ) - : hx.throwError( - "BigNumber.toString does not accept parameters", - gR.Logger.errors.UNEXPECTED_ARGUMENT, - {} - )), - ri(this).toString(10) - ); - }), - (t.prototype.toHexString = function () { - return this._hex; - }), - (t.prototype.toJSON = function (e) { - return { type: "BigNumber", hex: this.toHexString() }; - }), - (t.from = function (e) { - if (e instanceof t) return e; - if (typeof e == "string") - return e.match(/^-?0x[0-9a-f]+$/i) - ? new t(eAe, IU(e)) - : e.match(/^-?[0-9]+$/) - ? new t(eAe, IU(new BU(e))) - : hx.throwArgumentError("invalid BigNumber string", "value", e); - if (typeof e == "number") - return ( - e % 1 && Oy("underflow", "BigNumber.from", e), - (e >= Gst || e <= -Gst) && Oy("overflow", "BigNumber.from", e), - t.from(String(e)) - ); - var r = e; - if (typeof r == "bigint") return t.from(r.toString()); - if ((0, mR.isBytes)(r)) return t.from((0, mR.hexlify)(r)); - if (r) - if (r.toHexString) { - var n = r.toHexString(); - if (typeof n == "string") return t.from(n); - } else { - var n = r._hex; - if ( - (n == null && r.type === "BigNumber" && (n = r.hex), - typeof n == "string" && - ((0, mR.isHexString)(n) || - (n[0] === "-" && (0, mR.isHexString)(n.substring(1))))) - ) - return t.from(n); - } - return hx.throwArgumentError("invalid BigNumber value", "value", e); - }), - (t.isBigNumber = function (e) { - return !!(e && e._isBigNumber); - }), - t - ); - })(); - By.BigNumber = Gte; - function IU(t) { - if (typeof t != "string") return IU(t.toString(16)); - if (t[0] === "-") - return ( - (t = t.substring(1)), - t[0] === "-" && hx.throwArgumentError("invalid hex", "value", t), - (t = IU(t)), - t === "0x00" ? t : "-" + t - ); - if ((t.substring(0, 2) !== "0x" && (t = "0x" + t), t === "0x")) - return "0x00"; - for ( - t.length % 2 && (t = "0x0" + t.substring(2)); - t.length > 4 && t.substring(0, 4) === "0x00"; - - ) - t = "0x" + t.substring(4); - return t; - } - function Kh(t) { - return Gte.from(IU(t)); - } - function ri(t) { - var e = Gte.from(t).toHexString(); - return e[0] === "-" - ? new BU("-" + e.substring(3), 16) - : new BU(e.substring(2), 16); - } - function Oy(t, e, r) { - var n = { fault: t, operation: e }; - return ( - r != null && (n.value = r), - hx.throwError(t, gR.Logger.errors.NUMERIC_FAULT, n) - ); - } - function ngr(t) { - return new BU(t, 36).toString(16); - } - By._base36To16 = ngr; - function igr(t) { - return new BU(t, 16).toString(36); - } - By._base16To36 = igr; - }); - var Qst = I((ib) => { - "use strict"; - m(); - g(); - Object.defineProperty(ib, "__esModule", { value: !0 }); - ib.FixedNumber = ib.FixedFormat = ib.parseFixed = ib.formatFixed = void 0; - var $te = Ar(), - NU = rr(), - ogr = Q2e(), - Zd = new NU.Logger(ogr.version), - px = Jte(), - CU = {}, - Zst = px.BigNumber.from(0), - Xst = px.BigNumber.from(-1); - function Yst(t, e, r, n) { - var i = { fault: e, operation: r }; - return ( - n !== void 0 && (i.value = n), - Zd.throwError(t, NU.Logger.errors.NUMERIC_FAULT, i) - ); - } - var RU = "0"; - for (; RU.length < 256; ) RU += RU; - function tAe(t) { - if (typeof t != "number") - try { - t = px.BigNumber.from(t).toNumber(); - } catch {} - return typeof t == "number" && t >= 0 && t <= 256 && !(t % 1) - ? "1" + RU.substring(0, t) - : Zd.throwArgumentError("invalid decimal size", "decimals", t); - } - function Zte(t, e) { - e == null && (e = 0); - var r = tAe(e); - t = px.BigNumber.from(t); - var n = t.lt(Zst); - n && (t = t.mul(Xst)); - for (var i = t.mod(r).toString(); i.length < r.length - 1; ) i = "0" + i; - i = i.match(/^([0-9]*[1-9]|0)(0*)/)[1]; - var o = t.div(r).toString(); - return ( - r.length === 1 ? (t = o) : (t = o + "." + i), n && (t = "-" + t), t - ); - } - ib.formatFixed = Zte; - function nb(t, e) { - e == null && (e = 0); - var r = tAe(e); - (typeof t != "string" || !t.match(/^-?[0-9.]+$/)) && - Zd.throwArgumentError("invalid decimal value", "value", t); - var n = t.substring(0, 1) === "-"; - n && (t = t.substring(1)), - t === "." && Zd.throwArgumentError("missing value", "value", t); - var i = t.split("."); - i.length > 2 && - Zd.throwArgumentError("too many decimal points", "value", t); - var o = i[0], - a = i[1]; - for (o || (o = "0"), a || (a = "0"); a[a.length - 1] === "0"; ) - a = a.substring(0, a.length - 1); - for ( - a.length > r.length - 1 && - Yst( - "fractional component exceeds decimals", - "underflow", - "parseFixed" - ), - a === "" && (a = "0"); - a.length < r.length - 1; - - ) - a += "0"; - var s = px.BigNumber.from(o), - c = px.BigNumber.from(a), - u = s.mul(r).add(c); - return n && (u = u.mul(Xst)), u; - } - ib.parseFixed = nb; - var Xte = (function () { - function t(e, r, n, i) { - e !== CU && - Zd.throwError( - "cannot use FixedFormat constructor; use FixedFormat.from", - NU.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "new FixedFormat" } - ), - (this.signed = r), - (this.width = n), - (this.decimals = i), - (this.name = (r ? "" : "u") + "fixed" + String(n) + "x" + String(i)), - (this._multiplier = tAe(i)), - Object.freeze(this); - } - return ( - (t.from = function (e) { - if (e instanceof t) return e; - typeof e == "number" && (e = "fixed128x" + e); - var r = !0, - n = 128, - i = 18; - if (typeof e == "string") { - if (e !== "fixed") - if (e === "ufixed") r = !1; - else { - var o = e.match(/^(u?)fixed([0-9]+)x([0-9]+)$/); - o || Zd.throwArgumentError("invalid fixed format", "format", e), - (r = o[1] !== "u"), - (n = parseInt(o[2])), - (i = parseInt(o[3])); - } - } else if (e) { - var a = function (s, c, u) { - return e[s] == null - ? u - : (typeof e[s] !== c && - Zd.throwArgumentError( - "invalid fixed format (" + s + " not " + c + ")", - "format." + s, - e[s] - ), - e[s]); - }; - (r = a("signed", "boolean", r)), - (n = a("width", "number", n)), - (i = a("decimals", "number", i)); - } - return ( - n % 8 && - Zd.throwArgumentError( - "invalid fixed format width (not byte aligned)", - "format.width", - n - ), - i > 80 && - Zd.throwArgumentError( - "invalid fixed format (decimals too large)", - "format.decimals", - i - ), - new t(CU, r, n, i) - ); - }), - t - ); - })(); - ib.FixedFormat = Xte; - var rAe = (function () { - function t(e, r, n, i) { - e !== CU && - Zd.throwError( - "cannot use FixedNumber constructor; use FixedNumber.from", - NU.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "new FixedFormat" } - ), - (this.format = i), - (this._hex = r), - (this._value = n), - (this._isFixedNumber = !0), - Object.freeze(this); - } - return ( - (t.prototype._checkFormat = function (e) { - this.format.name !== e.format.name && - Zd.throwArgumentError( - "incompatible format; use fixedNumber.toFormat", - "other", - e - ); - }), - (t.prototype.addUnsafe = function (e) { - this._checkFormat(e); - var r = nb(this._value, this.format.decimals), - n = nb(e._value, e.format.decimals); - return t.fromValue(r.add(n), this.format.decimals, this.format); - }), - (t.prototype.subUnsafe = function (e) { - this._checkFormat(e); - var r = nb(this._value, this.format.decimals), - n = nb(e._value, e.format.decimals); - return t.fromValue(r.sub(n), this.format.decimals, this.format); - }), - (t.prototype.mulUnsafe = function (e) { - this._checkFormat(e); - var r = nb(this._value, this.format.decimals), - n = nb(e._value, e.format.decimals); - return t.fromValue( - r.mul(n).div(this.format._multiplier), - this.format.decimals, - this.format - ); - }), - (t.prototype.divUnsafe = function (e) { - this._checkFormat(e); - var r = nb(this._value, this.format.decimals), - n = nb(e._value, e.format.decimals); - return t.fromValue( - r.mul(this.format._multiplier).div(n), - this.format.decimals, - this.format - ); - }), - (t.prototype.floor = function () { - var e = this.toString().split("."); - e.length === 1 && e.push("0"); - var r = t.from(e[0], this.format), - n = !e[1].match(/^(0*)$/); - return ( - this.isNegative() && n && (r = r.subUnsafe($st.toFormat(r.format))), - r - ); - }), - (t.prototype.ceiling = function () { - var e = this.toString().split("."); - e.length === 1 && e.push("0"); - var r = t.from(e[0], this.format), - n = !e[1].match(/^(0*)$/); - return ( - !this.isNegative() && - n && - (r = r.addUnsafe($st.toFormat(r.format))), - r - ); - }), - (t.prototype.round = function (e) { - e == null && (e = 0); - var r = this.toString().split("."); - if ( - (r.length === 1 && r.push("0"), - (e < 0 || e > 80 || e % 1) && - Zd.throwArgumentError("invalid decimal count", "decimals", e), - r[1].length <= e) - ) - return this; - var n = t.from("1" + RU.substring(0, e), this.format), - i = agr.toFormat(this.format); - return this.mulUnsafe(n).addUnsafe(i).floor().divUnsafe(n); - }), - (t.prototype.isZero = function () { - return this._value === "0.0" || this._value === "0"; - }), - (t.prototype.isNegative = function () { - return this._value[0] === "-"; - }), - (t.prototype.toString = function () { - return this._value; - }), - (t.prototype.toHexString = function (e) { - if (e == null) return this._hex; - e % 8 && Zd.throwArgumentError("invalid byte width", "width", e); - var r = px.BigNumber.from(this._hex) - .fromTwos(this.format.width) - .toTwos(e) - .toHexString(); - return (0, $te.hexZeroPad)(r, e / 8); - }), - (t.prototype.toUnsafeFloat = function () { - return parseFloat(this.toString()); - }), - (t.prototype.toFormat = function (e) { - return t.fromString(this._value, e); - }), - (t.fromValue = function (e, r, n) { - return ( - n == null && - r != null && - !(0, px.isBigNumberish)(r) && - ((n = r), (r = null)), - r == null && (r = 0), - n == null && (n = "fixed"), - t.fromString(Zte(e, r), Xte.from(n)) - ); - }), - (t.fromString = function (e, r) { - r == null && (r = "fixed"); - var n = Xte.from(r), - i = nb(e, n.decimals); - !n.signed && - i.lt(Zst) && - Yst("unsigned value cannot be negative", "overflow", "value", e); - var o = null; - n.signed - ? (o = i.toTwos(n.width).toHexString()) - : ((o = i.toHexString()), - (o = (0, $te.hexZeroPad)(o, n.width / 8))); - var a = Zte(i, n.decimals); - return new t(CU, o, a, n); - }), - (t.fromBytes = function (e, r) { - r == null && (r = "fixed"); - var n = Xte.from(r); - if ((0, $te.arrayify)(e).length > n.width / 8) - throw new Error("overflow"); - var i = px.BigNumber.from(e); - n.signed && (i = i.fromTwos(n.width)); - var o = i.toTwos((n.signed ? 0 : 1) + n.width).toHexString(), - a = Zte(i, n.decimals); - return new t(CU, o, a, n); - }), - (t.from = function (e, r) { - if (typeof e == "string") return t.fromString(e, r); - if ((0, $te.isBytes)(e)) return t.fromBytes(e, r); - try { - return t.fromValue(e, 0, r); - } catch (n) { - if (n.code !== NU.Logger.errors.INVALID_ARGUMENT) throw n; - } - return Zd.throwArgumentError("invalid FixedNumber value", "value", e); - }), - (t.isFixedNumber = function (e) { - return !!(e && e._isFixedNumber); - }), - t - ); - })(); - ib.FixedNumber = rAe; - var $st = rAe.from(1), - agr = rAe.from("0.5"); - }); - var Ro = I((Yc) => { - "use strict"; - m(); - g(); - Object.defineProperty(Yc, "__esModule", { value: !0 }); - Yc._base36To16 = - Yc._base16To36 = - Yc.parseFixed = - Yc.FixedNumber = - Yc.FixedFormat = - Yc.formatFixed = - Yc.BigNumber = - void 0; - var sgr = Jte(); - Object.defineProperty(Yc, "BigNumber", { - enumerable: !0, - get: function () { - return sgr.BigNumber; - }, - }); - var Yte = Qst(); - Object.defineProperty(Yc, "formatFixed", { - enumerable: !0, - get: function () { - return Yte.formatFixed; - }, - }); - Object.defineProperty(Yc, "FixedFormat", { - enumerable: !0, - get: function () { - return Yte.FixedFormat; - }, - }); - Object.defineProperty(Yc, "FixedNumber", { - enumerable: !0, - get: function () { - return Yte.FixedNumber; - }, - }); - Object.defineProperty(Yc, "parseFixed", { - enumerable: !0, - get: function () { - return Yte.parseFixed; - }, - }); - var eut = Jte(); - Object.defineProperty(Yc, "_base16To36", { - enumerable: !0, - get: function () { - return eut._base16To36; - }, - }); - Object.defineProperty(Yc, "_base36To16", { - enumerable: !0, - get: function () { - return eut._base36To16; - }, - }); - }); - var tut = I((Qte) => { - "use strict"; - m(); - g(); - Object.defineProperty(Qte, "__esModule", { value: !0 }); - Qte.version = void 0; - Qte.version = "properties/5.7.0"; - }); - var $r = I((xs) => { - "use strict"; - m(); - g(); - var ugr = - (xs && xs.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - cgr = - (xs && xs.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(xs, "__esModule", { value: !0 }); - xs.Description = - xs.deepCopy = - xs.shallowCopy = - xs.checkProperties = - xs.resolveProperties = - xs.getStatic = - xs.defineReadOnly = - void 0; - var lgr = rr(), - fgr = tut(), - ere = new lgr.Logger(fgr.version); - function rut(t, e, r) { - Object.defineProperty(t, e, { enumerable: !0, value: r, writable: !1 }); - } - xs.defineReadOnly = rut; - function dgr(t, e) { - for (var r = 0; r < 32; r++) { - if (t[e]) return t[e]; - if (!t.prototype || typeof t.prototype != "object") break; - t = Object.getPrototypeOf(t.prototype).constructor; - } - return null; - } - xs.getStatic = dgr; - function hgr(t) { - return ugr(this, void 0, void 0, function () { - var e, r; - return cgr(this, function (n) { - switch (n.label) { - case 0: - return ( - (e = Object.keys(t).map(function (i) { - var o = t[i]; - return Promise.resolve(o).then(function (a) { - return { key: i, value: a }; - }); - })), - [4, Promise.all(e)] - ); - case 1: - return ( - (r = n.sent()), - [ - 2, - r.reduce(function (i, o) { - return (i[o.key] = o.value), i; - }, {}), - ] - ); - } - }); - }); - } - xs.resolveProperties = hgr; - function pgr(t, e) { - (!t || typeof t != "object") && - ere.throwArgumentError("invalid object", "object", t), - Object.keys(t).forEach(function (r) { - e[r] || - ere.throwArgumentError( - "invalid object key - " + r, - "transaction:" + r, - t - ); - }); - } - xs.checkProperties = pgr; - function ygr(t) { - var e = {}; - for (var r in t) e[r] = t[r]; - return e; - } - xs.shallowCopy = ygr; - var mgr = { bigint: !0, boolean: !0, function: !0, number: !0, string: !0 }; - function nut(t) { - if (t == null || mgr[typeof t]) return !0; - if (Array.isArray(t) || typeof t == "object") { - if (!Object.isFrozen(t)) return !1; - for (var e = Object.keys(t), r = 0; r < e.length; r++) { - var n = null; - try { - n = t[e[r]]; - } catch { - continue; - } - if (!nut(n)) return !1; - } - return !0; - } - return ere.throwArgumentError("Cannot deepCopy " + typeof t, "object", t); - } - function ggr(t) { - if (nut(t)) return t; - if (Array.isArray(t)) - return Object.freeze( - t.map(function (i) { - return tre(i); - }) - ); - if (typeof t == "object") { - var e = {}; - for (var r in t) { - var n = t[r]; - n !== void 0 && rut(e, r, tre(n)); - } - return e; - } - return ere.throwArgumentError("Cannot deepCopy " + typeof t, "object", t); - } - function tre(t) { - return ggr(t); - } - xs.deepCopy = tre; - var vgr = (function () { - function t(e) { - for (var r in e) this[r] = tre(e[r]); - } - return t; - })(); - xs.Description = vgr; - }); - var vR = I((rre) => { - "use strict"; - m(); - g(); - Object.defineProperty(rre, "__esModule", { value: !0 }); - rre.version = void 0; - rre.version = "abi/5.7.0"; - }); - var cre = I((qr) => { - "use strict"; - m(); - g(); - var are = - (qr && qr.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(qr, "__esModule", { value: !0 }); - qr.ErrorFragment = - qr.FunctionFragment = - qr.ConstructorFragment = - qr.EventFragment = - qr.Fragment = - qr.ParamType = - qr.FormatTypes = - void 0; - var aAe = Ro(), - bgr = $r(), - sre = rr(), - wgr = vR(), - di = new sre.Logger(wgr.version), - GT = {}, - iut = { calldata: !0, memory: !0, storage: !0 }, - _gr = { calldata: !0, memory: !0 }; - function nre(t, e) { - if (t === "bytes" || t === "string") { - if (iut[e]) return !0; - } else if (t === "address") { - if (e === "payable") return !0; - } else if ((t.indexOf("[") >= 0 || t === "tuple") && _gr[e]) return !0; - return ( - (iut[e] || e === "payable") && - di.throwArgumentError("invalid modifier", "name", e), - !1 - ); - } - function xgr(t, e) { - var r = t; - function n(w) { - di.throwArgumentError( - "unexpected character at position " + w, - "param", - t - ); - } - t = t.replace(/\s/g, " "); - function i(w) { - var M = { type: "", name: "", parent: w, state: { allowType: !0 } }; - return e && (M.indexed = !1), M; - } - for ( - var o = { type: "", name: "", state: { allowType: !0 } }, a = o, s = 0; - s < t.length; - s++ - ) { - var c = t[s]; - switch (c) { - case "(": - a.state.allowType && a.type === "" - ? (a.type = "tuple") - : a.state.allowParams || n(s), - (a.state.allowType = !1), - (a.type = bR(a.type)), - (a.components = [i(a)]), - (a = a.components[0]); - break; - case ")": - delete a.state, - a.name === "indexed" && - (e || n(s), (a.indexed = !0), (a.name = "")), - nre(a.type, a.name) && (a.name = ""), - (a.type = bR(a.type)); - var u = a; - (a = a.parent), - a || n(s), - delete u.parent, - (a.state.allowParams = !1), - (a.state.allowName = !0), - (a.state.allowArray = !0); - break; - case ",": - delete a.state, - a.name === "indexed" && - (e || n(s), (a.indexed = !0), (a.name = "")), - nre(a.type, a.name) && (a.name = ""), - (a.type = bR(a.type)); - var h = i(a.parent); - a.parent.components.push(h), delete a.parent, (a = h); - break; - case " ": - a.state.allowType && - a.type !== "" && - ((a.type = bR(a.type)), - delete a.state.allowType, - (a.state.allowName = !0), - (a.state.allowParams = !0)), - a.state.allowName && - a.name !== "" && - (a.name === "indexed" - ? (e || n(s), - a.indexed && n(s), - (a.indexed = !0), - (a.name = "")) - : nre(a.type, a.name) - ? (a.name = "") - : (a.state.allowName = !1)); - break; - case "[": - a.state.allowArray || n(s), - (a.type += c), - (a.state.allowArray = !1), - (a.state.allowName = !1), - (a.state.readArray = !0); - break; - case "]": - a.state.readArray || n(s), - (a.type += c), - (a.state.readArray = !1), - (a.state.allowArray = !0), - (a.state.allowName = !0); - break; - default: - a.state.allowType - ? ((a.type += c), - (a.state.allowParams = !0), - (a.state.allowArray = !0)) - : a.state.allowName - ? ((a.name += c), delete a.state.allowArray) - : a.state.readArray - ? (a.type += c) - : n(s); - } - } - return ( - a.parent && di.throwArgumentError("unexpected eof", "param", t), - delete o.state, - a.name === "indexed" - ? (e || n(r.length - 7), - a.indexed && n(r.length - 7), - (a.indexed = !0), - (a.name = "")) - : nre(a.type, a.name) && (a.name = ""), - (o.type = bR(o.type)), - o - ); - } - function ire(t, e) { - for (var r in e) (0, bgr.defineReadOnly)(t, r, e[r]); - } - qr.FormatTypes = Object.freeze({ - sighash: "sighash", - minimal: "minimal", - full: "full", - json: "json", - }); - var Sgr = new RegExp(/^(.*)\[([0-9]*)\]$/), - JT = (function () { - function t(e, r) { - e !== GT && - di.throwError( - "use fromString", - sre.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "new ParamType()" } - ), - ire(this, r); - var n = this.type.match(Sgr); - n - ? ire(this, { - arrayLength: parseInt(n[2] || "-1"), - arrayChildren: t.fromObject({ - type: n[1], - components: this.components, - }), - baseType: "array", - }) - : ire(this, { - arrayLength: null, - arrayChildren: null, - baseType: this.components != null ? "tuple" : this.type, - }), - (this._isParamType = !0), - Object.freeze(this); - } - return ( - (t.prototype.format = function (e) { - if ( - (e || (e = qr.FormatTypes.sighash), - qr.FormatTypes[e] || - di.throwArgumentError("invalid format type", "format", e), - e === qr.FormatTypes.json) - ) { - var r = { - type: this.baseType === "tuple" ? "tuple" : this.type, - name: this.name || void 0, - }; - return ( - typeof this.indexed == "boolean" && (r.indexed = this.indexed), - this.components && - (r.components = this.components.map(function (i) { - return JSON.parse(i.format(e)); - })), - JSON.stringify(r) - ); - } - var n = ""; - return ( - this.baseType === "array" - ? ((n += this.arrayChildren.format(e)), - (n += - "[" + - (this.arrayLength < 0 ? "" : String(this.arrayLength)) + - "]")) - : this.baseType === "tuple" - ? (e !== qr.FormatTypes.sighash && (n += this.type), - (n += - "(" + - this.components - .map(function (i) { - return i.format(e); - }) - .join(e === qr.FormatTypes.full ? ", " : ",") + - ")")) - : (n += this.type), - e !== qr.FormatTypes.sighash && - (this.indexed === !0 && (n += " indexed"), - e === qr.FormatTypes.full && - this.name && - (n += " " + this.name)), - n - ); - }), - (t.from = function (e, r) { - return typeof e == "string" ? t.fromString(e, r) : t.fromObject(e); - }), - (t.fromObject = function (e) { - return t.isParamType(e) - ? e - : new t(GT, { - name: e.name || null, - type: bR(e.type), - indexed: e.indexed == null ? null : !!e.indexed, - components: e.components - ? e.components.map(t.fromObject) - : null, - }); - }), - (t.fromString = function (e, r) { - function n(i) { - return t.fromObject({ - name: i.name, - type: i.type, - indexed: i.indexed, - components: i.components, - }); - } - return n(xgr(e, !!r)); - }), - (t.isParamType = function (e) { - return !!(e != null && e._isParamType); - }), - t - ); - })(); - qr.ParamType = JT; - function DU(t, e) { - return Egr(t).map(function (r) { - return JT.fromString(r, e); - }); - } - var ure = (function () { - function t(e, r) { - e !== GT && - di.throwError( - "use a static from method", - sre.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "new Fragment()" } - ), - ire(this, r), - (this._isFragment = !0), - Object.freeze(this); - } - return ( - (t.from = function (e) { - return t.isFragment(e) - ? e - : typeof e == "string" - ? t.fromString(e) - : t.fromObject(e); - }), - (t.fromObject = function (e) { - if (t.isFragment(e)) return e; - switch (e.type) { - case "function": - return iAe.fromObject(e); - case "event": - return nAe.fromObject(e); - case "constructor": - return ore.fromObject(e); - case "error": - return oAe.fromObject(e); - case "fallback": - case "receive": - return null; - } - return di.throwArgumentError("invalid fragment object", "value", e); - }), - (t.fromString = function (e) { - return ( - (e = e.replace(/\s/g, " ")), - (e = e - .replace(/\(/g, " (") - .replace(/\)/g, ") ") - .replace(/\s+/g, " ")), - (e = e.trim()), - e.split(" ")[0] === "event" - ? nAe.fromString(e.substring(5).trim()) - : e.split(" ")[0] === "function" - ? iAe.fromString(e.substring(8).trim()) - : e.split("(")[0].trim() === "constructor" - ? ore.fromString(e.trim()) - : e.split(" ")[0] === "error" - ? oAe.fromString(e.substring(5).trim()) - : di.throwArgumentError("unsupported fragment", "value", e) - ); - }), - (t.isFragment = function (e) { - return !!(e && e._isFragment); - }), - t - ); - })(); - qr.Fragment = ure; - var nAe = (function (t) { - are(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.prototype.format = function (r) { - if ( - (r || (r = qr.FormatTypes.sighash), - qr.FormatTypes[r] || - di.throwArgumentError("invalid format type", "format", r), - r === qr.FormatTypes.json) - ) - return JSON.stringify({ - type: "event", - anonymous: this.anonymous, - name: this.name, - inputs: this.inputs.map(function (i) { - return JSON.parse(i.format(r)); - }), - }); - var n = ""; - return ( - r !== qr.FormatTypes.sighash && (n += "event "), - (n += - this.name + - "(" + - this.inputs - .map(function (i) { - return i.format(r); - }) - .join(r === qr.FormatTypes.full ? ", " : ",") + - ") "), - r !== qr.FormatTypes.sighash && - this.anonymous && - (n += "anonymous "), - n.trim() - ); - }), - (e.from = function (r) { - return typeof r == "string" ? e.fromString(r) : e.fromObject(r); - }), - (e.fromObject = function (r) { - if (e.isEventFragment(r)) return r; - r.type !== "event" && - di.throwArgumentError("invalid event object", "value", r); - var n = { - name: FU(r.name), - anonymous: r.anonymous, - inputs: r.inputs ? r.inputs.map(JT.fromObject) : [], - type: "event", - }; - return new e(GT, n); - }), - (e.fromString = function (r) { - var n = r.match(LU); - n || di.throwArgumentError("invalid event string", "value", r); - var i = !1; - return ( - n[3].split(" ").forEach(function (o) { - switch (o.trim()) { - case "anonymous": - i = !0; - break; - case "": - break; - default: - di.warn("unknown modifier: " + o); - } - }), - e.fromObject({ - name: n[1].trim(), - anonymous: i, - inputs: DU(n[2], !0), - type: "event", - }) - ); - }), - (e.isEventFragment = function (r) { - return r && r._isFragment && r.type === "event"; - }), - e - ); - })(ure); - qr.EventFragment = nAe; - function aut(t, e) { - e.gas = null; - var r = t.split("@"); - return r.length !== 1 - ? (r.length > 2 && - di.throwArgumentError( - "invalid human-readable ABI signature", - "value", - t - ), - r[1].match(/^[0-9]+$/) || - di.throwArgumentError( - "invalid human-readable ABI signature gas", - "value", - t - ), - (e.gas = aAe.BigNumber.from(r[1])), - r[0]) - : t; - } - function sut(t, e) { - (e.constant = !1), - (e.payable = !1), - (e.stateMutability = "nonpayable"), - t.split(" ").forEach(function (r) { - switch (r.trim()) { - case "constant": - e.constant = !0; - break; - case "payable": - (e.payable = !0), (e.stateMutability = "payable"); - break; - case "nonpayable": - (e.payable = !1), (e.stateMutability = "nonpayable"); - break; - case "pure": - (e.constant = !0), (e.stateMutability = "pure"); - break; - case "view": - (e.constant = !0), (e.stateMutability = "view"); - break; - case "external": - case "public": - case "": - break; - default: - console.log("unknown modifier: " + r); - } - }); - } - function uut(t) { - var e = { constant: !1, payable: !0, stateMutability: "payable" }; - return ( - t.stateMutability != null - ? ((e.stateMutability = t.stateMutability), - (e.constant = - e.stateMutability === "view" || e.stateMutability === "pure"), - t.constant != null && - !!t.constant !== e.constant && - di.throwArgumentError( - "cannot have constant function with mutability " + - e.stateMutability, - "value", - t - ), - (e.payable = e.stateMutability === "payable"), - t.payable != null && - !!t.payable !== e.payable && - di.throwArgumentError( - "cannot have payable function with mutability " + - e.stateMutability, - "value", - t - )) - : t.payable != null - ? ((e.payable = !!t.payable), - t.constant == null && - !e.payable && - t.type !== "constructor" && - di.throwArgumentError( - "unable to determine stateMutability", - "value", - t - ), - (e.constant = !!t.constant), - e.constant - ? (e.stateMutability = "view") - : (e.stateMutability = e.payable ? "payable" : "nonpayable"), - e.payable && - e.constant && - di.throwArgumentError( - "cannot have constant payable function", - "value", - t - )) - : t.constant != null - ? ((e.constant = !!t.constant), - (e.payable = !e.constant), - (e.stateMutability = e.constant ? "view" : "payable")) - : t.type !== "constructor" && - di.throwArgumentError( - "unable to determine stateMutability", - "value", - t - ), - e - ); - } - var ore = (function (t) { - are(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.prototype.format = function (r) { - if ( - (r || (r = qr.FormatTypes.sighash), - qr.FormatTypes[r] || - di.throwArgumentError("invalid format type", "format", r), - r === qr.FormatTypes.json) - ) - return JSON.stringify({ - type: "constructor", - stateMutability: - this.stateMutability !== "nonpayable" - ? this.stateMutability - : void 0, - payable: this.payable, - gas: this.gas ? this.gas.toNumber() : void 0, - inputs: this.inputs.map(function (i) { - return JSON.parse(i.format(r)); - }), - }); - r === qr.FormatTypes.sighash && - di.throwError( - "cannot format a constructor for sighash", - sre.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "format(sighash)" } - ); - var n = - "constructor(" + - this.inputs - .map(function (i) { - return i.format(r); - }) - .join(r === qr.FormatTypes.full ? ", " : ",") + - ") "; - return ( - this.stateMutability && - this.stateMutability !== "nonpayable" && - (n += this.stateMutability + " "), - n.trim() - ); - }), - (e.from = function (r) { - return typeof r == "string" ? e.fromString(r) : e.fromObject(r); - }), - (e.fromObject = function (r) { - if (e.isConstructorFragment(r)) return r; - r.type !== "constructor" && - di.throwArgumentError("invalid constructor object", "value", r); - var n = uut(r); - n.constant && - di.throwArgumentError("constructor cannot be constant", "value", r); - var i = { - name: null, - type: r.type, - inputs: r.inputs ? r.inputs.map(JT.fromObject) : [], - payable: n.payable, - stateMutability: n.stateMutability, - gas: r.gas ? aAe.BigNumber.from(r.gas) : null, - }; - return new e(GT, i); - }), - (e.fromString = function (r) { - var n = { type: "constructor" }; - r = aut(r, n); - var i = r.match(LU); - return ( - (!i || i[1].trim() !== "constructor") && - di.throwArgumentError("invalid constructor string", "value", r), - (n.inputs = DU(i[2].trim(), !1)), - sut(i[3].trim(), n), - e.fromObject(n) - ); - }), - (e.isConstructorFragment = function (r) { - return r && r._isFragment && r.type === "constructor"; - }), - e - ); - })(ure); - qr.ConstructorFragment = ore; - var iAe = (function (t) { - are(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.prototype.format = function (r) { - if ( - (r || (r = qr.FormatTypes.sighash), - qr.FormatTypes[r] || - di.throwArgumentError("invalid format type", "format", r), - r === qr.FormatTypes.json) - ) - return JSON.stringify({ - type: "function", - name: this.name, - constant: this.constant, - stateMutability: - this.stateMutability !== "nonpayable" - ? this.stateMutability - : void 0, - payable: this.payable, - gas: this.gas ? this.gas.toNumber() : void 0, - inputs: this.inputs.map(function (i) { - return JSON.parse(i.format(r)); - }), - outputs: this.outputs.map(function (i) { - return JSON.parse(i.format(r)); - }), - }); - var n = ""; - return ( - r !== qr.FormatTypes.sighash && (n += "function "), - (n += - this.name + - "(" + - this.inputs - .map(function (i) { - return i.format(r); - }) - .join(r === qr.FormatTypes.full ? ", " : ",") + - ") "), - r !== qr.FormatTypes.sighash && - (this.stateMutability - ? this.stateMutability !== "nonpayable" && - (n += this.stateMutability + " ") - : this.constant && (n += "view "), - this.outputs && - this.outputs.length && - (n += - "returns (" + - this.outputs - .map(function (i) { - return i.format(r); - }) - .join(", ") + - ") "), - this.gas != null && (n += "@" + this.gas.toString() + " ")), - n.trim() - ); - }), - (e.from = function (r) { - return typeof r == "string" ? e.fromString(r) : e.fromObject(r); - }), - (e.fromObject = function (r) { - if (e.isFunctionFragment(r)) return r; - r.type !== "function" && - di.throwArgumentError("invalid function object", "value", r); - var n = uut(r), - i = { - type: r.type, - name: FU(r.name), - constant: n.constant, - inputs: r.inputs ? r.inputs.map(JT.fromObject) : [], - outputs: r.outputs ? r.outputs.map(JT.fromObject) : [], - payable: n.payable, - stateMutability: n.stateMutability, - gas: r.gas ? aAe.BigNumber.from(r.gas) : null, - }; - return new e(GT, i); - }), - (e.fromString = function (r) { - var n = { type: "function" }; - r = aut(r, n); - var i = r.split(" returns "); - i.length > 2 && - di.throwArgumentError("invalid function string", "value", r); - var o = i[0].match(LU); - if ( - (o || - di.throwArgumentError("invalid function signature", "value", r), - (n.name = o[1].trim()), - n.name && FU(n.name), - (n.inputs = DU(o[2], !1)), - sut(o[3].trim(), n), - i.length > 1) - ) { - var a = i[1].match(LU); - (a[1].trim() != "" || a[3].trim() != "") && - di.throwArgumentError("unexpected tokens", "value", r), - (n.outputs = DU(a[2], !1)); - } else n.outputs = []; - return e.fromObject(n); - }), - (e.isFunctionFragment = function (r) { - return r && r._isFragment && r.type === "function"; - }), - e - ); - })(ore); - qr.FunctionFragment = iAe; - function out(t) { - var e = t.format(); - return ( - (e === "Error(string)" || e === "Panic(uint256)") && - di.throwArgumentError( - "cannot specify user defined " + e + " error", - "fragment", - t - ), - t - ); - } - var oAe = (function (t) { - are(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.prototype.format = function (r) { - if ( - (r || (r = qr.FormatTypes.sighash), - qr.FormatTypes[r] || - di.throwArgumentError("invalid format type", "format", r), - r === qr.FormatTypes.json) - ) - return JSON.stringify({ - type: "error", - name: this.name, - inputs: this.inputs.map(function (i) { - return JSON.parse(i.format(r)); - }), - }); - var n = ""; - return ( - r !== qr.FormatTypes.sighash && (n += "error "), - (n += - this.name + - "(" + - this.inputs - .map(function (i) { - return i.format(r); - }) - .join(r === qr.FormatTypes.full ? ", " : ",") + - ") "), - n.trim() - ); - }), - (e.from = function (r) { - return typeof r == "string" ? e.fromString(r) : e.fromObject(r); - }), - (e.fromObject = function (r) { - if (e.isErrorFragment(r)) return r; - r.type !== "error" && - di.throwArgumentError("invalid error object", "value", r); - var n = { - type: r.type, - name: FU(r.name), - inputs: r.inputs ? r.inputs.map(JT.fromObject) : [], - }; - return out(new e(GT, n)); - }), - (e.fromString = function (r) { - var n = { type: "error" }, - i = r.match(LU); - return ( - i || di.throwArgumentError("invalid error signature", "value", r), - (n.name = i[1].trim()), - n.name && FU(n.name), - (n.inputs = DU(i[2], !1)), - out(e.fromObject(n)) - ); - }), - (e.isErrorFragment = function (r) { - return r && r._isFragment && r.type === "error"; - }), - e - ); - })(ure); - qr.ErrorFragment = oAe; - function bR(t) { - return ( - t.match(/^uint($|[^1-9])/) - ? (t = "uint256" + t.substring(4)) - : t.match(/^int($|[^1-9])/) && (t = "int256" + t.substring(3)), - t - ); - } - var Agr = new RegExp("^[a-zA-Z$_][a-zA-Z0-9$_]*$"); - function FU(t) { - return ( - (!t || !t.match(Agr)) && - di.throwArgumentError('invalid identifier "' + t + '"', "value", t), - t - ); - } - var LU = new RegExp("^([^)(]*)\\((.*)\\)([^)(]*)$"); - function Egr(t) { - t = t.trim(); - for (var e = [], r = "", n = 0, i = 0; i < t.length; i++) { - var o = t[i]; - o === "," && n === 0 - ? (e.push(r), (r = "")) - : ((r += o), - o === "(" - ? n++ - : o === ")" && - (n--, - n === -1 && - di.throwArgumentError("unbalanced parenthesis", "value", t))); - } - return r && e.push(r), e; - } - }); - var Iy = I((ob) => { - "use strict"; - m(); - g(); - Object.defineProperty(ob, "__esModule", { value: !0 }); - ob.Reader = ob.Writer = ob.Coder = ob.checkResultErrors = void 0; - var AA = Ar(), - cut = Ro(), - qU = $r(), - sAe = rr(), - Mgr = vR(), - uAe = new sAe.Logger(Mgr.version); - function Tgr(t) { - var e = [], - r = function (n, i) { - if (!!Array.isArray(i)) - for (var o in i) { - var a = n.slice(); - a.push(o); - try { - r(a, i[o]); - } catch (s) { - e.push({ path: a, error: s }); - } - } - }; - return r([], t), e; - } - ob.checkResultErrors = Tgr; - var kgr = (function () { - function t(e, r, n, i) { - (this.name = e), - (this.type = r), - (this.localName = n), - (this.dynamic = i); - } - return ( - (t.prototype._throwError = function (e, r) { - uAe.throwArgumentError(e, this.localName, r); - }), - t - ); - })(); - ob.Coder = kgr; - var Pgr = (function () { - function t(e) { - (0, qU.defineReadOnly)(this, "wordSize", e || 32), - (this._data = []), - (this._dataLength = 0), - (this._padding = new Uint8Array(e)); - } - return ( - Object.defineProperty(t.prototype, "data", { - get: function () { - return (0, AA.hexConcat)(this._data); - }, - enumerable: !1, - configurable: !0, - }), - Object.defineProperty(t.prototype, "length", { - get: function () { - return this._dataLength; - }, - enumerable: !1, - configurable: !0, - }), - (t.prototype._writeData = function (e) { - return this._data.push(e), (this._dataLength += e.length), e.length; - }), - (t.prototype.appendWriter = function (e) { - return this._writeData((0, AA.concat)(e._data)); - }), - (t.prototype.writeBytes = function (e) { - var r = (0, AA.arrayify)(e), - n = r.length % this.wordSize; - return ( - n && (r = (0, AA.concat)([r, this._padding.slice(n)])), - this._writeData(r) - ); - }), - (t.prototype._getValue = function (e) { - var r = (0, AA.arrayify)(cut.BigNumber.from(e)); - return ( - r.length > this.wordSize && - uAe.throwError( - "value out-of-bounds", - sAe.Logger.errors.BUFFER_OVERRUN, - { length: this.wordSize, offset: r.length } - ), - r.length % this.wordSize && - (r = (0, AA.concat)([ - this._padding.slice(r.length % this.wordSize), - r, - ])), - r - ); - }), - (t.prototype.writeValue = function (e) { - return this._writeData(this._getValue(e)); - }), - (t.prototype.writeUpdatableValue = function () { - var e = this, - r = this._data.length; - return ( - this._data.push(this._padding), - (this._dataLength += this.wordSize), - function (n) { - e._data[r] = e._getValue(n); - } - ); - }), - t - ); - })(); - ob.Writer = Pgr; - var Ogr = (function () { - function t(e, r, n, i) { - (0, qU.defineReadOnly)(this, "_data", (0, AA.arrayify)(e)), - (0, qU.defineReadOnly)(this, "wordSize", r || 32), - (0, qU.defineReadOnly)(this, "_coerceFunc", n), - (0, qU.defineReadOnly)(this, "allowLoose", i), - (this._offset = 0); - } - return ( - Object.defineProperty(t.prototype, "data", { - get: function () { - return (0, AA.hexlify)(this._data); - }, - enumerable: !1, - configurable: !0, - }), - Object.defineProperty(t.prototype, "consumed", { - get: function () { - return this._offset; - }, - enumerable: !1, - configurable: !0, - }), - (t.coerce = function (e, r) { - var n = e.match("^u?int([0-9]+)$"); - return n && parseInt(n[1]) <= 48 && (r = r.toNumber()), r; - }), - (t.prototype.coerce = function (e, r) { - return this._coerceFunc ? this._coerceFunc(e, r) : t.coerce(e, r); - }), - (t.prototype._peekBytes = function (e, r, n) { - var i = Math.ceil(r / this.wordSize) * this.wordSize; - return ( - this._offset + i > this._data.length && - (this.allowLoose && n && this._offset + r <= this._data.length - ? (i = r) - : uAe.throwError( - "data out-of-bounds", - sAe.Logger.errors.BUFFER_OVERRUN, - { length: this._data.length, offset: this._offset + i } - )), - this._data.slice(this._offset, this._offset + i) - ); - }), - (t.prototype.subReader = function (e) { - return new t( - this._data.slice(this._offset + e), - this.wordSize, - this._coerceFunc, - this.allowLoose - ); - }), - (t.prototype.readBytes = function (e, r) { - var n = this._peekBytes(0, e, !!r); - return (this._offset += n.length), n.slice(0, e); - }), - (t.prototype.readValue = function () { - return cut.BigNumber.from(this.readBytes(this.wordSize)); - }), - t - ); - })(); - ob.Reader = Ogr; - }); - var lut = I((gmn, lre) => { - m(); - g(); - (function () { - "use strict"; - var t = "input is invalid type", - e = "finalize already called", - r = typeof window == "object", - n = r ? window : {}; - n.JS_SHA3_NO_WINDOW && (r = !1); - var i = !r && typeof self == "object", - o = - !n.JS_SHA3_NO_NODE_JS && - typeof process == "object" && - process.versions && - process.versions.node; - o ? (n = window) : i && (n = self); - var a = !n.JS_SHA3_NO_COMMON_JS && typeof lre == "object" && lre.exports, - s = typeof define == "function" && define.amd, - c = !n.JS_SHA3_NO_ARRAY_BUFFER && typeof ArrayBuffer < "u", - u = "0123456789abcdef".split(""), - h = [31, 7936, 2031616, 520093696], - w = [4, 1024, 262144, 67108864], - M = [1, 256, 65536, 16777216], - k = [6, 1536, 393216, 100663296], - O = [0, 8, 16, 24], - D = [ - 1, 0, 32898, 0, 32906, 2147483648, 2147516416, 2147483648, 32907, 0, - 2147483649, 0, 2147516545, 2147483648, 32777, 2147483648, 138, 0, 136, - 0, 2147516425, 0, 2147483658, 0, 2147516555, 0, 139, 2147483648, - 32905, 2147483648, 32771, 2147483648, 32770, 2147483648, 128, - 2147483648, 32778, 0, 2147483658, 2147483648, 2147516545, 2147483648, - 32896, 2147483648, 2147483649, 0, 2147516424, 2147483648, - ], - F = [224, 256, 384, 512], - N = [128, 256], - q = ["hex", "buffer", "arrayBuffer", "array", "digest"], - z = { 128: 168, 256: 136 }; - (n.JS_SHA3_NO_NODE_JS || !Array.isArray) && - (Array.isArray = function (L) { - return Object.prototype.toString.call(L) === "[object Array]"; - }), - c && - (n.JS_SHA3_NO_ARRAY_BUFFER_IS_VIEW || !ArrayBuffer.isView) && - (ArrayBuffer.isView = function (L) { - return ( - typeof L == "object" && - L.buffer && - L.buffer.constructor === ArrayBuffer - ); - }); - for ( - var H = function (L, ee, ge) { - return function (fe) { - return new E(L, ee, L).update(fe)[ge](); - }; - }, - Z = function (L, ee, ge) { - return function (fe, V) { - return new E(L, ee, V).update(fe)[ge](); - }; - }, - $ = function (L, ee, ge) { - return function (fe, V, ye, ae) { - return d["cshake" + L].update(fe, V, ye, ae)[ge](); - }; - }, - ue = function (L, ee, ge) { - return function (fe, V, ye, ae) { - return d["kmac" + L].update(fe, V, ye, ae)[ge](); - }; - }, - te = function (L, ee, ge, fe) { - for (var V = 0; V < q.length; ++V) { - var ye = q[V]; - L[ye] = ee(ge, fe, ye); - } - return L; - }, - ne = function (L, ee) { - var ge = H(L, ee, "hex"); - return ( - (ge.create = function () { - return new E(L, ee, L); - }), - (ge.update = function (fe) { - return ge.create().update(fe); - }), - te(ge, H, L, ee) - ); - }, - A = function (L, ee) { - var ge = Z(L, ee, "hex"); - return ( - (ge.create = function (fe) { - return new E(L, ee, fe); - }), - (ge.update = function (fe, V) { - return ge.create(V).update(fe); - }), - te(ge, Z, L, ee) - ); - }, - l = function (L, ee) { - var ge = z[L], - fe = $(L, ee, "hex"); - return ( - (fe.create = function (V, ye, ae) { - return !ye && !ae - ? d["shake" + L].create(V) - : new E(L, ee, V).bytepad([ye, ae], ge); - }), - (fe.update = function (V, ye, ae, le) { - return fe.create(ye, ae, le).update(V); - }), - te(fe, $, L, ee) - ); - }, - p = function (L, ee) { - var ge = z[L], - fe = ue(L, ee, "hex"); - return ( - (fe.create = function (V, ye, ae) { - return new B(L, ee, ye) - .bytepad(["KMAC", ae], ge) - .bytepad([V], ge); - }), - (fe.update = function (V, ye, ae, le) { - return fe.create(V, ae, le).update(ye); - }), - te(fe, ue, L, ee) - ); - }, - y = [ - { name: "keccak", padding: M, bits: F, createMethod: ne }, - { name: "sha3", padding: k, bits: F, createMethod: ne }, - { name: "shake", padding: h, bits: N, createMethod: A }, - { name: "cshake", padding: w, bits: N, createMethod: l }, - { name: "kmac", padding: w, bits: N, createMethod: p }, - ], - d = {}, - v = [], - _ = 0; - _ < y.length; - ++_ - ) - for (var S = y[_], b = S.bits, f = 0; f < b.length; ++f) { - var x = S.name + "_" + b[f]; - if ( - (v.push(x), - (d[x] = S.createMethod(b[f], S.padding)), - S.name !== "sha3") - ) { - var C = S.name + b[f]; - v.push(C), (d[C] = d[x]); - } - } - function E(L, ee, ge) { - (this.blocks = []), - (this.s = []), - (this.padding = ee), - (this.outputBits = ge), - (this.reset = !0), - (this.finalized = !1), - (this.block = 0), - (this.start = 0), - (this.blockCount = (1600 - (L << 1)) >> 5), - (this.byteCount = this.blockCount << 2), - (this.outputBlocks = ge >> 5), - (this.extraBytes = (ge & 31) >> 3); - for (var fe = 0; fe < 50; ++fe) this.s[fe] = 0; - } - (E.prototype.update = function (L) { - if (this.finalized) throw new Error(e); - var ee, - ge = typeof L; - if (ge !== "string") { - if (ge === "object") { - if (L === null) throw new Error(t); - if (c && L.constructor === ArrayBuffer) L = new Uint8Array(L); - else if (!Array.isArray(L) && (!c || !ArrayBuffer.isView(L))) - throw new Error(t); - } else throw new Error(t); - ee = !0; - } - for ( - var fe = this.blocks, - V = this.byteCount, - ye = L.length, - ae = this.blockCount, - le = 0, - Me = this.s, - de, - ve; - le < ye; - - ) { - if (this.reset) - for (this.reset = !1, fe[0] = this.block, de = 1; de < ae + 1; ++de) - fe[de] = 0; - if (ee) - for (de = this.start; le < ye && de < V; ++le) - fe[de >> 2] |= L[le] << O[de++ & 3]; - else - for (de = this.start; le < ye && de < V; ++le) - (ve = L.charCodeAt(le)), - ve < 128 - ? (fe[de >> 2] |= ve << O[de++ & 3]) - : ve < 2048 - ? ((fe[de >> 2] |= (192 | (ve >> 6)) << O[de++ & 3]), - (fe[de >> 2] |= (128 | (ve & 63)) << O[de++ & 3])) - : ve < 55296 || ve >= 57344 - ? ((fe[de >> 2] |= (224 | (ve >> 12)) << O[de++ & 3]), - (fe[de >> 2] |= (128 | ((ve >> 6) & 63)) << O[de++ & 3]), - (fe[de >> 2] |= (128 | (ve & 63)) << O[de++ & 3])) - : ((ve = - 65536 + - (((ve & 1023) << 10) | (L.charCodeAt(++le) & 1023))), - (fe[de >> 2] |= (240 | (ve >> 18)) << O[de++ & 3]), - (fe[de >> 2] |= (128 | ((ve >> 12) & 63)) << O[de++ & 3]), - (fe[de >> 2] |= (128 | ((ve >> 6) & 63)) << O[de++ & 3]), - (fe[de >> 2] |= (128 | (ve & 63)) << O[de++ & 3])); - if (((this.lastByteIndex = de), de >= V)) { - for ( - this.start = de - V, this.block = fe[ae], de = 0; - de < ae; - ++de - ) - Me[de] ^= fe[de]; - G(Me), (this.reset = !0); - } else this.start = de; - } - return this; - }), - (E.prototype.encode = function (L, ee) { - var ge = L & 255, - fe = 1, - V = [ge]; - for (L = L >> 8, ge = L & 255; ge > 0; ) - V.unshift(ge), (L = L >> 8), (ge = L & 255), ++fe; - return ee ? V.push(fe) : V.unshift(fe), this.update(V), V.length; - }), - (E.prototype.encodeString = function (L) { - var ee, - ge = typeof L; - if (ge !== "string") { - if (ge === "object") { - if (L === null) throw new Error(t); - if (c && L.constructor === ArrayBuffer) L = new Uint8Array(L); - else if (!Array.isArray(L) && (!c || !ArrayBuffer.isView(L))) - throw new Error(t); - } else throw new Error(t); - ee = !0; - } - var fe = 0, - V = L.length; - if (ee) fe = V; - else - for (var ye = 0; ye < L.length; ++ye) { - var ae = L.charCodeAt(ye); - ae < 128 - ? (fe += 1) - : ae < 2048 - ? (fe += 2) - : ae < 55296 || ae >= 57344 - ? (fe += 3) - : ((ae = - 65536 + - (((ae & 1023) << 10) | (L.charCodeAt(++ye) & 1023))), - (fe += 4)); - } - return (fe += this.encode(fe * 8)), this.update(L), fe; - }), - (E.prototype.bytepad = function (L, ee) { - for (var ge = this.encode(ee), fe = 0; fe < L.length; ++fe) - ge += this.encodeString(L[fe]); - var V = ee - (ge % ee), - ye = []; - return (ye.length = V), this.update(ye), this; - }), - (E.prototype.finalize = function () { - if (!this.finalized) { - this.finalized = !0; - var L = this.blocks, - ee = this.lastByteIndex, - ge = this.blockCount, - fe = this.s; - if ( - ((L[ee >> 2] |= this.padding[ee & 3]), - this.lastByteIndex === this.byteCount) - ) - for (L[0] = L[ge], ee = 1; ee < ge + 1; ++ee) L[ee] = 0; - for (L[ge - 1] |= 2147483648, ee = 0; ee < ge; ++ee) - fe[ee] ^= L[ee]; - G(fe); - } - }), - (E.prototype.toString = E.prototype.hex = - function () { - this.finalize(); - for ( - var L = this.blockCount, - ee = this.s, - ge = this.outputBlocks, - fe = this.extraBytes, - V = 0, - ye = 0, - ae = "", - le; - ye < ge; - - ) { - for (V = 0; V < L && ye < ge; ++V, ++ye) - (le = ee[V]), - (ae += - u[(le >> 4) & 15] + - u[le & 15] + - u[(le >> 12) & 15] + - u[(le >> 8) & 15] + - u[(le >> 20) & 15] + - u[(le >> 16) & 15] + - u[(le >> 28) & 15] + - u[(le >> 24) & 15]); - ye % L === 0 && (G(ee), (V = 0)); - } - return ( - fe && - ((le = ee[V]), - (ae += u[(le >> 4) & 15] + u[le & 15]), - fe > 1 && (ae += u[(le >> 12) & 15] + u[(le >> 8) & 15]), - fe > 2 && (ae += u[(le >> 20) & 15] + u[(le >> 16) & 15])), - ae - ); - }), - (E.prototype.arrayBuffer = function () { - this.finalize(); - var L = this.blockCount, - ee = this.s, - ge = this.outputBlocks, - fe = this.extraBytes, - V = 0, - ye = 0, - ae = this.outputBits >> 3, - le; - fe - ? (le = new ArrayBuffer((ge + 1) << 2)) - : (le = new ArrayBuffer(ae)); - for (var Me = new Uint32Array(le); ye < ge; ) { - for (V = 0; V < L && ye < ge; ++V, ++ye) Me[ye] = ee[V]; - ye % L === 0 && G(ee); - } - return fe && ((Me[V] = ee[V]), (le = le.slice(0, ae))), le; - }), - (E.prototype.buffer = E.prototype.arrayBuffer), - (E.prototype.digest = E.prototype.array = - function () { - this.finalize(); - for ( - var L = this.blockCount, - ee = this.s, - ge = this.outputBlocks, - fe = this.extraBytes, - V = 0, - ye = 0, - ae = [], - le, - Me; - ye < ge; - - ) { - for (V = 0; V < L && ye < ge; ++V, ++ye) - (le = ye << 2), - (Me = ee[V]), - (ae[le] = Me & 255), - (ae[le + 1] = (Me >> 8) & 255), - (ae[le + 2] = (Me >> 16) & 255), - (ae[le + 3] = (Me >> 24) & 255); - ye % L === 0 && G(ee); - } - return ( - fe && - ((le = ye << 2), - (Me = ee[V]), - (ae[le] = Me & 255), - fe > 1 && (ae[le + 1] = (Me >> 8) & 255), - fe > 2 && (ae[le + 2] = (Me >> 16) & 255)), - ae - ); - }); - function B(L, ee, ge) { - E.call(this, L, ee, ge); - } - (B.prototype = new E()), - (B.prototype.finalize = function () { - return ( - this.encode(this.outputBits, !0), E.prototype.finalize.call(this) - ); - }); - var G = function (L) { - var ee, - ge, - fe, - V, - ye, - ae, - le, - Me, - de, - ve, - De, - me, - _e, - Ye, - Ee, - Be, - kt, - Ve, - We, - er, - Ue, - Y, - W, - j, - ce, - ze, - we, - xe, - Ft, - Ke, - pe, - Re, - Se, - Pe, - At, - Ie, - je, - qt, - Fe, - He, - lr, - Xe, - Ze, - Ir, - $e, - tt, - oe, - ie, - re, - U, - se, - be, - Qe, - Ae, - ke, - Ct, - ut, - St, - wt, - zt, - jt, - Ht, - Ut; - for (fe = 0; fe < 48; fe += 2) - (V = L[0] ^ L[10] ^ L[20] ^ L[30] ^ L[40]), - (ye = L[1] ^ L[11] ^ L[21] ^ L[31] ^ L[41]), - (ae = L[2] ^ L[12] ^ L[22] ^ L[32] ^ L[42]), - (le = L[3] ^ L[13] ^ L[23] ^ L[33] ^ L[43]), - (Me = L[4] ^ L[14] ^ L[24] ^ L[34] ^ L[44]), - (de = L[5] ^ L[15] ^ L[25] ^ L[35] ^ L[45]), - (ve = L[6] ^ L[16] ^ L[26] ^ L[36] ^ L[46]), - (De = L[7] ^ L[17] ^ L[27] ^ L[37] ^ L[47]), - (me = L[8] ^ L[18] ^ L[28] ^ L[38] ^ L[48]), - (_e = L[9] ^ L[19] ^ L[29] ^ L[39] ^ L[49]), - (ee = me ^ ((ae << 1) | (le >>> 31))), - (ge = _e ^ ((le << 1) | (ae >>> 31))), - (L[0] ^= ee), - (L[1] ^= ge), - (L[10] ^= ee), - (L[11] ^= ge), - (L[20] ^= ee), - (L[21] ^= ge), - (L[30] ^= ee), - (L[31] ^= ge), - (L[40] ^= ee), - (L[41] ^= ge), - (ee = V ^ ((Me << 1) | (de >>> 31))), - (ge = ye ^ ((de << 1) | (Me >>> 31))), - (L[2] ^= ee), - (L[3] ^= ge), - (L[12] ^= ee), - (L[13] ^= ge), - (L[22] ^= ee), - (L[23] ^= ge), - (L[32] ^= ee), - (L[33] ^= ge), - (L[42] ^= ee), - (L[43] ^= ge), - (ee = ae ^ ((ve << 1) | (De >>> 31))), - (ge = le ^ ((De << 1) | (ve >>> 31))), - (L[4] ^= ee), - (L[5] ^= ge), - (L[14] ^= ee), - (L[15] ^= ge), - (L[24] ^= ee), - (L[25] ^= ge), - (L[34] ^= ee), - (L[35] ^= ge), - (L[44] ^= ee), - (L[45] ^= ge), - (ee = Me ^ ((me << 1) | (_e >>> 31))), - (ge = de ^ ((_e << 1) | (me >>> 31))), - (L[6] ^= ee), - (L[7] ^= ge), - (L[16] ^= ee), - (L[17] ^= ge), - (L[26] ^= ee), - (L[27] ^= ge), - (L[36] ^= ee), - (L[37] ^= ge), - (L[46] ^= ee), - (L[47] ^= ge), - (ee = ve ^ ((V << 1) | (ye >>> 31))), - (ge = De ^ ((ye << 1) | (V >>> 31))), - (L[8] ^= ee), - (L[9] ^= ge), - (L[18] ^= ee), - (L[19] ^= ge), - (L[28] ^= ee), - (L[29] ^= ge), - (L[38] ^= ee), - (L[39] ^= ge), - (L[48] ^= ee), - (L[49] ^= ge), - (Ye = L[0]), - (Ee = L[1]), - (tt = (L[11] << 4) | (L[10] >>> 28)), - (oe = (L[10] << 4) | (L[11] >>> 28)), - (xe = (L[20] << 3) | (L[21] >>> 29)), - (Ft = (L[21] << 3) | (L[20] >>> 29)), - (zt = (L[31] << 9) | (L[30] >>> 23)), - (jt = (L[30] << 9) | (L[31] >>> 23)), - (Xe = (L[40] << 18) | (L[41] >>> 14)), - (Ze = (L[41] << 18) | (L[40] >>> 14)), - (Pe = (L[2] << 1) | (L[3] >>> 31)), - (At = (L[3] << 1) | (L[2] >>> 31)), - (Be = (L[13] << 12) | (L[12] >>> 20)), - (kt = (L[12] << 12) | (L[13] >>> 20)), - (ie = (L[22] << 10) | (L[23] >>> 22)), - (re = (L[23] << 10) | (L[22] >>> 22)), - (Ke = (L[33] << 13) | (L[32] >>> 19)), - (pe = (L[32] << 13) | (L[33] >>> 19)), - (Ht = (L[42] << 2) | (L[43] >>> 30)), - (Ut = (L[43] << 2) | (L[42] >>> 30)), - (Ae = (L[5] << 30) | (L[4] >>> 2)), - (ke = (L[4] << 30) | (L[5] >>> 2)), - (Ie = (L[14] << 6) | (L[15] >>> 26)), - (je = (L[15] << 6) | (L[14] >>> 26)), - (Ve = (L[25] << 11) | (L[24] >>> 21)), - (We = (L[24] << 11) | (L[25] >>> 21)), - (U = (L[34] << 15) | (L[35] >>> 17)), - (se = (L[35] << 15) | (L[34] >>> 17)), - (Re = (L[45] << 29) | (L[44] >>> 3)), - (Se = (L[44] << 29) | (L[45] >>> 3)), - (j = (L[6] << 28) | (L[7] >>> 4)), - (ce = (L[7] << 28) | (L[6] >>> 4)), - (Ct = (L[17] << 23) | (L[16] >>> 9)), - (ut = (L[16] << 23) | (L[17] >>> 9)), - (qt = (L[26] << 25) | (L[27] >>> 7)), - (Fe = (L[27] << 25) | (L[26] >>> 7)), - (er = (L[36] << 21) | (L[37] >>> 11)), - (Ue = (L[37] << 21) | (L[36] >>> 11)), - (be = (L[47] << 24) | (L[46] >>> 8)), - (Qe = (L[46] << 24) | (L[47] >>> 8)), - (Ir = (L[8] << 27) | (L[9] >>> 5)), - ($e = (L[9] << 27) | (L[8] >>> 5)), - (ze = (L[18] << 20) | (L[19] >>> 12)), - (we = (L[19] << 20) | (L[18] >>> 12)), - (St = (L[29] << 7) | (L[28] >>> 25)), - (wt = (L[28] << 7) | (L[29] >>> 25)), - (He = (L[38] << 8) | (L[39] >>> 24)), - (lr = (L[39] << 8) | (L[38] >>> 24)), - (Y = (L[48] << 14) | (L[49] >>> 18)), - (W = (L[49] << 14) | (L[48] >>> 18)), - (L[0] = Ye ^ (~Be & Ve)), - (L[1] = Ee ^ (~kt & We)), - (L[10] = j ^ (~ze & xe)), - (L[11] = ce ^ (~we & Ft)), - (L[20] = Pe ^ (~Ie & qt)), - (L[21] = At ^ (~je & Fe)), - (L[30] = Ir ^ (~tt & ie)), - (L[31] = $e ^ (~oe & re)), - (L[40] = Ae ^ (~Ct & St)), - (L[41] = ke ^ (~ut & wt)), - (L[2] = Be ^ (~Ve & er)), - (L[3] = kt ^ (~We & Ue)), - (L[12] = ze ^ (~xe & Ke)), - (L[13] = we ^ (~Ft & pe)), - (L[22] = Ie ^ (~qt & He)), - (L[23] = je ^ (~Fe & lr)), - (L[32] = tt ^ (~ie & U)), - (L[33] = oe ^ (~re & se)), - (L[42] = Ct ^ (~St & zt)), - (L[43] = ut ^ (~wt & jt)), - (L[4] = Ve ^ (~er & Y)), - (L[5] = We ^ (~Ue & W)), - (L[14] = xe ^ (~Ke & Re)), - (L[15] = Ft ^ (~pe & Se)), - (L[24] = qt ^ (~He & Xe)), - (L[25] = Fe ^ (~lr & Ze)), - (L[34] = ie ^ (~U & be)), - (L[35] = re ^ (~se & Qe)), - (L[44] = St ^ (~zt & Ht)), - (L[45] = wt ^ (~jt & Ut)), - (L[6] = er ^ (~Y & Ye)), - (L[7] = Ue ^ (~W & Ee)), - (L[16] = Ke ^ (~Re & j)), - (L[17] = pe ^ (~Se & ce)), - (L[26] = He ^ (~Xe & Pe)), - (L[27] = lr ^ (~Ze & At)), - (L[36] = U ^ (~be & Ir)), - (L[37] = se ^ (~Qe & $e)), - (L[46] = zt ^ (~Ht & Ae)), - (L[47] = jt ^ (~Ut & ke)), - (L[8] = Y ^ (~Ye & Be)), - (L[9] = W ^ (~Ee & kt)), - (L[18] = Re ^ (~j & ze)), - (L[19] = Se ^ (~ce & we)), - (L[28] = Xe ^ (~Pe & Ie)), - (L[29] = Ze ^ (~At & je)), - (L[38] = be ^ (~Ir & tt)), - (L[39] = Qe ^ (~$e & oe)), - (L[48] = Ht ^ (~Ae & Ct)), - (L[49] = Ut ^ (~ke & ut)), - (L[0] ^= D[fe]), - (L[1] ^= D[fe + 1]); - }; - if (a) lre.exports = d; - else { - for (_ = 0; _ < v.length; ++_) n[v[_]] = d[v[_]]; - s && - define(function () { - return d; - }); - } - })(); - }); - var Hh = I((wR) => { - "use strict"; - m(); - g(); - var Bgr = - (wR && wR.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(wR, "__esModule", { value: !0 }); - wR.keccak256 = void 0; - var Igr = Bgr(lut()), - Cgr = Ar(); - function Rgr(t) { - return "0x" + Igr.default.keccak_256((0, Cgr.arrayify)(t)); - } - wR.keccak256 = Rgr; - }); - var fut = I((fre) => { - "use strict"; - m(); - g(); - Object.defineProperty(fre, "__esModule", { value: !0 }); - fre.version = void 0; - fre.version = "rlp/5.7.0"; - }); - var zU = I((_R) => { - "use strict"; - m(); - g(); - Object.defineProperty(_R, "__esModule", { value: !0 }); - _R.decode = _R.encode = void 0; - var $T = Ar(), - yx = rr(), - Ngr = fut(), - ab = new yx.Logger(Ngr.version); - function dut(t) { - for (var e = []; t; ) e.unshift(t & 255), (t >>= 8); - return e; - } - function hut(t, e, r) { - for (var n = 0, i = 0; i < r; i++) n = n * 256 + t[e + i]; - return n; - } - function yut(t) { - if (Array.isArray(t)) { - var e = []; - if ( - (t.forEach(function (o) { - e = e.concat(yut(o)); - }), - e.length <= 55) - ) - return e.unshift(192 + e.length), e; - var r = dut(e.length); - return r.unshift(247 + r.length), r.concat(e); - } - (0, $T.isBytesLike)(t) || - ab.throwArgumentError("RLP object must be BytesLike", "object", t); - var n = Array.prototype.slice.call((0, $T.arrayify)(t)); - if (n.length === 1 && n[0] <= 127) return n; - if (n.length <= 55) return n.unshift(128 + n.length), n; - var i = dut(n.length); - return i.unshift(183 + i.length), i.concat(n); - } - function Dgr(t) { - return (0, $T.hexlify)(yut(t)); - } - _R.encode = Dgr; - function put(t, e, r, n) { - for (var i = []; r < e + 1 + n; ) { - var o = mut(t, r); - i.push(o.result), - (r += o.consumed), - r > e + 1 + n && - ab.throwError( - "child data too short", - yx.Logger.errors.BUFFER_OVERRUN, - {} - ); - } - return { consumed: 1 + n, result: i }; - } - function mut(t, e) { - if ( - (t.length === 0 && - ab.throwError("data too short", yx.Logger.errors.BUFFER_OVERRUN, {}), - t[e] >= 248) - ) { - var r = t[e] - 247; - e + 1 + r > t.length && - ab.throwError( - "data short segment too short", - yx.Logger.errors.BUFFER_OVERRUN, - {} - ); - var n = hut(t, e + 1, r); - return ( - e + 1 + r + n > t.length && - ab.throwError( - "data long segment too short", - yx.Logger.errors.BUFFER_OVERRUN, - {} - ), - put(t, e, e + 1 + r, r + n) - ); - } else if (t[e] >= 192) { - var i = t[e] - 192; - return ( - e + 1 + i > t.length && - ab.throwError( - "data array too short", - yx.Logger.errors.BUFFER_OVERRUN, - {} - ), - put(t, e, e + 1, i) - ); - } else if (t[e] >= 184) { - var r = t[e] - 183; - e + 1 + r > t.length && - ab.throwError( - "data array too short", - yx.Logger.errors.BUFFER_OVERRUN, - {} - ); - var o = hut(t, e + 1, r); - e + 1 + r + o > t.length && - ab.throwError( - "data array too short", - yx.Logger.errors.BUFFER_OVERRUN, - {} - ); - var a = (0, $T.hexlify)(t.slice(e + 1 + r, e + 1 + r + o)); - return { consumed: 1 + r + o, result: a }; - } else if (t[e] >= 128) { - var s = t[e] - 128; - e + 1 + s > t.length && - ab.throwError("data too short", yx.Logger.errors.BUFFER_OVERRUN, {}); - var a = (0, $T.hexlify)(t.slice(e + 1, e + 1 + s)); - return { consumed: 1 + s, result: a }; - } - return { consumed: 1, result: (0, $T.hexlify)(t[e]) }; - } - function Fgr(t) { - var e = (0, $T.arrayify)(t), - r = mut(e, 0); - return ( - r.consumed !== e.length && - ab.throwArgumentError("invalid rlp data", "data", t), - r.result - ); - } - _R.decode = Fgr; - }); - var gut = I((dre) => { - "use strict"; - m(); - g(); - Object.defineProperty(dre, "__esModule", { value: !0 }); - dre.version = void 0; - dre.version = "address/5.7.0"; - }); - var Vh = I((Cy) => { - "use strict"; - m(); - g(); - Object.defineProperty(Cy, "__esModule", { value: !0 }); - Cy.getCreate2Address = - Cy.getContractAddress = - Cy.getIcapAddress = - Cy.isAddress = - Cy.getAddress = - void 0; - var mx = Ar(), - cAe = Ro(), - lAe = Hh(), - Lgr = zU(), - qgr = rr(), - zgr = gut(), - EA = new qgr.Logger(zgr.version); - function vut(t) { - (0, mx.isHexString)(t, 20) || - EA.throwArgumentError("invalid address", "address", t), - (t = t.toLowerCase()); - for ( - var e = t.substring(2).split(""), r = new Uint8Array(40), n = 0; - n < 40; - n++ - ) - r[n] = e[n].charCodeAt(0); - for ( - var i = (0, mx.arrayify)((0, lAe.keccak256)(r)), n = 0; - n < 40; - n += 2 - ) - i[n >> 1] >> 4 >= 8 && (e[n] = e[n].toUpperCase()), - (i[n >> 1] & 15) >= 8 && (e[n + 1] = e[n + 1].toUpperCase()); - return "0x" + e.join(""); - } - var jgr = 9007199254740991; - function Ugr(t) { - return Math.log10 ? Math.log10(t) : Math.log(t) / Math.LN10; - } - var fAe = {}; - for (hg = 0; hg < 10; hg++) fAe[String(hg)] = String(hg); - var hg; - for (hg = 0; hg < 26; hg++) - fAe[String.fromCharCode(65 + hg)] = String(10 + hg); - var hg, - but = Math.floor(Ugr(jgr)); - function wut(t) { - (t = t.toUpperCase()), (t = t.substring(4) + t.substring(0, 2) + "00"); - for ( - var e = t - .split("") - .map(function (i) { - return fAe[i]; - }) - .join(""); - e.length >= but; - - ) { - var r = e.substring(0, but); - e = (parseInt(r, 10) % 97) + e.substring(r.length); - } - for (var n = String(98 - (parseInt(e, 10) % 97)); n.length < 2; ) - n = "0" + n; - return n; - } - function ZT(t) { - var e = null; - if ( - (typeof t != "string" && - EA.throwArgumentError("invalid address", "address", t), - t.match(/^(0x)?[0-9a-fA-F]{40}$/)) - ) - t.substring(0, 2) !== "0x" && (t = "0x" + t), - (e = vut(t)), - t.match(/([A-F].*[a-f])|([a-f].*[A-F])/) && - e !== t && - EA.throwArgumentError("bad address checksum", "address", t); - else if (t.match(/^XE[0-9]{2}[0-9A-Za-z]{30,31}$/)) { - for ( - t.substring(2, 4) !== wut(t) && - EA.throwArgumentError("bad icap checksum", "address", t), - e = (0, cAe._base36To16)(t.substring(4)); - e.length < 40; - - ) - e = "0" + e; - e = vut("0x" + e); - } else EA.throwArgumentError("invalid address", "address", t); - return e; - } - Cy.getAddress = ZT; - function Kgr(t) { - try { - return ZT(t), !0; - } catch {} - return !1; - } - Cy.isAddress = Kgr; - function Hgr(t) { - for ( - var e = (0, cAe._base16To36)(ZT(t).substring(2)).toUpperCase(); - e.length < 30; - - ) - e = "0" + e; - return "XE" + wut("XE00" + e) + e; - } - Cy.getIcapAddress = Hgr; - function Vgr(t) { - var e = null; - try { - e = ZT(t.from); - } catch { - EA.throwArgumentError("missing from address", "transaction", t); - } - var r = (0, mx.stripZeros)( - (0, mx.arrayify)(cAe.BigNumber.from(t.nonce).toHexString()) - ); - return ZT( - (0, mx.hexDataSlice)((0, lAe.keccak256)((0, Lgr.encode)([e, r])), 12) - ); - } - Cy.getContractAddress = Vgr; - function Wgr(t, e, r) { - return ( - (0, mx.hexDataLength)(e) !== 32 && - EA.throwArgumentError("salt must be 32 bytes", "salt", e), - (0, mx.hexDataLength)(r) !== 32 && - EA.throwArgumentError( - "initCodeHash must be 32 bytes", - "initCodeHash", - r - ), - ZT( - (0, mx.hexDataSlice)( - (0, lAe.keccak256)((0, mx.concat)(["0xff", ZT(t), e, r])), - 12 - ) - ) - ); - } - Cy.getCreate2Address = Wgr; - }); - var xut = I((xR) => { - "use strict"; - m(); - g(); - var Ggr = - (xR && xR.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(xR, "__esModule", { value: !0 }); - xR.AddressCoder = void 0; - var _ut = Vh(), - Jgr = Ar(), - $gr = Iy(), - Zgr = (function (t) { - Ggr(e, t); - function e(r) { - return t.call(this, "address", "address", r, !1) || this; - } - return ( - (e.prototype.defaultValue = function () { - return "0x0000000000000000000000000000000000000000"; - }), - (e.prototype.encode = function (r, n) { - try { - n = (0, _ut.getAddress)(n); - } catch (i) { - this._throwError(i.message, n); - } - return r.writeValue(n); - }), - (e.prototype.decode = function (r) { - return (0, _ut.getAddress)( - (0, Jgr.hexZeroPad)(r.readValue().toHexString(), 20) - ); - }), - e - ); - })($gr.Coder); - xR.AddressCoder = Zgr; - }); - var Sut = I((SR) => { - "use strict"; - m(); - g(); - var Xgr = - (SR && SR.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(SR, "__esModule", { value: !0 }); - SR.AnonymousCoder = void 0; - var Ygr = Iy(), - Qgr = (function (t) { - Xgr(e, t); - function e(r) { - var n = t.call(this, r.name, r.type, void 0, r.dynamic) || this; - return (n.coder = r), n; - } - return ( - (e.prototype.defaultValue = function () { - return this.coder.defaultValue(); - }), - (e.prototype.encode = function (r, n) { - return this.coder.encode(r, n); - }), - (e.prototype.decode = function (r) { - return this.coder.decode(r); - }), - e - ); - })(Ygr.Coder); - SR.AnonymousCoder = Qgr; - }); - var hAe = I((sb) => { - "use strict"; - m(); - g(); - var evr = - (sb && sb.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(sb, "__esModule", { value: !0 }); - sb.ArrayCoder = sb.unpack = sb.pack = void 0; - var ER = rr(), - tvr = vR(), - AR = new ER.Logger(tvr.version), - dAe = Iy(), - rvr = Sut(); - function Aut(t, e, r) { - var n = null; - if (Array.isArray(r)) n = r; - else if (r && typeof r == "object") { - var i = {}; - n = e.map(function (u) { - var h = u.localName; - return ( - h || - AR.throwError( - "cannot encode object for signature with missing names", - ER.Logger.errors.INVALID_ARGUMENT, - { argument: "values", coder: u, value: r } - ), - i[h] && - AR.throwError( - "cannot encode object for signature with duplicate names", - ER.Logger.errors.INVALID_ARGUMENT, - { argument: "values", coder: u, value: r } - ), - (i[h] = !0), - r[h] - ); - }); - } else AR.throwArgumentError("invalid tuple value", "tuple", r); - e.length !== n.length && - AR.throwArgumentError("types/value length mismatch", "tuple", r); - var o = new dAe.Writer(t.wordSize), - a = new dAe.Writer(t.wordSize), - s = []; - e.forEach(function (u, h) { - var w = n[h]; - if (u.dynamic) { - var M = a.length; - u.encode(a, w); - var k = o.writeUpdatableValue(); - s.push(function (O) { - k(O + M); - }); - } else u.encode(o, w); - }), - s.forEach(function (u) { - u(o.length); - }); - var c = t.appendWriter(o); - return (c += t.appendWriter(a)), c; - } - sb.pack = Aut; - function Eut(t, e) { - var r = [], - n = t.subReader(0); - e.forEach(function (s) { - var c = null; - if (s.dynamic) { - var u = t.readValue(), - h = n.subReader(u.toNumber()); - try { - c = s.decode(h); - } catch (w) { - if (w.code === ER.Logger.errors.BUFFER_OVERRUN) throw w; - (c = w), - (c.baseType = s.name), - (c.name = s.localName), - (c.type = s.type); - } - } else - try { - c = s.decode(t); - } catch (w) { - if (w.code === ER.Logger.errors.BUFFER_OVERRUN) throw w; - (c = w), - (c.baseType = s.name), - (c.name = s.localName), - (c.type = s.type); - } - c != null && r.push(c); - }); - var i = e.reduce(function (s, c) { - var u = c.localName; - return u && (s[u] || (s[u] = 0), s[u]++), s; - }, {}); - e.forEach(function (s, c) { - var u = s.localName; - if ( - !(!u || i[u] !== 1) && - (u === "length" && (u = "_length"), r[u] == null) - ) { - var h = r[c]; - h instanceof Error - ? Object.defineProperty(r, u, { - enumerable: !0, - get: function () { - throw h; - }, - }) - : (r[u] = h); - } - }); - for ( - var o = function (s) { - var c = r[s]; - c instanceof Error && - Object.defineProperty(r, s, { - enumerable: !0, - get: function () { - throw c; - }, - }); - }, - a = 0; - a < r.length; - a++ - ) - o(a); - return Object.freeze(r); - } - sb.unpack = Eut; - var nvr = (function (t) { - evr(e, t); - function e(r, n, i) { - var o = this, - a = r.type + "[" + (n >= 0 ? n : "") + "]", - s = n === -1 || r.dynamic; - return ( - (o = t.call(this, "array", a, i, s) || this), - (o.coder = r), - (o.length = n), - o - ); - } - return ( - (e.prototype.defaultValue = function () { - for ( - var r = this.coder.defaultValue(), n = [], i = 0; - i < this.length; - i++ - ) - n.push(r); - return n; - }), - (e.prototype.encode = function (r, n) { - Array.isArray(n) || this._throwError("expected array value", n); - var i = this.length; - i === -1 && ((i = n.length), r.writeValue(n.length)), - AR.checkArgumentCount( - n.length, - i, - "coder array" + (this.localName ? " " + this.localName : "") - ); - for (var o = [], a = 0; a < n.length; a++) o.push(this.coder); - return Aut(r, o, n); - }), - (e.prototype.decode = function (r) { - var n = this.length; - n === -1 && - ((n = r.readValue().toNumber()), - n * 32 > r._data.length && - AR.throwError( - "insufficient data length", - ER.Logger.errors.BUFFER_OVERRUN, - { length: r._data.length, count: n } - )); - for (var i = [], o = 0; o < n; o++) - i.push(new rvr.AnonymousCoder(this.coder)); - return r.coerce(this.name, Eut(r, i)); - }), - e - ); - })(dAe.Coder); - sb.ArrayCoder = nvr; - }); - var Mut = I((MR) => { - "use strict"; - m(); - g(); - var ivr = - (MR && MR.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(MR, "__esModule", { value: !0 }); - MR.BooleanCoder = void 0; - var ovr = Iy(), - avr = (function (t) { - ivr(e, t); - function e(r) { - return t.call(this, "bool", "bool", r, !1) || this; - } - return ( - (e.prototype.defaultValue = function () { - return !1; - }), - (e.prototype.encode = function (r, n) { - return r.writeValue(n ? 1 : 0); - }), - (e.prototype.decode = function (r) { - return r.coerce(this.type, !r.readValue().isZero()); - }), - e - ); - })(ovr.Coder); - MR.BooleanCoder = avr; - }); - var pAe = I((MA) => { - "use strict"; - m(); - g(); - var Tut = - (MA && MA.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(MA, "__esModule", { value: !0 }); - MA.BytesCoder = MA.DynamicBytesCoder = void 0; - var kut = Ar(), - svr = Iy(), - Put = (function (t) { - Tut(e, t); - function e(r, n) { - return t.call(this, r, r, n, !0) || this; - } - return ( - (e.prototype.defaultValue = function () { - return "0x"; - }), - (e.prototype.encode = function (r, n) { - n = (0, kut.arrayify)(n); - var i = r.writeValue(n.length); - return (i += r.writeBytes(n)), i; - }), - (e.prototype.decode = function (r) { - return r.readBytes(r.readValue().toNumber(), !0); - }), - e - ); - })(svr.Coder); - MA.DynamicBytesCoder = Put; - var uvr = (function (t) { - Tut(e, t); - function e(r) { - return t.call(this, "bytes", r) || this; - } - return ( - (e.prototype.decode = function (r) { - return r.coerce( - this.name, - (0, kut.hexlify)(t.prototype.decode.call(this, r)) - ); - }), - e - ); - })(Put); - MA.BytesCoder = uvr; - }); - var But = I((TR) => { - "use strict"; - m(); - g(); - var cvr = - (TR && TR.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(TR, "__esModule", { value: !0 }); - TR.FixedBytesCoder = void 0; - var Out = Ar(), - lvr = Iy(), - fvr = (function (t) { - cvr(e, t); - function e(r, n) { - var i = this, - o = "bytes" + String(r); - return (i = t.call(this, o, o, n, !1) || this), (i.size = r), i; - } - return ( - (e.prototype.defaultValue = function () { - return "0x0000000000000000000000000000000000000000000000000000000000000000".substring( - 0, - 2 + this.size * 2 - ); - }), - (e.prototype.encode = function (r, n) { - var i = (0, Out.arrayify)(n); - return ( - i.length !== this.size && - this._throwError("incorrect data length", n), - r.writeBytes(i) - ); - }), - (e.prototype.decode = function (r) { - return r.coerce( - this.name, - (0, Out.hexlify)(r.readBytes(this.size)) - ); - }), - e - ); - })(lvr.Coder); - TR.FixedBytesCoder = fvr; - }); - var Iut = I((kR) => { - "use strict"; - m(); - g(); - var dvr = - (kR && kR.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(kR, "__esModule", { value: !0 }); - kR.NullCoder = void 0; - var hvr = Iy(), - pvr = (function (t) { - dvr(e, t); - function e(r) { - return t.call(this, "null", "", r, !1) || this; - } - return ( - (e.prototype.defaultValue = function () { - return null; - }), - (e.prototype.encode = function (r, n) { - return ( - n != null && this._throwError("not null", n), r.writeBytes([]) - ); - }), - (e.prototype.decode = function (r) { - return r.readBytes(0), r.coerce(this.name, null); - }), - e - ); - })(hvr.Coder); - kR.NullCoder = pvr; - }); - var Cut = I((hre) => { - "use strict"; - m(); - g(); - Object.defineProperty(hre, "__esModule", { value: !0 }); - hre.AddressZero = void 0; - hre.AddressZero = "0x0000000000000000000000000000000000000000"; - }); - var Rut = I((Iu) => { - "use strict"; - m(); - g(); - Object.defineProperty(Iu, "__esModule", { value: !0 }); - Iu.MaxInt256 = - Iu.MinInt256 = - Iu.MaxUint256 = - Iu.WeiPerEther = - Iu.Two = - Iu.One = - Iu.Zero = - Iu.NegativeOne = - void 0; - var TA = Ro(), - yvr = TA.BigNumber.from(-1); - Iu.NegativeOne = yvr; - var mvr = TA.BigNumber.from(0); - Iu.Zero = mvr; - var gvr = TA.BigNumber.from(1); - Iu.One = gvr; - var vvr = TA.BigNumber.from(2); - Iu.Two = vvr; - var bvr = TA.BigNumber.from("1000000000000000000"); - Iu.WeiPerEther = bvr; - var wvr = TA.BigNumber.from( - "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - ); - Iu.MaxUint256 = wvr; - var _vr = TA.BigNumber.from( - "-0x8000000000000000000000000000000000000000000000000000000000000000" - ); - Iu.MinInt256 = _vr; - var xvr = TA.BigNumber.from( - "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - ); - Iu.MaxInt256 = xvr; - }); - var Nut = I((pre) => { - "use strict"; - m(); - g(); - Object.defineProperty(pre, "__esModule", { value: !0 }); - pre.HashZero = void 0; - pre.HashZero = - "0x0000000000000000000000000000000000000000000000000000000000000000"; - }); - var Dut = I((yre) => { - "use strict"; - m(); - g(); - Object.defineProperty(yre, "__esModule", { value: !0 }); - yre.EtherSymbol = void 0; - yre.EtherSymbol = "\u039E"; - }); - var ub = I((ua) => { - "use strict"; - m(); - g(); - Object.defineProperty(ua, "__esModule", { value: !0 }); - ua.EtherSymbol = - ua.HashZero = - ua.MaxInt256 = - ua.MinInt256 = - ua.MaxUint256 = - ua.WeiPerEther = - ua.Two = - ua.One = - ua.Zero = - ua.NegativeOne = - ua.AddressZero = - void 0; - var Svr = Cut(); - Object.defineProperty(ua, "AddressZero", { - enumerable: !0, - get: function () { - return Svr.AddressZero; - }, - }); - var kA = Rut(); - Object.defineProperty(ua, "NegativeOne", { - enumerable: !0, - get: function () { - return kA.NegativeOne; - }, - }); - Object.defineProperty(ua, "Zero", { - enumerable: !0, - get: function () { - return kA.Zero; - }, - }); - Object.defineProperty(ua, "One", { - enumerable: !0, - get: function () { - return kA.One; - }, - }); - Object.defineProperty(ua, "Two", { - enumerable: !0, - get: function () { - return kA.Two; - }, - }); - Object.defineProperty(ua, "WeiPerEther", { - enumerable: !0, - get: function () { - return kA.WeiPerEther; - }, - }); - Object.defineProperty(ua, "MaxUint256", { - enumerable: !0, - get: function () { - return kA.MaxUint256; - }, - }); - Object.defineProperty(ua, "MinInt256", { - enumerable: !0, - get: function () { - return kA.MinInt256; - }, - }); - Object.defineProperty(ua, "MaxInt256", { - enumerable: !0, - get: function () { - return kA.MaxInt256; - }, - }); - var Avr = Nut(); - Object.defineProperty(ua, "HashZero", { - enumerable: !0, - get: function () { - return Avr.HashZero; - }, - }); - var Evr = Dut(); - Object.defineProperty(ua, "EtherSymbol", { - enumerable: !0, - get: function () { - return Evr.EtherSymbol; - }, - }); - }); - var Fut = I((PR) => { - "use strict"; - m(); - g(); - var Mvr = - (PR && PR.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(PR, "__esModule", { value: !0 }); - PR.NumberCoder = void 0; - var Tvr = Ro(), - mre = ub(), - kvr = Iy(), - Pvr = (function (t) { - Mvr(e, t); - function e(r, n, i) { - var o = this, - a = (n ? "int" : "uint") + r * 8; - return ( - (o = t.call(this, a, a, i, !1) || this), - (o.size = r), - (o.signed = n), - o - ); - } - return ( - (e.prototype.defaultValue = function () { - return 0; - }), - (e.prototype.encode = function (r, n) { - var i = Tvr.BigNumber.from(n), - o = mre.MaxUint256.mask(r.wordSize * 8); - if (this.signed) { - var a = o.mask(this.size * 8 - 1); - (i.gt(a) || i.lt(a.add(mre.One).mul(mre.NegativeOne))) && - this._throwError("value out-of-bounds", n); - } else - (i.lt(mre.Zero) || i.gt(o.mask(this.size * 8))) && - this._throwError("value out-of-bounds", n); - return ( - (i = i.toTwos(this.size * 8).mask(this.size * 8)), - this.signed && - (i = i.fromTwos(this.size * 8).toTwos(8 * r.wordSize)), - r.writeValue(i) - ); - }), - (e.prototype.decode = function (r) { - var n = r.readValue().mask(this.size * 8); - return ( - this.signed && (n = n.fromTwos(this.size * 8)), - r.coerce(this.name, n) - ); - }), - e - ); - })(kvr.Coder); - PR.NumberCoder = Pvr; - }); - var Lut = I((gre) => { - "use strict"; - m(); - g(); - Object.defineProperty(gre, "__esModule", { value: !0 }); - gre.version = void 0; - gre.version = "strings/5.7.0"; - }); - var bre = I((is) => { - "use strict"; - m(); - g(); - Object.defineProperty(is, "__esModule", { value: !0 }); - is.toUtf8CodePoints = - is.toUtf8String = - is._toUtf8String = - is._toEscapedUtf8String = - is.toUtf8Bytes = - is.Utf8ErrorFuncs = - is.Utf8ErrorReason = - is.UnicodeNormalizationForm = - void 0; - var qut = Ar(), - Ovr = rr(), - Bvr = Lut(), - zut = new Ovr.Logger(Bvr.version), - vre; - (function (t) { - (t.current = ""), - (t.NFC = "NFC"), - (t.NFD = "NFD"), - (t.NFKC = "NFKC"), - (t.NFKD = "NFKD"); - })( - (vre = is.UnicodeNormalizationForm || (is.UnicodeNormalizationForm = {})) - ); - var Ry; - (function (t) { - (t.UNEXPECTED_CONTINUE = "unexpected continuation byte"), - (t.BAD_PREFIX = "bad codepoint prefix"), - (t.OVERRUN = "string overrun"), - (t.MISSING_CONTINUE = "missing continuation byte"), - (t.OUT_OF_RANGE = "out of UTF-8 range"), - (t.UTF16_SURROGATE = "UTF-16 surrogate"), - (t.OVERLONG = "overlong representation"); - })((Ry = is.Utf8ErrorReason || (is.Utf8ErrorReason = {}))); - function Ivr(t, e, r, n, i) { - return zut.throwArgumentError( - "invalid codepoint at offset " + e + "; " + t, - "bytes", - r - ); - } - function jut(t, e, r, n, i) { - if (t === Ry.BAD_PREFIX || t === Ry.UNEXPECTED_CONTINUE) { - for (var o = 0, a = e + 1; a < r.length && r[a] >> 6 === 2; a++) o++; - return o; - } - return t === Ry.OVERRUN ? r.length - e - 1 : 0; - } - function Cvr(t, e, r, n, i) { - return t === Ry.OVERLONG - ? (n.push(i), 0) - : (n.push(65533), jut(t, e, r, n, i)); - } - is.Utf8ErrorFuncs = Object.freeze({ - error: Ivr, - ignore: jut, - replace: Cvr, - }); - function mAe(t, e) { - e == null && (e = is.Utf8ErrorFuncs.error), (t = (0, qut.arrayify)(t)); - for (var r = [], n = 0; n < t.length; ) { - var i = t[n++]; - if (i >> 7 === 0) { - r.push(i); - continue; - } - var o = null, - a = null; - if ((i & 224) === 192) (o = 1), (a = 127); - else if ((i & 240) === 224) (o = 2), (a = 2047); - else if ((i & 248) === 240) (o = 3), (a = 65535); - else { - (i & 192) === 128 - ? (n += e(Ry.UNEXPECTED_CONTINUE, n - 1, t, r)) - : (n += e(Ry.BAD_PREFIX, n - 1, t, r)); - continue; - } - if (n - 1 + o >= t.length) { - n += e(Ry.OVERRUN, n - 1, t, r); - continue; - } - for (var s = i & ((1 << (8 - o - 1)) - 1), c = 0; c < o; c++) { - var u = t[n]; - if ((u & 192) != 128) { - (n += e(Ry.MISSING_CONTINUE, n, t, r)), (s = null); - break; - } - (s = (s << 6) | (u & 63)), n++; - } - if (s !== null) { - if (s > 1114111) { - n += e(Ry.OUT_OF_RANGE, n - 1 - o, t, r, s); - continue; - } - if (s >= 55296 && s <= 57343) { - n += e(Ry.UTF16_SURROGATE, n - 1 - o, t, r, s); - continue; - } - if (s <= a) { - n += e(Ry.OVERLONG, n - 1 - o, t, r, s); - continue; - } - r.push(s); - } - } - return r; - } - function Uut(t, e) { - e === void 0 && (e = vre.current), - e != vre.current && (zut.checkNormalize(), (t = t.normalize(e))); - for (var r = [], n = 0; n < t.length; n++) { - var i = t.charCodeAt(n); - if (i < 128) r.push(i); - else if (i < 2048) r.push((i >> 6) | 192), r.push((i & 63) | 128); - else if ((i & 64512) == 55296) { - n++; - var o = t.charCodeAt(n); - if (n >= t.length || (o & 64512) !== 56320) - throw new Error("invalid utf-8 string"); - var a = 65536 + ((i & 1023) << 10) + (o & 1023); - r.push((a >> 18) | 240), - r.push(((a >> 12) & 63) | 128), - r.push(((a >> 6) & 63) | 128), - r.push((a & 63) | 128); - } else - r.push((i >> 12) | 224), - r.push(((i >> 6) & 63) | 128), - r.push((i & 63) | 128); - } - return (0, qut.arrayify)(r); - } - is.toUtf8Bytes = Uut; - function yAe(t) { - var e = "0000" + t.toString(16); - return "\\u" + e.substring(e.length - 4); - } - function Rvr(t, e) { - return ( - '"' + - mAe(t, e) - .map(function (r) { - if (r < 256) { - switch (r) { - case 8: - return "\\b"; - case 9: - return "\\t"; - case 10: - return "\\n"; - case 13: - return "\\r"; - case 34: - return '\\"'; - case 92: - return "\\\\"; - } - if (r >= 32 && r < 127) return String.fromCharCode(r); - } - return r <= 65535 - ? yAe(r) - : ((r -= 65536), - yAe(((r >> 10) & 1023) + 55296) + yAe((r & 1023) + 56320)); - }) - .join("") + - '"' - ); - } - is._toEscapedUtf8String = Rvr; - function Kut(t) { - return t - .map(function (e) { - return e <= 65535 - ? String.fromCharCode(e) - : ((e -= 65536), - String.fromCharCode( - ((e >> 10) & 1023) + 55296, - (e & 1023) + 56320 - )); - }) - .join(""); - } - is._toUtf8String = Kut; - function Nvr(t, e) { - return Kut(mAe(t, e)); - } - is.toUtf8String = Nvr; - function Dvr(t, e) { - return e === void 0 && (e = vre.current), mAe(Uut(t, e)); - } - is.toUtf8CodePoints = Dvr; - }); - var Vut = I((OR) => { - "use strict"; - m(); - g(); - Object.defineProperty(OR, "__esModule", { value: !0 }); - OR.parseBytes32String = OR.formatBytes32String = void 0; - var Fvr = ub(), - gAe = Ar(), - Hut = bre(); - function Lvr(t) { - var e = (0, Hut.toUtf8Bytes)(t); - if (e.length > 31) - throw new Error("bytes32 string must be less than 32 bytes"); - return (0, gAe.hexlify)((0, gAe.concat)([e, Fvr.HashZero]).slice(0, 32)); - } - OR.formatBytes32String = Lvr; - function qvr(t) { - var e = (0, gAe.arrayify)(t); - if (e.length !== 32) - throw new Error("invalid bytes32 - not 32 bytes long"); - if (e[31] !== 0) - throw new Error("invalid bytes32 string - no null terminator"); - for (var r = 31; e[r - 1] === 0; ) r--; - return (0, Hut.toUtf8String)(e.slice(0, r)); - } - OR.parseBytes32String = qvr; - }); - var Zut = I((cb) => { - "use strict"; - m(); - g(); - Object.defineProperty(cb, "__esModule", { value: !0 }); - cb.nameprep = - cb._nameprepTableC = - cb._nameprepTableB2 = - cb._nameprepTableA1 = - void 0; - var jU = bre(); - function zvr(t) { - if (t.length % 4 !== 0) throw new Error("bad data"); - for (var e = [], r = 0; r < t.length; r += 4) - e.push(parseInt(t.substring(r, r + 4), 16)); - return e; - } - function vAe(t, e) { - e || - (e = function (i) { - return [parseInt(i, 16)]; - }); - var r = 0, - n = {}; - return ( - t.split(",").forEach(function (i) { - var o = i.split(":"); - (r += parseInt(o[0], 16)), (n[r] = e(o[1])); - }), - n - ); - } - function Wut(t) { - var e = 0; - return t.split(",").map(function (r) { - var n = r.split("-"); - n.length === 1 ? (n[1] = "0") : n[1] === "" && (n[1] = "1"); - var i = e + parseInt(n[0], 16); - return (e = parseInt(n[1], 16)), { l: i, h: e }; - }); - } - function bAe(t, e) { - for (var r = 0, n = 0; n < e.length; n++) { - var i = e[n]; - if ( - ((r += i.l), t >= r && t <= r + i.h && (t - r) % (i.d || 1) === 0) - ) { - if (i.e && i.e.indexOf(t - r) !== -1) continue; - return i; - } - } - return null; - } - var jvr = Wut( - "221,13-1b,5f-,40-10,51-f,11-3,3-3,2-2,2-4,8,2,15,2d,28-8,88,48,27-,3-5,11-20,27-,8,28,3-5,12,18,b-a,1c-4,6-16,2-d,2-2,2,1b-4,17-9,8f-,10,f,1f-2,1c-34,33-14e,4,36-,13-,6-2,1a-f,4,9-,3-,17,8,2-2,5-,2,8-,3-,4-8,2-3,3,6-,16-6,2-,7-3,3-,17,8,3,3,3-,2,6-3,3-,4-a,5,2-6,10-b,4,8,2,4,17,8,3,6-,b,4,4-,2-e,2-4,b-10,4,9-,3-,17,8,3-,5-,9-2,3-,4-7,3-3,3,4-3,c-10,3,7-2,4,5-2,3,2,3-2,3-2,4-2,9,4-3,6-2,4,5-8,2-e,d-d,4,9,4,18,b,6-3,8,4,5-6,3-8,3-3,b-11,3,9,4,18,b,6-3,8,4,5-6,3-6,2,3-3,b-11,3,9,4,18,11-3,7-,4,5-8,2-7,3-3,b-11,3,13-2,19,a,2-,8-2,2-3,7,2,9-11,4-b,3b-3,1e-24,3,2-,3,2-,2-5,5,8,4,2,2-,3,e,4-,6,2,7-,b-,3-21,49,23-5,1c-3,9,25,10-,2-2f,23,6,3,8-2,5-5,1b-45,27-9,2a-,2-3,5b-4,45-4,53-5,8,40,2,5-,8,2,5-,28,2,5-,20,2,5-,8,2,5-,8,8,18,20,2,5-,8,28,14-5,1d-22,56-b,277-8,1e-2,52-e,e,8-a,18-8,15-b,e,4,3-b,5e-2,b-15,10,b-5,59-7,2b-555,9d-3,5b-5,17-,7-,27-,7-,9,2,2,2,20-,36,10,f-,7,14-,4,a,54-3,2-6,6-5,9-,1c-10,13-1d,1c-14,3c-,10-6,32-b,240-30,28-18,c-14,a0,115-,3,66-,b-76,5,5-,1d,24,2,5-2,2,8-,35-2,19,f-10,1d-3,311-37f,1b,5a-b,d7-19,d-3,41,57-,68-4,29-3,5f,29-37,2e-2,25-c,2c-2,4e-3,30,78-3,64-,20,19b7-49,51a7-59,48e-2,38-738,2ba5-5b,222f-,3c-94,8-b,6-4,1b,6,2,3,3,6d-20,16e-f,41-,37-7,2e-2,11-f,5-b,18-,b,14,5-3,6,88-,2,bf-2,7-,7-,7-,4-2,8,8-9,8-2ff,20,5-b,1c-b4,27-,27-cbb1,f7-9,28-2,b5-221,56,48,3-,2-,3-,5,d,2,5,3,42,5-,9,8,1d,5,6,2-2,8,153-3,123-3,33-27fd,a6da-5128,21f-5df,3-fffd,3-fffd,3-fffd,3-fffd,3-fffd,3-fffd,3-fffd,3-fffd,3-fffd,3-fffd,3-fffd,3,2-1d,61-ff7d" - ), - Uvr = "ad,34f,1806,180b,180c,180d,200b,200c,200d,2060,feff" - .split(",") - .map(function (t) { - return parseInt(t, 16); - }), - Kvr = [ - { h: 25, s: 32, l: 65 }, - { h: 30, s: 32, e: [23], l: 127 }, - { h: 54, s: 1, e: [48], l: 64, d: 2 }, - { h: 14, s: 1, l: 57, d: 2 }, - { h: 44, s: 1, l: 17, d: 2 }, - { h: 10, s: 1, e: [2, 6, 8], l: 61, d: 2 }, - { h: 16, s: 1, l: 68, d: 2 }, - { h: 84, s: 1, e: [18, 24, 66], l: 19, d: 2 }, - { h: 26, s: 32, e: [17], l: 435 }, - { h: 22, s: 1, l: 71, d: 2 }, - { h: 15, s: 80, l: 40 }, - { h: 31, s: 32, l: 16 }, - { h: 32, s: 1, l: 80, d: 2 }, - { h: 52, s: 1, l: 42, d: 2 }, - { h: 12, s: 1, l: 55, d: 2 }, - { h: 40, s: 1, e: [38], l: 15, d: 2 }, - { h: 14, s: 1, l: 48, d: 2 }, - { h: 37, s: 48, l: 49 }, - { h: 148, s: 1, l: 6351, d: 2 }, - { h: 88, s: 1, l: 160, d: 2 }, - { h: 15, s: 16, l: 704 }, - { h: 25, s: 26, l: 854 }, - { h: 25, s: 32, l: 55915 }, - { h: 37, s: 40, l: 1247 }, - { h: 25, s: -119711, l: 53248 }, - { h: 25, s: -119763, l: 52 }, - { h: 25, s: -119815, l: 52 }, - { h: 25, s: -119867, e: [1, 4, 5, 7, 8, 11, 12, 17], l: 52 }, - { h: 25, s: -119919, l: 52 }, - { h: 24, s: -119971, e: [2, 7, 8, 17], l: 52 }, - { h: 24, s: -120023, e: [2, 7, 13, 15, 16, 17], l: 52 }, - { h: 25, s: -120075, l: 52 }, - { h: 25, s: -120127, l: 52 }, - { h: 25, s: -120179, l: 52 }, - { h: 25, s: -120231, l: 52 }, - { h: 25, s: -120283, l: 52 }, - { h: 25, s: -120335, l: 52 }, - { h: 24, s: -119543, e: [17], l: 56 }, - { h: 24, s: -119601, e: [17], l: 58 }, - { h: 24, s: -119659, e: [17], l: 58 }, - { h: 24, s: -119717, e: [17], l: 58 }, - { h: 24, s: -119775, e: [17], l: 58 }, - ], - Hvr = vAe( - "b5:3bc,c3:ff,7:73,2:253,5:254,3:256,1:257,5:259,1:25b,3:260,1:263,2:269,1:268,5:26f,1:272,2:275,7:280,3:283,5:288,3:28a,1:28b,5:292,3f:195,1:1bf,29:19e,125:3b9,8b:3b2,1:3b8,1:3c5,3:3c6,1:3c0,1a:3ba,1:3c1,1:3c3,2:3b8,1:3b5,1bc9:3b9,1c:1f76,1:1f77,f:1f7a,1:1f7b,d:1f78,1:1f79,1:1f7c,1:1f7d,107:63,5:25b,4:68,1:68,1:68,3:69,1:69,1:6c,3:6e,4:70,1:71,1:72,1:72,1:72,7:7a,2:3c9,2:7a,2:6b,1:e5,1:62,1:63,3:65,1:66,2:6d,b:3b3,1:3c0,6:64,1b574:3b8,1a:3c3,20:3b8,1a:3c3,20:3b8,1a:3c3,20:3b8,1a:3c3,20:3b8,1a:3c3" - ), - Vvr = vAe( - "179:1,2:1,2:1,5:1,2:1,a:4f,a:1,8:1,2:1,2:1,3:1,5:1,3:1,4:1,2:1,3:1,4:1,8:2,1:1,2:2,1:1,2:2,27:2,195:26,2:25,1:25,1:25,2:40,2:3f,1:3f,33:1,11:-6,1:-9,1ac7:-3a,6d:-8,1:-8,1:-8,1:-8,1:-8,1:-8,1:-8,1:-8,9:-8,1:-8,1:-8,1:-8,1:-8,1:-8,b:-8,1:-8,1:-8,1:-8,1:-8,1:-8,1:-8,1:-8,9:-8,1:-8,1:-8,1:-8,1:-8,1:-8,1:-8,1:-8,9:-8,1:-8,1:-8,1:-8,1:-8,1:-8,c:-8,2:-8,2:-8,2:-8,9:-8,1:-8,1:-8,1:-8,1:-8,1:-8,1:-8,1:-8,49:-8,1:-8,1:-4a,1:-4a,d:-56,1:-56,1:-56,1:-56,d:-8,1:-8,f:-8,1:-8,3:-7" - ), - Wvr = vAe( - "df:00730073,51:00690307,19:02BC006E,a7:006A030C,18a:002003B9,16:03B903080301,20:03C503080301,1d7:05650582,190f:00680331,1:00740308,1:0077030A,1:0079030A,1:006102BE,b6:03C50313,2:03C503130300,2:03C503130301,2:03C503130342,2a:1F0003B9,1:1F0103B9,1:1F0203B9,1:1F0303B9,1:1F0403B9,1:1F0503B9,1:1F0603B9,1:1F0703B9,1:1F0003B9,1:1F0103B9,1:1F0203B9,1:1F0303B9,1:1F0403B9,1:1F0503B9,1:1F0603B9,1:1F0703B9,1:1F2003B9,1:1F2103B9,1:1F2203B9,1:1F2303B9,1:1F2403B9,1:1F2503B9,1:1F2603B9,1:1F2703B9,1:1F2003B9,1:1F2103B9,1:1F2203B9,1:1F2303B9,1:1F2403B9,1:1F2503B9,1:1F2603B9,1:1F2703B9,1:1F6003B9,1:1F6103B9,1:1F6203B9,1:1F6303B9,1:1F6403B9,1:1F6503B9,1:1F6603B9,1:1F6703B9,1:1F6003B9,1:1F6103B9,1:1F6203B9,1:1F6303B9,1:1F6403B9,1:1F6503B9,1:1F6603B9,1:1F6703B9,3:1F7003B9,1:03B103B9,1:03AC03B9,2:03B10342,1:03B1034203B9,5:03B103B9,6:1F7403B9,1:03B703B9,1:03AE03B9,2:03B70342,1:03B7034203B9,5:03B703B9,6:03B903080300,1:03B903080301,3:03B90342,1:03B903080342,b:03C503080300,1:03C503080301,1:03C10313,2:03C50342,1:03C503080342,b:1F7C03B9,1:03C903B9,1:03CE03B9,2:03C90342,1:03C9034203B9,5:03C903B9,ac:00720073,5b:00B00063,6:00B00066,d:006E006F,a:0073006D,1:00740065006C,1:0074006D,124f:006800700061,2:00610075,2:006F0076,b:00700061,1:006E0061,1:03BC0061,1:006D0061,1:006B0061,1:006B0062,1:006D0062,1:00670062,3:00700066,1:006E0066,1:03BC0066,4:0068007A,1:006B0068007A,1:006D0068007A,1:00670068007A,1:00740068007A,15:00700061,1:006B00700061,1:006D00700061,1:006700700061,8:00700076,1:006E0076,1:03BC0076,1:006D0076,1:006B0076,1:006D0076,1:00700077,1:006E0077,1:03BC0077,1:006D0077,1:006B0077,1:006D0077,1:006B03C9,1:006D03C9,2:00620071,3:00632215006B0067,1:0063006F002E,1:00640062,1:00670079,2:00680070,2:006B006B,1:006B006D,9:00700068,2:00700070006D,1:00700072,2:00730076,1:00770062,c723:00660066,1:00660069,1:0066006C,1:006600660069,1:00660066006C,1:00730074,1:00730074,d:05740576,1:05740565,1:0574056B,1:057E0576,1:0574056D", - zvr - ), - Gvr = Wut( - "80-20,2a0-,39c,32,f71,18e,7f2-f,19-7,30-4,7-5,f81-b,5,a800-20ff,4d1-1f,110,fa-6,d174-7,2e84-,ffff-,ffff-,ffff-,ffff-,ffff-,ffff-,ffff-,ffff-,ffff-,ffff-,ffff-,ffff-,2,1f-5f,ff7f-20001" - ); - function Jvr(t) { - return t.reduce(function (e, r) { - return ( - r.forEach(function (n) { - e.push(n); - }), - e - ); - }, []); - } - function Gut(t) { - return !!bAe(t, jvr); - } - cb._nameprepTableA1 = Gut; - function Jut(t) { - var e = bAe(t, Kvr); - if (e) return [t + e.s]; - var r = Hvr[t]; - if (r) return r; - var n = Vvr[t]; - if (n) return [t + n[0]]; - var i = Wvr[t]; - return i || null; - } - cb._nameprepTableB2 = Jut; - function $ut(t) { - return !!bAe(t, Gvr); - } - cb._nameprepTableC = $ut; - function $vr(t) { - if (t.match(/^[a-z0-9-]*$/i) && t.length <= 59) return t.toLowerCase(); - var e = (0, jU.toUtf8CodePoints)(t); - (e = Jvr( - e.map(function (n) { - if (Uvr.indexOf(n) >= 0) return []; - if (n >= 65024 && n <= 65039) return []; - var i = Jut(n); - return i || [n]; - }) - )), - (e = (0, jU.toUtf8CodePoints)( - (0, jU._toUtf8String)(e), - jU.UnicodeNormalizationForm.NFKC - )), - e.forEach(function (n) { - if ($ut(n)) throw new Error("STRINGPREP_CONTAINS_PROHIBITED"); - }), - e.forEach(function (n) { - if (Gut(n)) throw new Error("STRINGPREP_CONTAINS_UNASSIGNED"); - }); - var r = (0, jU._toUtf8String)(e); - if ( - r.substring(0, 1) === "-" || - r.substring(2, 4) === "--" || - r.substring(r.length - 1) === "-" - ) - throw new Error("invalid hyphen"); - return r; - } - cb.nameprep = $vr; - }); - var Eo = I((Ua) => { - "use strict"; - m(); - g(); - Object.defineProperty(Ua, "__esModule", { value: !0 }); - Ua.nameprep = - Ua.parseBytes32String = - Ua.formatBytes32String = - Ua.UnicodeNormalizationForm = - Ua.Utf8ErrorReason = - Ua.Utf8ErrorFuncs = - Ua.toUtf8String = - Ua.toUtf8CodePoints = - Ua.toUtf8Bytes = - Ua._toEscapedUtf8String = - void 0; - var Xut = Vut(); - Object.defineProperty(Ua, "formatBytes32String", { - enumerable: !0, - get: function () { - return Xut.formatBytes32String; - }, - }); - Object.defineProperty(Ua, "parseBytes32String", { - enumerable: !0, - get: function () { - return Xut.parseBytes32String; - }, - }); - var Zvr = Zut(); - Object.defineProperty(Ua, "nameprep", { - enumerable: !0, - get: function () { - return Zvr.nameprep; - }, - }); - var XT = bre(); - Object.defineProperty(Ua, "_toEscapedUtf8String", { - enumerable: !0, - get: function () { - return XT._toEscapedUtf8String; - }, - }); - Object.defineProperty(Ua, "toUtf8Bytes", { - enumerable: !0, - get: function () { - return XT.toUtf8Bytes; - }, - }); - Object.defineProperty(Ua, "toUtf8CodePoints", { - enumerable: !0, - get: function () { - return XT.toUtf8CodePoints; - }, - }); - Object.defineProperty(Ua, "toUtf8String", { - enumerable: !0, - get: function () { - return XT.toUtf8String; - }, - }); - Object.defineProperty(Ua, "UnicodeNormalizationForm", { - enumerable: !0, - get: function () { - return XT.UnicodeNormalizationForm; - }, - }); - Object.defineProperty(Ua, "Utf8ErrorFuncs", { - enumerable: !0, - get: function () { - return XT.Utf8ErrorFuncs; - }, - }); - Object.defineProperty(Ua, "Utf8ErrorReason", { - enumerable: !0, - get: function () { - return XT.Utf8ErrorReason; - }, - }); - }); - var Qut = I((BR) => { - "use strict"; - m(); - g(); - var Xvr = - (BR && BR.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(BR, "__esModule", { value: !0 }); - BR.StringCoder = void 0; - var Yut = Eo(), - Yvr = pAe(), - Qvr = (function (t) { - Xvr(e, t); - function e(r) { - return t.call(this, "string", r) || this; - } - return ( - (e.prototype.defaultValue = function () { - return ""; - }), - (e.prototype.encode = function (r, n) { - return t.prototype.encode.call(this, r, (0, Yut.toUtf8Bytes)(n)); - }), - (e.prototype.decode = function (r) { - return (0, Yut.toUtf8String)(t.prototype.decode.call(this, r)); - }), - e - ); - })(Yvr.DynamicBytesCoder); - BR.StringCoder = Qvr; - }); - var tct = I((IR) => { - "use strict"; - m(); - g(); - var ebr = - (IR && IR.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(IR, "__esModule", { value: !0 }); - IR.TupleCoder = void 0; - var tbr = Iy(), - ect = hAe(), - rbr = (function (t) { - ebr(e, t); - function e(r, n) { - var i = this, - o = !1, - a = []; - r.forEach(function (c) { - c.dynamic && (o = !0), a.push(c.type); - }); - var s = "tuple(" + a.join(",") + ")"; - return ( - (i = t.call(this, "tuple", s, n, o) || this), (i.coders = r), i - ); - } - return ( - (e.prototype.defaultValue = function () { - var r = []; - this.coders.forEach(function (i) { - r.push(i.defaultValue()); - }); - var n = this.coders.reduce(function (i, o) { - var a = o.localName; - return a && (i[a] || (i[a] = 0), i[a]++), i; - }, {}); - return ( - this.coders.forEach(function (i, o) { - var a = i.localName; - !a || - n[a] !== 1 || - (a === "length" && (a = "_length"), - r[a] == null && (r[a] = r[o])); - }), - Object.freeze(r) - ); - }), - (e.prototype.encode = function (r, n) { - return (0, ect.pack)(r, this.coders, n); - }), - (e.prototype.decode = function (r) { - return r.coerce(this.name, (0, ect.unpack)(r, this.coders)); - }), - e - ); - })(tbr.Coder); - IR.TupleCoder = rbr; - }); - var _Ae = I((CR) => { - "use strict"; - m(); - g(); - Object.defineProperty(CR, "__esModule", { value: !0 }); - CR.defaultAbiCoder = CR.AbiCoder = void 0; - var nbr = Ar(), - ibr = $r(), - nct = rr(), - obr = vR(), - wre = new nct.Logger(obr.version), - rct = Iy(), - abr = xut(), - sbr = hAe(), - ubr = Mut(), - cbr = pAe(), - lbr = But(), - fbr = Iut(), - dbr = Fut(), - hbr = Qut(), - _re = tct(), - wAe = cre(), - pbr = new RegExp(/^bytes([0-9]*)$/), - ybr = new RegExp(/^(u?int)([0-9]*)$/), - ict = (function () { - function t(e) { - (0, ibr.defineReadOnly)(this, "coerceFunc", e || null); - } - return ( - (t.prototype._getCoder = function (e) { - var r = this; - switch (e.baseType) { - case "address": - return new abr.AddressCoder(e.name); - case "bool": - return new ubr.BooleanCoder(e.name); - case "string": - return new hbr.StringCoder(e.name); - case "bytes": - return new cbr.BytesCoder(e.name); - case "array": - return new sbr.ArrayCoder( - this._getCoder(e.arrayChildren), - e.arrayLength, - e.name - ); - case "tuple": - return new _re.TupleCoder( - (e.components || []).map(function (o) { - return r._getCoder(o); - }), - e.name - ); - case "": - return new fbr.NullCoder(e.name); - } - var n = e.type.match(ybr); - if (n) { - var i = parseInt(n[2] || "256"); - return ( - (i === 0 || i > 256 || i % 8 !== 0) && - wre.throwArgumentError( - "invalid " + n[1] + " bit length", - "param", - e - ), - new dbr.NumberCoder(i / 8, n[1] === "int", e.name) - ); - } - if (((n = e.type.match(pbr)), n)) { - var i = parseInt(n[1]); - return ( - (i === 0 || i > 32) && - wre.throwArgumentError("invalid bytes length", "param", e), - new lbr.FixedBytesCoder(i, e.name) - ); - } - return wre.throwArgumentError("invalid type", "type", e.type); - }), - (t.prototype._getWordSize = function () { - return 32; - }), - (t.prototype._getReader = function (e, r) { - return new rct.Reader(e, this._getWordSize(), this.coerceFunc, r); - }), - (t.prototype._getWriter = function () { - return new rct.Writer(this._getWordSize()); - }), - (t.prototype.getDefaultValue = function (e) { - var r = this, - n = e.map(function (o) { - return r._getCoder(wAe.ParamType.from(o)); - }), - i = new _re.TupleCoder(n, "_"); - return i.defaultValue(); - }), - (t.prototype.encode = function (e, r) { - var n = this; - e.length !== r.length && - wre.throwError( - "types/values length mismatch", - nct.Logger.errors.INVALID_ARGUMENT, - { - count: { types: e.length, values: r.length }, - value: { types: e, values: r }, - } - ); - var i = e.map(function (s) { - return n._getCoder(wAe.ParamType.from(s)); - }), - o = new _re.TupleCoder(i, "_"), - a = this._getWriter(); - return o.encode(a, r), a.data; - }), - (t.prototype.decode = function (e, r, n) { - var i = this, - o = e.map(function (s) { - return i._getCoder(wAe.ParamType.from(s)); - }), - a = new _re.TupleCoder(o, "_"); - return a.decode(this._getReader((0, nbr.arrayify)(r), n)); - }), - t - ); - })(); - CR.AbiCoder = ict; - CR.defaultAbiCoder = new ict(); - }); - var xAe = I((xre) => { - "use strict"; - m(); - g(); - Object.defineProperty(xre, "__esModule", { value: !0 }); - xre.id = void 0; - var mbr = Hh(), - gbr = Eo(); - function vbr(t) { - return (0, mbr.keccak256)((0, gbr.toUtf8Bytes)(t)); - } - xre.id = vbr; - }); - var SAe = I((Sre) => { - "use strict"; - m(); - g(); - Object.defineProperty(Sre, "__esModule", { value: !0 }); - Sre.version = void 0; - Sre.version = "hash/5.7.0"; - }); - var act = I((RR) => { - "use strict"; - m(); - g(); - Object.defineProperty(RR, "__esModule", { value: !0 }); - RR.encode = RR.decode = void 0; - var oct = Ar(); - function bbr(t) { - t = atob(t); - for (var e = [], r = 0; r < t.length; r++) e.push(t.charCodeAt(r)); - return (0, oct.arrayify)(e); - } - RR.decode = bbr; - function wbr(t) { - t = (0, oct.arrayify)(t); - for (var e = "", r = 0; r < t.length; r++) e += String.fromCharCode(t[r]); - return btoa(e); - } - RR.encode = wbr; - }); - var lb = I((NR) => { - "use strict"; - m(); - g(); - Object.defineProperty(NR, "__esModule", { value: !0 }); - NR.encode = NR.decode = void 0; - var sct = act(); - Object.defineProperty(NR, "decode", { - enumerable: !0, - get: function () { - return sct.decode; - }, - }); - Object.defineProperty(NR, "encode", { - enumerable: !0, - get: function () { - return sct.encode; - }, - }); - }); - var EAe = I((Cu) => { - "use strict"; - m(); - g(); - Object.defineProperty(Cu, "__esModule", { value: !0 }); - Cu.read_emoji_trie = - Cu.read_zero_terminated_array = - Cu.read_mapped_map = - Cu.read_member_array = - Cu.signed = - Cu.read_compressed_payload = - Cu.read_payload = - Cu.decode_arithmetic = - void 0; - function cct(t, e) { - e == null && (e = 1); - var r = [], - n = r.forEach, - i = function (o, a) { - n.call(o, function (s) { - a > 0 && Array.isArray(s) ? i(s, a - 1) : r.push(s); - }); - }; - return i(t, e), r; - } - function _br(t) { - for (var e = {}, r = 0; r < t.length; r++) { - var n = t[r]; - e[n[0]] = n[1]; - } - return e; - } - function lct(t) { - var e = 0; - function r() { - return (t[e++] << 8) | t[e++]; - } - for (var n = r(), i = 1, o = [0, 1], a = 1; a < n; a++) - o.push((i += r())); - var s = r(), - c = e; - e += s; - var u = 0, - h = 0; - function w() { - return u == 0 && ((h = (h << 8) | t[e++]), (u = 8)), (h >> --u) & 1; - } - for ( - var M = 31, - k = Math.pow(2, M), - O = k >>> 1, - D = O >> 1, - F = k - 1, - N = 0, - a = 0; - a < M; - a++ - ) - N = (N << 1) | w(); - for (var q = [], z = 0, H = k; ; ) { - for ( - var Z = Math.floor(((N - z + 1) * i - 1) / H), $ = 0, ue = n; - ue - $ > 1; - - ) { - var te = ($ + ue) >>> 1; - Z < o[te] ? (ue = te) : ($ = te); - } - if ($ == 0) break; - q.push($); - for ( - var ne = z + Math.floor((H * o[$]) / i), - A = z + Math.floor((H * o[$ + 1]) / i) - 1; - ((ne ^ A) & O) == 0; - - ) - (N = ((N << 1) & F) | w()), - (ne = (ne << 1) & F), - (A = ((A << 1) & F) | 1); - for (; ne & ~A & D; ) - (N = (N & O) | ((N << 1) & (F >>> 1)) | w()), - (ne = (ne << 1) ^ O), - (A = ((A ^ O) << 1) | O | 1); - (z = ne), (H = 1 + A - ne); - } - var l = n - 4; - return q.map(function (p) { - switch (p - l) { - case 3: - return l + 65792 + ((t[c++] << 16) | (t[c++] << 8) | t[c++]); - case 2: - return l + 256 + ((t[c++] << 8) | t[c++]); - case 1: - return l + t[c++]; - default: - return p - 1; - } - }); - } - Cu.decode_arithmetic = lct; - function fct(t) { - var e = 0; - return function () { - return t[e++]; - }; - } - Cu.read_payload = fct; - function xbr(t) { - return fct(lct(t)); - } - Cu.read_compressed_payload = xbr; - function dct(t) { - return t & 1 ? ~t >> 1 : t >> 1; - } - Cu.signed = dct; - function Sbr(t, e) { - for (var r = Array(t), n = 0; n < t; n++) r[n] = 1 + e(); - return r; - } - function uct(t, e) { - for (var r = Array(t), n = 0, i = -1; n < t; n++) r[n] = i += 1 + e(); - return r; - } - function Abr(t, e) { - for (var r = Array(t), n = 0, i = 0; n < t; n++) r[n] = i += dct(e()); - return r; - } - function AAe(t, e) { - for ( - var r = uct(t(), t), n = t(), i = uct(n, t), o = Sbr(n, t), a = 0; - a < n; - a++ - ) - for (var s = 0; s < o[a]; s++) r.push(i[a] + s); - return e - ? r.map(function (c) { - return e[c]; - }) - : r; - } - Cu.read_member_array = AAe; - function Ebr(t) { - for (var e = []; ; ) { - var r = t(); - if (r == 0) break; - e.push(Mbr(r, t)); - } - for (;;) { - var r = t() - 1; - if (r < 0) break; - e.push(Tbr(r, t)); - } - return _br(cct(e)); - } - Cu.read_mapped_map = Ebr; - function hct(t) { - for (var e = []; ; ) { - var r = t(); - if (r == 0) break; - e.push(r); - } - return e; - } - Cu.read_zero_terminated_array = hct; - function pct(t, e, r) { - for ( - var n = Array(t) - .fill(void 0) - .map(function () { - return []; - }), - i = 0; - i < e; - i++ - ) - Abr(t, r).forEach(function (o, a) { - return n[a].push(o); - }); - return n; - } - function Mbr(t, e) { - var r = 1 + e(), - n = e(), - i = hct(e), - o = pct(i.length, 1 + t, e); - return cct( - o.map(function (a, s) { - var c = a[0], - u = a.slice(1); - return Array(i[s]) - .fill(void 0) - .map(function (h, w) { - var M = w * n; - return [ - c + w * r, - u.map(function (k) { - return k + M; - }), - ]; - }); - }) - ); - } - function Tbr(t, e) { - var r = 1 + e(), - n = pct(r, 1 + t, e); - return n.map(function (i) { - return [i[0], i.slice(1)]; - }); - } - function kbr(t) { - var e = AAe(t).sort(function (n, i) { - return n - i; - }); - return r(); - function r() { - for (var n = []; ; ) { - var i = AAe(t, e); - if (i.length == 0) break; - n.push({ set: new Set(i), node: r() }); - } - n.sort(function (h, w) { - return w.set.size - h.set.size; - }); - var o = t(), - a = o % 3; - o = (o / 3) | 0; - var s = !!(o & 1); - o >>= 1; - var c = o == 1, - u = o == 2; - return { branches: n, valid: a, fe0f: s, save: c, check: u }; - } - } - Cu.read_emoji_trie = kbr; - }); - var yct = I((Are) => { - "use strict"; - m(); - g(); - Object.defineProperty(Are, "__esModule", { value: !0 }); - Are.getData = void 0; - var Pbr = lb(), - Obr = EAe(); - function Bbr() { - return (0, Obr.read_compressed_payload)( - (0, Pbr.decode)( - "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" - ) - ); - } - Are.getData = Bbr; - }); - var bct = I((DR) => { - "use strict"; - m(); - g(); - Object.defineProperty(DR, "__esModule", { value: !0 }); - DR.ens_normalize = DR.ens_normalize_post_check = void 0; - var Ibr = Eo(), - Cbr = yct(), - Ere = (0, Cbr.getData)(), - Mre = EAe(), - Rbr = new Set((0, Mre.read_member_array)(Ere)), - Nbr = new Set((0, Mre.read_member_array)(Ere)), - Dbr = (0, Mre.read_mapped_map)(Ere), - Fbr = (0, Mre.read_emoji_trie)(Ere), - mct = 45, - gct = 95; - function vct(t) { - return (0, Ibr.toUtf8CodePoints)(t); - } - function Lbr(t) { - return t.filter(function (e) { - return e != 65039; - }); - } - function MAe(t) { - for (var e = 0, r = t.split("."); e < r.length; e++) { - var n = r[e], - i = vct(n); - try { - for (var o = i.lastIndexOf(gct) - 1; o >= 0; o--) - if (i[o] !== gct) - throw new Error("underscore only allowed at start"); - if ( - i.length >= 4 && - i.every(function (a) { - return a < 128; - }) && - i[2] === mct && - i[3] === mct - ) - throw new Error("invalid label extension"); - } catch (a) { - throw new Error('Invalid label "' + n + '": ' + a.message); - } - } - return t; - } - DR.ens_normalize_post_check = MAe; - function qbr(t) { - return MAe(zbr(t, Lbr)); - } - DR.ens_normalize = qbr; - function zbr(t, e) { - for (var r = vct(t).reverse(), n = []; r.length; ) { - var i = Ubr(r); - if (i) { - n.push.apply(n, e(i)); - continue; - } - var o = r.pop(); - if (Rbr.has(o)) { - n.push(o); - continue; - } - if (!Nbr.has(o)) { - var a = Dbr[o]; - if (a) { - n.push.apply(n, a); - continue; - } - throw new Error( - "Disallowed codepoint: 0x" + o.toString(16).toUpperCase() - ); - } - } - return MAe(jbr(String.fromCodePoint.apply(String, n))); - } - function jbr(t) { - return t.normalize("NFC"); - } - function Ubr(t, e) { - var r, - n = Fbr, - i, - o, - a = [], - s = t.length; - e && (e.length = 0); - for ( - var c = function () { - var h = t[--s]; - if ( - ((n = - (r = n.branches.find(function (w) { - return w.set.has(h); - })) === null || r === void 0 - ? void 0 - : r.node), - !n) - ) - return "break"; - if (n.save) o = h; - else if (n.check && h === o) return "break"; - a.push(h), - n.fe0f && (a.push(65039), s > 0 && t[s - 1] == 65039 && s--), - n.valid && - ((i = a.slice()), - n.valid == 2 && i.splice(1, 1), - e && e.push.apply(e, t.slice(s).reverse()), - (t.length = s)); - }; - s; - - ) { - var u = c(); - if (u === "break") break; - } - return i; - } - }); - var TAe = I((fb) => { - "use strict"; - m(); - g(); - Object.defineProperty(fb, "__esModule", { value: !0 }); - fb.dnsEncode = fb.namehash = fb.isValidName = fb.ensNormalize = void 0; - var Tre = Ar(), - xct = Eo(), - wct = Hh(), - Kbr = rr(), - Hbr = SAe(), - Vbr = new Kbr.Logger(Hbr.version), - Wbr = bct(), - Sct = new Uint8Array(32); - Sct.fill(0); - function _ct(t) { - if (t.length === 0) throw new Error("invalid ENS name; empty component"); - return t; - } - function kre(t) { - var e = (0, xct.toUtf8Bytes)((0, Wbr.ens_normalize)(t)), - r = []; - if (t.length === 0) return r; - for (var n = 0, i = 0; i < e.length; i++) { - var o = e[i]; - o === 46 && (r.push(_ct(e.slice(n, i))), (n = i + 1)); - } - if (n >= e.length) throw new Error("invalid ENS name; empty component"); - return r.push(_ct(e.slice(n))), r; - } - function Gbr(t) { - return kre(t) - .map(function (e) { - return (0, xct.toUtf8String)(e); - }) - .join("."); - } - fb.ensNormalize = Gbr; - function Jbr(t) { - try { - return kre(t).length !== 0; - } catch {} - return !1; - } - fb.isValidName = Jbr; - function $br(t) { - typeof t != "string" && - Vbr.throwArgumentError("invalid ENS name; not a string", "name", t); - for (var e = Sct, r = kre(t); r.length; ) - e = (0, wct.keccak256)( - (0, Tre.concat)([e, (0, wct.keccak256)(r.pop())]) - ); - return (0, Tre.hexlify)(e); - } - fb.namehash = $br; - function Zbr(t) { - return ( - (0, Tre.hexlify)( - (0, Tre.concat)( - kre(t).map(function (e) { - if (e.length > 63) - throw new Error( - "invalid DNS encoded entry; length exceeds 63 bytes" - ); - var r = new Uint8Array(e.length + 1); - return r.set(e, 1), (r[0] = r.length - 1), r; - }) - ) - ) + "00" - ); - } - fb.dnsEncode = Zbr; - }); - var Act = I((YT) => { - "use strict"; - m(); - g(); - Object.defineProperty(YT, "__esModule", { value: !0 }); - YT.hashMessage = YT.messagePrefix = void 0; - var Xbr = Ar(), - Ybr = Hh(), - kAe = Eo(); - YT.messagePrefix = `Ethereum Signed Message: -`; - function Qbr(t) { - return ( - typeof t == "string" && (t = (0, kAe.toUtf8Bytes)(t)), - (0, Ybr.keccak256)( - (0, Xbr.concat)([ - (0, kAe.toUtf8Bytes)(YT.messagePrefix), - (0, kAe.toUtf8Bytes)(String(t.length)), - t, - ]) - ) - ); - } - YT.hashMessage = Qbr; - }); - var Cct = I((PA) => { - "use strict"; - m(); - g(); - var e1r = - (PA && PA.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - t1r = - (PA && PA.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(PA, "__esModule", { value: !0 }); - PA.TypedDataEncoder = void 0; - var kct = Vh(), - e6 = Ro(), - fc = Ar(), - FR = Hh(), - QT = $r(), - r1r = rr(), - n1r = SAe(), - _a = new r1r.Logger(n1r.version), - Pct = xAe(), - Oct = new Uint8Array(32); - Oct.fill(0); - var i1r = e6.BigNumber.from(-1), - Bct = e6.BigNumber.from(0), - Ict = e6.BigNumber.from(1), - o1r = e6.BigNumber.from( - "0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - ); - function a1r(t) { - var e = (0, fc.arrayify)(t), - r = e.length % 32; - return r ? (0, fc.hexConcat)([e, Oct.slice(r)]) : (0, fc.hexlify)(e); - } - var s1r = (0, fc.hexZeroPad)(Ict.toHexString(), 32), - u1r = (0, fc.hexZeroPad)(Bct.toHexString(), 32), - Ect = { - name: "string", - version: "string", - chainId: "uint256", - verifyingContract: "address", - salt: "bytes32", - }, - PAe = ["name", "version", "chainId", "verifyingContract", "salt"]; - function Mct(t) { - return function (e) { - return ( - typeof e != "string" && - _a.throwArgumentError( - "invalid domain value for " + JSON.stringify(t), - "domain." + t, - e - ), - e - ); - }; - } - var c1r = { - name: Mct("name"), - version: Mct("version"), - chainId: function (t) { - try { - return e6.BigNumber.from(t).toString(); - } catch {} - return _a.throwArgumentError( - 'invalid domain value for "chainId"', - "domain.chainId", - t - ); - }, - verifyingContract: function (t) { - try { - return (0, kct.getAddress)(t).toLowerCase(); - } catch {} - return _a.throwArgumentError( - 'invalid domain value "verifyingContract"', - "domain.verifyingContract", - t - ); - }, - salt: function (t) { - try { - var e = (0, fc.arrayify)(t); - if (e.length !== 32) throw new Error("bad length"); - return (0, fc.hexlify)(e); - } catch {} - return _a.throwArgumentError( - 'invalid domain value "salt"', - "domain.salt", - t - ); - }, - }; - function OAe(t) { - { - var e = t.match(/^(u?)int(\d*)$/); - if (e) { - var r = e[1] === "", - n = parseInt(e[2] || "256"); - (n % 8 !== 0 || n > 256 || (e[2] && e[2] !== String(n))) && - _a.throwArgumentError("invalid numeric width", "type", t); - var i = o1r.mask(r ? n - 1 : n), - o = r ? i.add(Ict).mul(i1r) : Bct; - return function (s) { - var c = e6.BigNumber.from(s); - return ( - (c.lt(o) || c.gt(i)) && - _a.throwArgumentError( - "value out-of-bounds for " + t, - "value", - s - ), - (0, fc.hexZeroPad)(c.toTwos(256).toHexString(), 32) - ); - }; - } - } - { - var e = t.match(/^bytes(\d+)$/); - if (e) { - var a = parseInt(e[1]); - return ( - (a === 0 || a > 32 || e[1] !== String(a)) && - _a.throwArgumentError("invalid bytes width", "type", t), - function (c) { - var u = (0, fc.arrayify)(c); - return ( - u.length !== a && - _a.throwArgumentError("invalid length for " + t, "value", c), - a1r(c) - ); - } - ); - } - } - switch (t) { - case "address": - return function (s) { - return (0, fc.hexZeroPad)((0, kct.getAddress)(s), 32); - }; - case "bool": - return function (s) { - return s ? s1r : u1r; - }; - case "bytes": - return function (s) { - return (0, FR.keccak256)(s); - }; - case "string": - return function (s) { - return (0, Pct.id)(s); - }; - } - return null; - } - function Tct(t, e) { - return ( - t + - "(" + - e - .map(function (r) { - var n = r.name, - i = r.type; - return i + " " + n; - }) - .join(",") + - ")" - ); - } - var l1r = (function () { - function t(e) { - (0, QT.defineReadOnly)( - this, - "types", - Object.freeze((0, QT.deepCopy)(e)) - ), - (0, QT.defineReadOnly)(this, "_encoderCache", {}), - (0, QT.defineReadOnly)(this, "_types", {}); - var r = {}, - n = {}, - i = {}; - Object.keys(e).forEach(function (w) { - (r[w] = {}), (n[w] = []), (i[w] = {}); - }); - var o = function (w) { - var M = {}; - e[w].forEach(function (k) { - M[k.name] && - _a.throwArgumentError( - "duplicate variable name " + - JSON.stringify(k.name) + - " in " + - JSON.stringify(w), - "types", - e - ), - (M[k.name] = !0); - var O = k.type.match(/^([^\x5b]*)(\x5b|$)/)[1]; - O === w && - _a.throwArgumentError( - "circular type reference to " + JSON.stringify(O), - "types", - e - ); - var D = OAe(O); - D || - (n[O] || - _a.throwArgumentError( - "unknown type " + JSON.stringify(O), - "types", - e - ), - n[O].push(w), - (r[w][O] = !0)); - }); - }; - for (var a in e) o(a); - var s = Object.keys(n).filter(function (w) { - return n[w].length === 0; - }); - s.length === 0 - ? _a.throwArgumentError("missing primary type", "types", e) - : s.length > 1 && - _a.throwArgumentError( - "ambiguous primary types or unused types: " + - s - .map(function (w) { - return JSON.stringify(w); - }) - .join(", "), - "types", - e - ), - (0, QT.defineReadOnly)(this, "primaryType", s[0]); - function c(w, M) { - M[w] && - _a.throwArgumentError( - "circular type reference to " + JSON.stringify(w), - "types", - e - ), - (M[w] = !0), - Object.keys(r[w]).forEach(function (k) { - !n[k] || - (c(k, M), - Object.keys(M).forEach(function (O) { - i[O][k] = !0; - })); - }), - delete M[w]; - } - c(this.primaryType, {}); - for (var u in i) { - var h = Object.keys(i[u]); - h.sort(), - (this._types[u] = - Tct(u, e[u]) + - h - .map(function (w) { - return Tct(w, e[w]); - }) - .join("")); - } - } - return ( - (t.prototype.getEncoder = function (e) { - var r = this._encoderCache[e]; - return r || (r = this._encoderCache[e] = this._getEncoder(e)), r; - }), - (t.prototype._getEncoder = function (e) { - var r = this; - { - var n = OAe(e); - if (n) return n; - } - var i = e.match(/^(.*)(\x5b(\d*)\x5d)$/); - if (i) { - var o = i[1], - a = this.getEncoder(o), - s = parseInt(i[3]); - return function (h) { - s >= 0 && - h.length !== s && - _a.throwArgumentError( - "array length mismatch; expected length ${ arrayLength }", - "value", - h - ); - var w = h.map(a); - return ( - r._types[o] && (w = w.map(FR.keccak256)), - (0, FR.keccak256)((0, fc.hexConcat)(w)) - ); - }; - } - var c = this.types[e]; - if (c) { - var u = (0, Pct.id)(this._types[e]); - return function (h) { - var w = c.map(function (M) { - var k = M.name, - O = M.type, - D = r.getEncoder(O)(h[k]); - return r._types[O] ? (0, FR.keccak256)(D) : D; - }); - return w.unshift(u), (0, fc.hexConcat)(w); - }; - } - return _a.throwArgumentError("unknown type: " + e, "type", e); - }), - (t.prototype.encodeType = function (e) { - var r = this._types[e]; - return ( - r || - _a.throwArgumentError( - "unknown type: " + JSON.stringify(e), - "name", - e - ), - r - ); - }), - (t.prototype.encodeData = function (e, r) { - return this.getEncoder(e)(r); - }), - (t.prototype.hashStruct = function (e, r) { - return (0, FR.keccak256)(this.encodeData(e, r)); - }), - (t.prototype.encode = function (e) { - return this.encodeData(this.primaryType, e); - }), - (t.prototype.hash = function (e) { - return this.hashStruct(this.primaryType, e); - }), - (t.prototype._visit = function (e, r, n) { - var i = this; - { - var o = OAe(e); - if (o) return n(e, r); - } - var a = e.match(/^(.*)(\x5b(\d*)\x5d)$/); - if (a) { - var s = a[1], - c = parseInt(a[3]); - return ( - c >= 0 && - r.length !== c && - _a.throwArgumentError( - "array length mismatch; expected length ${ arrayLength }", - "value", - r - ), - r.map(function (h) { - return i._visit(s, h, n); - }) - ); - } - var u = this.types[e]; - return u - ? u.reduce(function (h, w) { - var M = w.name, - k = w.type; - return (h[M] = i._visit(k, r[M], n)), h; - }, {}) - : _a.throwArgumentError("unknown type: " + e, "type", e); - }), - (t.prototype.visit = function (e, r) { - return this._visit(this.primaryType, e, r); - }), - (t.from = function (e) { - return new t(e); - }), - (t.getPrimaryType = function (e) { - return t.from(e).primaryType; - }), - (t.hashStruct = function (e, r, n) { - return t.from(r).hashStruct(e, n); - }), - (t.hashDomain = function (e) { - var r = []; - for (var n in e) { - var i = Ect[n]; - i || - _a.throwArgumentError( - "invalid typed-data domain key: " + JSON.stringify(n), - "domain", - e - ), - r.push({ name: n, type: i }); - } - return ( - r.sort(function (o, a) { - return PAe.indexOf(o.name) - PAe.indexOf(a.name); - }), - t.hashStruct("EIP712Domain", { EIP712Domain: r }, e) - ); - }), - (t.encode = function (e, r, n) { - return (0, fc.hexConcat)([ - "0x1901", - t.hashDomain(e), - t.from(r).hash(n), - ]); - }), - (t.hash = function (e, r, n) { - return (0, FR.keccak256)(t.encode(e, r, n)); - }), - (t.resolveNames = function (e, r, n, i) { - return e1r(this, void 0, void 0, function () { - var o, a, s, c, u, h, w, M; - return t1r(this, function (k) { - switch (k.label) { - case 0: - (e = (0, QT.shallowCopy)(e)), - (o = {}), - e.verifyingContract && - !(0, fc.isHexString)(e.verifyingContract, 20) && - (o[e.verifyingContract] = "0x"), - (a = t.from(r)), - a.visit(n, function (O, D) { - return ( - O === "address" && - !(0, fc.isHexString)(D, 20) && - (o[D] = "0x"), - D - ); - }), - (s = []); - for (c in o) s.push(c); - (u = 0), (k.label = 1); - case 1: - return u < s.length - ? ((h = s[u]), (w = o), (M = h), [4, i(h)]) - : [3, 4]; - case 2: - (w[M] = k.sent()), (k.label = 3); - case 3: - return u++, [3, 1]; - case 4: - return ( - e.verifyingContract && - o[e.verifyingContract] && - (e.verifyingContract = o[e.verifyingContract]), - (n = a.visit(n, function (O, D) { - return O === "address" && o[D] ? o[D] : D; - })), - [2, { domain: e, value: n }] - ); - } - }); - }); - }), - (t.getPayload = function (e, r, n) { - t.hashDomain(e); - var i = {}, - o = []; - PAe.forEach(function (c) { - var u = e[c]; - u != null && - ((i[c] = c1r[c](u)), o.push({ name: c, type: Ect[c] })); - }); - var a = t.from(r), - s = (0, QT.shallowCopy)(r); - return ( - s.EIP712Domain - ? _a.throwArgumentError( - "types must not contain EIP712Domain type", - "types.EIP712Domain", - r - ) - : (s.EIP712Domain = o), - a.encode(n), - { - types: s, - domain: i, - primaryType: a.primaryType, - message: a.visit(n, function (c, u) { - if (c.match(/^bytes(\d*)/)) - return (0, fc.hexlify)((0, fc.arrayify)(u)); - if (c.match(/^u?int/)) return e6.BigNumber.from(u).toString(); - switch (c) { - case "address": - return u.toLowerCase(); - case "bool": - return !!u; - case "string": - return ( - typeof u != "string" && - _a.throwArgumentError("invalid string", "value", u), - u - ); - } - return _a.throwArgumentError("unsupported type", "type", c); - }), - } - ); - }), - t - ); - })(); - PA.TypedDataEncoder = l1r; - }); - var db = I((Ru) => { - "use strict"; - m(); - g(); - Object.defineProperty(Ru, "__esModule", { value: !0 }); - Ru._TypedDataEncoder = - Ru.hashMessage = - Ru.messagePrefix = - Ru.ensNormalize = - Ru.isValidName = - Ru.namehash = - Ru.dnsEncode = - Ru.id = - void 0; - var f1r = xAe(); - Object.defineProperty(Ru, "id", { - enumerable: !0, - get: function () { - return f1r.id; - }, - }); - var BAe = TAe(); - Object.defineProperty(Ru, "dnsEncode", { - enumerable: !0, - get: function () { - return BAe.dnsEncode; - }, - }); - Object.defineProperty(Ru, "isValidName", { - enumerable: !0, - get: function () { - return BAe.isValidName; - }, - }); - Object.defineProperty(Ru, "namehash", { - enumerable: !0, - get: function () { - return BAe.namehash; - }, - }); - var Rct = Act(); - Object.defineProperty(Ru, "hashMessage", { - enumerable: !0, - get: function () { - return Rct.hashMessage; - }, - }); - Object.defineProperty(Ru, "messagePrefix", { - enumerable: !0, - get: function () { - return Rct.messagePrefix; - }, - }); - var d1r = TAe(); - Object.defineProperty(Ru, "ensNormalize", { - enumerable: !0, - get: function () { - return d1r.ensNormalize; - }, - }); - var h1r = Cct(); - Object.defineProperty(Ru, "_TypedDataEncoder", { - enumerable: !0, - get: function () { - return h1r.TypedDataEncoder; - }, - }); - }); - var jct = I((Qc) => { - "use strict"; - m(); - g(); - var Bre = - (Qc && Qc.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(Qc, "__esModule", { value: !0 }); - Qc.Interface = - Qc.Indexed = - Qc.ErrorDescription = - Qc.TransactionDescription = - Qc.LogDescription = - Qc.checkResultErrors = - void 0; - var p1r = Vh(), - Nct = Ro(), - ca = Ar(), - Pre = db(), - Dct = Hh(), - dc = $r(), - y1r = _Ae(), - m1r = Iy(); - Object.defineProperty(Qc, "checkResultErrors", { - enumerable: !0, - get: function () { - return m1r.checkResultErrors; - }, - }); - var gx = cre(), - Ore = rr(), - g1r = vR(), - xa = new Ore.Logger(g1r.version), - Lct = (function (t) { - Bre(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return e; - })(dc.Description); - Qc.LogDescription = Lct; - var qct = (function (t) { - Bre(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return e; - })(dc.Description); - Qc.TransactionDescription = qct; - var zct = (function (t) { - Bre(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return e; - })(dc.Description); - Qc.ErrorDescription = zct; - var IAe = (function (t) { - Bre(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.isIndexed = function (r) { - return !!(r && r._isIndexed); - }), - e - ); - })(dc.Description); - Qc.Indexed = IAe; - var v1r = { - "0x08c379a0": { - signature: "Error(string)", - name: "Error", - inputs: ["string"], - reason: !0, - }, - "0x4e487b71": { - signature: "Panic(uint256)", - name: "Panic", - inputs: ["uint256"], - }, - }; - function Fct(t, e) { - var r = new Error( - "deferred error during ABI decoding triggered accessing " + t - ); - return (r.error = e), r; - } - var b1r = (function () { - function t(e) { - var r = this.constructor, - n = this, - i = []; - typeof e == "string" ? (i = JSON.parse(e)) : (i = e), - (0, dc.defineReadOnly)( - this, - "fragments", - i - .map(function (o) { - return gx.Fragment.from(o); - }) - .filter(function (o) { - return o != null; - }) - ), - (0, dc.defineReadOnly)( - this, - "_abiCoder", - (0, dc.getStatic)(r, "getAbiCoder")() - ), - (0, dc.defineReadOnly)(this, "functions", {}), - (0, dc.defineReadOnly)(this, "errors", {}), - (0, dc.defineReadOnly)(this, "events", {}), - (0, dc.defineReadOnly)(this, "structs", {}), - this.fragments.forEach(function (o) { - var a = null; - switch (o.type) { - case "constructor": - if (n.deploy) { - xa.warn("duplicate definition - constructor"); - return; - } - (0, dc.defineReadOnly)(n, "deploy", o); - return; - case "function": - a = n.functions; - break; - case "event": - a = n.events; - break; - case "error": - a = n.errors; - break; - default: - return; - } - var s = o.format(); - if (a[s]) { - xa.warn("duplicate definition - " + s); - return; - } - a[s] = o; - }), - this.deploy || - (0, dc.defineReadOnly)( - this, - "deploy", - gx.ConstructorFragment.from({ payable: !1, type: "constructor" }) - ), - (0, dc.defineReadOnly)(this, "_isInterface", !0); - } - return ( - (t.prototype.format = function (e) { - e || (e = gx.FormatTypes.full), - e === gx.FormatTypes.sighash && - xa.throwArgumentError( - "interface does not support formatting sighash", - "format", - e - ); - var r = this.fragments.map(function (n) { - return n.format(e); - }); - return e === gx.FormatTypes.json - ? JSON.stringify( - r.map(function (n) { - return JSON.parse(n); - }) - ) - : r; - }), - (t.getAbiCoder = function () { - return y1r.defaultAbiCoder; - }), - (t.getAddress = function (e) { - return (0, p1r.getAddress)(e); - }), - (t.getSighash = function (e) { - return (0, ca.hexDataSlice)((0, Pre.id)(e.format()), 0, 4); - }), - (t.getEventTopic = function (e) { - return (0, Pre.id)(e.format()); - }), - (t.prototype.getFunction = function (e) { - if ((0, ca.isHexString)(e)) { - for (var r in this.functions) - if (e === this.getSighash(r)) return this.functions[r]; - xa.throwArgumentError("no matching function", "sighash", e); - } - if (e.indexOf("(") === -1) { - var n = e.trim(), - i = Object.keys(this.functions).filter(function (a) { - return a.split("(")[0] === n; - }); - return ( - i.length === 0 - ? xa.throwArgumentError("no matching function", "name", n) - : i.length > 1 && - xa.throwArgumentError( - "multiple matching functions", - "name", - n - ), - this.functions[i[0]] - ); - } - var o = this.functions[gx.FunctionFragment.fromString(e).format()]; - return ( - o || xa.throwArgumentError("no matching function", "signature", e), - o - ); - }), - (t.prototype.getEvent = function (e) { - if ((0, ca.isHexString)(e)) { - var r = e.toLowerCase(); - for (var n in this.events) - if (r === this.getEventTopic(n)) return this.events[n]; - xa.throwArgumentError("no matching event", "topichash", r); - } - if (e.indexOf("(") === -1) { - var i = e.trim(), - o = Object.keys(this.events).filter(function (s) { - return s.split("(")[0] === i; - }); - return ( - o.length === 0 - ? xa.throwArgumentError("no matching event", "name", i) - : o.length > 1 && - xa.throwArgumentError("multiple matching events", "name", i), - this.events[o[0]] - ); - } - var a = this.events[gx.EventFragment.fromString(e).format()]; - return ( - a || xa.throwArgumentError("no matching event", "signature", e), a - ); - }), - (t.prototype.getError = function (e) { - if ((0, ca.isHexString)(e)) { - var r = (0, dc.getStatic)(this.constructor, "getSighash"); - for (var n in this.errors) { - var i = this.errors[n]; - if (e === r(i)) return this.errors[n]; - } - xa.throwArgumentError("no matching error", "sighash", e); - } - if (e.indexOf("(") === -1) { - var o = e.trim(), - a = Object.keys(this.errors).filter(function (c) { - return c.split("(")[0] === o; - }); - return ( - a.length === 0 - ? xa.throwArgumentError("no matching error", "name", o) - : a.length > 1 && - xa.throwArgumentError("multiple matching errors", "name", o), - this.errors[a[0]] - ); - } - var s = this.errors[gx.FunctionFragment.fromString(e).format()]; - return ( - s || xa.throwArgumentError("no matching error", "signature", e), s - ); - }), - (t.prototype.getSighash = function (e) { - if (typeof e == "string") - try { - e = this.getFunction(e); - } catch (r) { - try { - e = this.getError(e); - } catch { - throw r; - } - } - return (0, dc.getStatic)(this.constructor, "getSighash")(e); - }), - (t.prototype.getEventTopic = function (e) { - return ( - typeof e == "string" && (e = this.getEvent(e)), - (0, dc.getStatic)(this.constructor, "getEventTopic")(e) - ); - }), - (t.prototype._decodeParams = function (e, r) { - return this._abiCoder.decode(e, r); - }), - (t.prototype._encodeParams = function (e, r) { - return this._abiCoder.encode(e, r); - }), - (t.prototype.encodeDeploy = function (e) { - return this._encodeParams(this.deploy.inputs, e || []); - }), - (t.prototype.decodeErrorResult = function (e, r) { - typeof e == "string" && (e = this.getError(e)); - var n = (0, ca.arrayify)(r); - return ( - (0, ca.hexlify)(n.slice(0, 4)) !== this.getSighash(e) && - xa.throwArgumentError( - "data signature does not match error " + e.name + ".", - "data", - (0, ca.hexlify)(n) - ), - this._decodeParams(e.inputs, n.slice(4)) - ); - }), - (t.prototype.encodeErrorResult = function (e, r) { - return ( - typeof e == "string" && (e = this.getError(e)), - (0, ca.hexlify)( - (0, ca.concat)([ - this.getSighash(e), - this._encodeParams(e.inputs, r || []), - ]) - ) - ); - }), - (t.prototype.decodeFunctionData = function (e, r) { - typeof e == "string" && (e = this.getFunction(e)); - var n = (0, ca.arrayify)(r); - return ( - (0, ca.hexlify)(n.slice(0, 4)) !== this.getSighash(e) && - xa.throwArgumentError( - "data signature does not match function " + e.name + ".", - "data", - (0, ca.hexlify)(n) - ), - this._decodeParams(e.inputs, n.slice(4)) - ); - }), - (t.prototype.encodeFunctionData = function (e, r) { - return ( - typeof e == "string" && (e = this.getFunction(e)), - (0, ca.hexlify)( - (0, ca.concat)([ - this.getSighash(e), - this._encodeParams(e.inputs, r || []), - ]) - ) - ); - }), - (t.prototype.decodeFunctionResult = function (e, r) { - typeof e == "string" && (e = this.getFunction(e)); - var n = (0, ca.arrayify)(r), - i = null, - o = "", - a = null, - s = null, - c = null; - switch (n.length % this._abiCoder._getWordSize()) { - case 0: - try { - return this._abiCoder.decode(e.outputs, n); - } catch {} - break; - case 4: { - var u = (0, ca.hexlify)(n.slice(0, 4)), - h = v1r[u]; - if (h) - (a = this._abiCoder.decode(h.inputs, n.slice(4))), - (s = h.name), - (c = h.signature), - h.reason && (i = a[0]), - s === "Error" - ? (o = - "; VM Exception while processing transaction: reverted with reason string " + - JSON.stringify(a[0])) - : s === "Panic" && - (o = - "; VM Exception while processing transaction: reverted with panic code " + - a[0]); - else - try { - var w = this.getError(u); - (a = this._abiCoder.decode(w.inputs, n.slice(4))), - (s = w.name), - (c = w.format()); - } catch {} - break; - } - } - return xa.throwError( - "call revert exception" + o, - Ore.Logger.errors.CALL_EXCEPTION, - { - method: e.format(), - data: (0, ca.hexlify)(r), - errorArgs: a, - errorName: s, - errorSignature: c, - reason: i, - } - ); - }), - (t.prototype.encodeFunctionResult = function (e, r) { - return ( - typeof e == "string" && (e = this.getFunction(e)), - (0, ca.hexlify)(this._abiCoder.encode(e.outputs, r || [])) - ); - }), - (t.prototype.encodeFilterTopics = function (e, r) { - var n = this; - typeof e == "string" && (e = this.getEvent(e)), - r.length > e.inputs.length && - xa.throwError( - "too many arguments for " + e.format(), - Ore.Logger.errors.UNEXPECTED_ARGUMENT, - { argument: "values", value: r } - ); - var i = []; - e.anonymous || i.push(this.getEventTopic(e)); - var o = function (a, s) { - return a.type === "string" - ? (0, Pre.id)(s) - : a.type === "bytes" - ? (0, Dct.keccak256)((0, ca.hexlify)(s)) - : (a.type === "bool" && - typeof s == "boolean" && - (s = s ? "0x01" : "0x00"), - a.type.match(/^u?int/) && - (s = Nct.BigNumber.from(s).toHexString()), - a.type === "address" && n._abiCoder.encode(["address"], [s]), - (0, ca.hexZeroPad)((0, ca.hexlify)(s), 32)); - }; - for ( - r.forEach(function (a, s) { - var c = e.inputs[s]; - if (!c.indexed) { - a != null && - xa.throwArgumentError( - "cannot filter non-indexed parameters; must be null", - "contract." + c.name, - a - ); - return; - } - a == null - ? i.push(null) - : c.baseType === "array" || c.baseType === "tuple" - ? xa.throwArgumentError( - "filtering with tuples or arrays not supported", - "contract." + c.name, - a - ) - : Array.isArray(a) - ? i.push( - a.map(function (u) { - return o(c, u); - }) - ) - : i.push(o(c, a)); - }); - i.length && i[i.length - 1] === null; - - ) - i.pop(); - return i; - }), - (t.prototype.encodeEventLog = function (e, r) { - var n = this; - typeof e == "string" && (e = this.getEvent(e)); - var i = [], - o = [], - a = []; - return ( - e.anonymous || i.push(this.getEventTopic(e)), - r.length !== e.inputs.length && - xa.throwArgumentError( - "event arguments/values mismatch", - "values", - r - ), - e.inputs.forEach(function (s, c) { - var u = r[c]; - if (s.indexed) - if (s.type === "string") i.push((0, Pre.id)(u)); - else if (s.type === "bytes") i.push((0, Dct.keccak256)(u)); - else { - if (s.baseType === "tuple" || s.baseType === "array") - throw new Error("not implemented"); - i.push(n._abiCoder.encode([s.type], [u])); - } - else o.push(s), a.push(u); - }), - { data: this._abiCoder.encode(o, a), topics: i } - ); - }), - (t.prototype.decodeEventLog = function (e, r, n) { - if ( - (typeof e == "string" && (e = this.getEvent(e)), - n != null && !e.anonymous) - ) { - var i = this.getEventTopic(e); - (!(0, ca.isHexString)(n[0], 32) || n[0].toLowerCase() !== i) && - xa.throwError( - "fragment/topic mismatch", - Ore.Logger.errors.INVALID_ARGUMENT, - { argument: "topics[0]", expected: i, value: n[0] } - ), - (n = n.slice(1)); - } - var o = [], - a = [], - s = []; - e.inputs.forEach(function (D, F) { - D.indexed - ? D.type === "string" || - D.type === "bytes" || - D.baseType === "tuple" || - D.baseType === "array" - ? (o.push( - gx.ParamType.fromObject({ type: "bytes32", name: D.name }) - ), - s.push(!0)) - : (o.push(D), s.push(!1)) - : (a.push(D), s.push(!1)); - }); - var c = - n != null ? this._abiCoder.decode(o, (0, ca.concat)(n)) : null, - u = this._abiCoder.decode(a, r, !0), - h = [], - w = 0, - M = 0; - e.inputs.forEach(function (D, F) { - if (D.indexed) - if (c == null) h[F] = new IAe({ _isIndexed: !0, hash: null }); - else if (s[F]) h[F] = new IAe({ _isIndexed: !0, hash: c[M++] }); - else - try { - h[F] = c[M++]; - } catch (q) { - h[F] = q; - } - else - try { - h[F] = u[w++]; - } catch (q) { - h[F] = q; - } - if (D.name && h[D.name] == null) { - var N = h[F]; - N instanceof Error - ? Object.defineProperty(h, D.name, { - enumerable: !0, - get: function () { - throw Fct("property " + JSON.stringify(D.name), N); - }, - }) - : (h[D.name] = N); - } - }); - for ( - var k = function (D) { - var F = h[D]; - F instanceof Error && - Object.defineProperty(h, D, { - enumerable: !0, - get: function () { - throw Fct("index " + D, F); - }, - }); - }, - O = 0; - O < h.length; - O++ - ) - k(O); - return Object.freeze(h); - }), - (t.prototype.parseTransaction = function (e) { - var r = this.getFunction(e.data.substring(0, 10).toLowerCase()); - return r - ? new qct({ - args: this._abiCoder.decode( - r.inputs, - "0x" + e.data.substring(10) - ), - functionFragment: r, - name: r.name, - signature: r.format(), - sighash: this.getSighash(r), - value: Nct.BigNumber.from(e.value || "0"), - }) - : null; - }), - (t.prototype.parseLog = function (e) { - var r = this.getEvent(e.topics[0]); - return !r || r.anonymous - ? null - : new Lct({ - eventFragment: r, - name: r.name, - signature: r.format(), - topic: this.getEventTopic(r), - args: this.decodeEventLog(r, e.data, e.topics), - }); - }), - (t.prototype.parseError = function (e) { - var r = (0, ca.hexlify)(e), - n = this.getError(r.substring(0, 10).toLowerCase()); - return n - ? new zct({ - args: this._abiCoder.decode(n.inputs, "0x" + r.substring(10)), - errorFragment: n, - name: n.name, - signature: n.format(), - sighash: this.getSighash(n), - }) - : null; - }), - (t.isInterface = function (e) { - return !!(e && e._isInterface); - }), - t - ); - })(); - Qc.Interface = b1r; - }); - var Ire = I((Yi) => { - "use strict"; - m(); - g(); - Object.defineProperty(Yi, "__esModule", { value: !0 }); - Yi.TransactionDescription = - Yi.LogDescription = - Yi.checkResultErrors = - Yi.Indexed = - Yi.Interface = - Yi.defaultAbiCoder = - Yi.AbiCoder = - Yi.FormatTypes = - Yi.ParamType = - Yi.FunctionFragment = - Yi.Fragment = - Yi.EventFragment = - Yi.ErrorFragment = - Yi.ConstructorFragment = - void 0; - var t6 = cre(); - Object.defineProperty(Yi, "ConstructorFragment", { - enumerable: !0, - get: function () { - return t6.ConstructorFragment; - }, - }); - Object.defineProperty(Yi, "ErrorFragment", { - enumerable: !0, - get: function () { - return t6.ErrorFragment; - }, - }); - Object.defineProperty(Yi, "EventFragment", { - enumerable: !0, - get: function () { - return t6.EventFragment; - }, - }); - Object.defineProperty(Yi, "FormatTypes", { - enumerable: !0, - get: function () { - return t6.FormatTypes; - }, - }); - Object.defineProperty(Yi, "Fragment", { - enumerable: !0, - get: function () { - return t6.Fragment; - }, - }); - Object.defineProperty(Yi, "FunctionFragment", { - enumerable: !0, - get: function () { - return t6.FunctionFragment; - }, - }); - Object.defineProperty(Yi, "ParamType", { - enumerable: !0, - get: function () { - return t6.ParamType; - }, - }); - var Uct = _Ae(); - Object.defineProperty(Yi, "AbiCoder", { - enumerable: !0, - get: function () { - return Uct.AbiCoder; - }, - }); - Object.defineProperty(Yi, "defaultAbiCoder", { - enumerable: !0, - get: function () { - return Uct.defaultAbiCoder; - }, - }); - var UU = jct(); - Object.defineProperty(Yi, "checkResultErrors", { - enumerable: !0, - get: function () { - return UU.checkResultErrors; - }, - }); - Object.defineProperty(Yi, "Indexed", { - enumerable: !0, - get: function () { - return UU.Indexed; - }, - }); - Object.defineProperty(Yi, "Interface", { - enumerable: !0, - get: function () { - return UU.Interface; - }, - }); - Object.defineProperty(Yi, "LogDescription", { - enumerable: !0, - get: function () { - return UU.LogDescription; - }, - }); - Object.defineProperty(Yi, "TransactionDescription", { - enumerable: !0, - get: function () { - return UU.TransactionDescription; - }, - }); - }); - var Kct = I((Cre) => { - "use strict"; - m(); - g(); - Object.defineProperty(Cre, "__esModule", { value: !0 }); - Cre.version = void 0; - Cre.version = "abstract-provider/5.7.0"; - }); - var vx = I((Nu) => { - "use strict"; - m(); - g(); - var Nre = - (Nu && Nu.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(), - w1r = - (Nu && Nu.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - _1r = - (Nu && Nu.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(Nu, "__esModule", { value: !0 }); - Nu.Provider = - Nu.TransactionOrderForkEvent = - Nu.TransactionForkEvent = - Nu.BlockForkEvent = - Nu.ForkEvent = - void 0; - var x1r = Ro(), - Rre = Ar(), - CAe = $r(), - S1r = rr(), - A1r = Kct(), - KU = new S1r.Logger(A1r.version), - Dre = (function (t) { - Nre(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.isForkEvent = function (r) { - return !!(r && r._isForkEvent); - }), - e - ); - })(CAe.Description); - Nu.ForkEvent = Dre; - var E1r = (function (t) { - Nre(e, t); - function e(r, n) { - var i = this; - return ( - (0, Rre.isHexString)(r, 32) || - KU.throwArgumentError("invalid blockHash", "blockHash", r), - (i = - t.call(this, { - _isForkEvent: !0, - _isBlockForkEvent: !0, - expiry: n || 0, - blockHash: r, - }) || this), - i - ); - } - return e; - })(Dre); - Nu.BlockForkEvent = E1r; - var M1r = (function (t) { - Nre(e, t); - function e(r, n) { - var i = this; - return ( - (0, Rre.isHexString)(r, 32) || - KU.throwArgumentError("invalid transaction hash", "hash", r), - (i = - t.call(this, { - _isForkEvent: !0, - _isTransactionForkEvent: !0, - expiry: n || 0, - hash: r, - }) || this), - i - ); - } - return e; - })(Dre); - Nu.TransactionForkEvent = M1r; - var T1r = (function (t) { - Nre(e, t); - function e(r, n, i) { - var o = this; - return ( - (0, Rre.isHexString)(r, 32) || - KU.throwArgumentError("invalid transaction hash", "beforeHash", r), - (0, Rre.isHexString)(n, 32) || - KU.throwArgumentError("invalid transaction hash", "afterHash", n), - (o = - t.call(this, { - _isForkEvent: !0, - _isTransactionOrderForkEvent: !0, - expiry: i || 0, - beforeHash: r, - afterHash: n, - }) || this), - o - ); - } - return e; - })(Dre); - Nu.TransactionOrderForkEvent = T1r; - var k1r = (function () { - function t() { - var e = this.constructor; - KU.checkAbstract(e, t), - (0, CAe.defineReadOnly)(this, "_isProvider", !0); - } - return ( - (t.prototype.getFeeData = function () { - return w1r(this, void 0, void 0, function () { - var e, r, n, i, o, a; - return _1r(this, function (s) { - switch (s.label) { - case 0: - return [ - 4, - (0, CAe.resolveProperties)({ - block: this.getBlock("latest"), - gasPrice: this.getGasPrice().catch(function (c) { - return null; - }), - }), - ]; - case 1: - return ( - (e = s.sent()), - (r = e.block), - (n = e.gasPrice), - (i = null), - (o = null), - (a = null), - r && - r.baseFeePerGas && - ((i = r.baseFeePerGas), - (a = x1r.BigNumber.from("1500000000")), - (o = r.baseFeePerGas.mul(2).add(a))), - [ - 2, - { - lastBaseFeePerGas: i, - maxFeePerGas: o, - maxPriorityFeePerGas: a, - gasPrice: n, - }, - ] - ); - } - }); - }); - }), - (t.prototype.addListener = function (e, r) { - return this.on(e, r); - }), - (t.prototype.removeListener = function (e, r) { - return this.off(e, r); - }), - (t.isProvider = function (e) { - return !!(e && e._isProvider); - }), - t - ); - })(); - Nu.Provider = k1r; - }); - var Hct = I((Fre) => { - "use strict"; - m(); - g(); - Object.defineProperty(Fre, "__esModule", { value: !0 }); - Fre.version = void 0; - Fre.version = "abstract-signer/5.7.0"; - }); - var r6 = I((Dy) => { - "use strict"; - m(); - g(); - var P1r = - (Dy && Dy.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(), - pg = - (Dy && Dy.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - yg = - (Dy && Dy.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(Dy, "__esModule", { value: !0 }); - Dy.VoidSigner = Dy.Signer = void 0; - var OA = $r(), - bx = rr(), - O1r = Hct(), - Ny = new bx.Logger(O1r.version), - B1r = [ - "accessList", - "ccipReadEnabled", - "chainId", - "customData", - "data", - "from", - "gasLimit", - "gasPrice", - "maxFeePerGas", - "maxPriorityFeePerGas", - "nonce", - "to", - "type", - "value", - ], - I1r = [ - bx.Logger.errors.INSUFFICIENT_FUNDS, - bx.Logger.errors.NONCE_EXPIRED, - bx.Logger.errors.REPLACEMENT_UNDERPRICED, - ], - Vct = (function () { - function t() { - var e = this.constructor; - Ny.checkAbstract(e, t), (0, OA.defineReadOnly)(this, "_isSigner", !0); - } - return ( - (t.prototype.getBalance = function (e) { - return pg(this, void 0, void 0, function () { - return yg(this, function (r) { - switch (r.label) { - case 0: - return ( - this._checkProvider("getBalance"), - [4, this.provider.getBalance(this.getAddress(), e)] - ); - case 1: - return [2, r.sent()]; - } - }); - }); - }), - (t.prototype.getTransactionCount = function (e) { - return pg(this, void 0, void 0, function () { - return yg(this, function (r) { - switch (r.label) { - case 0: - return ( - this._checkProvider("getTransactionCount"), - [ - 4, - this.provider.getTransactionCount(this.getAddress(), e), - ] - ); - case 1: - return [2, r.sent()]; - } - }); - }); - }), - (t.prototype.estimateGas = function (e) { - return pg(this, void 0, void 0, function () { - var r; - return yg(this, function (n) { - switch (n.label) { - case 0: - return ( - this._checkProvider("estimateGas"), - [4, (0, OA.resolveProperties)(this.checkTransaction(e))] - ); - case 1: - return (r = n.sent()), [4, this.provider.estimateGas(r)]; - case 2: - return [2, n.sent()]; - } - }); - }); - }), - (t.prototype.call = function (e, r) { - return pg(this, void 0, void 0, function () { - var n; - return yg(this, function (i) { - switch (i.label) { - case 0: - return ( - this._checkProvider("call"), - [4, (0, OA.resolveProperties)(this.checkTransaction(e))] - ); - case 1: - return (n = i.sent()), [4, this.provider.call(n, r)]; - case 2: - return [2, i.sent()]; - } - }); - }); - }), - (t.prototype.sendTransaction = function (e) { - return pg(this, void 0, void 0, function () { - var r, n; - return yg(this, function (i) { - switch (i.label) { - case 0: - return ( - this._checkProvider("sendTransaction"), - [4, this.populateTransaction(e)] - ); - case 1: - return (r = i.sent()), [4, this.signTransaction(r)]; - case 2: - return ( - (n = i.sent()), [4, this.provider.sendTransaction(n)] - ); - case 3: - return [2, i.sent()]; - } - }); - }); - }), - (t.prototype.getChainId = function () { - return pg(this, void 0, void 0, function () { - var e; - return yg(this, function (r) { - switch (r.label) { - case 0: - return ( - this._checkProvider("getChainId"), - [4, this.provider.getNetwork()] - ); - case 1: - return (e = r.sent()), [2, e.chainId]; - } - }); - }); - }), - (t.prototype.getGasPrice = function () { - return pg(this, void 0, void 0, function () { - return yg(this, function (e) { - switch (e.label) { - case 0: - return ( - this._checkProvider("getGasPrice"), - [4, this.provider.getGasPrice()] - ); - case 1: - return [2, e.sent()]; - } - }); - }); - }), - (t.prototype.getFeeData = function () { - return pg(this, void 0, void 0, function () { - return yg(this, function (e) { - switch (e.label) { - case 0: - return ( - this._checkProvider("getFeeData"), - [4, this.provider.getFeeData()] - ); - case 1: - return [2, e.sent()]; - } - }); - }); - }), - (t.prototype.resolveName = function (e) { - return pg(this, void 0, void 0, function () { - return yg(this, function (r) { - switch (r.label) { - case 0: - return ( - this._checkProvider("resolveName"), - [4, this.provider.resolveName(e)] - ); - case 1: - return [2, r.sent()]; - } - }); - }); - }), - (t.prototype.checkTransaction = function (e) { - for (var r in e) - B1r.indexOf(r) === -1 && - Ny.throwArgumentError( - "invalid transaction key: " + r, - "transaction", - e - ); - var n = (0, OA.shallowCopy)(e); - return ( - n.from == null - ? (n.from = this.getAddress()) - : (n.from = Promise.all([ - Promise.resolve(n.from), - this.getAddress(), - ]).then(function (i) { - return ( - i[0].toLowerCase() !== i[1].toLowerCase() && - Ny.throwArgumentError( - "from address mismatch", - "transaction", - e - ), - i[0] - ); - })), - n - ); - }), - (t.prototype.populateTransaction = function (e) { - return pg(this, void 0, void 0, function () { - var r, - n, - i, - o, - a = this; - return yg(this, function (s) { - switch (s.label) { - case 0: - return [ - 4, - (0, OA.resolveProperties)(this.checkTransaction(e)), - ]; - case 1: - return ( - (r = s.sent()), - r.to != null && - ((r.to = Promise.resolve(r.to).then(function (c) { - return pg(a, void 0, void 0, function () { - var u; - return yg(this, function (h) { - switch (h.label) { - case 0: - return c == null - ? [2, null] - : [4, this.resolveName(c)]; - case 1: - return ( - (u = h.sent()), - u == null && - Ny.throwArgumentError( - "provided ENS name resolves to null", - "tx.to", - c - ), - [2, u] - ); - } - }); - }); - })), - r.to.catch(function (c) {})), - (n = - r.maxFeePerGas != null || - r.maxPriorityFeePerGas != null), - r.gasPrice != null && (r.type === 2 || n) - ? Ny.throwArgumentError( - "eip-1559 transaction do not support gasPrice", - "transaction", - e - ) - : (r.type === 0 || r.type === 1) && - n && - Ny.throwArgumentError( - "pre-eip-1559 transaction do not support maxFeePerGas/maxPriorityFeePerGas", - "transaction", - e - ), - (r.type === 2 || r.type == null) && - r.maxFeePerGas != null && - r.maxPriorityFeePerGas != null - ? ((r.type = 2), [3, 5]) - : [3, 2] - ); - case 2: - return r.type === 0 || r.type === 1 - ? (r.gasPrice == null && - (r.gasPrice = this.getGasPrice()), - [3, 5]) - : [3, 3]; - case 3: - return [4, this.getFeeData()]; - case 4: - (i = s.sent()), - r.type == null - ? i.maxFeePerGas != null && - i.maxPriorityFeePerGas != null - ? ((r.type = 2), - r.gasPrice != null - ? ((o = r.gasPrice), - delete r.gasPrice, - (r.maxFeePerGas = o), - (r.maxPriorityFeePerGas = o)) - : (r.maxFeePerGas == null && - (r.maxFeePerGas = i.maxFeePerGas), - r.maxPriorityFeePerGas == null && - (r.maxPriorityFeePerGas = - i.maxPriorityFeePerGas))) - : i.gasPrice != null - ? (n && - Ny.throwError( - "network does not support EIP-1559", - bx.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "populateTransaction" } - ), - r.gasPrice == null && (r.gasPrice = i.gasPrice), - (r.type = 0)) - : Ny.throwError( - "failed to get consistent fee data", - bx.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "signer.getFeeData" } - ) - : r.type === 2 && - (r.maxFeePerGas == null && - (r.maxFeePerGas = i.maxFeePerGas), - r.maxPriorityFeePerGas == null && - (r.maxPriorityFeePerGas = i.maxPriorityFeePerGas)), - (s.label = 5); - case 5: - return ( - r.nonce == null && - (r.nonce = this.getTransactionCount("pending")), - r.gasLimit == null && - (r.gasLimit = this.estimateGas(r).catch(function (c) { - if (I1r.indexOf(c.code) >= 0) throw c; - return Ny.throwError( - "cannot estimate gas; transaction may fail or may require manual gas limit", - bx.Logger.errors.UNPREDICTABLE_GAS_LIMIT, - { error: c, tx: r } - ); - })), - r.chainId == null - ? (r.chainId = this.getChainId()) - : (r.chainId = Promise.all([ - Promise.resolve(r.chainId), - this.getChainId(), - ]).then(function (c) { - return ( - c[1] !== 0 && - c[0] !== c[1] && - Ny.throwArgumentError( - "chainId address mismatch", - "transaction", - e - ), - c[0] - ); - })), - [4, (0, OA.resolveProperties)(r)] - ); - case 6: - return [2, s.sent()]; - } - }); - }); - }), - (t.prototype._checkProvider = function (e) { - this.provider || - Ny.throwError( - "missing provider", - bx.Logger.errors.UNSUPPORTED_OPERATION, - { operation: e || "_checkProvider" } - ); - }), - (t.isSigner = function (e) { - return !!(e && e._isSigner); - }), - t - ); - })(); - Dy.Signer = Vct; - var C1r = (function (t) { - P1r(e, t); - function e(r, n) { - var i = t.call(this) || this; - return ( - (0, OA.defineReadOnly)(i, "address", r), - (0, OA.defineReadOnly)(i, "provider", n || null), - i - ); - } - return ( - (e.prototype.getAddress = function () { - return Promise.resolve(this.address); - }), - (e.prototype._fail = function (r, n) { - return Promise.resolve().then(function () { - Ny.throwError(r, bx.Logger.errors.UNSUPPORTED_OPERATION, { - operation: n, - }); - }); - }), - (e.prototype.signMessage = function (r) { - return this._fail("VoidSigner cannot sign messages", "signMessage"); - }), - (e.prototype.signTransaction = function (r) { - return this._fail( - "VoidSigner cannot sign transactions", - "signTransaction" - ); - }), - (e.prototype._signTypedData = function (r, n, i) { - return this._fail( - "VoidSigner cannot sign typed data", - "signTypedData" - ); - }), - (e.prototype.connect = function (r) { - return new e(this.address, r); - }), - e - ); - })(Vct); - Dy.VoidSigner = C1r; - }); - var Wct = I((LR) => { - "use strict"; - m(); - g(); - var R1r = - (LR && LR.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(LR, "__esModule", { value: !0 }); - LR.EC = void 0; - var N1r = R1r(F5()), - D1r = N1r.default.ec; - LR.EC = D1r; - }); - var Gct = I((Lre) => { - "use strict"; - m(); - g(); - Object.defineProperty(Lre, "__esModule", { value: !0 }); - Lre.version = void 0; - Lre.version = "signing-key/5.7.0"; - }); - var qR = I((BA) => { - "use strict"; - m(); - g(); - Object.defineProperty(BA, "__esModule", { value: !0 }); - BA.computePublicKey = BA.recoverPublicKey = BA.SigningKey = void 0; - var F1r = Wct(), - Ss = Ar(), - HU = $r(), - L1r = rr(), - q1r = Gct(), - NAe = new L1r.Logger(q1r.version), - RAe = null; - function hb() { - return RAe || (RAe = new F1r.EC("secp256k1")), RAe; - } - var Jct = (function () { - function t(e) { - (0, HU.defineReadOnly)(this, "curve", "secp256k1"), - (0, HU.defineReadOnly)(this, "privateKey", (0, Ss.hexlify)(e)), - (0, Ss.hexDataLength)(this.privateKey) !== 32 && - NAe.throwArgumentError( - "invalid private key", - "privateKey", - "[[ REDACTED ]]" - ); - var r = hb().keyFromPrivate((0, Ss.arrayify)(this.privateKey)); - (0, HU.defineReadOnly)( - this, - "publicKey", - "0x" + r.getPublic(!1, "hex") - ), - (0, HU.defineReadOnly)( - this, - "compressedPublicKey", - "0x" + r.getPublic(!0, "hex") - ), - (0, HU.defineReadOnly)(this, "_isSigningKey", !0); - } - return ( - (t.prototype._addPoint = function (e) { - var r = hb().keyFromPublic((0, Ss.arrayify)(this.publicKey)), - n = hb().keyFromPublic((0, Ss.arrayify)(e)); - return "0x" + r.pub.add(n.pub).encodeCompressed("hex"); - }), - (t.prototype.signDigest = function (e) { - var r = hb().keyFromPrivate((0, Ss.arrayify)(this.privateKey)), - n = (0, Ss.arrayify)(e); - n.length !== 32 && - NAe.throwArgumentError("bad digest length", "digest", e); - var i = r.sign(n, { canonical: !0 }); - return (0, Ss.splitSignature)({ - recoveryParam: i.recoveryParam, - r: (0, Ss.hexZeroPad)("0x" + i.r.toString(16), 32), - s: (0, Ss.hexZeroPad)("0x" + i.s.toString(16), 32), - }); - }), - (t.prototype.computeSharedSecret = function (e) { - var r = hb().keyFromPrivate((0, Ss.arrayify)(this.privateKey)), - n = hb().keyFromPublic((0, Ss.arrayify)($ct(e))); - return (0, Ss.hexZeroPad)( - "0x" + r.derive(n.getPublic()).toString(16), - 32 - ); - }), - (t.isSigningKey = function (e) { - return !!(e && e._isSigningKey); - }), - t - ); - })(); - BA.SigningKey = Jct; - function z1r(t, e) { - var r = (0, Ss.splitSignature)(e), - n = { r: (0, Ss.arrayify)(r.r), s: (0, Ss.arrayify)(r.s) }; - return ( - "0x" + - hb() - .recoverPubKey((0, Ss.arrayify)(t), n, r.recoveryParam) - .encode("hex", !1) - ); - } - BA.recoverPublicKey = z1r; - function $ct(t, e) { - var r = (0, Ss.arrayify)(t); - if (r.length === 32) { - var n = new Jct(r); - return e - ? "0x" + hb().keyFromPrivate(r).getPublic(!0, "hex") - : n.publicKey; - } else { - if (r.length === 33) - return e - ? (0, Ss.hexlify)(r) - : "0x" + hb().keyFromPublic(r).getPublic(!1, "hex"); - if (r.length === 65) - return e - ? "0x" + hb().keyFromPublic(r).getPublic(!0, "hex") - : (0, Ss.hexlify)(r); - } - return NAe.throwArgumentError( - "invalid public or private key", - "key", - "[REDACTED]" - ); - } - BA.computePublicKey = $ct; - }); - var Zct = I((qre) => { - "use strict"; - m(); - g(); - Object.defineProperty(qre, "__esModule", { value: !0 }); - qre.version = void 0; - qre.version = "transactions/5.7.0"; - }); - var e0 = I((os) => { - "use strict"; - m(); - g(); - var j1r = - (os && os.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - U1r = - (os && os.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - K1r = - (os && os.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - j1r(e, t, r); - return U1r(e, t), e; - }; - Object.defineProperty(os, "__esModule", { value: !0 }); - os.parse = - os.serialize = - os.accessListify = - os.recoverAddress = - os.computeAddress = - os.TransactionTypes = - void 0; - var VU = Vh(), - n6 = Ro(), - hi = Ar(), - H1r = ub(), - zR = Hh(), - V1r = $r(), - IA = K1r(zU()), - Xct = qR(), - FAe = rr(), - W1r = Zct(), - tl = new FAe.Logger(W1r.version), - G1r; - (function (t) { - (t[(t.legacy = 0)] = "legacy"), - (t[(t.eip2930 = 1)] = "eip2930"), - (t[(t.eip1559 = 2)] = "eip1559"); - })((G1r = os.TransactionTypes || (os.TransactionTypes = {}))); - function LAe(t) { - return t === "0x" ? null : (0, VU.getAddress)(t); - } - function el(t) { - return t === "0x" ? H1r.Zero : n6.BigNumber.from(t); - } - var J1r = [ - { name: "nonce", maxLength: 32, numeric: !0 }, - { name: "gasPrice", maxLength: 32, numeric: !0 }, - { name: "gasLimit", maxLength: 32, numeric: !0 }, - { name: "to", length: 20 }, - { name: "value", maxLength: 32, numeric: !0 }, - { name: "data" }, - ], - $1r = { - chainId: !0, - data: !0, - gasLimit: !0, - gasPrice: !0, - nonce: !0, - to: !0, - type: !0, - value: !0, - }; - function Yct(t) { - var e = (0, Xct.computePublicKey)(t); - return (0, VU.getAddress)( - (0, hi.hexDataSlice)((0, zR.keccak256)((0, hi.hexDataSlice)(e, 1)), 12) - ); - } - os.computeAddress = Yct; - function qAe(t, e) { - return Yct((0, Xct.recoverPublicKey)((0, hi.arrayify)(t), e)); - } - os.recoverAddress = qAe; - function Qp(t, e) { - var r = (0, hi.stripZeros)(n6.BigNumber.from(t).toHexString()); - return ( - r.length > 32 && - tl.throwArgumentError( - "invalid length for " + e, - "transaction:" + e, - t - ), - r - ); - } - function DAe(t, e) { - return { - address: (0, VU.getAddress)(t), - storageKeys: (e || []).map(function (r, n) { - return ( - (0, hi.hexDataLength)(r) !== 32 && - tl.throwArgumentError( - "invalid access list storageKey", - "accessList[" + t + ":" + n + "]", - r - ), - r.toLowerCase() - ); - }), - }; - } - function zre(t) { - if (Array.isArray(t)) - return t.map(function (r, n) { - return Array.isArray(r) - ? (r.length > 2 && - tl.throwArgumentError( - "access list expected to be [ address, storageKeys[] ]", - "value[" + n + "]", - r - ), - DAe(r[0], r[1])) - : DAe(r.address, r.storageKeys); - }); - var e = Object.keys(t).map(function (r) { - var n = t[r].reduce(function (i, o) { - return (i[o] = !0), i; - }, {}); - return DAe(r, Object.keys(n).sort()); - }); - return ( - e.sort(function (r, n) { - return r.address.localeCompare(n.address); - }), - e - ); - } - os.accessListify = zre; - function Qct(t) { - return zre(t).map(function (e) { - return [e.address, e.storageKeys]; - }); - } - function elt(t, e) { - if (t.gasPrice != null) { - var r = n6.BigNumber.from(t.gasPrice), - n = n6.BigNumber.from(t.maxFeePerGas || 0); - r.eq(n) || - tl.throwArgumentError( - "mismatch EIP-1559 gasPrice != maxFeePerGas", - "tx", - { gasPrice: r, maxFeePerGas: n } - ); - } - var i = [ - Qp(t.chainId || 0, "chainId"), - Qp(t.nonce || 0, "nonce"), - Qp(t.maxPriorityFeePerGas || 0, "maxPriorityFeePerGas"), - Qp(t.maxFeePerGas || 0, "maxFeePerGas"), - Qp(t.gasLimit || 0, "gasLimit"), - t.to != null ? (0, VU.getAddress)(t.to) : "0x", - Qp(t.value || 0, "value"), - t.data || "0x", - Qct(t.accessList || []), - ]; - if (e) { - var o = (0, hi.splitSignature)(e); - i.push(Qp(o.recoveryParam, "recoveryParam")), - i.push((0, hi.stripZeros)(o.r)), - i.push((0, hi.stripZeros)(o.s)); - } - return (0, hi.hexConcat)(["0x02", IA.encode(i)]); - } - function tlt(t, e) { - var r = [ - Qp(t.chainId || 0, "chainId"), - Qp(t.nonce || 0, "nonce"), - Qp(t.gasPrice || 0, "gasPrice"), - Qp(t.gasLimit || 0, "gasLimit"), - t.to != null ? (0, VU.getAddress)(t.to) : "0x", - Qp(t.value || 0, "value"), - t.data || "0x", - Qct(t.accessList || []), - ]; - if (e) { - var n = (0, hi.splitSignature)(e); - r.push(Qp(n.recoveryParam, "recoveryParam")), - r.push((0, hi.stripZeros)(n.r)), - r.push((0, hi.stripZeros)(n.s)); - } - return (0, hi.hexConcat)(["0x01", IA.encode(r)]); - } - function Z1r(t, e) { - (0, V1r.checkProperties)(t, $1r); - var r = []; - J1r.forEach(function (a) { - var s = t[a.name] || [], - c = {}; - a.numeric && (c.hexPad = "left"), - (s = (0, hi.arrayify)((0, hi.hexlify)(s, c))), - a.length && - s.length !== a.length && - s.length > 0 && - tl.throwArgumentError( - "invalid length for " + a.name, - "transaction:" + a.name, - s - ), - a.maxLength && - ((s = (0, hi.stripZeros)(s)), - s.length > a.maxLength && - tl.throwArgumentError( - "invalid length for " + a.name, - "transaction:" + a.name, - s - )), - r.push((0, hi.hexlify)(s)); - }); - var n = 0; - if ( - (t.chainId != null - ? ((n = t.chainId), - typeof n != "number" && - tl.throwArgumentError( - "invalid transaction.chainId", - "transaction", - t - )) - : e && - !(0, hi.isBytesLike)(e) && - e.v > 28 && - (n = Math.floor((e.v - 35) / 2)), - n !== 0 && (r.push((0, hi.hexlify)(n)), r.push("0x"), r.push("0x")), - !e) - ) - return IA.encode(r); - var i = (0, hi.splitSignature)(e), - o = 27 + i.recoveryParam; - return ( - n !== 0 - ? (r.pop(), - r.pop(), - r.pop(), - (o += n * 2 + 8), - i.v > 28 && - i.v !== o && - tl.throwArgumentError( - "transaction.chainId/signature.v mismatch", - "signature", - e - )) - : i.v !== o && - tl.throwArgumentError( - "transaction.chainId/signature.v mismatch", - "signature", - e - ), - r.push((0, hi.hexlify)(o)), - r.push((0, hi.stripZeros)((0, hi.arrayify)(i.r))), - r.push((0, hi.stripZeros)((0, hi.arrayify)(i.s))), - IA.encode(r) - ); - } - function X1r(t, e) { - if (t.type == null || t.type === 0) - return ( - t.accessList != null && - tl.throwArgumentError( - "untyped transactions do not support accessList; include type: 1", - "transaction", - t - ), - Z1r(t, e) - ); - switch (t.type) { - case 1: - return tlt(t, e); - case 2: - return elt(t, e); - default: - break; - } - return tl.throwError( - "unsupported transaction type: " + t.type, - FAe.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "serializeTransaction", transactionType: t.type } - ); - } - os.serialize = X1r; - function rlt(t, e, r) { - try { - var n = el(e[0]).toNumber(); - if (n !== 0 && n !== 1) throw new Error("bad recid"); - t.v = n; - } catch { - tl.throwArgumentError("invalid v for transaction type: 1", "v", e[0]); - } - (t.r = (0, hi.hexZeroPad)(e[1], 32)), - (t.s = (0, hi.hexZeroPad)(e[2], 32)); - try { - var i = (0, zR.keccak256)(r(t)); - t.from = qAe(i, { r: t.r, s: t.s, recoveryParam: t.v }); - } catch {} - } - function Y1r(t) { - var e = IA.decode(t.slice(1)); - e.length !== 9 && - e.length !== 12 && - tl.throwArgumentError( - "invalid component count for transaction type: 2", - "payload", - (0, hi.hexlify)(t) - ); - var r = el(e[2]), - n = el(e[3]), - i = { - type: 2, - chainId: el(e[0]).toNumber(), - nonce: el(e[1]).toNumber(), - maxPriorityFeePerGas: r, - maxFeePerGas: n, - gasPrice: null, - gasLimit: el(e[4]), - to: LAe(e[5]), - value: el(e[6]), - data: e[7], - accessList: zre(e[8]), - }; - return ( - e.length === 9 || - ((i.hash = (0, zR.keccak256)(t)), rlt(i, e.slice(9), elt)), - i - ); - } - function Q1r(t) { - var e = IA.decode(t.slice(1)); - e.length !== 8 && - e.length !== 11 && - tl.throwArgumentError( - "invalid component count for transaction type: 1", - "payload", - (0, hi.hexlify)(t) - ); - var r = { - type: 1, - chainId: el(e[0]).toNumber(), - nonce: el(e[1]).toNumber(), - gasPrice: el(e[2]), - gasLimit: el(e[3]), - to: LAe(e[4]), - value: el(e[5]), - data: e[6], - accessList: zre(e[7]), - }; - return ( - e.length === 8 || - ((r.hash = (0, zR.keccak256)(t)), rlt(r, e.slice(8), tlt)), - r - ); - } - function ewr(t) { - var e = IA.decode(t); - e.length !== 9 && - e.length !== 6 && - tl.throwArgumentError("invalid raw transaction", "rawTransaction", t); - var r = { - nonce: el(e[0]).toNumber(), - gasPrice: el(e[1]), - gasLimit: el(e[2]), - to: LAe(e[3]), - value: el(e[4]), - data: e[5], - chainId: 0, - }; - if (e.length === 6) return r; - try { - r.v = n6.BigNumber.from(e[6]).toNumber(); - } catch { - return r; - } - if ( - ((r.r = (0, hi.hexZeroPad)(e[7], 32)), - (r.s = (0, hi.hexZeroPad)(e[8], 32)), - n6.BigNumber.from(r.r).isZero() && n6.BigNumber.from(r.s).isZero()) - ) - (r.chainId = r.v), (r.v = 0); - else { - (r.chainId = Math.floor((r.v - 35) / 2)), - r.chainId < 0 && (r.chainId = 0); - var n = r.v - 27, - i = e.slice(0, 6); - r.chainId !== 0 && - (i.push((0, hi.hexlify)(r.chainId)), - i.push("0x"), - i.push("0x"), - (n -= r.chainId * 2 + 8)); - var o = (0, zR.keccak256)(IA.encode(i)); - try { - r.from = qAe(o, { - r: (0, hi.hexlify)(r.r), - s: (0, hi.hexlify)(r.s), - recoveryParam: n, - }); - } catch {} - r.hash = (0, zR.keccak256)(t); - } - return (r.type = null), r; - } - function twr(t) { - var e = (0, hi.arrayify)(t); - if (e[0] > 127) return ewr(e); - switch (e[0]) { - case 1: - return Q1r(e); - case 2: - return Y1r(e); - default: - break; - } - return tl.throwError( - "unsupported transaction type: " + e[0], - FAe.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "parseTransaction", transactionType: e[0] } - ); - } - os.parse = twr; - }); - var nlt = I((jre) => { - "use strict"; - m(); - g(); - Object.defineProperty(jre, "__esModule", { value: !0 }); - jre.version = void 0; - jre.version = "contracts/5.7.0"; - }); - var UAe = I((rl) => { - "use strict"; - m(); - g(); - var Hre = - (rl && rl.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(), - RA = - (rl && rl.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - NA = - (rl && rl.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }, - rwr = - (rl && rl.__spreadArray) || - function (t, e, r) { - if (r || arguments.length === 2) - for (var n = 0, i = e.length, o; n < i; n++) - (o || !(n in e)) && - (o || (o = Array.prototype.slice.call(e, 0, n)), (o[n] = e[n])); - return t.concat(o || Array.prototype.slice.call(e)); - }; - Object.defineProperty(rl, "__esModule", { value: !0 }); - rl.ContractFactory = rl.Contract = rl.BaseContract = void 0; - var Ure = Ire(), - nwr = vx(), - zAe = r6(), - GU = Vh(), - CA = Ro(), - i6 = Ar(), - mr = $r(), - iwr = e0(), - hc = rr(), - owr = nlt(), - ho = new hc.Logger(owr.version), - awr = { - chainId: !0, - data: !0, - from: !0, - gasLimit: !0, - gasPrice: !0, - nonce: !0, - to: !0, - value: !0, - type: !0, - accessList: !0, - maxFeePerGas: !0, - maxPriorityFeePerGas: !0, - customData: !0, - ccipReadEnabled: !0, - }; - function Kre(t, e) { - return RA(this, void 0, void 0, function () { - var r, n; - return NA(this, function (i) { - switch (i.label) { - case 0: - return [4, e]; - case 1: - (r = i.sent()), - typeof r != "string" && - ho.throwArgumentError( - "invalid address or ENS name", - "name", - r - ); - try { - return [2, (0, GU.getAddress)(r)]; - } catch {} - return ( - t || - ho.throwError( - "a provider or signer is needed to resolve ENS names", - hc.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "resolveName" } - ), - [4, t.resolveName(r)] - ); - case 2: - return ( - (n = i.sent()), - n == null && - ho.throwArgumentError( - "resolver or addr is not configured for ENS name", - "name", - r - ), - [2, n] - ); - } - }); - }); - } - function WU(t, e, r) { - return RA(this, void 0, void 0, function () { - return NA(this, function (n) { - switch (n.label) { - case 0: - return Array.isArray(r) - ? [ - 4, - Promise.all( - r.map(function (i, o) { - return WU(t, Array.isArray(e) ? e[o] : e[i.name], i); - }) - ), - ] - : [3, 2]; - case 1: - return [2, n.sent()]; - case 2: - return r.type !== "address" ? [3, 4] : [4, Kre(t, e)]; - case 3: - return [2, n.sent()]; - case 4: - return r.type !== "tuple" ? [3, 6] : [4, WU(t, e, r.components)]; - case 5: - return [2, n.sent()]; - case 6: - return r.baseType !== "array" - ? [3, 8] - : Array.isArray(e) - ? [ - 4, - Promise.all( - e.map(function (i) { - return WU(t, i, r.arrayChildren); - }) - ), - ] - : [ - 2, - Promise.reject( - ho.makeError( - "invalid value for array", - hc.Logger.errors.INVALID_ARGUMENT, - { argument: "value", value: e } - ) - ), - ]; - case 7: - return [2, n.sent()]; - case 8: - return [2, e]; - } - }); - }); - } - function Vre(t, e, r) { - return RA(this, void 0, void 0, function () { - var n, - i, - o, - a, - s, - c, - u, - h, - w, - M, - k = this; - return NA(this, function (O) { - switch (O.label) { - case 0: - return ( - (n = {}), - r.length === e.inputs.length + 1 && - typeof r[r.length - 1] == "object" && - (n = (0, mr.shallowCopy)(r.pop())), - ho.checkArgumentCount( - r.length, - e.inputs.length, - "passed to contract" - ), - t.signer - ? n.from - ? (n.from = (0, mr.resolveProperties)({ - override: Kre(t.signer, n.from), - signer: t.signer.getAddress(), - }).then(function (D) { - return RA(k, void 0, void 0, function () { - return NA(this, function (F) { - return ( - (0, GU.getAddress)(D.signer) !== D.override && - ho.throwError( - "Contract with a Signer cannot override from", - hc.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "overrides.from" } - ), - [2, D.override] - ); - }); - }); - })) - : (n.from = t.signer.getAddress()) - : n.from && (n.from = Kre(t.provider, n.from)), - [ - 4, - (0, mr.resolveProperties)({ - args: WU(t.signer || t.provider, r, e.inputs), - address: t.resolvedAddress, - overrides: (0, mr.resolveProperties)(n) || {}, - }), - ] - ); - case 1: - if ( - ((i = O.sent()), - (o = t.interface.encodeFunctionData(e, i.args)), - (a = { data: o, to: i.address }), - (s = i.overrides), - s.nonce != null && - (a.nonce = CA.BigNumber.from(s.nonce).toNumber()), - s.gasLimit != null && - (a.gasLimit = CA.BigNumber.from(s.gasLimit)), - s.gasPrice != null && - (a.gasPrice = CA.BigNumber.from(s.gasPrice)), - s.maxFeePerGas != null && - (a.maxFeePerGas = CA.BigNumber.from(s.maxFeePerGas)), - s.maxPriorityFeePerGas != null && - (a.maxPriorityFeePerGas = CA.BigNumber.from( - s.maxPriorityFeePerGas - )), - s.from != null && (a.from = s.from), - s.type != null && (a.type = s.type), - s.accessList != null && - (a.accessList = (0, iwr.accessListify)(s.accessList)), - a.gasLimit == null && e.gas != null) - ) { - for ( - c = 21e3, u = (0, i6.arrayify)(o), h = 0; - h < u.length; - h++ - ) - (c += 4), u[h] && (c += 64); - a.gasLimit = CA.BigNumber.from(e.gas).add(c); - } - return ( - s.value && - ((w = CA.BigNumber.from(s.value)), - !w.isZero() && - !e.payable && - ho.throwError( - "non-payable method cannot override value", - hc.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "overrides.value", value: n.value } - ), - (a.value = w)), - s.customData && - (a.customData = (0, mr.shallowCopy)(s.customData)), - s.ccipReadEnabled && (a.ccipReadEnabled = !!s.ccipReadEnabled), - delete n.nonce, - delete n.gasLimit, - delete n.gasPrice, - delete n.from, - delete n.value, - delete n.type, - delete n.accessList, - delete n.maxFeePerGas, - delete n.maxPriorityFeePerGas, - delete n.customData, - delete n.ccipReadEnabled, - (M = Object.keys(n).filter(function (D) { - return n[D] != null; - })), - M.length && - ho.throwError( - "cannot override " + - M.map(function (D) { - return JSON.stringify(D); - }).join(","), - hc.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "overrides", overrides: M } - ), - [2, a] - ); - } - }); - }); - } - function swr(t, e) { - return function () { - for (var r = [], n = 0; n < arguments.length; n++) r[n] = arguments[n]; - return Vre(t, e, r); - }; - } - function uwr(t, e) { - var r = t.signer || t.provider; - return function () { - for (var n = [], i = 0; i < arguments.length; i++) n[i] = arguments[i]; - return RA(this, void 0, void 0, function () { - var o; - return NA(this, function (a) { - switch (a.label) { - case 0: - return ( - r || - ho.throwError( - "estimate require a provider or signer", - hc.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "estimateGas" } - ), - [4, Vre(t, e, n)] - ); - case 1: - return (o = a.sent()), [4, r.estimateGas(o)]; - case 2: - return [2, a.sent()]; - } - }); - }); - }; - } - function slt(t, e) { - var r = e.wait.bind(e); - e.wait = function (n) { - return r(n).then(function (i) { - return ( - (i.events = i.logs.map(function (o) { - var a = (0, mr.deepCopy)(o), - s = null; - try { - s = t.interface.parseLog(o); - } catch {} - return ( - s && - ((a.args = s.args), - (a.decode = function (c, u) { - return t.interface.decodeEventLog(s.eventFragment, c, u); - }), - (a.event = s.name), - (a.eventSignature = s.signature)), - (a.removeListener = function () { - return t.provider; - }), - (a.getBlock = function () { - return t.provider.getBlock(i.blockHash); - }), - (a.getTransaction = function () { - return t.provider.getTransaction(i.transactionHash); - }), - (a.getTransactionReceipt = function () { - return Promise.resolve(i); - }), - a - ); - })), - i - ); - }); - }; - } - function ult(t, e, r) { - var n = t.signer || t.provider; - return function () { - for (var i = [], o = 0; o < arguments.length; o++) i[o] = arguments[o]; - return RA(this, void 0, void 0, function () { - var a, s, c, u, h; - return NA(this, function (w) { - switch (w.label) { - case 0: - return ( - (a = void 0), - i.length === e.inputs.length + 1 && - typeof i[i.length - 1] == "object" - ? ((s = (0, mr.shallowCopy)(i.pop())), - s.blockTag == null ? [3, 2] : [4, s.blockTag]) - : [3, 3] - ); - case 1: - (a = w.sent()), (w.label = 2); - case 2: - delete s.blockTag, i.push(s), (w.label = 3); - case 3: - return t.deployTransaction == null - ? [3, 5] - : [4, t._deployed(a)]; - case 4: - w.sent(), (w.label = 5); - case 5: - return [4, Vre(t, e, i)]; - case 6: - return (c = w.sent()), [4, n.call(c, a)]; - case 7: - u = w.sent(); - try { - return ( - (h = t.interface.decodeFunctionResult(e, u)), - r && e.outputs.length === 1 && (h = h[0]), - [2, h] - ); - } catch (M) { - throw ( - (M.code === hc.Logger.errors.CALL_EXCEPTION && - ((M.address = t.address), - (M.args = i), - (M.transaction = c)), - M) - ); - } - return [2]; - } - }); - }); - }; - } - function cwr(t, e) { - return function () { - for (var r = [], n = 0; n < arguments.length; n++) r[n] = arguments[n]; - return RA(this, void 0, void 0, function () { - var i, o; - return NA(this, function (a) { - switch (a.label) { - case 0: - return ( - t.signer || - ho.throwError( - "sending a transaction requires a signer", - hc.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "sendTransaction" } - ), - t.deployTransaction == null ? [3, 2] : [4, t._deployed()] - ); - case 1: - a.sent(), (a.label = 2); - case 2: - return [4, Vre(t, e, r)]; - case 3: - return (i = a.sent()), [4, t.signer.sendTransaction(i)]; - case 4: - return (o = a.sent()), slt(t, o), [2, o]; - } - }); - }); - }; - } - function ilt(t, e, r) { - return e.constant ? ult(t, e, r) : cwr(t, e); - } - function clt(t) { - return t.address && (t.topics == null || t.topics.length === 0) - ? "*" - : (t.address || "*") + - "@" + - (t.topics - ? t.topics - .map(function (e) { - return Array.isArray(e) ? e.join("|") : e; - }) - .join(":") - : ""); - } - var JU = (function () { - function t(e, r) { - (0, mr.defineReadOnly)(this, "tag", e), - (0, mr.defineReadOnly)(this, "filter", r), - (this._listeners = []); - } - return ( - (t.prototype.addListener = function (e, r) { - this._listeners.push({ listener: e, once: r }); - }), - (t.prototype.removeListener = function (e) { - var r = !1; - this._listeners = this._listeners.filter(function (n) { - return r || n.listener !== e ? !0 : ((r = !0), !1); - }); - }), - (t.prototype.removeAllListeners = function () { - this._listeners = []; - }), - (t.prototype.listeners = function () { - return this._listeners.map(function (e) { - return e.listener; - }); - }), - (t.prototype.listenerCount = function () { - return this._listeners.length; - }), - (t.prototype.run = function (e) { - var r = this, - n = this.listenerCount(); - return ( - (this._listeners = this._listeners.filter(function (i) { - var o = e.slice(); - return ( - setTimeout(function () { - i.listener.apply(r, o); - }, 0), - !i.once - ); - })), - n - ); - }), - (t.prototype.prepareEvent = function (e) {}), - (t.prototype.getEmit = function (e) { - return [e]; - }), - t - ); - })(), - lwr = (function (t) { - Hre(e, t); - function e() { - return t.call(this, "error", null) || this; - } - return e; - })(JU), - olt = (function (t) { - Hre(e, t); - function e(r, n, i, o) { - var a = this, - s = { address: r }, - c = n.getEventTopic(i); - return ( - o - ? (c !== o[0] && - ho.throwArgumentError("topic mismatch", "topics", o), - (s.topics = o.slice())) - : (s.topics = [c]), - (a = t.call(this, clt(s), s) || this), - (0, mr.defineReadOnly)(a, "address", r), - (0, mr.defineReadOnly)(a, "interface", n), - (0, mr.defineReadOnly)(a, "fragment", i), - a - ); - } - return ( - (e.prototype.prepareEvent = function (r) { - var n = this; - t.prototype.prepareEvent.call(this, r), - (r.event = this.fragment.name), - (r.eventSignature = this.fragment.format()), - (r.decode = function (i, o) { - return n.interface.decodeEventLog(n.fragment, i, o); - }); - try { - r.args = this.interface.decodeEventLog( - this.fragment, - r.data, - r.topics - ); - } catch (i) { - (r.args = null), (r.decodeError = i); - } - }), - (e.prototype.getEmit = function (r) { - var n = (0, Ure.checkResultErrors)(r.args); - if (n.length) throw n[0].error; - var i = (r.args || []).slice(); - return i.push(r), i; - }), - e - ); - })(JU), - alt = (function (t) { - Hre(e, t); - function e(r, n) { - var i = t.call(this, "*", { address: r }) || this; - return ( - (0, mr.defineReadOnly)(i, "address", r), - (0, mr.defineReadOnly)(i, "interface", n), - i - ); - } - return ( - (e.prototype.prepareEvent = function (r) { - var n = this; - t.prototype.prepareEvent.call(this, r); - try { - var i = this.interface.parseLog(r); - (r.event = i.name), - (r.eventSignature = i.signature), - (r.decode = function (o, a) { - return n.interface.decodeEventLog(i.eventFragment, o, a); - }), - (r.args = i.args); - } catch {} - }), - e - ); - })(JU), - llt = (function () { - function t(e, r, n) { - var i = this.constructor, - o = this; - (0, mr.defineReadOnly)( - this, - "interface", - (0, mr.getStatic)(i, "getInterface")(r) - ), - n == null - ? ((0, mr.defineReadOnly)(this, "provider", null), - (0, mr.defineReadOnly)(this, "signer", null)) - : zAe.Signer.isSigner(n) - ? ((0, mr.defineReadOnly)(this, "provider", n.provider || null), - (0, mr.defineReadOnly)(this, "signer", n)) - : nwr.Provider.isProvider(n) - ? ((0, mr.defineReadOnly)(this, "provider", n), - (0, mr.defineReadOnly)(this, "signer", null)) - : ho.throwArgumentError( - "invalid signer or provider", - "signerOrProvider", - n - ), - (0, mr.defineReadOnly)(this, "callStatic", {}), - (0, mr.defineReadOnly)(this, "estimateGas", {}), - (0, mr.defineReadOnly)(this, "functions", {}), - (0, mr.defineReadOnly)(this, "populateTransaction", {}), - (0, mr.defineReadOnly)(this, "filters", {}); - { - var a = {}; - Object.keys(this.interface.events).forEach(function (u) { - var h = o.interface.events[u]; - (0, mr.defineReadOnly)(o.filters, u, function () { - for (var w = [], M = 0; M < arguments.length; M++) - w[M] = arguments[M]; - return { - address: o.address, - topics: o.interface.encodeFilterTopics(h, w), - }; - }), - a[h.name] || (a[h.name] = []), - a[h.name].push(u); - }), - Object.keys(a).forEach(function (u) { - var h = a[u]; - h.length === 1 - ? (0, mr.defineReadOnly)(o.filters, u, o.filters[h[0]]) - : ho.warn( - "Duplicate definition of " + u + " (" + h.join(", ") + ")" - ); - }); - } - if ( - ((0, mr.defineReadOnly)(this, "_runningEvents", {}), - (0, mr.defineReadOnly)(this, "_wrappedEmits", {}), - e == null && - ho.throwArgumentError( - "invalid contract address or ENS name", - "addressOrName", - e - ), - (0, mr.defineReadOnly)(this, "address", e), - this.provider) - ) - (0, mr.defineReadOnly)( - this, - "resolvedAddress", - Kre(this.provider, e) - ); - else - try { - (0, mr.defineReadOnly)( - this, - "resolvedAddress", - Promise.resolve((0, GU.getAddress)(e)) - ); - } catch { - ho.throwError( - "provider is required to use ENS name as contract address", - hc.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "new Contract" } - ); - } - this.resolvedAddress.catch(function (u) {}); - var s = {}, - c = {}; - Object.keys(this.interface.functions).forEach(function (u) { - var h = o.interface.functions[u]; - if (c[u]) { - ho.warn("Duplicate ABI entry for " + JSON.stringify(u)); - return; - } - c[u] = !0; - { - var w = h.name; - s["%" + w] || (s["%" + w] = []), s["%" + w].push(u); - } - o[u] == null && (0, mr.defineReadOnly)(o, u, ilt(o, h, !0)), - o.functions[u] == null && - (0, mr.defineReadOnly)(o.functions, u, ilt(o, h, !1)), - o.callStatic[u] == null && - (0, mr.defineReadOnly)(o.callStatic, u, ult(o, h, !0)), - o.populateTransaction[u] == null && - (0, mr.defineReadOnly)(o.populateTransaction, u, swr(o, h)), - o.estimateGas[u] == null && - (0, mr.defineReadOnly)(o.estimateGas, u, uwr(o, h)); - }), - Object.keys(s).forEach(function (u) { - var h = s[u]; - if (!(h.length > 1)) { - u = u.substring(1); - var w = h[0]; - try { - o[u] == null && (0, mr.defineReadOnly)(o, u, o[w]); - } catch {} - o.functions[u] == null && - (0, mr.defineReadOnly)(o.functions, u, o.functions[w]), - o.callStatic[u] == null && - (0, mr.defineReadOnly)(o.callStatic, u, o.callStatic[w]), - o.populateTransaction[u] == null && - (0, mr.defineReadOnly)( - o.populateTransaction, - u, - o.populateTransaction[w] - ), - o.estimateGas[u] == null && - (0, mr.defineReadOnly)(o.estimateGas, u, o.estimateGas[w]); - } - }); - } - return ( - (t.getContractAddress = function (e) { - return (0, GU.getContractAddress)(e); - }), - (t.getInterface = function (e) { - return Ure.Interface.isInterface(e) ? e : new Ure.Interface(e); - }), - (t.prototype.deployed = function () { - return this._deployed(); - }), - (t.prototype._deployed = function (e) { - var r = this; - return ( - this._deployedPromise || - (this.deployTransaction - ? (this._deployedPromise = this.deployTransaction - .wait() - .then(function () { - return r; - })) - : (this._deployedPromise = this.provider - .getCode(this.address, e) - .then(function (n) { - return ( - n === "0x" && - ho.throwError( - "contract not deployed", - hc.Logger.errors.UNSUPPORTED_OPERATION, - { - contractAddress: r.address, - operation: "getDeployed", - } - ), - r - ); - }))), - this._deployedPromise - ); - }), - (t.prototype.fallback = function (e) { - var r = this; - this.signer || - ho.throwError( - "sending a transactions require a signer", - hc.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "sendTransaction(fallback)" } - ); - var n = (0, mr.shallowCopy)(e || {}); - return ( - ["from", "to"].forEach(function (i) { - n[i] != null && - ho.throwError( - "cannot override " + i, - hc.Logger.errors.UNSUPPORTED_OPERATION, - { operation: i } - ); - }), - (n.to = this.resolvedAddress), - this.deployed().then(function () { - return r.signer.sendTransaction(n); - }) - ); - }), - (t.prototype.connect = function (e) { - typeof e == "string" && (e = new zAe.VoidSigner(e, this.provider)); - var r = new this.constructor(this.address, this.interface, e); - return ( - this.deployTransaction && - (0, mr.defineReadOnly)( - r, - "deployTransaction", - this.deployTransaction - ), - r - ); - }), - (t.prototype.attach = function (e) { - return new this.constructor( - e, - this.interface, - this.signer || this.provider - ); - }), - (t.isIndexed = function (e) { - return Ure.Indexed.isIndexed(e); - }), - (t.prototype._normalizeRunningEvent = function (e) { - return this._runningEvents[e.tag] ? this._runningEvents[e.tag] : e; - }), - (t.prototype._getRunningEvent = function (e) { - if (typeof e == "string") { - if (e === "error") return this._normalizeRunningEvent(new lwr()); - if (e === "event") - return this._normalizeRunningEvent(new JU("event", null)); - if (e === "*") - return this._normalizeRunningEvent( - new alt(this.address, this.interface) - ); - var r = this.interface.getEvent(e); - return this._normalizeRunningEvent( - new olt(this.address, this.interface, r) - ); - } - if (e.topics && e.topics.length > 0) { - try { - var n = e.topics[0]; - if (typeof n != "string") throw new Error("invalid topic"); - var r = this.interface.getEvent(n); - return this._normalizeRunningEvent( - new olt(this.address, this.interface, r, e.topics) - ); - } catch {} - var i = { address: this.address, topics: e.topics }; - return this._normalizeRunningEvent(new JU(clt(i), i)); - } - return this._normalizeRunningEvent( - new alt(this.address, this.interface) - ); - }), - (t.prototype._checkRunningEvents = function (e) { - if (e.listenerCount() === 0) { - delete this._runningEvents[e.tag]; - var r = this._wrappedEmits[e.tag]; - r && - e.filter && - (this.provider.off(e.filter, r), - delete this._wrappedEmits[e.tag]); - } - }), - (t.prototype._wrapEvent = function (e, r, n) { - var i = this, - o = (0, mr.deepCopy)(r); - return ( - (o.removeListener = function () { - !n || (e.removeListener(n), i._checkRunningEvents(e)); - }), - (o.getBlock = function () { - return i.provider.getBlock(r.blockHash); - }), - (o.getTransaction = function () { - return i.provider.getTransaction(r.transactionHash); - }), - (o.getTransactionReceipt = function () { - return i.provider.getTransactionReceipt(r.transactionHash); - }), - e.prepareEvent(o), - o - ); - }), - (t.prototype._addEventListener = function (e, r, n) { - var i = this; - if ( - (this.provider || - ho.throwError( - "events require a provider or a signer with a provider", - hc.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "once" } - ), - e.addListener(r, n), - (this._runningEvents[e.tag] = e), - !this._wrappedEmits[e.tag]) - ) { - var o = function (a) { - var s = i._wrapEvent(e, a, r); - if (s.decodeError == null) - try { - var c = e.getEmit(s); - i.emit.apply(i, rwr([e.filter], c, !1)); - } catch (u) { - s.decodeError = u.error; - } - e.filter != null && i.emit("event", s), - s.decodeError != null && i.emit("error", s.decodeError, s); - }; - (this._wrappedEmits[e.tag] = o), - e.filter != null && this.provider.on(e.filter, o); - } - }), - (t.prototype.queryFilter = function (e, r, n) { - var i = this, - o = this._getRunningEvent(e), - a = (0, mr.shallowCopy)(o.filter); - return ( - typeof r == "string" && (0, i6.isHexString)(r, 32) - ? (n != null && - ho.throwArgumentError( - "cannot specify toBlock with blockhash", - "toBlock", - n - ), - (a.blockHash = r)) - : ((a.fromBlock = r ?? 0), (a.toBlock = n ?? "latest")), - this.provider.getLogs(a).then(function (s) { - return s.map(function (c) { - return i._wrapEvent(o, c, null); - }); - }) - ); - }), - (t.prototype.on = function (e, r) { - return ( - this._addEventListener(this._getRunningEvent(e), r, !1), this - ); - }), - (t.prototype.once = function (e, r) { - return ( - this._addEventListener(this._getRunningEvent(e), r, !0), this - ); - }), - (t.prototype.emit = function (e) { - for (var r = [], n = 1; n < arguments.length; n++) - r[n - 1] = arguments[n]; - if (!this.provider) return !1; - var i = this._getRunningEvent(e), - o = i.run(r) > 0; - return this._checkRunningEvents(i), o; - }), - (t.prototype.listenerCount = function (e) { - var r = this; - return this.provider - ? e == null - ? Object.keys(this._runningEvents).reduce(function (n, i) { - return n + r._runningEvents[i].listenerCount(); - }, 0) - : this._getRunningEvent(e).listenerCount() - : 0; - }), - (t.prototype.listeners = function (e) { - if (!this.provider) return []; - if (e == null) { - var r = []; - for (var n in this._runningEvents) - this._runningEvents[n].listeners().forEach(function (i) { - r.push(i); - }); - return r; - } - return this._getRunningEvent(e).listeners(); - }), - (t.prototype.removeAllListeners = function (e) { - if (!this.provider) return this; - if (e == null) { - for (var r in this._runningEvents) { - var n = this._runningEvents[r]; - n.removeAllListeners(), this._checkRunningEvents(n); - } - return this; - } - var i = this._getRunningEvent(e); - return i.removeAllListeners(), this._checkRunningEvents(i), this; - }), - (t.prototype.off = function (e, r) { - if (!this.provider) return this; - var n = this._getRunningEvent(e); - return n.removeListener(r), this._checkRunningEvents(n), this; - }), - (t.prototype.removeListener = function (e, r) { - return this.off(e, r); - }), - t - ); - })(); - rl.BaseContract = llt; - var jAe = (function (t) { - Hre(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return e; - })(llt); - rl.Contract = jAe; - var fwr = (function () { - function t(e, r, n) { - var i = this.constructor, - o = null; - typeof r == "string" - ? (o = r) - : (0, i6.isBytes)(r) - ? (o = (0, i6.hexlify)(r)) - : r && typeof r.object == "string" - ? (o = r.object) - : (o = "!"), - o.substring(0, 2) !== "0x" && (o = "0x" + o), - (!(0, i6.isHexString)(o) || o.length % 2) && - ho.throwArgumentError("invalid bytecode", "bytecode", r), - n && - !zAe.Signer.isSigner(n) && - ho.throwArgumentError("invalid signer", "signer", n), - (0, mr.defineReadOnly)(this, "bytecode", o), - (0, mr.defineReadOnly)( - this, - "interface", - (0, mr.getStatic)(i, "getInterface")(e) - ), - (0, mr.defineReadOnly)(this, "signer", n || null); - } - return ( - (t.prototype.getDeployTransaction = function () { - for (var e = [], r = 0; r < arguments.length; r++) - e[r] = arguments[r]; - var n = {}; - if ( - e.length === this.interface.deploy.inputs.length + 1 && - typeof e[e.length - 1] == "object" - ) { - n = (0, mr.shallowCopy)(e.pop()); - for (var i in n) - if (!awr[i]) throw new Error("unknown transaction override " + i); - } - if ( - (["data", "from", "to"].forEach(function (a) { - n[a] != null && - ho.throwError( - "cannot override " + a, - hc.Logger.errors.UNSUPPORTED_OPERATION, - { operation: a } - ); - }), - n.value) - ) { - var o = CA.BigNumber.from(n.value); - !o.isZero() && - !this.interface.deploy.payable && - ho.throwError( - "non-payable constructor cannot override value", - hc.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "overrides.value", value: n.value } - ); - } - return ( - ho.checkArgumentCount( - e.length, - this.interface.deploy.inputs.length, - " in Contract constructor" - ), - (n.data = (0, i6.hexlify)( - (0, i6.concat)([this.bytecode, this.interface.encodeDeploy(e)]) - )), - n - ); - }), - (t.prototype.deploy = function () { - for (var e = [], r = 0; r < arguments.length; r++) - e[r] = arguments[r]; - return RA(this, void 0, void 0, function () { - var n, i, o, a, s, c; - return NA(this, function (u) { - switch (u.label) { - case 0: - return ( - (n = {}), - e.length === this.interface.deploy.inputs.length + 1 && - (n = e.pop()), - ho.checkArgumentCount( - e.length, - this.interface.deploy.inputs.length, - " in Contract constructor" - ), - [4, WU(this.signer, e, this.interface.deploy.inputs)] - ); - case 1: - return ( - (i = u.sent()), - i.push(n), - (o = this.getDeployTransaction.apply(this, i)), - [4, this.signer.sendTransaction(o)] - ); - case 2: - return ( - (a = u.sent()), - (s = (0, mr.getStatic)( - this.constructor, - "getContractAddress" - )(a)), - (c = (0, mr.getStatic)(this.constructor, "getContract")( - s, - this.interface, - this.signer - )), - slt(c, a), - (0, mr.defineReadOnly)(c, "deployTransaction", a), - [2, c] - ); - } - }); - }); - }), - (t.prototype.attach = function (e) { - return this.constructor.getContract(e, this.interface, this.signer); - }), - (t.prototype.connect = function (e) { - return new this.constructor(this.interface, this.bytecode, e); - }), - (t.fromSolidity = function (e, r) { - e == null && - ho.throwError( - "missing compiler output", - hc.Logger.errors.MISSING_ARGUMENT, - { argument: "compilerOutput" } - ), - typeof e == "string" && (e = JSON.parse(e)); - var n = e.abi, - i = null; - return ( - e.bytecode - ? (i = e.bytecode) - : e.evm && e.evm.bytecode && (i = e.evm.bytecode), - new this(n, i, r) - ); - }), - (t.getInterface = function (e) { - return jAe.getInterface(e); - }), - (t.getContractAddress = function (e) { - return (0, GU.getContractAddress)(e); - }), - (t.getContract = function (e, r, n) { - return new jAe(e, r, n); - }), - t - ); - })(); - rl.ContractFactory = fwr; - }); - var jR = I((DA) => { - "use strict"; - m(); - g(); - Object.defineProperty(DA, "__esModule", { value: !0 }); - DA.Base58 = DA.Base32 = DA.BaseX = void 0; - var flt = Ar(), - Wre = $r(), - KAe = (function () { - function t(e) { - (0, Wre.defineReadOnly)(this, "alphabet", e), - (0, Wre.defineReadOnly)(this, "base", e.length), - (0, Wre.defineReadOnly)(this, "_alphabetMap", {}), - (0, Wre.defineReadOnly)(this, "_leader", e.charAt(0)); - for (var r = 0; r < e.length; r++) this._alphabetMap[e.charAt(r)] = r; - } - return ( - (t.prototype.encode = function (e) { - var r = (0, flt.arrayify)(e); - if (r.length === 0) return ""; - for (var n = [0], i = 0; i < r.length; ++i) { - for (var o = r[i], a = 0; a < n.length; ++a) - (o += n[a] << 8), - (n[a] = o % this.base), - (o = (o / this.base) | 0); - for (; o > 0; ) n.push(o % this.base), (o = (o / this.base) | 0); - } - for (var s = "", c = 0; r[c] === 0 && c < r.length - 1; ++c) - s += this._leader; - for (var u = n.length - 1; u >= 0; --u) s += this.alphabet[n[u]]; - return s; - }), - (t.prototype.decode = function (e) { - if (typeof e != "string") throw new TypeError("Expected String"); - var r = []; - if (e.length === 0) return new Uint8Array(r); - r.push(0); - for (var n = 0; n < e.length; n++) { - var i = this._alphabetMap[e[n]]; - if (i === void 0) - throw new Error("Non-base" + this.base + " character"); - for (var o = i, a = 0; a < r.length; ++a) - (o += r[a] * this.base), (r[a] = o & 255), (o >>= 8); - for (; o > 0; ) r.push(o & 255), (o >>= 8); - } - for (var s = 0; e[s] === this._leader && s < e.length - 1; ++s) - r.push(0); - return (0, flt.arrayify)(new Uint8Array(r.reverse())); - }), - t - ); - })(); - DA.BaseX = KAe; - var dwr = new KAe("abcdefghijklmnopqrstuvwxyz234567"); - DA.Base32 = dwr; - var hwr = new KAe( - "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz" - ); - DA.Base58 = hwr; - }); - var HAe = I(($U) => { - "use strict"; - m(); - g(); - Object.defineProperty($U, "__esModule", { value: !0 }); - $U.SupportedAlgorithm = void 0; - var pwr; - (function (t) { - (t.sha256 = "sha256"), (t.sha512 = "sha512"); - })((pwr = $U.SupportedAlgorithm || ($U.SupportedAlgorithm = {}))); - }); - var dlt = I((Gre) => { - "use strict"; - m(); - g(); - Object.defineProperty(Gre, "__esModule", { value: !0 }); - Gre.version = void 0; - Gre.version = "sha2/5.7.0"; - }); - var plt = I((Fy) => { - "use strict"; - m(); - g(); - var ywr = - (Fy && Fy.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Fy, "__esModule", { value: !0 }); - Fy.computeHmac = Fy.sha512 = Fy.sha256 = Fy.ripemd160 = void 0; - var ZU = ywr(jq()), - XU = Ar(), - mwr = HAe(), - hlt = rr(), - gwr = dlt(), - vwr = new hlt.Logger(gwr.version); - function bwr(t) { - return ( - "0x" + - ZU.default - .ripemd160() - .update((0, XU.arrayify)(t)) - .digest("hex") - ); - } - Fy.ripemd160 = bwr; - function wwr(t) { - return ( - "0x" + - ZU.default - .sha256() - .update((0, XU.arrayify)(t)) - .digest("hex") - ); - } - Fy.sha256 = wwr; - function _wr(t) { - return ( - "0x" + - ZU.default - .sha512() - .update((0, XU.arrayify)(t)) - .digest("hex") - ); - } - Fy.sha512 = _wr; - function xwr(t, e, r) { - return ( - mwr.SupportedAlgorithm[t] || - vwr.throwError( - "unsupported algorithm " + t, - hlt.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "hmac", algorithm: t } - ), - "0x" + - ZU.default - .hmac(ZU.default[t], (0, XU.arrayify)(e)) - .update((0, XU.arrayify)(r)) - .digest("hex") - ); - } - Fy.computeHmac = xwr; - }); - var pb = I((Ly) => { - "use strict"; - m(); - g(); - Object.defineProperty(Ly, "__esModule", { value: !0 }); - Ly.SupportedAlgorithm = - Ly.sha512 = - Ly.sha256 = - Ly.ripemd160 = - Ly.computeHmac = - void 0; - var Jre = plt(); - Object.defineProperty(Ly, "computeHmac", { - enumerable: !0, - get: function () { - return Jre.computeHmac; - }, - }); - Object.defineProperty(Ly, "ripemd160", { - enumerable: !0, - get: function () { - return Jre.ripemd160; - }, - }); - Object.defineProperty(Ly, "sha256", { - enumerable: !0, - get: function () { - return Jre.sha256; - }, - }); - Object.defineProperty(Ly, "sha512", { - enumerable: !0, - get: function () { - return Jre.sha512; - }, - }); - var Swr = HAe(); - Object.defineProperty(Ly, "SupportedAlgorithm", { - enumerable: !0, - get: function () { - return Swr.SupportedAlgorithm; - }, - }); - }); - var mlt = I(($re) => { - "use strict"; - m(); - g(); - Object.defineProperty($re, "__esModule", { value: !0 }); - $re.pbkdf2 = void 0; - var UR = Ar(), - ylt = pb(); - function Awr(t, e, r, n, i) { - (t = (0, UR.arrayify)(t)), (e = (0, UR.arrayify)(e)); - var o, - a = 1, - s = new Uint8Array(n), - c = new Uint8Array(e.length + 4); - c.set(e); - for (var u, h, w = 1; w <= a; w++) { - (c[e.length] = (w >> 24) & 255), - (c[e.length + 1] = (w >> 16) & 255), - (c[e.length + 2] = (w >> 8) & 255), - (c[e.length + 3] = w & 255); - var M = (0, UR.arrayify)((0, ylt.computeHmac)(i, t, c)); - o || - ((o = M.length), - (h = new Uint8Array(o)), - (a = Math.ceil(n / o)), - (u = n - (a - 1) * o)), - h.set(M); - for (var k = 1; k < r; k++) { - M = (0, UR.arrayify)((0, ylt.computeHmac)(i, t, M)); - for (var O = 0; O < o; O++) h[O] ^= M[O]; - } - var D = (w - 1) * o, - F = w === a ? u : o; - s.set((0, UR.arrayify)(h).slice(0, F), D); - } - return (0, UR.hexlify)(s); - } - $re.pbkdf2 = Awr; - }); - var Xre = I((Zre) => { - "use strict"; - m(); - g(); - Object.defineProperty(Zre, "__esModule", { value: !0 }); - Zre.pbkdf2 = void 0; - var Ewr = mlt(); - Object.defineProperty(Zre, "pbkdf2", { - enumerable: !0, - get: function () { - return Ewr.pbkdf2; - }, - }); - }); - var glt = I((Yre) => { - "use strict"; - m(); - g(); - Object.defineProperty(Yre, "__esModule", { value: !0 }); - Yre.version = void 0; - Yre.version = "wordlists/5.7.0"; - }); - var yb = I((o6) => { - "use strict"; - m(); - g(); - Object.defineProperty(o6, "__esModule", { value: !0 }); - o6.Wordlist = o6.logger = void 0; - var Mwr = !1, - Twr = db(), - vlt = $r(), - kwr = rr(), - Pwr = glt(); - o6.logger = new kwr.Logger(Pwr.version); - var Owr = (function () { - function t(e) { - var r = this.constructor; - o6.logger.checkAbstract(r, t), - (0, vlt.defineReadOnly)(this, "locale", e); - } - return ( - (t.prototype.split = function (e) { - return e.toLowerCase().split(/ +/g); - }), - (t.prototype.join = function (e) { - return e.join(" "); - }), - (t.check = function (e) { - for (var r = [], n = 0; n < 2048; n++) { - var i = e.getWord(n); - if (n !== e.getWordIndex(i)) return "0x"; - r.push(i); - } - return (0, Twr.id)( - r.join(` -`) + - ` -` - ); - }), - (t.register = function (e, r) { - if ((r || (r = e.locale), Mwr)) - try { - var n = window; - n._ethers && - n._ethers.wordlists && - (n._ethers.wordlists[r] || - (0, vlt.defineReadOnly)(n._ethers.wordlists, r, e)); - } catch {} - }), - t - ); - })(); - o6.Wordlist = Owr; - }); - var _lt = I((KR) => { - "use strict"; - m(); - g(); - var Bwr = - (KR && KR.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(KR, "__esModule", { value: !0 }); - KR.langCz = void 0; - var VAe = yb(), - Iwr = - "AbdikaceAbecedaAdresaAgreseAkceAktovkaAlejAlkoholAmputaceAnanasAndulkaAnekdotaAnketaAntikaAnulovatArchaAroganceAsfaltAsistentAspiraceAstmaAstronomAtlasAtletikaAtolAutobusAzylBabkaBachorBacilBaculkaBadatelBagetaBagrBahnoBakterieBaladaBaletkaBalkonBalonekBalvanBalzaBambusBankomatBarbarBaretBarmanBarokoBarvaBaterkaBatohBavlnaBazalkaBazilikaBazukaBednaBeranBesedaBestieBetonBezinkaBezmocBeztakBicyklBidloBiftekBikinyBilanceBiografBiologBitvaBizonBlahobytBlatouchBlechaBleduleBleskBlikatBliznaBlokovatBlouditBludBobekBobrBodlinaBodnoutBohatostBojkotBojovatBokorysBolestBorecBoroviceBotaBoubelBouchatBoudaBouleBouratBoxerBradavkaBramboraBrankaBratrBreptaBriketaBrkoBrlohBronzBroskevBrunetkaBrusinkaBrzdaBrzyBublinaBubnovatBuchtaBuditelBudkaBudovaBufetBujarostBukviceBuldokBulvaBundaBunkrBurzaButikBuvolBuzolaBydletBylinaBytovkaBzukotCapartCarevnaCedrCeduleCejchCejnCelaCelerCelkemCelniceCeninaCennostCenovkaCentrumCenzorCestopisCetkaChalupaChapadloCharitaChataChechtatChemieChichotChirurgChladChlebaChlubitChmelChmuraChobotChocholChodbaCholeraChomoutChopitChorobaChovChrapotChrlitChrtChrupChtivostChudinaChutnatChvatChvilkaChvostChybaChystatChytitCibuleCigaretaCihelnaCihlaCinkotCirkusCisternaCitaceCitrusCizinecCizostClonaCokolivCouvatCtitelCtnostCudnostCuketaCukrCupotCvaknoutCvalCvikCvrkotCyklistaDalekoDarebaDatelDatumDceraDebataDechovkaDecibelDeficitDeflaceDeklDekretDemokratDepreseDerbyDeskaDetektivDikobrazDiktovatDiodaDiplomDiskDisplejDivadloDivochDlahaDlouhoDluhopisDnesDobroDobytekDocentDochutitDodnesDohledDohodaDohraDojemDojniceDokladDokolaDoktorDokumentDolarDolevaDolinaDomaDominantDomluvitDomovDonutitDopadDopisDoplnitDoposudDoprovodDopustitDorazitDorostDortDosahDoslovDostatekDosudDosytaDotazDotekDotknoutDoufatDoutnatDovozceDozaduDoznatDozorceDrahotaDrakDramatikDravecDrazeDrdolDrobnostDrogerieDrozdDrsnostDrtitDrzostDubenDuchovnoDudekDuhaDuhovkaDusitDusnoDutostDvojiceDvorecDynamitEkologEkonomieElektronElipsaEmailEmiseEmoceEmpatieEpizodaEpochaEpopejEposEsejEsenceEskortaEskymoEtiketaEuforieEvoluceExekuceExkurzeExpediceExplozeExportExtraktFackaFajfkaFakultaFanatikFantazieFarmacieFavoritFazoleFederaceFejetonFenkaFialkaFigurantFilozofFiltrFinanceFintaFixaceFjordFlanelFlirtFlotilaFondFosforFotbalFotkaFotonFrakceFreskaFrontaFukarFunkceFyzikaGalejeGarantGenetikaGeologGilotinaGlazuraGlejtGolemGolfistaGotikaGrafGramofonGranuleGrepGrilGrogGroteskaGumaHadiceHadrHalaHalenkaHanbaHanopisHarfaHarpunaHavranHebkostHejkalHejnoHejtmanHektarHelmaHematomHerecHernaHesloHezkyHistorikHladovkaHlasivkyHlavaHledatHlenHlodavecHlohHloupostHltatHlubinaHluchotaHmatHmotaHmyzHnisHnojivoHnoutHoblinaHobojHochHodinyHodlatHodnotaHodovatHojnostHokejHolinkaHolkaHolubHomoleHonitbaHonoraceHoralHordaHorizontHorkoHorlivecHormonHorninaHoroskopHorstvoHospodaHostinaHotovostHoubaHoufHoupatHouskaHovorHradbaHraniceHravostHrazdaHrbolekHrdinaHrdloHrdostHrnekHrobkaHromadaHrotHroudaHrozenHrstkaHrubostHryzatHubenostHubnoutHudbaHukotHumrHusitaHustotaHvozdHybnostHydrantHygienaHymnaHysterikIdylkaIhnedIkonaIluzeImunitaInfekceInflaceInkasoInovaceInspekceInternetInvalidaInvestorInzerceIronieJablkoJachtaJahodaJakmileJakostJalovecJantarJarmarkJaroJasanJasnoJatkaJavorJazykJedinecJedleJednatelJehlanJekotJelenJelitoJemnostJenomJepiceJeseterJevitJezdecJezeroJinakJindyJinochJiskraJistotaJitrniceJizvaJmenovatJogurtJurtaKabaretKabelKabinetKachnaKadetKadidloKahanKajakKajutaKakaoKaktusKalamitaKalhotyKalibrKalnostKameraKamkolivKamnaKanibalKanoeKantorKapalinaKapelaKapitolaKapkaKapleKapotaKaprKapustaKapybaraKaramelKarotkaKartonKasaKatalogKatedraKauceKauzaKavalecKazajkaKazetaKazivostKdekolivKdesiKedlubenKempKeramikaKinoKlacekKladivoKlamKlapotKlasikaKlaunKlecKlenbaKlepatKlesnoutKlidKlimaKlisnaKloboukKlokanKlopaKloubKlubovnaKlusatKluzkostKmenKmitatKmotrKnihaKnotKoaliceKoberecKobkaKoblihaKobylaKocourKohoutKojenecKokosKoktejlKolapsKoledaKolizeKoloKomandoKometaKomikKomnataKomoraKompasKomunitaKonatKonceptKondiceKonecKonfeseKongresKoninaKonkursKontaktKonzervaKopanecKopieKopnoutKoprovkaKorbelKorektorKormidloKoroptevKorpusKorunaKorytoKorzetKosatecKostkaKotelKotletaKotoulKoukatKoupelnaKousekKouzloKovbojKozaKozorohKrabiceKrachKrajinaKralovatKrasopisKravataKreditKrejcarKresbaKrevetaKriketKritikKrizeKrkavecKrmelecKrmivoKrocanKrokKronikaKropitKroupaKrovkaKrtekKruhadloKrupiceKrutostKrvinkaKrychleKryptaKrystalKrytKudlankaKufrKujnostKuklaKulajdaKulichKulkaKulometKulturaKunaKupodivuKurtKurzorKutilKvalitaKvasinkaKvestorKynologKyselinaKytaraKyticeKytkaKytovecKyvadloLabradorLachtanLadnostLaikLakomecLamelaLampaLanovkaLasiceLasoLasturaLatinkaLavinaLebkaLeckdyLedenLedniceLedovkaLedvinaLegendaLegieLegraceLehceLehkostLehnoutLektvarLenochodLentilkaLepenkaLepidloLetadloLetecLetmoLetokruhLevhartLevitaceLevobokLibraLichotkaLidojedLidskostLihovinaLijavecLilekLimetkaLinieLinkaLinoleumListopadLitinaLitovatLobistaLodivodLogikaLogopedLokalitaLoketLomcovatLopataLopuchLordLososLotrLoudalLouhLoukaLouskatLovecLstivostLucernaLuciferLumpLuskLustraceLviceLyraLyrikaLysinaMadamMadloMagistrMahagonMajetekMajitelMajoritaMakakMakoviceMakrelaMalbaMalinaMalovatMalviceMaminkaMandleMankoMarnostMasakrMaskotMasopustMaticeMatrikaMaturitaMazanecMazivoMazlitMazurkaMdlobaMechanikMeditaceMedovinaMelasaMelounMentolkaMetlaMetodaMetrMezeraMigraceMihnoutMihuleMikinaMikrofonMilenecMilimetrMilostMimikaMincovnaMinibarMinometMinulostMiskaMistrMixovatMladostMlhaMlhovinaMlokMlsatMluvitMnichMnohemMobilMocnostModelkaModlitbaMohylaMokroMolekulaMomentkaMonarchaMonoklMonstrumMontovatMonzunMosazMoskytMostMotivaceMotorkaMotykaMouchaMoudrostMozaikaMozekMozolMramorMravenecMrkevMrtvolaMrzetMrzutostMstitelMudrcMuflonMulatMumieMuniceMusetMutaceMuzeumMuzikantMyslivecMzdaNabouratNachytatNadaceNadbytekNadhozNadobroNadpisNahlasNahnatNahodileNahraditNaivitaNajednouNajistoNajmoutNaklonitNakonecNakrmitNalevoNamazatNamluvitNanometrNaokoNaopakNaostroNapadatNapevnoNaplnitNapnoutNaposledNaprostoNaroditNarubyNarychloNasaditNasekatNaslepoNastatNatolikNavenekNavrchNavzdoryNazvatNebeNechatNeckyNedalekoNedbatNeduhNegaceNehetNehodaNejenNejprveNeklidNelibostNemilostNemocNeochotaNeonkaNepokojNerostNervNesmyslNesouladNetvorNeuronNevinaNezvykleNicotaNijakNikamNikdyNiklNikterakNitroNoclehNohaviceNominaceNoraNorekNositelNosnostNouzeNovinyNovotaNozdraNudaNudleNugetNutitNutnostNutrieNymfaObalObarvitObavaObdivObecObehnatObejmoutObezitaObhajobaObilniceObjasnitObjektObklopitOblastOblekOblibaOblohaObludaObnosObohatitObojekOboutObrazecObrnaObrubaObrysObsahObsluhaObstaratObuvObvazObvinitObvodObvykleObyvatelObzorOcasOcelOcenitOchladitOchotaOchranaOcitnoutOdbojOdbytOdchodOdcizitOdebratOdeslatOdevzdatOdezvaOdhadceOdhoditOdjetOdjinudOdkazOdkoupitOdlivOdlukaOdmlkaOdolnostOdpadOdpisOdploutOdporOdpustitOdpykatOdrazkaOdsouditOdstupOdsunOdtokOdtudOdvahaOdvetaOdvolatOdvracetOdznakOfinaOfsajdOhlasOhniskoOhradaOhrozitOhryzekOkapOkeniceOklikaOknoOkouzlitOkovyOkrasaOkresOkrsekOkruhOkupantOkurkaOkusitOlejninaOlizovatOmakOmeletaOmezitOmladinaOmlouvatOmluvaOmylOnehdyOpakovatOpasekOperaceOpiceOpilostOpisovatOporaOpoziceOpravduOprotiOrbitalOrchestrOrgieOrliceOrlojOrtelOsadaOschnoutOsikaOsivoOslavaOslepitOslnitOslovitOsnovaOsobaOsolitOspalecOstenOstrahaOstudaOstychOsvojitOteplitOtiskOtopOtrhatOtrlostOtrokOtrubyOtvorOvanoutOvarOvesOvlivnitOvoceOxidOzdobaPachatelPacientPadouchPahorekPaktPalandaPalecPalivoPalubaPamfletPamlsekPanenkaPanikaPannaPanovatPanstvoPantoflePaprikaParketaParodiePartaParukaParybaPasekaPasivitaPastelkaPatentPatronaPavoukPaznehtPazourekPeckaPedagogPejsekPekloPelotonPenaltaPendrekPenzePeriskopPeroPestrostPetardaPeticePetrolejPevninaPexesoPianistaPihaPijavicePiklePiknikPilinaPilnostPilulkaPinzetaPipetaPisatelPistolePitevnaPivnicePivovarPlacentaPlakatPlamenPlanetaPlastikaPlatitPlavidloPlazPlechPlemenoPlentaPlesPletivoPlevelPlivatPlnitPlnoPlochaPlodinaPlombaPloutPlukPlynPobavitPobytPochodPocitPoctivecPodatPodcenitPodepsatPodhledPodivitPodkladPodmanitPodnikPodobaPodporaPodrazPodstataPodvodPodzimPoeziePohankaPohnutkaPohovorPohromaPohybPointaPojistkaPojmoutPokazitPoklesPokojPokrokPokutaPokynPolednePolibekPolknoutPolohaPolynomPomaluPominoutPomlkaPomocPomstaPomysletPonechatPonorkaPonurostPopadatPopelPopisekPoplachPoprositPopsatPopudPoradcePorcePorodPoruchaPoryvPosaditPosedPosilaPoskokPoslanecPosouditPospoluPostavaPosudekPosypPotahPotkanPotleskPotomekPotravaPotupaPotvoraPoukazPoutoPouzdroPovahaPovidlaPovlakPovozPovrchPovstatPovykPovzdechPozdravPozemekPoznatekPozorPozvatPracovatPrahoryPraktikaPralesPraotecPraporekPrasePravdaPrincipPrknoProbuditProcentoProdejProfeseProhraProjektProlomitPromilePronikatPropadProrokProsbaProtonProutekProvazPrskavkaPrstenPrudkostPrutPrvekPrvohoryPsanecPsovodPstruhPtactvoPubertaPuchPudlPukavecPuklinaPukrlePultPumpaPuncPupenPusaPusinkaPustinaPutovatPutykaPyramidaPyskPytelRacekRachotRadiaceRadniceRadonRaftRagbyRaketaRakovinaRamenoRampouchRandeRarachRaritaRasovnaRastrRatolestRazanceRazidloReagovatReakceReceptRedaktorReferentReflexRejnokReklamaRekordRekrutRektorReputaceRevizeRevmaRevolverRezervaRiskovatRizikoRobotikaRodokmenRohovkaRokleRokokoRomanetoRopovodRopuchaRorejsRosolRostlinaRotmistrRotopedRotundaRoubenkaRouchoRoupRouraRovinaRovniceRozborRozchodRozdatRozeznatRozhodceRozinkaRozjezdRozkazRozlohaRozmarRozpadRozruchRozsahRoztokRozumRozvodRubrikaRuchadloRukaviceRukopisRybaRybolovRychlostRydloRypadloRytinaRyzostSadistaSahatSakoSamecSamizdatSamotaSanitkaSardinkaSasankaSatelitSazbaSazeniceSborSchovatSebrankaSeceseSedadloSedimentSedloSehnatSejmoutSekeraSektaSekundaSekvojeSemenoSenoServisSesaditSeshoraSeskokSeslatSestraSesuvSesypatSetbaSetinaSetkatSetnoutSetrvatSeverSeznamShodaShrnoutSifonSilniceSirkaSirotekSirupSituaceSkafandrSkaliskoSkanzenSkautSkeptikSkicaSkladbaSkleniceSkloSkluzSkobaSkokanSkoroSkriptaSkrzSkupinaSkvostSkvrnaSlabikaSladidloSlaninaSlastSlavnostSledovatSlepecSlevaSlezinaSlibSlinaSlizniceSlonSloupekSlovoSluchSluhaSlunceSlupkaSlzaSmaragdSmetanaSmilstvoSmlouvaSmogSmradSmrkSmrtkaSmutekSmyslSnadSnahaSnobSobotaSochaSodovkaSokolSopkaSotvaSoubojSoucitSoudceSouhlasSouladSoumrakSoupravaSousedSoutokSouvisetSpalovnaSpasitelSpisSplavSpodekSpojenecSpoluSponzorSpornostSpoustaSprchaSpustitSrandaSrazSrdceSrnaSrnecSrovnatSrpenSrstSrubStaniceStarostaStatikaStavbaStehnoStezkaStodolaStolekStopaStornoStoupatStrachStresStrhnoutStromStrunaStudnaStupniceStvolStykSubjektSubtropySucharSudostSuknoSundatSunoutSurikataSurovinaSvahSvalstvoSvetrSvatbaSvazekSvisleSvitekSvobodaSvodidloSvorkaSvrabSykavkaSykotSynekSynovecSypatSypkostSyrovostSyselSytostTabletkaTabuleTahounTajemnoTajfunTajgaTajitTajnostTaktikaTamhleTamponTancovatTanecTankerTapetaTaveninaTazatelTechnikaTehdyTekutinaTelefonTemnotaTendenceTenistaTenorTeplotaTepnaTeprveTerapieTermoskaTextilTichoTiskopisTitulekTkadlecTkaninaTlapkaTleskatTlukotTlupaTmelToaletaTopinkaTopolTorzoTouhaToulecTradiceTraktorTrampTrasaTraverzaTrefitTrestTrezorTrhavinaTrhlinaTrochuTrojiceTroskaTroubaTrpceTrpitelTrpkostTrubecTruchlitTruhliceTrusTrvatTudyTuhnoutTuhostTundraTuristaTurnajTuzemskoTvarohTvorbaTvrdostTvrzTygrTykevUbohostUbozeUbratUbrousekUbrusUbytovnaUchoUctivostUdivitUhraditUjednatUjistitUjmoutUkazatelUklidnitUklonitUkotvitUkrojitUliceUlitaUlovitUmyvadloUnavitUniformaUniknoutUpadnoutUplatnitUplynoutUpoutatUpravitUranUrazitUsednoutUsilovatUsmrtitUsnadnitUsnoutUsouditUstlatUstrnoutUtahovatUtkatUtlumitUtonoutUtopenecUtrousitUvalitUvolnitUvozovkaUzdravitUzelUzeninaUzlinaUznatVagonValchaValounVanaVandalVanilkaVaranVarhanyVarovatVcelkuVchodVdovaVedroVegetaceVejceVelbloudVeletrhVelitelVelmocVelrybaVenkovVerandaVerzeVeselkaVeskrzeVesniceVespoduVestaVeterinaVeverkaVibraceVichrVideohraVidinaVidleVilaViniceVisetVitalitaVizeVizitkaVjezdVkladVkusVlajkaVlakVlasecVlevoVlhkostVlivVlnovkaVloupatVnucovatVnukVodaVodivostVodoznakVodstvoVojenskyVojnaVojskoVolantVolbaVolitVolnoVoskovkaVozidloVozovnaVpravoVrabecVracetVrahVrataVrbaVrcholekVrhatVrstvaVrtuleVsaditVstoupitVstupVtipVybavitVybratVychovatVydatVydraVyfotitVyhledatVyhnoutVyhoditVyhraditVyhubitVyjasnitVyjetVyjmoutVyklopitVykonatVylekatVymazatVymezitVymizetVymysletVynechatVynikatVynutitVypadatVyplatitVypravitVypustitVyrazitVyrovnatVyrvatVyslovitVysokoVystavitVysunoutVysypatVytasitVytesatVytratitVyvinoutVyvolatVyvrhelVyzdobitVyznatVzaduVzbuditVzchopitVzdorVzduchVzdychatVzestupVzhledemVzkazVzlykatVznikVzorekVzpouraVztahVztekXylofonZabratZabydletZachovatZadarmoZadusitZafoukatZahltitZahoditZahradaZahynoutZajatecZajetZajistitZaklepatZakoupitZalepitZamezitZamotatZamysletZanechatZanikatZaplatitZapojitZapsatZarazitZastavitZasunoutZatajitZatemnitZatknoutZaujmoutZavalitZaveletZavinitZavolatZavrtatZazvonitZbavitZbrusuZbudovatZbytekZdalekaZdarmaZdatnostZdivoZdobitZdrojZdvihZdymadloZeleninaZemanZeminaZeptatZezaduZezdolaZhatitZhltnoutZhlubokaZhotovitZhrubaZimaZimniceZjemnitZklamatZkoumatZkratkaZkumavkaZlatoZlehkaZlobaZlomZlostZlozvykZmapovatZmarZmatekZmijeZmizetZmocnitZmodratZmrzlinaZmutovatZnakZnalostZnamenatZnovuZobrazitZotavitZoubekZoufaleZploditZpomalitZpravaZprostitZprudkaZprvuZradaZranitZrcadloZrnitostZrnoZrovnaZrychlitZrzavostZtichaZtratitZubovinaZubrZvednoutZvenkuZveselaZvonZvratZvukovodZvyk", - YU = null; - function blt(t) { - if ( - YU == null && - ((YU = Iwr.replace(/([A-Z])/g, " $1") - .toLowerCase() - .substring(1) - .split(" ")), - VAe.Wordlist.check(t) !== - "0x25f44555f4af25b51a711136e1c7d6e50ce9f8917d39d6b1f076b2bb4d2fac1a") - ) - throw ( - ((YU = null), new Error("BIP39 Wordlist for en (English) FAILED")) - ); - } - var Cwr = (function (t) { - Bwr(e, t); - function e() { - return t.call(this, "cz") || this; - } - return ( - (e.prototype.getWord = function (r) { - return blt(this), YU[r]; - }), - (e.prototype.getWordIndex = function (r) { - return blt(this), YU.indexOf(r); - }), - e - ); - })(VAe.Wordlist), - wlt = new Cwr(); - KR.langCz = wlt; - VAe.Wordlist.register(wlt); - }); - var Alt = I((HR) => { - "use strict"; - m(); - g(); - var Rwr = - (HR && HR.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(HR, "__esModule", { value: !0 }); - HR.langEn = void 0; - var WAe = yb(), - Nwr = - "AbandonAbilityAbleAboutAboveAbsentAbsorbAbstractAbsurdAbuseAccessAccidentAccountAccuseAchieveAcidAcousticAcquireAcrossActActionActorActressActualAdaptAddAddictAddressAdjustAdmitAdultAdvanceAdviceAerobicAffairAffordAfraidAgainAgeAgentAgreeAheadAimAirAirportAisleAlarmAlbumAlcoholAlertAlienAllAlleyAllowAlmostAloneAlphaAlreadyAlsoAlterAlwaysAmateurAmazingAmongAmountAmusedAnalystAnchorAncientAngerAngleAngryAnimalAnkleAnnounceAnnualAnotherAnswerAntennaAntiqueAnxietyAnyApartApologyAppearAppleApproveAprilArchArcticAreaArenaArgueArmArmedArmorArmyAroundArrangeArrestArriveArrowArtArtefactArtistArtworkAskAspectAssaultAssetAssistAssumeAsthmaAthleteAtomAttackAttendAttitudeAttractAuctionAuditAugustAuntAuthorAutoAutumnAverageAvocadoAvoidAwakeAwareAwayAwesomeAwfulAwkwardAxisBabyBachelorBaconBadgeBagBalanceBalconyBallBambooBananaBannerBarBarelyBargainBarrelBaseBasicBasketBattleBeachBeanBeautyBecauseBecomeBeefBeforeBeginBehaveBehindBelieveBelowBeltBenchBenefitBestBetrayBetterBetweenBeyondBicycleBidBikeBindBiologyBirdBirthBitterBlackBladeBlameBlanketBlastBleakBlessBlindBloodBlossomBlouseBlueBlurBlushBoardBoatBodyBoilBombBoneBonusBookBoostBorderBoringBorrowBossBottomBounceBoxBoyBracketBrainBrandBrassBraveBreadBreezeBrickBridgeBriefBrightBringBriskBroccoliBrokenBronzeBroomBrotherBrownBrushBubbleBuddyBudgetBuffaloBuildBulbBulkBulletBundleBunkerBurdenBurgerBurstBusBusinessBusyButterBuyerBuzzCabbageCabinCableCactusCageCakeCallCalmCameraCampCanCanalCancelCandyCannonCanoeCanvasCanyonCapableCapitalCaptainCarCarbonCardCargoCarpetCarryCartCaseCashCasinoCastleCasualCatCatalogCatchCategoryCattleCaughtCauseCautionCaveCeilingCeleryCementCensusCenturyCerealCertainChairChalkChampionChangeChaosChapterChargeChaseChatCheapCheckCheeseChefCherryChestChickenChiefChildChimneyChoiceChooseChronicChuckleChunkChurnCigarCinnamonCircleCitizenCityCivilClaimClapClarifyClawClayCleanClerkCleverClickClientCliffClimbClinicClipClockClogCloseClothCloudClownClubClumpClusterClutchCoachCoastCoconutCodeCoffeeCoilCoinCollectColorColumnCombineComeComfortComicCommonCompanyConcertConductConfirmCongressConnectConsiderControlConvinceCookCoolCopperCopyCoralCoreCornCorrectCostCottonCouchCountryCoupleCourseCousinCoverCoyoteCrackCradleCraftCramCraneCrashCraterCrawlCrazyCreamCreditCreekCrewCricketCrimeCrispCriticCropCrossCrouchCrowdCrucialCruelCruiseCrumbleCrunchCrushCryCrystalCubeCultureCupCupboardCuriousCurrentCurtainCurveCushionCustomCuteCycleDadDamageDampDanceDangerDaringDashDaughterDawnDayDealDebateDebrisDecadeDecemberDecideDeclineDecorateDecreaseDeerDefenseDefineDefyDegreeDelayDeliverDemandDemiseDenialDentistDenyDepartDependDepositDepthDeputyDeriveDescribeDesertDesignDeskDespairDestroyDetailDetectDevelopDeviceDevoteDiagramDialDiamondDiaryDiceDieselDietDifferDigitalDignityDilemmaDinnerDinosaurDirectDirtDisagreeDiscoverDiseaseDishDismissDisorderDisplayDistanceDivertDivideDivorceDizzyDoctorDocumentDogDollDolphinDomainDonateDonkeyDonorDoorDoseDoubleDoveDraftDragonDramaDrasticDrawDreamDressDriftDrillDrinkDripDriveDropDrumDryDuckDumbDuneDuringDustDutchDutyDwarfDynamicEagerEagleEarlyEarnEarthEasilyEastEasyEchoEcologyEconomyEdgeEditEducateEffortEggEightEitherElbowElderElectricElegantElementElephantElevatorEliteElseEmbarkEmbodyEmbraceEmergeEmotionEmployEmpowerEmptyEnableEnactEndEndlessEndorseEnemyEnergyEnforceEngageEngineEnhanceEnjoyEnlistEnoughEnrichEnrollEnsureEnterEntireEntryEnvelopeEpisodeEqualEquipEraEraseErodeErosionErrorEruptEscapeEssayEssenceEstateEternalEthicsEvidenceEvilEvokeEvolveExactExampleExcessExchangeExciteExcludeExcuseExecuteExerciseExhaustExhibitExileExistExitExoticExpandExpectExpireExplainExposeExpressExtendExtraEyeEyebrowFabricFaceFacultyFadeFaintFaithFallFalseFameFamilyFamousFanFancyFantasyFarmFashionFatFatalFatherFatigueFaultFavoriteFeatureFebruaryFederalFeeFeedFeelFemaleFenceFestivalFetchFeverFewFiberFictionFieldFigureFileFilmFilterFinalFindFineFingerFinishFireFirmFirstFiscalFishFitFitnessFixFlagFlameFlashFlatFlavorFleeFlightFlipFloatFlockFloorFlowerFluidFlushFlyFoamFocusFogFoilFoldFollowFoodFootForceForestForgetForkFortuneForumForwardFossilFosterFoundFoxFragileFrameFrequentFreshFriendFringeFrogFrontFrostFrownFrozenFruitFuelFunFunnyFurnaceFuryFutureGadgetGainGalaxyGalleryGameGapGarageGarbageGardenGarlicGarmentGasGaspGateGatherGaugeGazeGeneralGeniusGenreGentleGenuineGestureGhostGiantGiftGiggleGingerGiraffeGirlGiveGladGlanceGlareGlassGlideGlimpseGlobeGloomGloryGloveGlowGlueGoatGoddessGoldGoodGooseGorillaGospelGossipGovernGownGrabGraceGrainGrantGrapeGrassGravityGreatGreenGridGriefGritGroceryGroupGrowGruntGuardGuessGuideGuiltGuitarGunGymHabitHairHalfHammerHamsterHandHappyHarborHardHarshHarvestHatHaveHawkHazardHeadHealthHeartHeavyHedgehogHeightHelloHelmetHelpHenHeroHiddenHighHillHintHipHireHistoryHobbyHockeyHoldHoleHolidayHollowHomeHoneyHoodHopeHornHorrorHorseHospitalHostHotelHourHoverHubHugeHumanHumbleHumorHundredHungryHuntHurdleHurryHurtHusbandHybridIceIconIdeaIdentifyIdleIgnoreIllIllegalIllnessImageImitateImmenseImmuneImpactImposeImproveImpulseInchIncludeIncomeIncreaseIndexIndicateIndoorIndustryInfantInflictInformInhaleInheritInitialInjectInjuryInmateInnerInnocentInputInquiryInsaneInsectInsideInspireInstallIntactInterestIntoInvestInviteInvolveIronIslandIsolateIssueItemIvoryJacketJaguarJarJazzJealousJeansJellyJewelJobJoinJokeJourneyJoyJudgeJuiceJumpJungleJuniorJunkJustKangarooKeenKeepKetchupKeyKickKidKidneyKindKingdomKissKitKitchenKiteKittenKiwiKneeKnifeKnockKnowLabLabelLaborLadderLadyLakeLampLanguageLaptopLargeLaterLatinLaughLaundryLavaLawLawnLawsuitLayerLazyLeaderLeafLearnLeaveLectureLeftLegLegalLegendLeisureLemonLendLengthLensLeopardLessonLetterLevelLiarLibertyLibraryLicenseLifeLiftLightLikeLimbLimitLinkLionLiquidListLittleLiveLizardLoadLoanLobsterLocalLockLogicLonelyLongLoopLotteryLoudLoungeLoveLoyalLuckyLuggageLumberLunarLunchLuxuryLyricsMachineMadMagicMagnetMaidMailMainMajorMakeMammalManManageMandateMangoMansionManualMapleMarbleMarchMarginMarineMarketMarriageMaskMassMasterMatchMaterialMathMatrixMatterMaximumMazeMeadowMeanMeasureMeatMechanicMedalMediaMelodyMeltMemberMemoryMentionMenuMercyMergeMeritMerryMeshMessageMetalMethodMiddleMidnightMilkMillionMimicMindMinimumMinorMinuteMiracleMirrorMiseryMissMistakeMixMixedMixtureMobileModelModifyMomMomentMonitorMonkeyMonsterMonthMoonMoralMoreMorningMosquitoMotherMotionMotorMountainMouseMoveMovieMuchMuffinMuleMultiplyMuscleMuseumMushroomMusicMustMutualMyselfMysteryMythNaiveNameNapkinNarrowNastyNationNatureNearNeckNeedNegativeNeglectNeitherNephewNerveNestNetNetworkNeutralNeverNewsNextNiceNightNobleNoiseNomineeNoodleNormalNorthNoseNotableNoteNothingNoticeNovelNowNuclearNumberNurseNutOakObeyObjectObligeObscureObserveObtainObviousOccurOceanOctoberOdorOffOfferOfficeOftenOilOkayOldOliveOlympicOmitOnceOneOnionOnlineOnlyOpenOperaOpinionOpposeOptionOrangeOrbitOrchardOrderOrdinaryOrganOrientOriginalOrphanOstrichOtherOutdoorOuterOutputOutsideOvalOvenOverOwnOwnerOxygenOysterOzonePactPaddlePagePairPalacePalmPandaPanelPanicPantherPaperParadeParentParkParrotPartyPassPatchPathPatientPatrolPatternPausePavePaymentPeacePeanutPearPeasantPelicanPenPenaltyPencilPeoplePepperPerfectPermitPersonPetPhonePhotoPhrasePhysicalPianoPicnicPicturePiecePigPigeonPillPilotPinkPioneerPipePistolPitchPizzaPlacePlanetPlasticPlatePlayPleasePledgePluckPlugPlungePoemPoetPointPolarPolePolicePondPonyPoolPopularPortionPositionPossiblePostPotatoPotteryPovertyPowderPowerPracticePraisePredictPreferPreparePresentPrettyPreventPricePridePrimaryPrintPriorityPrisonPrivatePrizeProblemProcessProduceProfitProgramProjectPromoteProofPropertyProsperProtectProudProvidePublicPuddingPullPulpPulsePumpkinPunchPupilPuppyPurchasePurityPurposePursePushPutPuzzlePyramidQualityQuantumQuarterQuestionQuickQuitQuizQuoteRabbitRaccoonRaceRackRadarRadioRailRainRaiseRallyRampRanchRandomRangeRapidRareRateRatherRavenRawRazorReadyRealReasonRebelRebuildRecallReceiveRecipeRecordRecycleReduceReflectReformRefuseRegionRegretRegularRejectRelaxReleaseReliefRelyRemainRememberRemindRemoveRenderRenewRentReopenRepairRepeatReplaceReportRequireRescueResembleResistResourceResponseResultRetireRetreatReturnReunionRevealReviewRewardRhythmRibRibbonRiceRichRideRidgeRifleRightRigidRingRiotRippleRiskRitualRivalRiverRoadRoastRobotRobustRocketRomanceRoofRookieRoomRoseRotateRoughRoundRouteRoyalRubberRudeRugRuleRunRunwayRuralSadSaddleSadnessSafeSailSaladSalmonSalonSaltSaluteSameSampleSandSatisfySatoshiSauceSausageSaveSayScaleScanScareScatterSceneSchemeSchoolScienceScissorsScorpionScoutScrapScreenScriptScrubSeaSearchSeasonSeatSecondSecretSectionSecuritySeedSeekSegmentSelectSellSeminarSeniorSenseSentenceSeriesServiceSessionSettleSetupSevenShadowShaftShallowShareShedShellSheriffShieldShiftShineShipShiverShockShoeShootShopShortShoulderShoveShrimpShrugShuffleShySiblingSickSideSiegeSightSignSilentSilkSillySilverSimilarSimpleSinceSingSirenSisterSituateSixSizeSkateSketchSkiSkillSkinSkirtSkullSlabSlamSleepSlenderSliceSlideSlightSlimSloganSlotSlowSlushSmallSmartSmileSmokeSmoothSnackSnakeSnapSniffSnowSoapSoccerSocialSockSodaSoftSolarSoldierSolidSolutionSolveSomeoneSongSoonSorrySortSoulSoundSoupSourceSouthSpaceSpareSpatialSpawnSpeakSpecialSpeedSpellSpendSphereSpiceSpiderSpikeSpinSpiritSplitSpoilSponsorSpoonSportSpotSpraySpreadSpringSpySquareSqueezeSquirrelStableStadiumStaffStageStairsStampStandStartStateStaySteakSteelStemStepStereoStickStillStingStockStomachStoneStoolStoryStoveStrategyStreetStrikeStrongStruggleStudentStuffStumbleStyleSubjectSubmitSubwaySuccessSuchSuddenSufferSugarSuggestSuitSummerSunSunnySunsetSuperSupplySupremeSureSurfaceSurgeSurpriseSurroundSurveySuspectSustainSwallowSwampSwapSwarmSwearSweetSwiftSwimSwingSwitchSwordSymbolSymptomSyrupSystemTableTackleTagTailTalentTalkTankTapeTargetTaskTasteTattooTaxiTeachTeamTellTenTenantTennisTentTermTestTextThankThatThemeThenTheoryThereTheyThingThisThoughtThreeThriveThrowThumbThunderTicketTideTigerTiltTimberTimeTinyTipTiredTissueTitleToastTobaccoTodayToddlerToeTogetherToiletTokenTomatoTomorrowToneTongueTonightToolToothTopTopicToppleTorchTornadoTortoiseTossTotalTouristTowardTowerTownToyTrackTradeTrafficTragicTrainTransferTrapTrashTravelTrayTreatTreeTrendTrialTribeTrickTriggerTrimTripTrophyTroubleTruckTrueTrulyTrumpetTrustTruthTryTubeTuitionTumbleTunaTunnelTurkeyTurnTurtleTwelveTwentyTwiceTwinTwistTwoTypeTypicalUglyUmbrellaUnableUnawareUncleUncoverUnderUndoUnfairUnfoldUnhappyUniformUniqueUnitUniverseUnknownUnlockUntilUnusualUnveilUpdateUpgradeUpholdUponUpperUpsetUrbanUrgeUsageUseUsedUsefulUselessUsualUtilityVacantVacuumVagueValidValleyValveVanVanishVaporVariousVastVaultVehicleVelvetVendorVentureVenueVerbVerifyVersionVeryVesselVeteranViableVibrantViciousVictoryVideoViewVillageVintageViolinVirtualVirusVisaVisitVisualVitalVividVocalVoiceVoidVolcanoVolumeVoteVoyageWageWagonWaitWalkWallWalnutWantWarfareWarmWarriorWashWaspWasteWaterWaveWayWealthWeaponWearWeaselWeatherWebWeddingWeekendWeirdWelcomeWestWetWhaleWhatWheatWheelWhenWhereWhipWhisperWideWidthWifeWildWillWinWindowWineWingWinkWinnerWinterWireWisdomWiseWishWitnessWolfWomanWonderWoodWoolWordWorkWorldWorryWorthWrapWreckWrestleWristWriteWrongYardYearYellowYouYoungYouthZebraZeroZoneZoo", - QU = null; - function xlt(t) { - if ( - QU == null && - ((QU = Nwr.replace(/([A-Z])/g, " $1") - .toLowerCase() - .substring(1) - .split(" ")), - WAe.Wordlist.check(t) !== - "0x3c8acc1e7b08d8e76f9fda015ef48dc8c710a73cb7e0f77b2c18a9b5a7adde60") - ) - throw ( - ((QU = null), new Error("BIP39 Wordlist for en (English) FAILED")) - ); - } - var Dwr = (function (t) { - Rwr(e, t); - function e() { - return t.call(this, "en") || this; - } - return ( - (e.prototype.getWord = function (r) { - return xlt(this), QU[r]; - }), - (e.prototype.getWordIndex = function (r) { - return xlt(this), QU.indexOf(r); - }), - e - ); - })(WAe.Wordlist), - Slt = new Dwr(); - HR.langEn = Slt; - WAe.Wordlist.register(Slt); - }); - var Plt = I((VR) => { - "use strict"; - m(); - g(); - var Fwr = - (VR && VR.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(VR, "__esModule", { value: !0 }); - VR.langEs = void 0; - var Qre = Eo(), - ene = yb(), - Lwr = - "A/bacoAbdomenAbejaAbiertoAbogadoAbonoAbortoAbrazoAbrirAbueloAbusoAcabarAcademiaAccesoAccio/nAceiteAcelgaAcentoAceptarA/cidoAclararAcne/AcogerAcosoActivoActoActrizActuarAcudirAcuerdoAcusarAdictoAdmitirAdoptarAdornoAduanaAdultoAe/reoAfectarAficio/nAfinarAfirmarA/gilAgitarAgoni/aAgostoAgotarAgregarAgrioAguaAgudoA/guilaAgujaAhogoAhorroAireAislarAjedrezAjenoAjusteAlacra/nAlambreAlarmaAlbaA/lbumAlcaldeAldeaAlegreAlejarAlertaAletaAlfilerAlgaAlgodo/nAliadoAlientoAlivioAlmaAlmejaAlmi/barAltarAltezaAltivoAltoAlturaAlumnoAlzarAmableAmanteAmapolaAmargoAmasarA/mbarA/mbitoAmenoAmigoAmistadAmorAmparoAmplioAnchoAncianoAnclaAndarAnde/nAnemiaA/nguloAnilloA/nimoAni/sAnotarAntenaAntiguoAntojoAnualAnularAnuncioA~adirA~ejoA~oApagarAparatoApetitoApioAplicarApodoAporteApoyoAprenderAprobarApuestaApuroAradoAra~aArarA/rbitroA/rbolArbustoArchivoArcoArderArdillaArduoA/reaA/ridoAriesArmoni/aArne/sAromaArpaArpo/nArregloArrozArrugaArteArtistaAsaAsadoAsaltoAscensoAsegurarAseoAsesorAsientoAsiloAsistirAsnoAsombroA/speroAstillaAstroAstutoAsumirAsuntoAtajoAtaqueAtarAtentoAteoA/ticoAtletaA/tomoAtraerAtrozAtu/nAudazAudioAugeAulaAumentoAusenteAutorAvalAvanceAvaroAveAvellanaAvenaAvestruzAvio/nAvisoAyerAyudaAyunoAzafra/nAzarAzoteAzu/carAzufreAzulBabaBaborBacheBahi/aBaileBajarBalanzaBalco/nBaldeBambu/BancoBandaBa~oBarbaBarcoBarnizBarroBa/sculaBasto/nBasuraBatallaBateri/aBatirBatutaBau/lBazarBebe/BebidaBelloBesarBesoBestiaBichoBienBingoBlancoBloqueBlusaBoaBobinaBoboBocaBocinaBodaBodegaBoinaBolaBoleroBolsaBombaBondadBonitoBonoBonsa/iBordeBorrarBosqueBoteBoti/nBo/vedaBozalBravoBrazoBrechaBreveBrilloBrincoBrisaBrocaBromaBronceBroteBrujaBruscoBrutoBuceoBucleBuenoBueyBufandaBufo/nBu/hoBuitreBultoBurbujaBurlaBurroBuscarButacaBuzo/nCaballoCabezaCabinaCabraCacaoCada/verCadenaCaerCafe/Cai/daCaima/nCajaCajo/nCalCalamarCalcioCaldoCalidadCalleCalmaCalorCalvoCamaCambioCamelloCaminoCampoCa/ncerCandilCanelaCanguroCanicaCantoCa~aCa~o/nCaobaCaosCapazCapita/nCapoteCaptarCapuchaCaraCarbo/nCa/rcelCaretaCargaCari~oCarneCarpetaCarroCartaCasaCascoCaseroCaspaCastorCatorceCatreCaudalCausaCazoCebollaCederCedroCeldaCe/lebreCelosoCe/lulaCementoCenizaCentroCercaCerdoCerezaCeroCerrarCertezaCe/spedCetroChacalChalecoChampu/ChanclaChapaCharlaChicoChisteChivoChoqueChozaChuletaChuparCiclo/nCiegoCieloCienCiertoCifraCigarroCimaCincoCineCintaCipre/sCircoCiruelaCisneCitaCiudadClamorClanClaroClaseClaveClienteClimaCli/nicaCobreCoccio/nCochinoCocinaCocoCo/digoCodoCofreCogerCoheteCoji/nCojoColaColchaColegioColgarColinaCollarColmoColumnaCombateComerComidaCo/modoCompraCondeConejoCongaConocerConsejoContarCopaCopiaCorazo/nCorbataCorchoCordo/nCoronaCorrerCoserCosmosCostaCra/neoCra/terCrearCrecerCrei/doCremaCri/aCrimenCriptaCrisisCromoCro/nicaCroquetaCrudoCruzCuadroCuartoCuatroCuboCubrirCucharaCuelloCuentoCuerdaCuestaCuevaCuidarCulebraCulpaCultoCumbreCumplirCunaCunetaCuotaCupo/nCu/pulaCurarCuriosoCursoCurvaCutisDamaDanzaDarDardoDa/tilDeberDe/bilDe/cadaDecirDedoDefensaDefinirDejarDelfi/nDelgadoDelitoDemoraDensoDentalDeporteDerechoDerrotaDesayunoDeseoDesfileDesnudoDestinoDesvi/oDetalleDetenerDeudaDi/aDiabloDiademaDiamanteDianaDiarioDibujoDictarDienteDietaDiezDifi/cilDignoDilemaDiluirDineroDirectoDirigirDiscoDise~oDisfrazDivaDivinoDobleDoceDolorDomingoDonDonarDoradoDormirDorsoDosDosisDrago/nDrogaDuchaDudaDueloDue~oDulceDu/oDuqueDurarDurezaDuroE/banoEbrioEcharEcoEcuadorEdadEdicio/nEdificioEditorEducarEfectoEficazEjeEjemploElefanteElegirElementoElevarElipseE/liteElixirElogioEludirEmbudoEmitirEmocio/nEmpateEmpe~oEmpleoEmpresaEnanoEncargoEnchufeEnci/aEnemigoEneroEnfadoEnfermoEnga~oEnigmaEnlaceEnormeEnredoEnsayoEnse~arEnteroEntrarEnvaseEnvi/oE/pocaEquipoErizoEscalaEscenaEscolarEscribirEscudoEsenciaEsferaEsfuerzoEspadaEspejoEspi/aEsposaEspumaEsqui/EstarEsteEstiloEstufaEtapaEternoE/ticaEtniaEvadirEvaluarEventoEvitarExactoExamenExcesoExcusaExentoExigirExilioExistirE/xitoExpertoExplicarExponerExtremoFa/bricaFa/bulaFachadaFa/cilFactorFaenaFajaFaldaFalloFalsoFaltarFamaFamiliaFamosoFarao/nFarmaciaFarolFarsaFaseFatigaFaunaFavorFaxFebreroFechaFelizFeoFeriaFerozFe/rtilFervorFesti/nFiableFianzaFiarFibraFiccio/nFichaFideoFiebreFielFieraFiestaFiguraFijarFijoFilaFileteFilialFiltroFinFincaFingirFinitoFirmaFlacoFlautaFlechaFlorFlotaFluirFlujoFlu/orFobiaFocaFogataFogo/nFolioFolletoFondoFormaForroFortunaForzarFosaFotoFracasoFra/gilFranjaFraseFraudeFrei/rFrenoFresaFri/oFritoFrutaFuegoFuenteFuerzaFugaFumarFuncio/nFundaFurgo/nFuriaFusilFu/tbolFuturoGacelaGafasGaitaGajoGalaGaleri/aGalloGambaGanarGanchoGangaGansoGarajeGarzaGasolinaGastarGatoGavila/nGemeloGemirGenGe/neroGenioGenteGeranioGerenteGermenGestoGiganteGimnasioGirarGiroGlaciarGloboGloriaGolGolfoGolosoGolpeGomaGordoGorilaGorraGotaGoteoGozarGradaGra/ficoGranoGrasaGratisGraveGrietaGrilloGripeGrisGritoGrosorGru/aGruesoGrumoGrupoGuanteGuapoGuardiaGuerraGui/aGui~oGuionGuisoGuitarraGusanoGustarHaberHa/bilHablarHacerHachaHadaHallarHamacaHarinaHazHaza~aHebillaHebraHechoHeladoHelioHembraHerirHermanoHe/roeHervirHieloHierroHi/gadoHigieneHijoHimnoHistoriaHocicoHogarHogueraHojaHombreHongoHonorHonraHoraHormigaHornoHostilHoyoHuecoHuelgaHuertaHuesoHuevoHuidaHuirHumanoHu/medoHumildeHumoHundirHuraca/nHurtoIconoIdealIdiomaI/doloIglesiaIglu/IgualIlegalIlusio/nImagenIma/nImitarImparImperioImponerImpulsoIncapazI/ndiceInerteInfielInformeIngenioInicioInmensoInmuneInnatoInsectoInstanteIntere/sI/ntimoIntuirInu/tilInviernoIraIrisIroni/aIslaIsloteJabali/Jabo/nJamo/nJarabeJardi/nJarraJaulaJazmi/nJefeJeringaJineteJornadaJorobaJovenJoyaJuergaJuevesJuezJugadorJugoJugueteJuicioJuncoJunglaJunioJuntarJu/piterJurarJustoJuvenilJuzgarKiloKoalaLabioLacioLacraLadoLadro/nLagartoLa/grimaLagunaLaicoLamerLa/minaLa/mparaLanaLanchaLangostaLanzaLa/pizLargoLarvaLa/stimaLataLa/texLatirLaurelLavarLazoLealLeccio/nLecheLectorLeerLegio/nLegumbreLejanoLenguaLentoLe~aLeo/nLeopardoLesio/nLetalLetraLeveLeyendaLibertadLibroLicorLi/derLidiarLienzoLigaLigeroLimaLi/miteLimo/nLimpioLinceLindoLi/neaLingoteLinoLinternaLi/quidoLisoListaLiteraLitioLitroLlagaLlamaLlantoLlaveLlegarLlenarLlevarLlorarLloverLluviaLoboLocio/nLocoLocuraLo/gicaLogroLombrizLomoLonjaLoteLuchaLucirLugarLujoLunaLunesLupaLustroLutoLuzMacetaMachoMaderaMadreMaduroMaestroMafiaMagiaMagoMai/zMaldadMaletaMallaMaloMama/MamboMamutMancoMandoManejarMangaManiqui/ManjarManoMansoMantaMa~anaMapaMa/quinaMarMarcoMareaMarfilMargenMaridoMa/rmolMarro/nMartesMarzoMasaMa/scaraMasivoMatarMateriaMatizMatrizMa/ximoMayorMazorcaMechaMedallaMedioMe/dulaMejillaMejorMelenaMelo/nMemoriaMenorMensajeMenteMenu/MercadoMerengueMe/ritoMesMeso/nMetaMeterMe/todoMetroMezclaMiedoMielMiembroMigaMilMilagroMilitarMillo/nMimoMinaMineroMi/nimoMinutoMiopeMirarMisaMiseriaMisilMismoMitadMitoMochilaMocio/nModaModeloMohoMojarMoldeMolerMolinoMomentoMomiaMonarcaMonedaMonjaMontoMo~oMoradaMorderMorenoMorirMorroMorsaMortalMoscaMostrarMotivoMoverMo/vilMozoMuchoMudarMuebleMuelaMuerteMuestraMugreMujerMulaMuletaMultaMundoMu~ecaMuralMuroMu/sculoMuseoMusgoMu/sicaMusloNa/carNacio/nNadarNaipeNaranjaNarizNarrarNasalNatalNativoNaturalNa/useaNavalNaveNavidadNecioNe/ctarNegarNegocioNegroNeo/nNervioNetoNeutroNevarNeveraNichoNidoNieblaNietoNi~ezNi~oNi/tidoNivelNoblezaNocheNo/minaNoriaNormaNorteNotaNoticiaNovatoNovelaNovioNubeNucaNu/cleoNudilloNudoNueraNueveNuezNuloNu/meroNutriaOasisObesoObispoObjetoObraObreroObservarObtenerObvioOcaOcasoOce/anoOchentaOchoOcioOcreOctavoOctubreOcultoOcuparOcurrirOdiarOdioOdiseaOesteOfensaOfertaOficioOfrecerOgroOi/doOi/rOjoOlaOleadaOlfatoOlivoOllaOlmoOlorOlvidoOmbligoOndaOnzaOpacoOpcio/nO/peraOpinarOponerOptarO/pticaOpuestoOracio/nOradorOralO/rbitaOrcaOrdenOrejaO/rganoOrgi/aOrgulloOrienteOrigenOrillaOroOrquestaOrugaOsadi/aOscuroOseznoOsoOstraOto~oOtroOvejaO/vuloO/xidoOxi/genoOyenteOzonoPactoPadrePaellaPa/ginaPagoPai/sPa/jaroPalabraPalcoPaletaPa/lidoPalmaPalomaPalparPanPanalPa/nicoPanteraPa~ueloPapa/PapelPapillaPaquetePararParcelaParedParirParoPa/rpadoParquePa/rrafoPartePasarPaseoPasio/nPasoPastaPataPatioPatriaPausaPautaPavoPayasoPeato/nPecadoPeceraPechoPedalPedirPegarPeinePelarPelda~oPeleaPeligroPellejoPeloPelucaPenaPensarPe~o/nPeo/nPeorPepinoPeque~oPeraPerchaPerderPerezaPerfilPericoPerlaPermisoPerroPersonaPesaPescaPe/simoPesta~aPe/taloPetro/leoPezPezu~aPicarPicho/nPiePiedraPiernaPiezaPijamaPilarPilotoPimientaPinoPintorPinzaPi~aPiojoPipaPirataPisarPiscinaPisoPistaPito/nPizcaPlacaPlanPlataPlayaPlazaPleitoPlenoPlomoPlumaPluralPobrePocoPoderPodioPoemaPoesi/aPoetaPolenPolici/aPolloPolvoPomadaPomeloPomoPompaPonerPorcio/nPortalPosadaPoseerPosiblePostePotenciaPotroPozoPradoPrecozPreguntaPremioPrensaPresoPrevioPrimoPri/ncipePrisio/nPrivarProaProbarProcesoProductoProezaProfesorProgramaProlePromesaProntoPropioPro/ximoPruebaPu/blicoPucheroPudorPuebloPuertaPuestoPulgaPulirPulmo/nPulpoPulsoPumaPuntoPu~alPu~oPupaPupilaPure/QuedarQuejaQuemarQuererQuesoQuietoQui/micaQuinceQuitarRa/banoRabiaRaboRacio/nRadicalRai/zRamaRampaRanchoRangoRapazRa/pidoRaptoRasgoRaspaRatoRayoRazaRazo/nReaccio/nRealidadReba~oReboteRecaerRecetaRechazoRecogerRecreoRectoRecursoRedRedondoReducirReflejoReformaRefra/nRefugioRegaloRegirReglaRegresoRehe/nReinoRei/rRejaRelatoRelevoRelieveRellenoRelojRemarRemedioRemoRencorRendirRentaRepartoRepetirReposoReptilResRescateResinaRespetoRestoResumenRetiroRetornoRetratoReunirReve/sRevistaReyRezarRicoRiegoRiendaRiesgoRifaRi/gidoRigorRinco/nRi~o/nRi/oRiquezaRisaRitmoRitoRizoRobleRoceRociarRodarRodeoRodillaRoerRojizoRojoRomeroRomperRonRoncoRondaRopaRoperoRosaRoscaRostroRotarRubi/RuborRudoRuedaRugirRuidoRuinaRuletaRuloRumboRumorRupturaRutaRutinaSa/badoSaberSabioSableSacarSagazSagradoSalaSaldoSaleroSalirSalmo/nSalo/nSalsaSaltoSaludSalvarSambaSancio/nSandi/aSanearSangreSanidadSanoSantoSapoSaqueSardinaSarte/nSastreSata/nSaunaSaxofo/nSeccio/nSecoSecretoSectaSedSeguirSeisSelloSelvaSemanaSemillaSendaSensorSe~alSe~orSepararSepiaSequi/aSerSerieSermo/nServirSesentaSesio/nSetaSetentaSeveroSexoSextoSidraSiestaSieteSigloSignoSi/labaSilbarSilencioSillaSi/mboloSimioSirenaSistemaSitioSituarSobreSocioSodioSolSolapaSoldadoSoledadSo/lidoSoltarSolucio/nSombraSondeoSonidoSonoroSonrisaSopaSoplarSoporteSordoSorpresaSorteoSoste/nSo/tanoSuaveSubirSucesoSudorSuegraSueloSue~oSuerteSufrirSujetoSulta/nSumarSuperarSuplirSuponerSupremoSurSurcoSure~oSurgirSustoSutilTabacoTabiqueTablaTabu/TacoTactoTajoTalarTalcoTalentoTallaTalo/nTama~oTamborTangoTanqueTapaTapeteTapiaTapo/nTaquillaTardeTareaTarifaTarjetaTarotTarroTartaTatuajeTauroTazaTazo/nTeatroTechoTeclaTe/cnicaTejadoTejerTejidoTelaTele/fonoTemaTemorTemploTenazTenderTenerTenisTensoTeori/aTerapiaTercoTe/rminoTernuraTerrorTesisTesoroTestigoTeteraTextoTezTibioTiburo/nTiempoTiendaTierraTiesoTigreTijeraTildeTimbreTi/midoTimoTintaTi/oTi/picoTipoTiraTiro/nTita/nTi/tereTi/tuloTizaToallaTobilloTocarTocinoTodoTogaToldoTomarTonoTontoToparTopeToqueTo/raxToreroTormentaTorneoToroTorpedoTorreTorsoTortugaTosToscoToserTo/xicoTrabajoTractorTraerTra/ficoTragoTrajeTramoTranceTratoTraumaTrazarTre/bolTreguaTreintaTrenTreparTresTribuTrigoTripaTristeTriunfoTrofeoTrompaTroncoTropaTroteTrozoTrucoTruenoTrufaTuberi/aTuboTuertoTumbaTumorTu/nelTu/nicaTurbinaTurismoTurnoTutorUbicarU/lceraUmbralUnidadUnirUniversoUnoUntarU~aUrbanoUrbeUrgenteUrnaUsarUsuarioU/tilUtopi/aUvaVacaVaci/oVacunaVagarVagoVainaVajillaValeVa/lidoValleValorVa/lvulaVampiroVaraVariarVaro/nVasoVecinoVectorVehi/culoVeinteVejezVelaVeleroVelozVenaVencerVendaVenenoVengarVenirVentaVenusVerVeranoVerboVerdeVeredaVerjaVersoVerterVi/aViajeVibrarVicioVi/ctimaVidaVi/deoVidrioViejoViernesVigorVilVillaVinagreVinoVi~edoVioli/nViralVirgoVirtudVisorVi/speraVistaVitaminaViudoVivazViveroVivirVivoVolca/nVolumenVolverVorazVotarVotoVozVueloVulgarYacerYateYeguaYemaYernoYesoYodoYogaYogurZafiroZanjaZapatoZarzaZonaZorroZumoZurdo", - Mlt = {}, - eK = null; - function Tlt(t) { - return ( - ene.logger.checkNormalize(), - (0, Qre.toUtf8String)( - Array.prototype.filter.call( - (0, Qre.toUtf8Bytes)(t.normalize("NFD").toLowerCase()), - function (e) { - return (e >= 65 && e <= 90) || (e >= 97 && e <= 123); - } - ) - ) - ); - } - function qwr(t) { - var e = []; - return ( - Array.prototype.forEach.call((0, Qre.toUtf8Bytes)(t), function (r) { - r === 47 - ? (e.push(204), e.push(129)) - : r === 126 - ? (e.push(110), e.push(204), e.push(131)) - : e.push(r); - }), - (0, Qre.toUtf8String)(e) - ); - } - function Elt(t) { - if ( - eK == null && - ((eK = Lwr.replace(/([A-Z])/g, " $1") - .toLowerCase() - .substring(1) - .split(" ") - .map(function (e) { - return qwr(e); - })), - eK.forEach(function (e, r) { - Mlt[Tlt(e)] = r; - }), - ene.Wordlist.check(t) !== - "0xf74fb7092aeacdfbf8959557de22098da512207fb9f109cb526994938cf40300") - ) - throw ( - ((eK = null), new Error("BIP39 Wordlist for es (Spanish) FAILED")) - ); - } - var zwr = (function (t) { - Fwr(e, t); - function e() { - return t.call(this, "es") || this; - } - return ( - (e.prototype.getWord = function (r) { - return Elt(this), eK[r]; - }), - (e.prototype.getWordIndex = function (r) { - return Elt(this), Mlt[Tlt(r)]; - }), - e - ); - })(ene.Wordlist), - klt = new zwr(); - VR.langEs = klt; - ene.Wordlist.register(klt); - }); - var Rlt = I((WR) => { - "use strict"; - m(); - g(); - var jwr = - (WR && WR.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(WR, "__esModule", { value: !0 }); - WR.langFr = void 0; - var tne = Eo(), - rne = yb(), - Uwr = - "AbaisserAbandonAbdiquerAbeilleAbolirAborderAboutirAboyerAbrasifAbreuverAbriterAbrogerAbruptAbsenceAbsoluAbsurdeAbusifAbyssalAcade/mieAcajouAcarienAccablerAccepterAcclamerAccoladeAccrocheAccuserAcerbeAchatAcheterAcidulerAcierAcompteAcque/rirAcronymeActeurActifActuelAdepteAde/quatAdhe/sifAdjectifAdjugerAdmettreAdmirerAdopterAdorerAdoucirAdresseAdroitAdulteAdverbeAe/rerAe/ronefAffaireAffecterAfficheAffreuxAffublerAgacerAgencerAgileAgiterAgraferAgre/ableAgrumeAiderAiguilleAilierAimableAisanceAjouterAjusterAlarmerAlchimieAlerteAlge-breAlgueAlie/nerAlimentAlle/gerAlliageAllouerAllumerAlourdirAlpagaAltesseAlve/oleAmateurAmbiguAmbreAme/nagerAmertumeAmidonAmiralAmorcerAmourAmovibleAmphibieAmpleurAmusantAnalyseAnaphoreAnarchieAnatomieAncienAne/antirAngleAngoisseAnguleuxAnimalAnnexerAnnonceAnnuelAnodinAnomalieAnonymeAnormalAntenneAntidoteAnxieuxApaiserApe/ritifAplanirApologieAppareilAppelerApporterAppuyerAquariumAqueducArbitreArbusteArdeurArdoiseArgentArlequinArmatureArmementArmoireArmureArpenterArracherArriverArroserArsenicArte/rielArticleAspectAsphalteAspirerAssautAsservirAssietteAssocierAssurerAsticotAstreAstuceAtelierAtomeAtriumAtroceAttaqueAttentifAttirerAttraperAubaineAubergeAudaceAudibleAugurerAuroreAutomneAutrucheAvalerAvancerAvariceAvenirAverseAveugleAviateurAvideAvionAviserAvoineAvouerAvrilAxialAxiomeBadgeBafouerBagageBaguetteBaignadeBalancerBalconBaleineBalisageBambinBancaireBandageBanlieueBannie-reBanquierBarbierBarilBaronBarqueBarrageBassinBastionBatailleBateauBatterieBaudrierBavarderBeletteBe/lierBeloteBe/ne/ficeBerceauBergerBerlineBermudaBesaceBesogneBe/tailBeurreBiberonBicycleBiduleBijouBilanBilingueBillardBinaireBiologieBiopsieBiotypeBiscuitBisonBistouriBitumeBizarreBlafardBlagueBlanchirBlessantBlinderBlondBloquerBlousonBobardBobineBoireBoiserBolideBonbonBondirBonheurBonifierBonusBordureBorneBotteBoucleBoueuxBougieBoulonBouquinBourseBoussoleBoutiqueBoxeurBrancheBrasierBraveBrebisBre-cheBreuvageBricolerBrigadeBrillantBriocheBriqueBrochureBroderBronzerBrousseBroyeurBrumeBrusqueBrutalBruyantBuffleBuissonBulletinBureauBurinBustierButinerButoirBuvableBuvetteCabanonCabineCachetteCadeauCadreCafe/ineCaillouCaissonCalculerCalepinCalibreCalmerCalomnieCalvaireCamaradeCame/raCamionCampagneCanalCanetonCanonCantineCanularCapableCaporalCapriceCapsuleCapterCapucheCarabineCarboneCaresserCaribouCarnageCarotteCarreauCartonCascadeCasierCasqueCassureCauserCautionCavalierCaverneCaviarCe/dilleCeintureCe/lesteCelluleCendrierCensurerCentralCercleCe/re/bralCeriseCernerCerveauCesserChagrinChaiseChaleurChambreChanceChapitreCharbonChasseurChatonChaussonChavirerChemiseChenilleChe/quierChercherChevalChienChiffreChignonChime-reChiotChlorureChocolatChoisirChoseChouetteChromeChuteCigareCigogneCimenterCine/maCintrerCirculerCirerCirqueCiterneCitoyenCitronCivilClaironClameurClaquerClasseClavierClientClignerClimatClivageClocheClonageCloporteCobaltCobraCocasseCocotierCoderCodifierCoffreCognerCohe/sionCoifferCoincerCole-reColibriCollineColmaterColonelCombatCome/dieCommandeCompactConcertConduireConfierCongelerConnoterConsonneContactConvexeCopainCopieCorailCorbeauCordageCornicheCorpusCorrectCorte-geCosmiqueCostumeCotonCoudeCoupureCourageCouteauCouvrirCoyoteCrabeCrainteCravateCrayonCre/atureCre/diterCre/meuxCreuserCrevetteCriblerCrierCristalCrite-reCroireCroquerCrotaleCrucialCruelCrypterCubiqueCueillirCuille-reCuisineCuivreCulminerCultiverCumulerCupideCuratifCurseurCyanureCycleCylindreCyniqueDaignerDamierDangerDanseurDauphinDe/battreDe/biterDe/borderDe/briderDe/butantDe/calerDe/cembreDe/chirerDe/ciderDe/clarerDe/corerDe/crireDe/cuplerDe/daleDe/ductifDe/esseDe/fensifDe/filerDe/frayerDe/gagerDe/givrerDe/glutirDe/graferDe/jeunerDe/liceDe/logerDemanderDemeurerDe/molirDe/nicherDe/nouerDentelleDe/nuderDe/partDe/penserDe/phaserDe/placerDe/poserDe/rangerDe/roberDe/sastreDescenteDe/sertDe/signerDe/sobe/irDessinerDestrierDe/tacherDe/testerDe/tourerDe/tresseDevancerDevenirDevinerDevoirDiableDialogueDiamantDicterDiffe/rerDige/rerDigitalDigneDiluerDimancheDiminuerDioxydeDirectifDirigerDiscuterDisposerDissiperDistanceDivertirDiviserDocileDocteurDogmeDoigtDomaineDomicileDompterDonateurDonjonDonnerDopamineDortoirDorureDosageDoseurDossierDotationDouanierDoubleDouceurDouterDoyenDragonDraperDresserDribblerDroitureDuperieDuplexeDurableDurcirDynastieE/blouirE/carterE/charpeE/chelleE/clairerE/clipseE/cloreE/cluseE/coleE/conomieE/corceE/couterE/craserE/cre/merE/crivainE/crouE/cumeE/cureuilE/difierE/duquerEffacerEffectifEffigieEffortEffrayerEffusionE/galiserE/garerE/jecterE/laborerE/largirE/lectronE/le/gantE/le/phantE/le-veE/ligibleE/litismeE/logeE/luciderE/luderEmballerEmbellirEmbryonE/meraudeE/missionEmmenerE/motionE/mouvoirEmpereurEmployerEmporterEmpriseE/mulsionEncadrerEnche-reEnclaveEncocheEndiguerEndosserEndroitEnduireE/nergieEnfanceEnfermerEnfouirEngagerEnginEngloberE/nigmeEnjamberEnjeuEnleverEnnemiEnnuyeuxEnrichirEnrobageEnseigneEntasserEntendreEntierEntourerEntraverE/nume/rerEnvahirEnviableEnvoyerEnzymeE/olienE/paissirE/pargneE/patantE/pauleE/picerieE/pide/mieE/pierE/pilogueE/pineE/pisodeE/pitapheE/poqueE/preuveE/prouverE/puisantE/querreE/quipeE/rigerE/rosionErreurE/ruptionEscalierEspadonEspe-ceEspie-gleEspoirEspritEsquiverEssayerEssenceEssieuEssorerEstimeEstomacEstradeE/tage-reE/talerE/tancheE/tatiqueE/teindreE/tendoirE/ternelE/thanolE/thiqueEthnieE/tirerE/tofferE/toileE/tonnantE/tourdirE/trangeE/troitE/tudeEuphorieE/valuerE/vasionE/ventailE/videnceE/viterE/volutifE/voquerExactExage/rerExaucerExcellerExcitantExclusifExcuseExe/cuterExempleExercerExhalerExhorterExigenceExilerExisterExotiqueExpe/dierExplorerExposerExprimerExquisExtensifExtraireExulterFableFabuleuxFacetteFacileFactureFaiblirFalaiseFameuxFamilleFarceurFarfeluFarineFaroucheFascinerFatalFatigueFauconFautifFaveurFavoriFe/brileFe/conderFe/de/rerFe/linFemmeFe/murFendoirFe/odalFermerFe/roceFerveurFestivalFeuilleFeutreFe/vrierFiascoFicelerFictifFide-leFigureFilatureFiletageFilie-reFilleulFilmerFilouFiltrerFinancerFinirFioleFirmeFissureFixerFlairerFlammeFlasqueFlatteurFle/auFle-cheFleurFlexionFloconFloreFluctuerFluideFluvialFolieFonderieFongibleFontaineForcerForgeronFormulerFortuneFossileFoudreFouge-reFouillerFoulureFourmiFragileFraiseFranchirFrapperFrayeurFre/gateFreinerFrelonFre/mirFre/ne/sieFre-reFriableFrictionFrissonFrivoleFroidFromageFrontalFrotterFruitFugitifFuiteFureurFurieuxFurtifFusionFuturGagnerGalaxieGalerieGambaderGarantirGardienGarnirGarrigueGazelleGazonGe/antGe/latineGe/luleGendarmeGe/ne/ralGe/nieGenouGentilGe/ologieGe/ome-treGe/raniumGermeGestuelGeyserGibierGiclerGirafeGivreGlaceGlaiveGlisserGlobeGloireGlorieuxGolfeurGommeGonflerGorgeGorilleGoudronGouffreGoulotGoupilleGourmandGoutteGraduelGraffitiGraineGrandGrappinGratuitGravirGrenatGriffureGrillerGrimperGrognerGronderGrotteGroupeGrugerGrutierGruye-reGue/pardGuerrierGuideGuimauveGuitareGustatifGymnasteGyrostatHabitudeHachoirHalteHameauHangarHannetonHaricotHarmonieHarponHasardHe/liumHe/matomeHerbeHe/rissonHermineHe/ronHe/siterHeureuxHibernerHibouHilarantHistoireHiverHomardHommageHomoge-neHonneurHonorerHonteuxHordeHorizonHorlogeHormoneHorribleHouleuxHousseHublotHuileuxHumainHumbleHumideHumourHurlerHydromelHygie-neHymneHypnoseIdylleIgnorerIguaneIlliciteIllusionImageImbiberImiterImmenseImmobileImmuableImpactImpe/rialImplorerImposerImprimerImputerIncarnerIncendieIncidentInclinerIncoloreIndexerIndiceInductifIne/ditIneptieInexactInfiniInfligerInformerInfusionInge/rerInhalerInhiberInjecterInjureInnocentInoculerInonderInscrireInsecteInsigneInsoliteInspirerInstinctInsulterIntactIntenseIntimeIntrigueIntuitifInutileInvasionInventerInviterInvoquerIroniqueIrradierIrre/elIrriterIsolerIvoireIvresseJaguarJaillirJambeJanvierJardinJaugerJauneJavelotJetableJetonJeudiJeunesseJoindreJoncherJonglerJoueurJouissifJournalJovialJoyauJoyeuxJubilerJugementJuniorJuponJuristeJusticeJuteuxJuve/nileKayakKimonoKiosqueLabelLabialLabourerLace/rerLactoseLaguneLaineLaisserLaitierLambeauLamelleLampeLanceurLangageLanterneLapinLargeurLarmeLaurierLavaboLavoirLectureLe/galLe/gerLe/gumeLessiveLettreLevierLexiqueLe/zardLiasseLibe/rerLibreLicenceLicorneLie-geLie-vreLigatureLigoterLigueLimerLimiteLimonadeLimpideLine/aireLingotLionceauLiquideLisie-reListerLithiumLitigeLittoralLivreurLogiqueLointainLoisirLombricLoterieLouerLourdLoutreLouveLoyalLubieLucideLucratifLueurLugubreLuisantLumie-reLunaireLundiLuronLutterLuxueuxMachineMagasinMagentaMagiqueMaigreMaillonMaintienMairieMaisonMajorerMalaxerMale/ficeMalheurMaliceMalletteMammouthMandaterManiableManquantManteauManuelMarathonMarbreMarchandMardiMaritimeMarqueurMarronMartelerMascotteMassifMate/rielMatie-reMatraqueMaudireMaussadeMauveMaximalMe/chantMe/connuMe/dailleMe/decinMe/diterMe/duseMeilleurMe/langeMe/lodieMembreMe/moireMenacerMenerMenhirMensongeMentorMercrediMe/riteMerleMessagerMesureMe/talMe/te/oreMe/thodeMe/tierMeubleMiaulerMicrobeMietteMignonMigrerMilieuMillionMimiqueMinceMine/ralMinimalMinorerMinuteMiracleMiroiterMissileMixteMobileModerneMoelleuxMondialMoniteurMonnaieMonotoneMonstreMontagneMonumentMoqueurMorceauMorsureMortierMoteurMotifMoucheMoufleMoulinMoussonMoutonMouvantMultipleMunitionMurailleMure-neMurmureMuscleMuse/umMusicienMutationMuterMutuelMyriadeMyrtilleMyste-reMythiqueNageurNappeNarquoisNarrerNatationNationNatureNaufrageNautiqueNavireNe/buleuxNectarNe/fasteNe/gationNe/gligerNe/gocierNeigeNerveuxNettoyerNeuroneNeutronNeveuNicheNickelNitrateNiveauNobleNocifNocturneNoirceurNoisetteNomadeNombreuxNommerNormatifNotableNotifierNotoireNourrirNouveauNovateurNovembreNoviceNuageNuancerNuireNuisibleNume/roNuptialNuqueNutritifObe/irObjectifObligerObscurObserverObstacleObtenirObturerOccasionOccuperOce/anOctobreOctroyerOctuplerOculaireOdeurOdorantOffenserOfficierOffrirOgiveOiseauOisillonOlfactifOlivierOmbrageOmettreOnctueuxOndulerOne/reuxOniriqueOpaleOpaqueOpe/rerOpinionOpportunOpprimerOpterOptiqueOrageuxOrangeOrbiteOrdonnerOreilleOrganeOrgueilOrificeOrnementOrqueOrtieOscillerOsmoseOssatureOtarieOuraganOursonOutilOutragerOuvrageOvationOxydeOxyge-neOzonePaisiblePalacePalmare-sPalourdePalperPanachePandaPangolinPaniquerPanneauPanoramaPantalonPapayePapierPapoterPapyrusParadoxeParcelleParesseParfumerParlerParoleParrainParsemerPartagerParureParvenirPassionPaste-quePaternelPatiencePatronPavillonPavoiserPayerPaysagePeignePeintrePelagePe/licanPellePelousePeluchePendulePe/ne/trerPe/niblePensifPe/nuriePe/pitePe/plumPerdrixPerforerPe/riodePermuterPerplexePersilPertePeserPe/talePetitPe/trirPeuplePharaonPhobiePhoquePhotonPhrasePhysiquePianoPicturalPie-cePierrePieuvrePilotePinceauPipettePiquerPiroguePiscinePistonPivoterPixelPizzaPlacardPlafondPlaisirPlanerPlaquePlastronPlateauPleurerPlexusPliagePlombPlongerPluiePlumagePochettePoe/siePoe-tePointePoirierPoissonPoivrePolairePolicierPollenPolygonePommadePompierPonctuelPonde/rerPoneyPortiquePositionPosse/derPosturePotagerPoteauPotionPoucePoulainPoumonPourprePoussinPouvoirPrairiePratiquePre/cieuxPre/direPre/fixePre/ludePre/nomPre/sencePre/textePre/voirPrimitifPrincePrisonPriverProble-meProce/derProdigeProfondProgre-sProieProjeterProloguePromenerPropreProspe-reProte/gerProuesseProverbePrudencePruneauPsychosePublicPuceronPuiserPulpePulsarPunaisePunitifPupitrePurifierPuzzlePyramideQuasarQuerelleQuestionQuie/tudeQuitterQuotientRacineRaconterRadieuxRagondinRaideurRaisinRalentirRallongeRamasserRapideRasageRatisserRavagerRavinRayonnerRe/actifRe/agirRe/aliserRe/animerRecevoirRe/citerRe/clamerRe/colterRecruterReculerRecyclerRe/digerRedouterRefaireRe/flexeRe/formerRefrainRefugeRe/galienRe/gionRe/glageRe/gulierRe/ite/rerRejeterRejouerRelatifReleverReliefRemarqueReme-deRemiseRemonterRemplirRemuerRenardRenfortReniflerRenoncerRentrerRenvoiReplierReporterRepriseReptileRequinRe/serveRe/sineuxRe/soudreRespectResterRe/sultatRe/tablirRetenirRe/ticuleRetomberRetracerRe/unionRe/ussirRevancheRevivreRe/volteRe/vulsifRichesseRideauRieurRigideRigolerRincerRiposterRisibleRisqueRituelRivalRivie-reRocheuxRomanceRompreRonceRondinRoseauRosierRotatifRotorRotuleRougeRouilleRouleauRoutineRoyaumeRubanRubisRucheRuelleRugueuxRuinerRuisseauRuserRustiqueRythmeSablerSaboterSabreSacocheSafariSagesseSaisirSaladeSaliveSalonSaluerSamediSanctionSanglierSarcasmeSardineSaturerSaugrenuSaumonSauterSauvageSavantSavonnerScalpelScandaleSce/le/ratSce/narioSceptreSche/maScienceScinderScoreScrutinSculpterSe/anceSe/cableSe/cherSecouerSe/cre/terSe/datifSe/duireSeigneurSe/jourSe/lectifSemaineSemblerSemenceSe/minalSe/nateurSensibleSentenceSe/parerSe/quenceSereinSergentSe/rieuxSerrureSe/rumServiceSe/sameSe/virSevrageSextupleSide/ralSie-cleSie/gerSifflerSigleSignalSilenceSiliciumSimpleSince-reSinistreSiphonSiropSismiqueSituerSkierSocialSocleSodiumSoigneuxSoldatSoleilSolitudeSolubleSombreSommeilSomnolerSondeSongeurSonnetteSonoreSorcierSortirSosieSottiseSoucieuxSoudureSouffleSouleverSoupapeSourceSoutirerSouvenirSpacieuxSpatialSpe/cialSphe-reSpiralStableStationSternumStimulusStipulerStrictStudieuxStupeurStylisteSublimeSubstratSubtilSubvenirSucce-sSucreSuffixeSugge/rerSuiveurSulfateSuperbeSupplierSurfaceSuricateSurmenerSurpriseSursautSurvieSuspectSyllabeSymboleSyme/trieSynapseSyntaxeSyste-meTabacTablierTactileTaillerTalentTalismanTalonnerTambourTamiserTangibleTapisTaquinerTarderTarifTartineTasseTatamiTatouageTaupeTaureauTaxerTe/moinTemporelTenailleTendreTeneurTenirTensionTerminerTerneTerribleTe/tineTexteThe-meThe/orieThe/rapieThoraxTibiaTie-deTimideTirelireTiroirTissuTitaneTitreTituberTobogganTole/rantTomateToniqueTonneauToponymeTorcheTordreTornadeTorpilleTorrentTorseTortueTotemToucherTournageTousserToxineTractionTraficTragiqueTrahirTrainTrancherTravailTre-fleTremperTre/sorTreuilTriageTribunalTricoterTrilogieTriompheTriplerTriturerTrivialTromboneTroncTropicalTroupeauTuileTulipeTumulteTunnelTurbineTuteurTutoyerTuyauTympanTyphonTypiqueTyranUbuesqueUltimeUltrasonUnanimeUnifierUnionUniqueUnitaireUniversUraniumUrbainUrticantUsageUsineUsuelUsureUtileUtopieVacarmeVaccinVagabondVagueVaillantVaincreVaisseauValableValiseVallonValveVampireVanilleVapeurVarierVaseuxVassalVasteVecteurVedetteVe/ge/talVe/hiculeVeinardVe/loceVendrediVe/ne/rerVengerVenimeuxVentouseVerdureVe/rinVernirVerrouVerserVertuVestonVe/te/ranVe/tusteVexantVexerViaducViandeVictoireVidangeVide/oVignetteVigueurVilainVillageVinaigreViolonVipe-reVirementVirtuoseVirusVisageViseurVisionVisqueuxVisuelVitalVitesseViticoleVitrineVivaceVivipareVocationVoguerVoileVoisinVoitureVolailleVolcanVoltigerVolumeVoraceVortexVoterVouloirVoyageVoyelleWagonXe/nonYachtZe-breZe/nithZesteZoologie", - tK = null, - Blt = {}; - function Ilt(t) { - return ( - rne.logger.checkNormalize(), - (0, tne.toUtf8String)( - Array.prototype.filter.call( - (0, tne.toUtf8Bytes)(t.normalize("NFD").toLowerCase()), - function (e) { - return (e >= 65 && e <= 90) || (e >= 97 && e <= 123); - } - ) - ) - ); - } - function Kwr(t) { - var e = []; - return ( - Array.prototype.forEach.call((0, tne.toUtf8Bytes)(t), function (r) { - r === 47 - ? (e.push(204), e.push(129)) - : r === 45 - ? (e.push(204), e.push(128)) - : e.push(r); - }), - (0, tne.toUtf8String)(e) - ); - } - function Olt(t) { - if ( - tK == null && - ((tK = Uwr.replace(/([A-Z])/g, " $1") - .toLowerCase() - .substring(1) - .split(" ") - .map(function (e) { - return Kwr(e); - })), - tK.forEach(function (e, r) { - Blt[Ilt(e)] = r; - }), - rne.Wordlist.check(t) !== - "0x51deb7ae009149dc61a6bd18a918eb7ac78d2775726c68e598b92d002519b045") - ) - throw ((tK = null), new Error("BIP39 Wordlist for fr (French) FAILED")); - } - var Hwr = (function (t) { - jwr(e, t); - function e() { - return t.call(this, "fr") || this; - } - return ( - (e.prototype.getWord = function (r) { - return Olt(this), tK[r]; - }), - (e.prototype.getWordIndex = function (r) { - return Olt(this), Blt[Ilt(r)]; - }), - e - ); - })(rne.Wordlist), - Clt = new Hwr(); - WR.langFr = Clt; - rne.Wordlist.register(Clt); - }); - var Llt = I((GR) => { - "use strict"; - m(); - g(); - var Vwr = - (GR && GR.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(GR, "__esModule", { value: !0 }); - GR.langJa = void 0; - var Wwr = Ar(), - qy = Eo(), - nne = yb(), - Gwr = [ - "AQRASRAGBAGUAIRAHBAghAURAdBAdcAnoAMEAFBAFCBKFBQRBSFBCXBCDBCHBGFBEQBpBBpQBIkBHNBeOBgFBVCBhBBhNBmOBmRBiHBiFBUFBZDBvFBsXBkFBlcBjYBwDBMBBTBBTRBWBBWXXaQXaRXQWXSRXCFXYBXpHXOQXHRXhRXuRXmXXbRXlXXwDXTRXrCXWQXWGaBWaKcaYgasFadQalmaMBacAKaRKKBKKXKKjKQRKDRKCYKCRKIDKeVKHcKlXKjHKrYNAHNBWNaRNKcNIBNIONmXNsXNdXNnBNMBNRBNrXNWDNWMNFOQABQAHQBrQXBQXFQaRQKXQKDQKOQKFQNBQNDQQgQCXQCDQGBQGDQGdQYXQpBQpQQpHQLXQHuQgBQhBQhCQuFQmXQiDQUFQZDQsFQdRQkHQbRQlOQlmQPDQjDQwXQMBQMDQcFQTBQTHQrDDXQDNFDGBDGQDGRDpFDhFDmXDZXDbRDMYDRdDTRDrXSAhSBCSBrSGQSEQSHBSVRShYShkSyQSuFSiBSdcSoESocSlmSMBSFBSFKSFNSFdSFcCByCaRCKcCSBCSRCCrCGbCEHCYXCpBCpQCIBCIHCeNCgBCgFCVECVcCmkCmwCZXCZFCdRClOClmClFCjDCjdCnXCwBCwXCcRCFQCFjGXhGNhGDEGDMGCDGCHGIFGgBGVXGVEGVRGmXGsXGdYGoSGbRGnXGwXGwDGWRGFNGFLGFOGFdGFkEABEBDEBFEXOEaBEKSENBENDEYXEIgEIkEgBEgQEgHEhFEudEuFEiBEiHEiFEZDEvBEsXEsFEdXEdREkFEbBEbRElFEPCEfkEFNYAEYAhYBNYQdYDXYSRYCEYYoYgQYgRYuRYmCYZTYdBYbEYlXYjQYRbYWRpKXpQopQnpSFpCXpIBpISphNpdBpdRpbRpcZpFBpFNpFDpFopFrLADLBuLXQLXcLaFLCXLEhLpBLpFLHXLeVLhILdHLdRLoDLbRLrXIABIBQIBCIBsIBoIBMIBRIXaIaRIKYIKRINBINuICDIGBIIDIIkIgRIxFIyQIiHIdRIbYIbRIlHIwRIMYIcRIRVITRIFBIFNIFQOABOAFOBQOaFONBONMOQFOSFOCDOGBOEQOpBOLXOIBOIFOgQOgFOyQOycOmXOsXOdIOkHOMEOMkOWWHBNHXNHXWHNXHDuHDRHSuHSRHHoHhkHmRHdRHkQHlcHlRHwBHWcgAEgAggAkgBNgBQgBEgXOgYcgLXgHjgyQgiBgsFgdagMYgWSgFQgFEVBTVXEVKBVKNVKDVKYVKRVNBVNYVDBVDxVSBVSRVCjVGNVLXVIFVhBVhcVsXVdRVbRVlRhBYhKYhDYhGShxWhmNhdahdkhbRhjohMXhTRxAXxXSxKBxNBxEQxeNxeQxhXxsFxdbxlHxjcxFBxFNxFQxFOxFoyNYyYoybcyMYuBQuBRuBruDMuCouHBudQukkuoBulVuMXuFEmCYmCRmpRmeDmiMmjdmTFmFQiADiBOiaRiKRiNBiNRiSFiGkiGFiERipRiLFiIFihYibHijBijEiMXiWBiFBiFCUBQUXFUaRUNDUNcUNRUNFUDBUSHUCDUGBUGFUEqULNULoUIRUeEUeYUgBUhFUuRUiFUsXUdFUkHUbBUjSUjYUwXUMDUcHURdUTBUrBUrXUrQZAFZXZZaRZKFZNBZQFZCXZGBZYdZpBZLDZIFZHXZHNZeQZVRZVFZmXZiBZvFZdFZkFZbHZbFZwXZcCZcRZRBvBQvBGvBLvBWvCovMYsAFsBDsaRsKFsNFsDrsSHsSFsCXsCRsEBsEHsEfspBsLBsLDsIgsIRseGsbRsFBsFQsFSdNBdSRdCVdGHdYDdHcdVbdySduDdsXdlRdwXdWYdWcdWRkBMkXOkaRkNIkNFkSFkCFkYBkpRkeNkgBkhVkmXksFklVkMBkWDkFNoBNoaQoaFoNBoNXoNaoNEoSRoEroYXoYCoYbopRopFomXojkowXorFbBEbEIbdBbjYlaRlDElMXlFDjKjjSRjGBjYBjYkjpRjLXjIBjOFjeVjbRjwBnXQnSHnpFnLXnINnMBnTRwXBwXNwXYwNFwQFwSBwGFwLXwLDweNwgBwuHwjDwnXMBXMpFMIBMeNMTHcaQcNBcDHcSFcCXcpBcLXcLDcgFcuFcnXcwXccDcTQcrFTQErXNrCHrpFrgFrbFrTHrFcWNYWNbWEHWMXWTR", - "ABGHABIJAEAVAYJQALZJAIaRAHNXAHdcAHbRAZJMAZJRAZTRAdVJAklmAbcNAjdRAMnRAMWYAWpRAWgRAFgBAFhBAFdcBNJBBNJDBQKBBQhcBQlmBDEJBYJkBYJTBpNBBpJFBIJBBIJDBIcABOKXBOEJBOVJBOiJBOZJBepBBeLXBeIFBegBBgGJBVJXBuocBiJRBUJQBlXVBlITBwNFBMYVBcqXBTlmBWNFBWiJBWnRBFGHBFwXXKGJXNJBXNZJXDTTXSHSXSVRXSlHXCJDXGQJXEhXXYQJXYbRXOfXXeNcXVJFXhQJXhEJXdTRXjdXXMhBXcQTXRGBXTEBXTnQXFCXXFOFXFgFaBaFaBNJaBCJaBpBaBwXaNJKaNJDaQIBaDpRaEPDaHMFamDJalEJaMZJaFaFaFNBaFQJaFLDaFVHKBCYKBEBKBHDKXaFKXGdKXEJKXpHKXIBKXZDKXwXKKwLKNacKNYJKNJoKNWcKDGdKDTRKChXKGaRKGhBKGbRKEBTKEaRKEPTKLMDKLWRKOHDKVJcKdBcKlIBKlOPKFSBKFEPKFpFNBNJNJBQNBGHNBEPNBHXNBgFNBVXNBZDNBsXNBwXNNaRNNJDNNJENNJkNDCJNDVDNGJRNJiDNZJNNsCJNJFNNFSBNFCXNFEPNFLXNFIFQJBFQCaRQJEQQLJDQLJFQIaRQOqXQHaFQHHQQVJXQVJDQhNJQmEIQZJFQsJXQJrFQWbRDJABDBYJDXNFDXCXDXLXDXZDDXsJDQqXDSJFDJCXDEPkDEqXDYmQDpSJDOCkDOGQDHEIDVJDDuDuDWEBDJFgSBNDSBSFSBGHSBIBSBTQSKVYSJQNSJQiSJCXSEqXSJYVSIiJSOMYSHAHSHaQSeCFSepQSegBSHdHSHrFShSJSJuHSJUFSkNRSrSrSWEBSFaHSJFQSFCXSFGDSFYXSFODSFgBSFVXSFhBSFxFSFkFSFbBSFMFCADdCJXBCXaFCXKFCXNFCXCXCXGBCXEJCXYBCXLDCXIBCXOPCXHXCXgBCXhBCXiBCXlDCXcHCJNBCJNFCDCJCDGBCDVXCDhBCDiDCDJdCCmNCpJFCIaRCOqXCHCHCHZJCViJCuCuCmddCJiFCdNBCdHhClEJCnUJCreSCWlgCWTRCFBFCFNBCFYBCFVFCFhFCFdSCFTBCFWDGBNBGBQFGJBCGBEqGBpBGBgQGNBEGNJYGNkOGNJRGDUFGJpQGHaBGJeNGJeEGVBlGVKjGiJDGvJHGsVJGkEBGMIJGWjNGFBFGFCXGFGBGFYXGFpBGFMFEASJEAWpEJNFECJVEIXSEIQJEOqXEOcFEeNcEHEJEHlFEJgFEhlmEmDJEmZJEiMBEUqXEoSREPBFEPXFEPKFEPSFEPEFEPpFEPLXEPIBEJPdEPcFEPTBEJnXEqlHEMpREFCXEFODEFcFYASJYJAFYBaBYBVXYXpFYDhBYCJBYJGFYYbRYeNcYJeVYiIJYZJcYvJgYvJRYJsXYsJFYMYMYreVpBNHpBEJpBwXpQxFpYEJpeNDpJeDpeSFpeCHpHUJpHbBpHcHpmUJpiiJpUJrpsJuplITpFaBpFQqpFGBpFEfpFYBpFpBpFLJpFIDpFgBpFVXpFyQpFuFpFlFpFjDpFnXpFwXpJFMpFTBLXCJLXEFLXhFLXUJLXbFLalmLNJBLSJQLCLCLGJBLLDJLHaFLeNFLeSHLeCXLepFLhaRLZsJLsJDLsJrLocaLlLlLMdbLFNBLFSBLFEHLFkFIBBFIBXFIBaQIBKXIBSFIBpHIBLXIBgBIBhBIBuHIBmXIBiFIBZXIBvFIBbFIBjQIBwXIBWFIKTRIQUJIDGFICjQIYSRIINXIJeCIVaRImEkIZJFIvJRIsJXIdCJIJoRIbBQIjYBIcqXITFVIreVIFKFIFSFIFCJIFGFIFLDIFIBIJFOIFgBIFVXIJFhIFxFIFmXIFdHIFbBIJFrIJFWOBGBOQfXOOKjOUqXOfXBOqXEOcqXORVJOFIBOFlDHBIOHXiFHNTRHCJXHIaRHHJDHHEJHVbRHZJYHbIBHRsJHRkDHWlmgBKFgBSBgBCDgBGHgBpBgBIBgBVJgBuBgBvFgKDTgQVXgDUJgGSJgOqXgmUMgZIJgTUJgWIEgFBFgFNBgFDJgFSFgFGBgFYXgJFOgFgQgFVXgFhBgFbHgJFWVJABVQKcVDgFVOfXVeDFVhaRVmGdViJYVMaRVFNHhBNDhBCXhBEqhBpFhBLXhNJBhSJRheVXhhKEhxlmhZIJhdBQhkIJhbMNhMUJhMZJxNJgxQUJxDEkxDdFxSJRxplmxeSBxeCXxeGFxeYXxepQxegBxWVcxFEQxFLXxFIBxFgBxFxDxFZtxFdcxFbBxFwXyDJXyDlcuASJuDJpuDIBuCpJuGSJuIJFueEFuZIJusJXudWEuoIBuWGJuFBcuFKEuFNFuFQFuFDJuFGJuFVJuFUtuFdHuFTBmBYJmNJYmQhkmLJDmLJomIdXmiJYmvJRmsJRmklmmMBymMuCmclmmcnQiJABiJBNiJBDiBSFiBCJiBEFiBYBiBpFiBLXiBTHiJNciDEfiCZJiECJiJEqiOkHiHKFieNDiHJQieQcieDHieSFieCXieGFieEFieIHiegFihUJixNoioNXiFaBiFKFiFNDiFEPiFYXitFOitFHiFgBiFVEiFmXiFitiFbBiFMFiFrFUCXQUIoQUIJcUHQJUeCEUHwXUUJDUUqXUdWcUcqXUrnQUFNDUFSHUFCFUFEfUFLXUtFOZBXOZXSBZXpFZXVXZEQJZEJkZpDJZOqXZeNHZeCDZUqXZFBQZFEHZFLXvBAFvBKFvBCXvBEPvBpHvBIDvBgFvBuHvQNJvFNFvFGBvFIBvJFcsXCDsXLXsXsXsXlFsXcHsQqXsJQFsEqXseIFsFEHsFjDdBxOdNpRdNJRdEJbdpJRdhZJdnSJdrjNdFNJdFQHdFhNkNJDkYaRkHNRkHSRkVbRkuMRkjSJkcqDoSJFoEiJoYZJoOfXohEBoMGQocqXbBAFbBXFbBaFbBNDbBGBbBLXbBTBbBWDbGJYbIJHbFQqbFpQlDgQlOrFlVJRjGEBjZJRnXvJnXbBnEfHnOPDngJRnxfXnUJWwXEJwNpJwDpBwEfXwrEBMDCJMDGHMDIJMLJDcQGDcQpHcqXccqNFcqCXcFCJRBSBRBGBRBEJRBpQTBNFTBQJTBpBTBVXTFABTFSBTFCFTFGBTFMDrXCJrXLDrDNJrEfHrFQJrFitWNjdWNTR", - "AKLJMANOPFASNJIAEJWXAYJNRAIIbRAIcdaAeEfDAgidRAdjNYAMYEJAMIbRAFNJBAFpJFBBIJYBDZJFBSiJhBGdEBBEJfXBEJqXBEJWRBpaUJBLXrXBIYJMBOcfXBeEfFBestXBjNJRBcDJOBFEqXXNvJRXDMBhXCJNYXOAWpXONJWXHDEBXeIaRXhYJDXZJSJXMDJOXcASJXFVJXaBQqXaBZJFasXdQaFSJQaFEfXaFpJHaFOqXKBNSRKXvJBKQJhXKEJQJKEJGFKINJBKIJjNKgJNSKVElmKVhEBKiJGFKlBgJKjnUJKwsJYKMFIJKFNJDKFIJFKFOfXNJBSFNJBCXNBpJFNJBvQNJBMBNJLJXNJOqXNJeCXNJeGFNdsJCNbTKFNwXUJQNFEPQDiJcQDMSJQSFpBQGMQJQJeOcQyCJEQUJEBQJFBrQFEJqDXDJFDJXpBDJXIMDGiJhDIJGRDJeYcDHrDJDVXgFDkAWpDkIgRDjDEqDMvJRDJFNFDJFIBSKclmSJQOFSJQVHSJQjDSJGJBSJGJFSECJoSHEJqSJHTBSJVJDSViJYSZJNBSJsJDSFSJFSFEfXSJFLXCBUJVCJXSBCJXpBCXVJXCJXsXCJXdFCJNJHCLIJgCHiJFCVNJMChCJhCUHEJCsJTRCJdYcCoQJCCFEfXCFIJgCFUJxCFstFGJBaQGJBIDGQJqXGYJNRGJHKFGeQqDGHEJFGJeLXGHIiJGHdBlGUJEBGkIJTGFQPDGJFEqEAGegEJIJBEJVJXEhQJTEiJNcEJZJFEJoEqEjDEqEPDsXEPGJBEPOqXEPeQFEfDiDEJfEFEfepQEfMiJEqXNBEqDIDEqeSFEqVJXEMvJRYXNJDYXEJHYKVJcYYJEBYJeEcYJUqXYFpJFYFstXpAZJMpBSJFpNBNFpeQPDpHLJDpHIJFpHgJFpeitFpHZJFpJFADpFSJFpJFCJpFOqXpFitBpJFZJLXIJFLIJgRLVNJWLVHJMLwNpJLFGJBLFLJDLFOqXLJFUJIBDJXIBGJBIJBYQIJBIBIBOqXIBcqDIEGJFILNJTIIJEBIOiJhIJeNBIJeIBIhiJIIWoTRIJFAHIJFpBIJFuHIFUtFIJFTHOSBYJOEcqXOHEJqOvBpFOkVJrObBVJOncqDOcNJkHhNJRHuHJuHdMhBgBUqXgBsJXgONJBgHNJDgHHJQgJeitgHsJXgJyNagyDJBgZJDrgsVJQgkEJNgkjSJgJFAHgFCJDgFZtMVJXNFVXQfXVJXDJVXoQJVQVJQVDEfXVDvJHVEqNFVeQfXVHpJFVHxfXVVJSRVVmaRVlIJOhCXVJhHjYkhxCJVhWVUJhWiJcxBNJIxeEqDxfXBFxcFEPxFSJFxFYJXyBDQJydaUJyFOPDuYCJYuLvJRuHLJXuZJLDuFOPDuFZJHuFcqXmKHJdmCQJcmOsVJiJAGFitLCFieOfXiestXiZJMEikNJQirXzFiFQqXiFIJFiFZJFiFvtFUHpJFUteIcUteOcUVCJkUhdHcUbEJEUJqXQUMNJhURjYkUFitFZDGJHZJIxDZJVJXZJFDJZJFpQvBNJBvBSJFvJxBrseQqDsVFVJdFLJDkEJNBkmNJYkFLJDoQJOPoGsJRoEAHBoEJfFbBQqDbBZJHbFVJXlFIJBjYIrXjeitcjjCEBjWMNBwXQfXwXOaFwDsJXwCJTRwrCZJMDNJQcDDJFcqDOPRYiJFTBsJXTQIJBTFEfXTFLJDrXEJFrEJXMrFZJFWEJdEWYTlm", - "ABCDEFACNJTRAMBDJdAcNJVXBLNJEBXSIdWRXErNJkXYDJMBXZJCJaXMNJaYKKVJKcKDEJqXKDcNJhKVJrNYKbgJVXKFVJSBNBYBwDNJeQfXNJeEqXNhGJWENJFiJRQlIJbEQJfXxDQqXcfXQFNDEJQFwXUJDYcnUJDJIBgQDIUJTRDJFEqDSJQSJFSJQIJFSOPeZtSJFZJHCJXQfXCTDEqFGJBSJFGJBOfXGJBcqXGJHNJDGJRLiJEJfXEqEJFEJPEFpBEJYJBZJFYBwXUJYiJMEBYJZJyTYTONJXpQMFXFpeGIDdpJFstXpJFcPDLBVSJRLHQJqXLJFZJFIJBNJDIJBUqXIBkFDJIJEJPTIYJGWRIJeQPDIJeEfHIJFsJXOqGDSFHXEJqXgJCsJCgGQJqXgdQYJEgFMFNBgJFcqDVJwXUJVJFZJchIgJCCxOEJqXxOwXUJyDJBVRuscisciJBiJBieUtqXiJFDJkiFsJXQUGEZJcUJFsJXZtXIrXZDZJDrZJFNJDZJFstXvJFQqXvJFCJEsJXQJqkhkNGBbDJdTRbYJMEBlDwXUJMEFiJFcfXNJDRcNJWMTBLJXC", - "BraFUtHBFSJFdbNBLJXVJQoYJNEBSJBEJfHSJHwXUJCJdAZJMGjaFVJXEJPNJBlEJfFiJFpFbFEJqIJBVJCrIBdHiJhOPFChvJVJZJNJWxGFNIFLueIBQJqUHEJfUFstOZJDrlXEASJRlXVJXSFwVJNJWD", - "QJEJNNJDQJEJIBSFQJEJxegBQJEJfHEPSJBmXEJFSJCDEJqXLXNJFQqXIcQsFNJFIFEJqXUJgFsJXIJBUJEJfHNFvJxEqXNJnXUJFQqD", - "IJBEJqXZJ", - ], - Jwr = - "~~AzB~X~a~KN~Q~D~S~C~G~E~Y~p~L~I~O~eH~g~V~hxyumi~~U~~Z~~v~~s~~dkoblPjfnqwMcRTr~W~~~F~~~~~Jt", - t0 = null; - function Nlt(t) { - return (0, Wwr.hexlify)((0, qy.toUtf8Bytes)(t)); - } - var $wr = "0xe3818de38284e3818f", - Zwr = "0xe3818de38283e3818f"; - function Dlt(t) { - if (t0 !== null) return; - t0 = []; - var e = {}; - (e[(0, qy.toUtf8String)([227, 130, 154])] = !1), - (e[(0, qy.toUtf8String)([227, 130, 153])] = !1), - (e[(0, qy.toUtf8String)([227, 130, 133])] = (0, qy.toUtf8String)([ - 227, 130, 134, - ])), - (e[(0, qy.toUtf8String)([227, 129, 163])] = (0, qy.toUtf8String)([ - 227, 129, 164, - ])), - (e[(0, qy.toUtf8String)([227, 130, 131])] = (0, qy.toUtf8String)([ - 227, 130, 132, - ])), - (e[(0, qy.toUtf8String)([227, 130, 135])] = (0, qy.toUtf8String)([ - 227, 130, 136, - ])); - function r(w) { - for (var M = "", k = 0; k < w.length; k++) { - var O = w[k], - D = e[O]; - D !== !1 && (D && (O = D), (M += O)); - } - return M; - } - function n(w, M) { - return (w = r(w)), (M = r(M)), w < M ? -1 : w > M ? 1 : 0; - } - for (var i = 3; i <= 9; i++) - for (var o = Gwr[i - 3], a = 0; a < o.length; a += i) { - for (var s = [], c = 0; c < i; c++) { - var u = Jwr.indexOf(o[a + c]); - s.push(227), s.push(u & 64 ? 130 : 129), s.push((u & 63) + 128); - } - t0.push((0, qy.toUtf8String)(s)); - } - if ((t0.sort(n), Nlt(t0[442]) === $wr && Nlt(t0[443]) === Zwr)) { - var h = t0[442]; - (t0[442] = t0[443]), (t0[443] = h); - } - if ( - nne.Wordlist.check(t) !== - "0xcb36b09e6baa935787fd762ce65e80b0c6a8dabdfbc3a7f86ac0e2c4fd111600" - ) - throw ( - ((t0 = null), new Error("BIP39 Wordlist for ja (Japanese) FAILED")) - ); - } - var Xwr = (function (t) { - Vwr(e, t); - function e() { - return t.call(this, "ja") || this; - } - return ( - (e.prototype.getWord = function (r) { - return Dlt(this), t0[r]; - }), - (e.prototype.getWordIndex = function (r) { - return Dlt(this), t0.indexOf(r); - }), - (e.prototype.split = function (r) { - return nne.logger.checkNormalize(), r.split(/(?:\u3000| )+/g); - }), - (e.prototype.join = function (r) { - return r.join("\u3000"); - }), - e - ); - })(nne.Wordlist), - Flt = new Xwr(); - GR.langJa = Flt; - nne.Wordlist.register(Flt); - }); - var jlt = I((JR) => { - "use strict"; - m(); - g(); - var Ywr = - (JR && JR.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(JR, "__esModule", { value: !0 }); - JR.langKo = void 0; - var Qwr = Eo(), - GAe = yb(), - e_r = [ - "OYAa", - "ATAZoATBl3ATCTrATCl8ATDloATGg3ATHT8ATJT8ATJl3ATLlvATLn4ATMT8ATMX8ATMboATMgoAToLbAToMTATrHgATvHnAT3AnAT3JbAT3MTAT8DbAT8JTAT8LmAT8MYAT8MbAT#LnAUHT8AUHZvAUJXrAUJX8AULnrAXJnvAXLUoAXLgvAXMn6AXRg3AXrMbAX3JTAX3QbAYLn3AZLgvAZrSUAZvAcAZ8AaAZ8AbAZ8AnAZ8HnAZ8LgAZ8MYAZ8MgAZ8OnAaAboAaDTrAaFTrAaJTrAaJboAaLVoAaMXvAaOl8AaSeoAbAUoAbAg8AbAl4AbGnrAbMT8AbMXrAbMn4AbQb8AbSV8AbvRlAb8AUAb8AnAb8HgAb8JTAb8NTAb8RbAcGboAcLnvAcMT8AcMX8AcSToAcrAaAcrFnAc8AbAc8MgAfGgrAfHboAfJnvAfLV8AfLkoAfMT8AfMnoAfQb8AfScrAfSgrAgAZ8AgFl3AgGX8AgHZvAgHgrAgJXoAgJX8AgJboAgLZoAgLn4AgOX8AgoATAgoAnAgoCUAgoJgAgoLXAgoMYAgoSeAgrDUAgrJTAhrFnAhrLjAhrQgAjAgoAjJnrAkMX8AkOnoAlCTvAlCV8AlClvAlFg4AlFl6AlFn3AloSnAlrAXAlrAfAlrFUAlrFbAlrGgAlrOXAlvKnAlvMTAl3AbAl3MnAnATrAnAcrAnCZ3AnCl8AnDg8AnFboAnFl3AnHX4AnHbrAnHgrAnIl3AnJgvAnLXoAnLX4AnLbrAnLgrAnLhrAnMXoAnMgrAnOn3AnSbrAnSeoAnvLnAn3OnCTGgvCTSlvCTvAUCTvKnCTvNTCT3CZCT3GUCT3MTCT8HnCUCZrCULf8CULnvCU3HnCU3JUCY6NUCbDb8CbFZoCbLnrCboOTCboScCbrFnCbvLnCb8AgCb8HgCb$LnCkLfoClBn3CloDUDTHT8DTLl3DTSU8DTrAaDTrLXDTrLjDTrOYDTrOgDTvFXDTvFnDT3HUDT3LfDUCT9DUDT4DUFVoDUFV8DUFkoDUGgrDUJnrDULl8DUMT8DUMXrDUMX4DUMg8DUOUoDUOgvDUOg8DUSToDUSZ8DbDXoDbDgoDbGT8DbJn3DbLg3DbLn4DbMXrDbMg8DbOToDboJXGTClvGTDT8GTFZrGTLVoGTLlvGTLl3GTMg8GTOTvGTSlrGToCUGTrDgGTrJYGTrScGTtLnGTvAnGTvQgGUCZrGUDTvGUFZoGUHXrGULnvGUMT8GUoMgGXoLnGXrMXGXrMnGXvFnGYLnvGZOnvGZvOnGZ8LaGZ8LmGbAl3GbDYvGbDlrGbHX3GbJl4GbLV8GbLn3GbMn4GboJTGboRfGbvFUGb3GUGb4JnGgDX3GgFl$GgJlrGgLX6GgLZoGgLf8GgOXoGgrAgGgrJXGgrMYGgrScGgvATGgvOYGnAgoGnJgvGnLZoGnLg3GnLnrGnQn8GnSbrGnrMgHTClvHTDToHTFT3HTQT8HToJTHToJgHTrDUHTrMnHTvFYHTvRfHT8MnHT8SUHUAZ8HUBb4HUDTvHUoMYHXFl6HXJX6HXQlrHXrAUHXrMnHXrSbHXvFYHXvKXHX3LjHX3MeHYvQlHZrScHZvDbHbAcrHbFT3HbFl3HbJT8HbLTrHbMT8HbMXrHbMbrHbQb8HbSX3HboDbHboJTHbrFUHbrHgHbrJTHb8JTHb8MnHb8QgHgAlrHgDT3HgGgrHgHgrHgJTrHgJT8HgLX@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", - "ATLnDlATrAZoATrJX4ATrMT8ATrMX4ATrRTrATvDl8ATvJUoATvMl8AT3AToAT3MX8AT8CT3AT8DT8AT8HZrAT8HgoAUAgFnAUCTFnAXoMX8AXrAT8AXrGgvAXrJXvAXrOgoAXvLl3AZvAgoAZvFbrAZvJXoAZvJl8AZvJn3AZvMX8AZvSbrAZ8FZoAZ8LZ8AZ8MU8AZ8OTvAZ8SV8AZ8SX3AbAgFZAboJnoAbvGboAb8ATrAb8AZoAb8AgrAb8Al4Ab8Db8Ab8JnoAb8LX4Ab8LZrAb8LhrAb8MT8Ab8OUoAb8Qb8Ab8ST8AcrAUoAcrAc8AcrCZ3AcrFT3AcrFZrAcrJl4AcrJn3AcrMX3AcrOTvAc8AZ8Ac8MT8AfAcJXAgoFn4AgoGgvAgoGnrAgoLc8AgoMXoAgrLnrAkrSZ8AlFXCTAloHboAlrHbrAlrLhrAlrLkoAl3CZrAl3LUoAl3LZrAnrAl4AnrMT8An3HT4BT3IToBX4MnvBb!Ln$CTGXMnCToLZ4CTrHT8CT3JTrCT3RZrCT#GTvCU6GgvCU8Db8CU8GZrCU8HT8CboLl3CbrGgrCbrMU8Cb8DT3Cb8GnrCb8LX4Cb8MT8Cb8ObrCgrGgvCgrKX4Cl8FZoDTrAbvDTrDboDTrGT6DTrJgrDTrMX3DTrRZrDTrRg8DTvAVvDTvFZoDT3DT8DT3Ln3DT4HZrDT4MT8DT8AlrDT8MT8DUAkGbDUDbJnDYLnQlDbDUOYDbMTAnDbMXSnDboAT3DboFn4DboLnvDj6JTrGTCgFTGTGgFnGTJTMnGTLnPlGToJT8GTrCT3GTrLVoGTrLnvGTrMX3GTrMboGTvKl3GZClFnGZrDT3GZ8DTrGZ8FZ8GZ8MXvGZ8On8GZ8ST3GbCnQXGbMbFnGboFboGboJg3GboMXoGb3JTvGb3JboGb3Mn6Gb3Qb8GgDXLjGgMnAUGgrDloGgrHX4GgrSToGgvAXrGgvAZvGgvFbrGgvLl3GgvMnvGnDnLXGnrATrGnrMboGnuLl3HTATMnHTAgCnHTCTCTHTrGTvHTrHTvHTrJX8HTrLl8HTrMT8HTrMgoHTrOTrHTuOn3HTvAZrHTvDTvHTvGboHTvJU8HTvLl3HTvMXrHTvQb4HT4GT6HT4JT8HT4Jb#HT8Al3HT8GZrHT8GgrHT8HX4HT8Jb8HT8JnoHT8LTrHT8LgvHT8SToHT8SV8HUoJUoHUoJX8HUoLnrHXrLZoHXvAl3HX3LnrHX4FkvHX4LhrHX4MXoHX4OnoHZrAZ8HZrDb8HZrGZ8HZrJnrHZvGZ8HZvLnvHZ8JnvHZ8LhrHbCXJlHbMTAnHboJl4HbpLl3HbrJX8HbrLnrHbrMnvHbvRYrHgoSTrHgrFV8HgrGZ8HgrJXoHgrRnvHgvBb!HgvGTrHgvHX4HgvHn!HgvLTrHgvSU8HnDnLbHnFbJbHnvDn8Hn6GgvHn!BTvJTCTLnJTQgFnJTrAnvJTrLX4JTrOUoJTvFn3JTvLnrJTvNToJT3AgoJT3Jn4JT3LhvJT3ObrJT8AcrJT8Al3JT8JT8JT8JnoJT8LX4JT8LnrJT8MX3JT8Rg3JT8Sc8JUoBTvJU8AToJU8GZ8JU8GgvJU8JTrJU8JXrJU8JnrJU8LnvJU8ScvJXHnJlJXrGgvJXrJU8JXrLhrJXrMT8JXrMXrJXrQUoJXvCTvJXvGZ8JXvGgrJXvQT8JX8Ab8JX8DT8JX8GZ8JX8HZvJX8LnrJX8MT8JX8MXoJX8MnvJX8ST3JYGnCTJbAkGbJbCTAnJbLTAcJboDT3JboLb6JbrAnvJbrCn3JbrDl8JbrGboJbrIZoJbrJnvJbrMnvJbrQb4Jb8RZrJeAbAnJgJnFbJgScAnJgrATrJgvHZ8JgvMn4JlJlFbJlLiQXJlLjOnJlRbOlJlvNXoJlvRl3Jl4AcrJl8AUoJl8MnrJnFnMlJnHgGbJnoDT8JnoFV8JnoGgvJnoIT8JnoQToJnoRg3JnrCZ3JnrGgrJnrHTvJnrLf8JnrOX8JnvAT3JnvFZoJnvGT8JnvJl4JnvMT8JnvMX8JnvOXrJnvPX6JnvSX3JnvSZrJn3MT8Jn3MX8Jn3RTrLTATKnLTJnLTLTMXKnLTRTQlLToGb8LTrAZ8LTrCZ8LTrDb8LTrHT8LT3PX6LT4FZoLT$CTvLT$GgrLUvHX3LVoATrLVoAgoLVoJboLVoMX3LVoRg3LV8CZ3LV8FZoLV8GTvLXrDXoLXrFbrLXvAgvLXvFlrLXvLl3LXvRn6LX4Mb8LX8GT8LYCXMnLYrMnrLZoSTvLZrAZvLZrAloLZrFToLZrJXvLZrJboLZrJl4LZrLnrLZrMT8LZrOgvLZrRnvLZrST4LZvMX8LZvSlvLZ8AgoLZ8CT3LZ8JT8LZ8LV8LZ8LZoLZ8Lg8LZ8SV8LZ8SbrLZ$HT8LZ$Mn4La6CTvLbFbMnLbRYFTLbSnFZLboJT8LbrAT9LbrGb3LbrQb8LcrJX8LcrMXrLerHTvLerJbrLerNboLgrDb8LgrGZ8LgrHTrLgrMXrLgrSU8LgvJTrLgvLl3Lg6Ll3LhrLnrLhrMT8LhvAl4LiLnQXLkoAgrLkoJT8LkoJn4LlrSU8Ll3FZoLl3HTrLl3JX8Ll3JnoLl3LToLmLeFbLnDUFbLnLVAnLnrATrLnrAZoLnrAb8LnrAlrLnrGgvLnrJU8LnrLZrLnrLhrLnrMb8LnrOXrLnrSZ8LnvAb4LnvDTrLnvDl8LnvHTrLnvHbrLnvJT8LnvJU8LnvJbrLnvLhvLnvMX8LnvMb8LnvNnoLnvSU8Ln3Al3Ln4FZoLn4GT6Ln4JgvLn4LhrLn4MT8Ln4SToMToCZrMToJX8MToLX4MToLf8MToRg3MTrEloMTvGb6MT3BTrMT3Lb6MT8AcrMT8AgrMT8GZrMT8JnoMT8LnrMT8MX3MUOUAnMXAbFnMXoAloMXoJX8MXoLf8MXoLl8MXrAb8MXrDTvMXrGT8MXrGgrMXrHTrMXrLf8MXrMU8MXrOXvMXrQb8MXvGT8MXvHTrMXvLVoMX3AX3MX3Jn3MX3LhrMX3MX3MX4AlrMX4OboMX8GTvMX8GZrMX8GgrMX8JT8MX8JX8MX8LhrMX8MT8MYDUFbMYMgDbMbGnFfMbvLX4MbvLl3Mb8Mb8Mb8ST4MgGXCnMg8ATrMg8AgoMg8CZrMg8DTrMg8DboMg8HTrMg8JgrMg8LT8MloJXoMl8AhrMl8JT8MnLgAUMnoJXrMnoLX4MnoLhrMnoMT8MnrAl4MnrDb8MnrOTvMnrOgvMnrQb8MnrSU8MnvGgrMnvHZ8Mn3MToMn4DTrMn4LTrMn4Mg8NnBXAnOTFTFnOToAToOTrGgvOTrJX8OT3JXoOT6MTrOT8GgrOT8HTpOT8MToOUoHT8OUoJT8OUoLn3OXrAgoOXrDg8OXrMT8OXvSToOX6CTvOX8CZrOX8OgrOb6HgvOb8AToOb8MT8OcvLZ8OgvAlrOgvHTvOgvJTrOgvJnrOgvLZrOgvLn4OgvMT8OgvRTrOg8AZoOg8DbvOnrOXoOnvJn4OnvLhvOnvRTrOn3GgoOn3JnvOn6JbvOn8OTrPTGYFTPbBnFnPbGnDnPgDYQTPlrAnvPlrETvPlrLnvPlrMXvPlvFX4QTMTAnQTrJU8QYCnJlQYJlQlQbGTQbQb8JnrQb8LZoQb8LnvQb8MT8Qb8Ml8Qb8ST4QloAl4QloHZvQloJX8QloMn8QnJZOlRTrAZvRTrDTrRTvJn4RTvLhvRT4Jb8RZrAZrRZ8AkrRZ8JU8RZ8LV8RZ8LnvRbJlQXRg3GboRg3MnvRg8AZ8Rg8JboRg8Jl4RnLTCbRnvFl3RnvQb8SToAl4SToCZrSToFZoSToHXrSToJU8SToJgvSToJl4SToLhrSToMX3STrAlvSTrCT9STrCgrSTrGgrSTrHXrSTrHboSTrJnoSTrNboSTvLnrST4AZoST8Ab8ST8JT8SUoJn3SU6HZ#SU6JTvSU8Db8SU8HboSU8LgrSV8JT8SZrAcrSZrAl3SZrJT8SZrJnvSZrMT8SZvLUoSZ4FZoSZ8JnoSZ8RZrScoLnrScoMT8ScoMX8ScrAT4ScrAZ8ScrLZ8ScrLkvScvDb8ScvLf8ScvNToSgrFZrShvKnrSloHUoSloLnrSlrMXoSl8HgrSmrJUoSn3BX6", - "ATFlOn3ATLgrDYAT4MTAnAT8LTMnAYJnRTrAbGgJnrAbLV8LnAbvNTAnAeFbLg3AgOYMXoAlQbFboAnDboAfAnJgoJTBToDgAnBUJbAl3BboDUAnCTDlvLnCTFTrSnCYoQTLnDTwAbAnDUDTrSnDUHgHgrDX8LXFnDbJXAcrETvLTLnGTFTQbrGTMnGToGT3DUFbGUJlPX3GbQg8LnGboJbFnGb3GgAYGgAg8ScGgMbAXrGgvAbAnGnJTLnvGnvATFgHTDT6ATHTrDlJnHYLnMn8HZrSbJTHZ8LTFnHbFTJUoHgSeMT8HgrLjAnHgvAbAnHlFUrDlHnDgvAnHnHTFT3HnQTGnrJTAaMXvJTGbCn3JTOgrAnJXvAXMnJbMg8SnJbMnRg3Jb8LTMnJnAl3OnJnGYrQlJnJlQY3LTDlCn3LTJjLg3LTLgvFXLTMg3GTLV8HUOgLXFZLg3LXNXrMnLX8QXFnLX9AlMYLYLXPXrLZAbJU8LZDUJU8LZMXrSnLZ$AgFnLaPXrDULbFYrMnLbMn8LXLboJgJgLeFbLg3LgLZrSnLgOYAgoLhrRnJlLkCTrSnLkOnLhrLnFX%AYLnFZoJXLnHTvJbLnLloAbMTATLf8MTHgJn3MTMXrAXMT3MTFnMUITvFnMXFX%AYMXMXvFbMXrFTDbMYAcMX3MbLf8SnMb8JbFnMgMXrMTMgvAXFnMgvGgCmMnAloSnMnFnJTrOXvMXSnOX8HTMnObJT8ScObLZFl3ObMXCZoPTLgrQXPUFnoQXPU3RXJlPX3RkQXPbrJXQlPlrJbFnQUAhrDbQXGnCXvQYLnHlvQbLfLnvRTOgvJbRXJYrQlRYLnrQlRbLnrQlRlFT8JlRlFnrQXSTClCn3STHTrAnSTLZQlrSTMnGTrSToHgGbSTrGTDnSTvGXCnST3HgFbSU3HXAXSbAnJn3SbFT8LnScLfLnv", - "AT3JgJX8AT8FZoSnAT8JgFV8AT8LhrDbAZ8JT8DbAb8GgLhrAb8SkLnvAe8MT8SnAlMYJXLVAl3GYDTvAl3LfLnvBUDTvLl3CTOn3HTrCT3DUGgrCU8MT8AbCbFTrJUoCgrDb8MTDTLV8JX8DTLnLXQlDT8LZrSnDUQb8FZ8DUST4JnvDb8ScOUoDj6GbJl4GTLfCYMlGToAXvFnGboAXvLnGgAcrJn3GgvFnSToGnLf8JnvGn#HTDToHTLnFXJlHTvATFToHTvHTDToHTvMTAgoHT3STClvHT4AlFl6HT8HTDToHUoDgJTrHUoScMX3HbRZrMXoHboJg8LTHgDb8JTrHgMToLf8HgvLnLnoHnHn3HT4Hn6MgvAnJTJU8ScvJT3AaQT8JT8HTrAnJXrRg8AnJbAloMXoJbrATFToJbvMnoSnJgDb6GgvJgDb8MXoJgSX3JU8JguATFToJlPYLnQlJlQkDnLbJlQlFYJlJl8Lf8OTJnCTFnLbJnLTHXMnJnLXGXCnJnoFfRg3JnrMYRg3Jn3HgFl3KT8Dg8LnLTRlFnPTLTvPbLbvLVoSbrCZLXMY6HT3LXNU7DlrLXNXDTATLX8DX8LnLZDb8JU8LZMnoLhrLZSToJU8LZrLaLnrLZvJn3SnLZ8LhrSnLaJnoMT8LbFlrHTvLbrFTLnrLbvATLlvLb6OTFn3LcLnJZOlLeAT6Mn4LeJT3ObrLg6LXFlrLhrJg8LnLhvDlPX4LhvLfLnvLj6JTFT3LnFbrMXoLnQluCTvLnrQXCY6LnvLfLnvLnvMgLnvLnvSeLf8MTMbrJn3MT3JgST3MT8AnATrMT8LULnrMUMToCZrMUScvLf8MXoDT8SnMX6ATFToMX8AXMT8MX8FkMT8MX8HTrDUMX8ScoSnMYJT6CTvMgAcrMXoMg8SToAfMlvAXLg3MnFl3AnvOT3AnFl3OUoATHT8OU3RnLXrOXrOXrSnObPbvFn6Og8HgrSnOg8OX8DbPTvAgoJgPU3RYLnrPXrDnJZrPb8CTGgvPlrLTDlvPlvFUJnoQUvFXrQlQeMnoAl3QlrQlrSnRTFTrJUoSTDlLiLXSTFg6HT3STJgoMn4STrFTJTrSTrLZFl3ST4FnMXoSUrDlHUoScvHTvSnSfLkvMXo", - "AUoAcrMXoAZ8HboAg8AbOg6ATFgAg8AloMXoAl3AT8JTrAl8MX8MXoCT3SToJU8Cl8Db8MXoDT8HgrATrDboOT8MXoGTOTrATMnGT8LhrAZ8GnvFnGnQXHToGgvAcrHTvAXvLl3HbrAZoMXoHgBlFXLg3HgMnFXrSnHgrSb8JUoHn6HT8LgvITvATrJUoJUoLZrRnvJU8HT8Jb8JXvFX8QT8JXvLToJTrJYrQnGnQXJgrJnoATrJnoJU8ScvJnvMnvMXoLTCTLgrJXLTJlRTvQlLbRnJlQYvLbrMb8LnvLbvFn3RnoLdCVSTGZrLeSTvGXCnLg3MnoLn3MToLlrETvMT8SToAl3MbrDU6GTvMb8LX4LhrPlrLXGXCnSToLf8Rg3STrDb8LTrSTvLTHXMnSb3RYLnMnSgOg6ATFg", - "HUDlGnrQXrJTrHgLnrAcJYMb8DULc8LTvFgGnCk3Mg8JbAnLX4QYvFYHnMXrRUoJnGnvFnRlvFTJlQnoSTrBXHXrLYSUJgLfoMT8Se8DTrHbDb", - "AbDl8SToJU8An3RbAb8ST8DUSTrGnrAgoLbFU6Db8LTrMg8AaHT8Jb8ObDl8SToJU8Pb3RlvFYoJl", - ], - t_r = - "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*"; - function r_r(t) { - return ( - t >= 40 ? (t = t + 168 - 40) : t >= 19 && (t = t + 97 - 19), - (0, Qwr.toUtf8String)([225, (t >> 6) + 132, (t & 63) + 128]) - ); - } - var a6 = null; - function qlt(t) { - if ( - a6 == null && - ((a6 = []), - e_r.forEach(function (e, r) { - r += 4; - for (var n = 0; n < e.length; n += r) { - for (var i = "", o = 0; o < r; o++) i += r_r(t_r.indexOf(e[n + o])); - a6.push(i); - } - }), - a6.sort(), - GAe.Wordlist.check(t) !== - "0xf9eddeace9c5d3da9c93cf7d3cd38f6a13ed3affb933259ae865714e8a3ae71a") - ) - throw ((a6 = null), new Error("BIP39 Wordlist for ko (Korean) FAILED")); - } - var n_r = (function (t) { - Ywr(e, t); - function e() { - return t.call(this, "ko") || this; - } - return ( - (e.prototype.getWord = function (r) { - return qlt(this), a6[r]; - }), - (e.prototype.getWordIndex = function (r) { - return qlt(this), a6.indexOf(r); - }), - e - ); - })(GAe.Wordlist), - zlt = new n_r(); - JR.langKo = zlt; - GAe.Wordlist.register(zlt); - }); - var Hlt = I(($R) => { - "use strict"; - m(); - g(); - var i_r = - ($R && $R.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty($R, "__esModule", { value: !0 }); - $R.langIt = void 0; - var JAe = yb(), - o_r = - "AbacoAbbaglioAbbinatoAbeteAbissoAbolireAbrasivoAbrogatoAccadereAccennoAccusatoAcetoneAchilleAcidoAcquaAcreAcrilicoAcrobataAcutoAdagioAddebitoAddomeAdeguatoAderireAdipeAdottareAdulareAffabileAffettoAffissoAffrantoAforismaAfosoAfricanoAgaveAgenteAgevoleAggancioAgireAgitareAgonismoAgricoloAgrumetoAguzzoAlabardaAlatoAlbatroAlberatoAlboAlbumeAlceAlcolicoAlettoneAlfaAlgebraAlianteAlibiAlimentoAllagatoAllegroAllievoAllodolaAllusivoAlmenoAlogenoAlpacaAlpestreAltalenaAlternoAlticcioAltroveAlunnoAlveoloAlzareAmalgamaAmanitaAmarenaAmbitoAmbratoAmebaAmericaAmetistaAmicoAmmassoAmmendaAmmirareAmmonitoAmoreAmpioAmpliareAmuletoAnacardoAnagrafeAnalistaAnarchiaAnatraAncaAncellaAncoraAndareAndreaAnelloAngeloAngolareAngustoAnimaAnnegareAnnidatoAnnoAnnuncioAnonimoAnticipoAnziApaticoAperturaApodeApparireAppetitoAppoggioApprodoAppuntoAprileArabicaArachideAragostaAraldicaArancioAraturaArazzoArbitroArchivioArditoArenileArgentoArgineArgutoAriaArmoniaArneseArredatoArringaArrostoArsenicoArsoArteficeArzilloAsciuttoAscoltoAsepsiAsetticoAsfaltoAsinoAsolaAspiratoAsproAssaggioAsseAssolutoAssurdoAstaAstenutoAsticeAstrattoAtavicoAteismoAtomicoAtonoAttesaAttivareAttornoAttritoAttualeAusilioAustriaAutistaAutonomoAutunnoAvanzatoAvereAvvenireAvvisoAvvolgereAzioneAzotoAzzimoAzzurroBabeleBaccanoBacinoBacoBadessaBadilataBagnatoBaitaBalconeBaldoBalenaBallataBalzanoBambinoBandireBaraondaBarbaroBarcaBaritonoBarlumeBaroccoBasilicoBassoBatostaBattutoBauleBavaBavosaBeccoBeffaBelgioBelvaBendaBenevoleBenignoBenzinaBereBerlinaBetaBibitaBiciBidoneBifidoBigaBilanciaBimboBinocoloBiologoBipedeBipolareBirbanteBirraBiscottoBisestoBisnonnoBisonteBisturiBizzarroBlandoBlattaBollitoBonificoBordoBoscoBotanicoBottinoBozzoloBraccioBradipoBramaBrancaBravuraBretellaBrevettoBrezzaBrigliaBrillanteBrindareBroccoloBrodoBronzinaBrulloBrunoBubboneBucaBudinoBuffoneBuioBulboBuonoBurloneBurrascaBussolaBustaCadettoCaducoCalamaroCalcoloCalesseCalibroCalmoCaloriaCambusaCamerataCamiciaCamminoCamolaCampaleCanapaCandelaCaneCaninoCanottoCantinaCapaceCapelloCapitoloCapogiroCapperoCapraCapsulaCarapaceCarcassaCardoCarismaCarovanaCarrettoCartolinaCasaccioCascataCasermaCasoCassoneCastelloCasualeCatastaCatenaCatrameCautoCavilloCedibileCedrataCefaloCelebreCellulareCenaCenoneCentesimoCeramicaCercareCertoCerumeCervelloCesoiaCespoCetoChelaChiaroChiccaChiedereChimeraChinaChirurgoChitarraCiaoCiclismoCifrareCignoCilindroCiottoloCircaCirrosiCitricoCittadinoCiuffoCivettaCivileClassicoClinicaCloroCoccoCodardoCodiceCoerenteCognomeCollareColmatoColoreColposoColtivatoColzaComaCometaCommandoComodoComputerComuneConcisoCondurreConfermaCongelareConiugeConnessoConoscereConsumoContinuoConvegnoCopertoCopioneCoppiaCopricapoCorazzaCordataCoricatoCorniceCorollaCorpoCorredoCorsiaCorteseCosmicoCostanteCotturaCovatoCratereCravattaCreatoCredereCremosoCrescitaCretaCricetoCrinaleCrisiCriticoCroceCronacaCrostataCrucialeCruscaCucireCuculoCuginoCullatoCupolaCuratoreCursoreCurvoCuscinoCustodeDadoDainoDalmataDamerinoDanielaDannosoDanzareDatatoDavantiDavveroDebuttoDecennioDecisoDeclinoDecolloDecretoDedicatoDefinitoDeformeDegnoDelegareDelfinoDelirioDeltaDemenzaDenotatoDentroDepositoDerapataDerivareDerogaDescrittoDesertoDesiderioDesumereDetersivoDevotoDiametroDicembreDiedroDifesoDiffusoDigerireDigitaleDiluvioDinamicoDinnanziDipintoDiplomaDipoloDiradareDireDirottoDirupoDisagioDiscretoDisfareDisgeloDispostoDistanzaDisumanoDitoDivanoDiveltoDividereDivoratoDobloneDocenteDoganaleDogmaDolceDomatoDomenicaDominareDondoloDonoDormireDoteDottoreDovutoDozzinaDragoDruidoDubbioDubitareDucaleDunaDuomoDupliceDuraturoEbanoEccessoEccoEclissiEconomiaEderaEdicolaEdileEditoriaEducareEgemoniaEgliEgoismoEgregioElaboratoElargireEleganteElencatoElettoElevareElficoElicaElmoElsaElusoEmanatoEmblemaEmessoEmiroEmotivoEmozioneEmpiricoEmuloEndemicoEnduroEnergiaEnfasiEnotecaEntrareEnzimaEpatiteEpilogoEpisodioEpocaleEppureEquatoreErarioErbaErbosoEredeEremitaErigereErmeticoEroeErosivoErranteEsagonoEsameEsanimeEsaudireEscaEsempioEsercitoEsibitoEsigenteEsistereEsitoEsofagoEsortatoEsosoEspansoEspressoEssenzaEssoEstesoEstimareEstoniaEstrosoEsultareEtilicoEtnicoEtruscoEttoEuclideoEuropaEvasoEvidenzaEvitatoEvolutoEvvivaFabbricaFaccendaFachiroFalcoFamigliaFanaleFanfaraFangoFantasmaFareFarfallaFarinosoFarmacoFasciaFastosoFasulloFaticareFatoFavolosoFebbreFecolaFedeFegatoFelpaFeltroFemminaFendereFenomenoFermentoFerroFertileFessuraFestivoFettaFeudoFiabaFiduciaFifaFiguratoFiloFinanzaFinestraFinireFioreFiscaleFisicoFiumeFlaconeFlamencoFleboFlemmaFloridoFluenteFluoroFobicoFocacciaFocosoFoderatoFoglioFolataFolcloreFolgoreFondenteFoneticoFoniaFontanaForbitoForchettaForestaFormicaFornaioForoFortezzaForzareFosfatoFossoFracassoFranaFrassinoFratelloFreccettaFrenataFrescoFrigoFrollinoFrondeFrugaleFruttaFucilataFucsiaFuggenteFulmineFulvoFumanteFumettoFumosoFuneFunzioneFuocoFurboFurgoneFuroreFusoFutileGabbianoGaffeGalateoGallinaGaloppoGamberoGammaGaranziaGarboGarofanoGarzoneGasdottoGasolioGastricoGattoGaudioGazeboGazzellaGecoGelatinaGelsoGemelloGemmatoGeneGenitoreGennaioGenotipoGergoGhepardoGhiaccioGhisaGialloGildaGineproGiocareGioielloGiornoGioveGiratoGironeGittataGiudizioGiuratoGiustoGlobuloGlutineGnomoGobbaGolfGomitoGommoneGonfioGonnaGovernoGracileGradoGraficoGrammoGrandeGrattareGravosoGraziaGrecaGreggeGrifoneGrigioGrinzaGrottaGruppoGuadagnoGuaioGuantoGuardareGufoGuidareIbernatoIconaIdenticoIdillioIdoloIdraIdricoIdrogenoIgieneIgnaroIgnoratoIlareIllesoIllogicoIlludereImballoImbevutoImboccoImbutoImmaneImmersoImmolatoImpaccoImpetoImpiegoImportoImprontaInalareInarcareInattivoIncantoIncendioInchinoIncisivoInclusoIncontroIncrocioIncuboIndagineIndiaIndoleIneditoInfattiInfilareInflittoIngaggioIngegnoIngleseIngordoIngrossoInnescoInodoreInoltrareInondatoInsanoInsettoInsiemeInsonniaInsulinaIntasatoInteroIntonacoIntuitoInumidireInvalidoInveceInvitoIperboleIpnoticoIpotesiIppicaIrideIrlandaIronicoIrrigatoIrrorareIsolatoIsotopoIstericoIstitutoIstriceItaliaIterareLabbroLabirintoLaccaLaceratoLacrimaLacunaLaddoveLagoLampoLancettaLanternaLardosoLargaLaringeLastraLatenzaLatinoLattugaLavagnaLavoroLegaleLeggeroLemboLentezzaLenzaLeoneLepreLesivoLessatoLestoLetteraleLevaLevigatoLiberoLidoLievitoLillaLimaturaLimitareLimpidoLineareLinguaLiquidoLiraLiricaLiscaLiteLitigioLivreaLocandaLodeLogicaLombareLondraLongevoLoquaceLorenzoLotoLotteriaLuceLucidatoLumacaLuminosoLungoLupoLuppoloLusingaLussoLuttoMacabroMacchinaMaceroMacinatoMadamaMagicoMagliaMagneteMagroMaiolicaMalafedeMalgradoMalintesoMalsanoMaltoMalumoreManaManciaMandorlaMangiareManifestoMannaroManovraMansardaMantideManubrioMappaMaratonaMarcireMarettaMarmoMarsupioMascheraMassaiaMastinoMaterassoMatricolaMattoneMaturoMazurcaMeandroMeccanicoMecenateMedesimoMeditareMegaMelassaMelisMelodiaMeningeMenoMensolaMercurioMerendaMerloMeschinoMeseMessereMestoloMetalloMetodoMettereMiagolareMicaMicelioMicheleMicroboMidolloMieleMiglioreMilanoMiliteMimosaMineraleMiniMinoreMirinoMirtilloMiscelaMissivaMistoMisurareMitezzaMitigareMitraMittenteMnemonicoModelloModificaModuloMoganoMogioMoleMolossoMonasteroMoncoMondinaMonetarioMonileMonotonoMonsoneMontatoMonvisoMoraMordereMorsicatoMostroMotivatoMotosegaMottoMovenzaMovimentoMozzoMuccaMucosaMuffaMughettoMugnaioMulattoMulinelloMultiploMummiaMuntoMuovereMuraleMusaMuscoloMusicaMutevoleMutoNababboNaftaNanometroNarcisoNariceNarratoNascereNastrareNaturaleNauticaNaviglioNebulosaNecrosiNegativoNegozioNemmenoNeofitaNerettoNervoNessunoNettunoNeutraleNeveNevroticoNicchiaNinfaNitidoNobileNocivoNodoNomeNominaNordicoNormaleNorvegeseNostranoNotareNotiziaNotturnoNovellaNucleoNullaNumeroNuovoNutrireNuvolaNuzialeOasiObbedireObbligoObeliscoOblioOboloObsoletoOccasioneOcchioOccidenteOccorrereOccultareOcraOculatoOdiernoOdorareOffertaOffrireOffuscatoOggettoOggiOgnunoOlandeseOlfattoOliatoOlivaOlogrammaOltreOmaggioOmbelicoOmbraOmegaOmissioneOndosoOnereOniceOnnivoroOnorevoleOntaOperatoOpinioneOppostoOracoloOrafoOrdineOrecchinoOreficeOrfanoOrganicoOrigineOrizzonteOrmaOrmeggioOrnativoOrologioOrrendoOrribileOrtensiaOrticaOrzataOrzoOsareOscurareOsmosiOspedaleOspiteOssaOssidareOstacoloOsteOtiteOtreOttagonoOttimoOttobreOvaleOvestOvinoOviparoOvocitoOvunqueOvviareOzioPacchettoPacePacificoPadellaPadronePaesePagaPaginaPalazzinaPalesarePallidoPaloPaludePandoroPannelloPaoloPaonazzoPapricaParabolaParcellaParerePargoloPariParlatoParolaPartireParvenzaParzialePassivoPasticcaPataccaPatologiaPattumePavonePeccatoPedalarePedonalePeggioPelosoPenarePendicePenisolaPennutoPenombraPensarePentolaPepePepitaPerbenePercorsoPerdonatoPerforarePergamenaPeriodoPermessoPernoPerplessoPersuasoPertugioPervasoPesatorePesistaPesoPestiferoPetaloPettinePetulantePezzoPiacerePiantaPiattinoPiccinoPicozzaPiegaPietraPifferoPigiamaPigolioPigroPilaPiliferoPillolaPilotaPimpantePinetaPinnaPinoloPioggiaPiomboPiramidePireticoPiritePirolisiPitonePizzicoPlaceboPlanarePlasmaPlatanoPlenarioPochezzaPoderosoPodismoPoesiaPoggiarePolentaPoligonoPollicePolmonitePolpettaPolsoPoltronaPolverePomicePomodoroPontePopolosoPorfidoPorosoPorporaPorrePortataPosaPositivoPossessoPostulatoPotassioPoterePranzoPrassiPraticaPreclusoPredicaPrefissoPregiatoPrelievoPremerePrenotarePreparatoPresenzaPretestoPrevalsoPrimaPrincipePrivatoProblemaProcuraProdurreProfumoProgettoProlungaPromessaPronomePropostaProrogaProtesoProvaPrudentePrugnaPruritoPsichePubblicoPudicaPugilatoPugnoPulcePulitoPulsantePuntarePupazzoPupillaPuroQuadroQualcosaQuasiQuerelaQuotaRaccoltoRaddoppioRadicaleRadunatoRafficaRagazzoRagioneRagnoRamarroRamingoRamoRandagioRantolareRapatoRapinaRappresoRasaturaRaschiatoRasenteRassegnaRastrelloRataRavvedutoRealeRecepireRecintoReclutaReconditoRecuperoRedditoRedimereRegalatoRegistroRegolaRegressoRelazioneRemareRemotoRennaReplicaReprimereReputareResaResidenteResponsoRestauroReteRetinaRetoricaRettificaRevocatoRiassuntoRibadireRibelleRibrezzoRicaricaRiccoRicevereRiciclatoRicordoRicredutoRidicoloRidurreRifasareRiflessoRiformaRifugioRigareRigettatoRighelloRilassatoRilevatoRimanereRimbalzoRimedioRimorchioRinascitaRincaroRinforzoRinnovoRinomatoRinsavitoRintoccoRinunciaRinvenireRiparatoRipetutoRipienoRiportareRipresaRipulireRisataRischioRiservaRisibileRisoRispettoRistoroRisultatoRisvoltoRitardoRitegnoRitmicoRitrovoRiunioneRivaRiversoRivincitaRivoltoRizomaRobaRoboticoRobustoRocciaRocoRodaggioRodereRoditoreRogitoRollioRomanticoRompereRonzioRosolareRospoRotanteRotondoRotulaRovescioRubizzoRubricaRugaRullinoRumineRumorosoRuoloRupeRussareRusticoSabatoSabbiareSabotatoSagomaSalassoSaldaturaSalgemmaSalivareSalmoneSaloneSaltareSalutoSalvoSapereSapidoSaporitoSaracenoSarcasmoSartoSassosoSatelliteSatiraSatolloSaturnoSavanaSavioSaziatoSbadiglioSbalzoSbancatoSbarraSbattereSbavareSbendareSbirciareSbloccatoSbocciatoSbrinareSbruffoneSbuffareScabrosoScadenzaScalaScambiareScandaloScapolaScarsoScatenareScavatoSceltoScenicoScettroSchedaSchienaSciarpaScienzaScindereScippoSciroppoScivoloSclerareScodellaScolpitoScompartoSconfortoScoprireScortaScossoneScozzeseScribaScrollareScrutinioScuderiaScultoreScuolaScuroScusareSdebitareSdoganareSeccaturaSecondoSedanoSeggiolaSegnalatoSegregatoSeguitoSelciatoSelettivoSellaSelvaggioSemaforoSembrareSemeSeminatoSempreSensoSentireSepoltoSequenzaSerataSerbatoSerenoSerioSerpenteSerraglioServireSestinaSetolaSettimanaSfaceloSfaldareSfamatoSfarzosoSfaticatoSferaSfidaSfilatoSfingeSfocatoSfoderareSfogoSfoltireSforzatoSfrattoSfruttatoSfuggitoSfumareSfusoSgabelloSgarbatoSgonfiareSgorbioSgrassatoSguardoSibiloSiccomeSierraSiglaSignoreSilenzioSillabaSimboloSimpaticoSimulatoSinfoniaSingoloSinistroSinoSintesiSinusoideSiparioSismaSistoleSituatoSlittaSlogaturaSlovenoSmarritoSmemoratoSmentitoSmeraldoSmilzoSmontareSmottatoSmussatoSnellireSnervatoSnodoSobbalzoSobrioSoccorsoSocialeSodaleSoffittoSognoSoldatoSolenneSolidoSollazzoSoloSolubileSolventeSomaticoSommaSondaSonettoSonniferoSopireSoppesoSopraSorgereSorpassoSorrisoSorsoSorteggioSorvolatoSospiroSostaSottileSpadaSpallaSpargereSpatolaSpaventoSpazzolaSpecieSpedireSpegnereSpelaturaSperanzaSpessoreSpettraleSpezzatoSpiaSpigolosoSpillatoSpinosoSpiraleSplendidoSportivoSposoSprangaSprecareSpronatoSpruzzoSpuntinoSquilloSradicareSrotolatoStabileStaccoStaffaStagnareStampatoStantioStarnutoStaseraStatutoSteloSteppaSterzoStilettoStimaStirpeStivaleStizzosoStonatoStoricoStrappoStregatoStriduloStrozzareStruttoStuccareStufoStupendoSubentroSuccosoSudoreSuggeritoSugoSultanoSuonareSuperboSupportoSurgelatoSurrogatoSussurroSuturaSvagareSvedeseSveglioSvelareSvenutoSveziaSviluppoSvistaSvizzeraSvoltaSvuotareTabaccoTabulatoTacciareTaciturnoTaleTalismanoTamponeTanninoTaraTardivoTargatoTariffaTarpareTartarugaTastoTatticoTavernaTavolataTazzaTecaTecnicoTelefonoTemerarioTempoTemutoTendoneTeneroTensioneTentacoloTeoremaTermeTerrazzoTerzettoTesiTesseratoTestatoTetroTettoiaTifareTigellaTimbroTintoTipicoTipografoTiraggioTiroTitanioTitoloTitubanteTizioTizzoneToccareTollerareToltoTombolaTomoTonfoTonsillaTopazioTopologiaToppaTorbaTornareTorroneTortoraToscanoTossireTostaturaTotanoTraboccoTracheaTrafilaTragediaTralcioTramontoTransitoTrapanoTrarreTraslocoTrattatoTraveTrecciaTremolioTrespoloTributoTrichecoTrifoglioTrilloTrinceaTrioTristezzaTrituratoTrivellaTrombaTronoTroppoTrottolaTrovareTruccatoTubaturaTuffatoTulipanoTumultoTunisiaTurbareTurchinoTutaTutelaUbicatoUccelloUccisoreUdireUditivoUffaUfficioUgualeUlisseUltimatoUmanoUmileUmorismoUncinettoUngereUnghereseUnicornoUnificatoUnisonoUnitarioUnteUovoUpupaUraganoUrgenzaUrloUsanzaUsatoUscitoUsignoloUsuraioUtensileUtilizzoUtopiaVacanteVaccinatoVagabondoVagliatoValangaValgoValicoVallettaValorosoValutareValvolaVampataVangareVanitosoVanoVantaggioVanveraVaporeVaranoVarcatoVarianteVascaVedettaVedovaVedutoVegetaleVeicoloVelcroVelinaVellutoVeloceVenatoVendemmiaVentoVeraceVerbaleVergognaVerificaVeroVerrucaVerticaleVescicaVessilloVestaleVeteranoVetrinaVetustoViandanteVibranteVicendaVichingoVicinanzaVidimareVigiliaVignetoVigoreVileVillanoViminiVincitoreViolaViperaVirgolaVirologoVirulentoViscosoVisioneVispoVissutoVisuraVitaVitelloVittimaVivandaVividoViziareVoceVogaVolatileVolereVolpeVoragineVulcanoZampognaZannaZappatoZatteraZavorraZefiroZelanteZeloZenzeroZerbinoZibettoZincoZirconeZittoZollaZoticoZuccheroZufoloZuluZuppa", - rK = null; - function Ult(t) { - if ( - rK == null && - ((rK = o_r - .replace(/([A-Z])/g, " $1") - .toLowerCase() - .substring(1) - .split(" ")), - JAe.Wordlist.check(t) !== - "0x5c1362d88fd4cf614a96f3234941d29f7d37c08c5292fde03bf62c2db6ff7620") - ) - throw ( - ((rK = null), new Error("BIP39 Wordlist for it (Italian) FAILED")) - ); - } - var a_r = (function (t) { - i_r(e, t); - function e() { - return t.call(this, "it") || this; - } - return ( - (e.prototype.getWord = function (r) { - return Ult(this), rK[r]; - }), - (e.prototype.getWordIndex = function (r) { - return Ult(this), rK.indexOf(r); - }), - e - ); - })(JAe.Wordlist), - Klt = new a_r(); - $R.langIt = Klt; - JAe.Wordlist.register(Klt); - }); - var Jlt = I((FA) => { - "use strict"; - m(); - g(); - var s_r = - (FA && FA.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(FA, "__esModule", { value: !0 }); - FA.langZhTw = FA.langZhCn = void 0; - var u_r = Eo(), - nK = yb(), - $Ae = - "}aE#4A=Yv&co#4N#6G=cJ&SM#66|/Z#4t&kn~46#4K~4q%b9=IR#7l,mB#7W_X2*dl}Uo~7s}Uf&Iw#9c&cw~6O&H6&wx&IG%v5=IQ~8a&Pv#47$PR&50%Ko&QM&3l#5f,D9#4L|/H&tQ;v0~6n]nN> 2), - 128 + ZAe.indexOf($Ae[r * 3 + 1]), - 128 + ZAe.indexOf($Ae[r * 3 + 2]), - ]; - if (t.locale === "zh_tw") - for (var o = n % 4, a = o; a < 3; a++) - i[a] = ZAe.indexOf(c_r[e++]) + (a == 0 ? 228 : 128); - ZR[t.locale].push((0, u_r.toUtf8String)(i)); - } - if (nK.Wordlist.check(t) !== l_r[t.locale]) - throw ( - ((ZR[t.locale] = null), - new Error("BIP39 Wordlist for " + t.locale + " (Chinese) FAILED")) - ); - } - } - var Wlt = (function (t) { - s_r(e, t); - function e(r) { - return t.call(this, "zh_" + r) || this; - } - return ( - (e.prototype.getWord = function (r) { - return Vlt(this), ZR[this.locale][r]; - }), - (e.prototype.getWordIndex = function (r) { - return Vlt(this), ZR[this.locale].indexOf(r); - }), - (e.prototype.split = function (r) { - return (r = r.replace(/(?:\u3000| )+/g, "")), r.split(""); - }), - e - ); - })(nK.Wordlist), - XAe = new Wlt("cn"); - FA.langZhCn = XAe; - nK.Wordlist.register(XAe); - nK.Wordlist.register(XAe, "zh"); - var Glt = new Wlt("tw"); - FA.langZhTw = Glt; - nK.Wordlist.register(Glt); - }); - var $lt = I((ine) => { - "use strict"; - m(); - g(); - Object.defineProperty(ine, "__esModule", { value: !0 }); - ine.wordlists = void 0; - var d_r = _lt(), - h_r = Alt(), - p_r = Plt(), - y_r = Rlt(), - m_r = Llt(), - g_r = jlt(), - v_r = Hlt(), - YAe = Jlt(); - ine.wordlists = { - cz: d_r.langCz, - en: h_r.langEn, - es: p_r.langEs, - fr: y_r.langFr, - it: v_r.langIt, - ja: m_r.langJa, - ko: g_r.langKo, - zh: YAe.langZhCn, - zh_cn: YAe.langZhCn, - zh_tw: YAe.langZhTw, - }; - }); - var one = I((LA) => { - "use strict"; - m(); - g(); - Object.defineProperty(LA, "__esModule", { value: !0 }); - LA.wordlists = LA.Wordlist = LA.logger = void 0; - var Zlt = yb(); - Object.defineProperty(LA, "logger", { - enumerable: !0, - get: function () { - return Zlt.logger; - }, - }); - Object.defineProperty(LA, "Wordlist", { - enumerable: !0, - get: function () { - return Zlt.Wordlist; - }, - }); - var b_r = $lt(); - Object.defineProperty(LA, "wordlists", { - enumerable: !0, - get: function () { - return b_r.wordlists; - }, - }); - }); - var Xlt = I((ane) => { - "use strict"; - m(); - g(); - Object.defineProperty(ane, "__esModule", { value: !0 }); - ane.version = void 0; - ane.version = "hdnode/5.7.0"; - }); - var aK = I((il) => { - "use strict"; - m(); - g(); - Object.defineProperty(il, "__esModule", { value: !0 }); - il.getAccountPath = - il.isValidMnemonic = - il.entropyToMnemonic = - il.mnemonicToEntropy = - il.mnemonicToSeed = - il.HDNode = - il.defaultPath = - void 0; - var tft = jR(), - po = Ar(), - rft = Ro(), - iK = Eo(), - w_r = Xre(), - nl = $r(), - Ylt = qR(), - mb = pb(), - __r = e0(), - Qlt = one(), - x_r = rr(), - S_r = Xlt(), - oK = new x_r.Logger(S_r.version), - A_r = rft.BigNumber.from( - "0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141" - ), - E_r = (0, iK.toUtf8Bytes)("Bitcoin seed"), - YR = 2147483648; - function nft(t) { - return ((1 << t) - 1) << (8 - t); - } - function M_r(t) { - return (1 << t) - 1; - } - function sne(t) { - return (0, po.hexZeroPad)((0, po.hexlify)(t), 32); - } - function eft(t) { - return tft.Base58.encode( - (0, po.concat)([ - t, - (0, po.hexDataSlice)((0, mb.sha256)((0, mb.sha256)(t)), 0, 4), - ]) - ); - } - function QAe(t) { - if (t == null) return Qlt.wordlists.en; - if (typeof t == "string") { - var e = Qlt.wordlists[t]; - return ( - e == null && oK.throwArgumentError("unknown locale", "wordlist", t), e - ); - } - return t; - } - var XR = {}; - il.defaultPath = "m/44'/60'/0'/0/0"; - var T_r = (function () { - function t(e, r, n, i, o, a, s, c) { - if (e !== XR) - throw new Error("HDNode constructor cannot be called directly"); - if (r) { - var u = new Ylt.SigningKey(r); - (0, nl.defineReadOnly)(this, "privateKey", u.privateKey), - (0, nl.defineReadOnly)(this, "publicKey", u.compressedPublicKey); - } else - (0, nl.defineReadOnly)(this, "privateKey", null), - (0, nl.defineReadOnly)(this, "publicKey", (0, po.hexlify)(n)); - (0, nl.defineReadOnly)(this, "parentFingerprint", i), - (0, nl.defineReadOnly)( - this, - "fingerprint", - (0, po.hexDataSlice)( - (0, mb.ripemd160)((0, mb.sha256)(this.publicKey)), - 0, - 4 - ) - ), - (0, nl.defineReadOnly)( - this, - "address", - (0, __r.computeAddress)(this.publicKey) - ), - (0, nl.defineReadOnly)(this, "chainCode", o), - (0, nl.defineReadOnly)(this, "index", a), - (0, nl.defineReadOnly)(this, "depth", s), - c == null - ? ((0, nl.defineReadOnly)(this, "mnemonic", null), - (0, nl.defineReadOnly)(this, "path", null)) - : typeof c == "string" - ? ((0, nl.defineReadOnly)(this, "mnemonic", null), - (0, nl.defineReadOnly)(this, "path", c)) - : ((0, nl.defineReadOnly)(this, "mnemonic", c), - (0, nl.defineReadOnly)(this, "path", c.path)); - } - return ( - Object.defineProperty(t.prototype, "extendedKey", { - get: function () { - if (this.depth >= 256) throw new Error("Depth too large!"); - return eft( - (0, po.concat)([ - this.privateKey != null ? "0x0488ADE4" : "0x0488B21E", - (0, po.hexlify)(this.depth), - this.parentFingerprint, - (0, po.hexZeroPad)((0, po.hexlify)(this.index), 4), - this.chainCode, - this.privateKey != null - ? (0, po.concat)(["0x00", this.privateKey]) - : this.publicKey, - ]) - ); - }, - enumerable: !1, - configurable: !0, - }), - (t.prototype.neuter = function () { - return new t( - XR, - null, - this.publicKey, - this.parentFingerprint, - this.chainCode, - this.index, - this.depth, - this.path - ); - }), - (t.prototype._derive = function (e) { - if (e > 4294967295) throw new Error("invalid index - " + String(e)); - var r = this.path; - r && (r += "/" + (e & ~YR)); - var n = new Uint8Array(37); - if (e & YR) { - if (!this.privateKey) - throw new Error("cannot derive child of neutered node"); - n.set((0, po.arrayify)(this.privateKey), 1), r && (r += "'"); - } else n.set((0, po.arrayify)(this.publicKey)); - for (var i = 24; i >= 0; i -= 8) - n[33 + (i >> 3)] = (e >> (24 - i)) & 255; - var o = (0, po.arrayify)( - (0, mb.computeHmac)( - mb.SupportedAlgorithm.sha512, - this.chainCode, - n - ) - ), - a = o.slice(0, 32), - s = o.slice(32), - c = null, - u = null; - if (this.privateKey) - c = sne(rft.BigNumber.from(a).add(this.privateKey).mod(A_r)); - else { - var h = new Ylt.SigningKey((0, po.hexlify)(a)); - u = h._addPoint(this.publicKey); - } - var w = r, - M = this.mnemonic; - return ( - M && - (w = Object.freeze({ - phrase: M.phrase, - path: r, - locale: M.locale || "en", - })), - new t(XR, c, u, this.fingerprint, sne(s), e, this.depth + 1, w) - ); - }), - (t.prototype.derivePath = function (e) { - var r = e.split("/"); - if (r.length === 0 || (r[0] === "m" && this.depth !== 0)) - throw new Error("invalid path - " + e); - r[0] === "m" && r.shift(); - for (var n = this, i = 0; i < r.length; i++) { - var o = r[i]; - if (o.match(/^[0-9]+'$/)) { - var a = parseInt(o.substring(0, o.length - 1)); - if (a >= YR) throw new Error("invalid path index - " + o); - n = n._derive(YR + a); - } else if (o.match(/^[0-9]+$/)) { - var a = parseInt(o); - if (a >= YR) throw new Error("invalid path index - " + o); - n = n._derive(a); - } else throw new Error("invalid path component - " + o); - } - return n; - }), - (t._fromSeed = function (e, r) { - var n = (0, po.arrayify)(e); - if (n.length < 16 || n.length > 64) throw new Error("invalid seed"); - var i = (0, po.arrayify)( - (0, mb.computeHmac)(mb.SupportedAlgorithm.sha512, E_r, n) - ); - return new t( - XR, - sne(i.slice(0, 32)), - null, - "0x00000000", - sne(i.slice(32)), - 0, - 0, - r - ); - }), - (t.fromMnemonic = function (e, r, n) { - return ( - (n = QAe(n)), - (e = oft(eEe(e, n), n)), - t._fromSeed(ift(e, r), { phrase: e, path: "m", locale: n.locale }) - ); - }), - (t.fromSeed = function (e) { - return t._fromSeed(e, null); - }), - (t.fromExtendedKey = function (e) { - var r = tft.Base58.decode(e); - (r.length !== 82 || eft(r.slice(0, 78)) !== e) && - oK.throwArgumentError( - "invalid extended key", - "extendedKey", - "[REDACTED]" - ); - var n = r[4], - i = (0, po.hexlify)(r.slice(5, 9)), - o = parseInt((0, po.hexlify)(r.slice(9, 13)).substring(2), 16), - a = (0, po.hexlify)(r.slice(13, 45)), - s = r.slice(45, 78); - switch ((0, po.hexlify)(r.slice(0, 4))) { - case "0x0488b21e": - case "0x043587cf": - return new t(XR, null, (0, po.hexlify)(s), i, a, o, n, null); - case "0x0488ade4": - case "0x04358394 ": - if (s[0] !== 0) break; - return new t( - XR, - (0, po.hexlify)(s.slice(1)), - null, - i, - a, - o, - n, - null - ); - } - return oK.throwArgumentError( - "invalid extended key", - "extendedKey", - "[REDACTED]" - ); - }), - t - ); - })(); - il.HDNode = T_r; - function ift(t, e) { - e || (e = ""); - var r = (0, iK.toUtf8Bytes)( - "mnemonic" + e, - iK.UnicodeNormalizationForm.NFKD - ); - return (0, w_r.pbkdf2)( - (0, iK.toUtf8Bytes)(t, iK.UnicodeNormalizationForm.NFKD), - r, - 2048, - 64, - "sha512" - ); - } - il.mnemonicToSeed = ift; - function eEe(t, e) { - (e = QAe(e)), oK.checkNormalize(); - var r = e.split(t); - if (r.length % 3 !== 0) throw new Error("invalid mnemonic"); - for ( - var n = (0, po.arrayify)( - new Uint8Array(Math.ceil((11 * r.length) / 8)) - ), - i = 0, - o = 0; - o < r.length; - o++ - ) { - var a = e.getWordIndex(r[o].normalize("NFKD")); - if (a === -1) throw new Error("invalid mnemonic"); - for (var s = 0; s < 11; s++) - a & (1 << (10 - s)) && (n[i >> 3] |= 1 << (7 - (i % 8))), i++; - } - var c = (32 * r.length) / 3, - u = r.length / 3, - h = nft(u), - w = (0, po.arrayify)((0, mb.sha256)(n.slice(0, c / 8)))[0] & h; - if (w !== (n[n.length - 1] & h)) throw new Error("invalid checksum"); - return (0, po.hexlify)(n.slice(0, c / 8)); - } - il.mnemonicToEntropy = eEe; - function oft(t, e) { - if ( - ((e = QAe(e)), - (t = (0, po.arrayify)(t)), - t.length % 4 !== 0 || t.length < 16 || t.length > 32) - ) - throw new Error("invalid entropy"); - for (var r = [0], n = 11, i = 0; i < t.length; i++) - n > 8 - ? ((r[r.length - 1] <<= 8), (r[r.length - 1] |= t[i]), (n -= 8)) - : ((r[r.length - 1] <<= n), - (r[r.length - 1] |= t[i] >> (8 - n)), - r.push(t[i] & M_r(8 - n)), - (n += 3)); - var o = t.length / 4, - a = (0, po.arrayify)((0, mb.sha256)(t))[0] & nft(o); - return ( - (r[r.length - 1] <<= o), - (r[r.length - 1] |= a >> (8 - o)), - e.join( - r.map(function (s) { - return e.getWord(s); - }) - ) - ); - } - il.entropyToMnemonic = oft; - function k_r(t, e) { - try { - return eEe(t, e), !0; - } catch {} - return !1; - } - il.isValidMnemonic = k_r; - function P_r(t) { - return ( - (typeof t != "number" || t < 0 || t >= YR || t % 1) && - oK.throwArgumentError("invalid account index", "index", t), - "m/44'/60'/" + t + "'/0/0" - ); - } - il.getAccountPath = P_r; - }); - var aft = I((une) => { - "use strict"; - m(); - g(); - Object.defineProperty(une, "__esModule", { value: !0 }); - une.version = void 0; - une.version = "random/5.7.0"; - }); - var cft = I((lne) => { - "use strict"; - m(); - g(); - Object.defineProperty(lne, "__esModule", { value: !0 }); - lne.randomBytes = void 0; - var O_r = Ar(), - uft = rr(), - B_r = aft(), - tEe = new uft.Logger(B_r.version); - function I_r() { - if (typeof self < "u") return self; - if (typeof window < "u" || typeof window < "u") return window; - throw new Error("unable to locate global object"); - } - var sft = I_r(), - cne = sft.crypto || sft.msCrypto; - (!cne || !cne.getRandomValues) && - (tEe.warn("WARNING: Missing strong random number source"), - (cne = { - getRandomValues: function (t) { - return tEe.throwError( - "no secure random source avaialble", - uft.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "crypto.getRandomValues" } - ); - }, - })); - function C_r(t) { - (t <= 0 || t > 1024 || t % 1 || t != t) && - tEe.throwArgumentError("invalid length", "length", t); - var e = new Uint8Array(t); - return cne.getRandomValues(e), (0, O_r.arrayify)(e); - } - lne.randomBytes = C_r; - }); - var lft = I((fne) => { - "use strict"; - m(); - g(); - Object.defineProperty(fne, "__esModule", { value: !0 }); - fne.shuffled = void 0; - function R_r(t) { - t = t.slice(); - for (var e = t.length - 1; e > 0; e--) { - var r = Math.floor(Math.random() * (e + 1)), - n = t[e]; - (t[e] = t[r]), (t[r] = n); - } - return t; - } - fne.shuffled = R_r; - }); - var s6 = I((QR) => { - "use strict"; - m(); - g(); - Object.defineProperty(QR, "__esModule", { value: !0 }); - QR.shuffled = QR.randomBytes = void 0; - var N_r = cft(); - Object.defineProperty(QR, "randomBytes", { - enumerable: !0, - get: function () { - return N_r.randomBytes; - }, - }); - var D_r = lft(); - Object.defineProperty(QR, "shuffled", { - enumerable: !0, - get: function () { - return D_r.shuffled; - }, - }); - }); - var nEe = I((rEe, fft) => { - "use strict"; - m(); - g(); - (function (t) { - function e(f) { - return parseInt(f) === f; - } - function r(f) { - if (!e(f.length)) return !1; - for (var x = 0; x < f.length; x++) - if (!e(f[x]) || f[x] < 0 || f[x] > 255) return !1; - return !0; - } - function n(f, x) { - if (f.buffer && ArrayBuffer.isView(f) && f.name === "Uint8Array") - return ( - x && - (f.slice ? (f = f.slice()) : (f = Array.prototype.slice.call(f))), - f - ); - if (Array.isArray(f)) { - if (!r(f)) throw new Error("Array contains invalid value: " + f); - return new Uint8Array(f); - } - if (e(f.length) && r(f)) return new Uint8Array(f); - throw new Error("unsupported array-like object"); - } - function i(f) { - return new Uint8Array(f); - } - function o(f, x, C, E, B) { - (E != null || B != null) && - (f.slice - ? (f = f.slice(E, B)) - : (f = Array.prototype.slice.call(f, E, B))), - x.set(f, C); - } - var a = (function () { - function f(C) { - var E = [], - B = 0; - for (C = encodeURI(C); B < C.length; ) { - var G = C.charCodeAt(B++); - G === 37 - ? (E.push(parseInt(C.substr(B, 2), 16)), (B += 2)) - : E.push(G); - } - return n(E); - } - function x(C) { - for (var E = [], B = 0; B < C.length; ) { - var G = C[B]; - G < 128 - ? (E.push(String.fromCharCode(G)), B++) - : G > 191 && G < 224 - ? (E.push( - String.fromCharCode(((G & 31) << 6) | (C[B + 1] & 63)) - ), - (B += 2)) - : (E.push( - String.fromCharCode( - ((G & 15) << 12) | - ((C[B + 1] & 63) << 6) | - (C[B + 2] & 63) - ) - ), - (B += 3)); - } - return E.join(""); - } - return { toBytes: f, fromBytes: x }; - })(), - s = (function () { - function f(E) { - for (var B = [], G = 0; G < E.length; G += 2) - B.push(parseInt(E.substr(G, 2), 16)); - return B; - } - var x = "0123456789abcdef"; - function C(E) { - for (var B = [], G = 0; G < E.length; G++) { - var L = E[G]; - B.push(x[(L & 240) >> 4] + x[L & 15]); - } - return B.join(""); - } - return { toBytes: f, fromBytes: C }; - })(), - c = { 16: 10, 24: 12, 32: 14 }, - u = [ - 1, 2, 4, 8, 16, 32, 64, 128, 27, 54, 108, 216, 171, 77, 154, 47, 94, - 188, 99, 198, 151, 53, 106, 212, 179, 125, 250, 239, 197, 145, - ], - h = [ - 99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 171, - 118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175, 156, - 164, 114, 192, 183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241, - 113, 216, 49, 21, 4, 199, 35, 195, 24, 150, 5, 154, 7, 18, 128, 226, - 235, 39, 178, 117, 9, 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 179, - 41, 227, 47, 132, 83, 209, 0, 237, 32, 252, 177, 91, 106, 203, 190, - 57, 74, 76, 88, 207, 208, 239, 170, 251, 67, 77, 51, 133, 69, 249, 2, - 127, 80, 60, 159, 168, 81, 163, 64, 143, 146, 157, 56, 245, 188, 182, - 218, 33, 16, 255, 243, 210, 205, 12, 19, 236, 95, 151, 68, 23, 196, - 167, 126, 61, 100, 93, 25, 115, 96, 129, 79, 220, 34, 42, 144, 136, - 70, 238, 184, 20, 222, 94, 11, 219, 224, 50, 58, 10, 73, 6, 36, 92, - 194, 211, 172, 98, 145, 149, 228, 121, 231, 200, 55, 109, 141, 213, - 78, 169, 108, 86, 244, 234, 101, 122, 174, 8, 186, 120, 37, 46, 28, - 166, 180, 198, 232, 221, 116, 31, 75, 189, 139, 138, 112, 62, 181, - 102, 72, 3, 246, 14, 97, 53, 87, 185, 134, 193, 29, 158, 225, 248, - 152, 17, 105, 217, 142, 148, 155, 30, 135, 233, 206, 85, 40, 223, 140, - 161, 137, 13, 191, 230, 66, 104, 65, 153, 45, 15, 176, 84, 187, 22, - ], - w = [ - 82, 9, 106, 213, 48, 54, 165, 56, 191, 64, 163, 158, 129, 243, 215, - 251, 124, 227, 57, 130, 155, 47, 255, 135, 52, 142, 67, 68, 196, 222, - 233, 203, 84, 123, 148, 50, 166, 194, 35, 61, 238, 76, 149, 11, 66, - 250, 195, 78, 8, 46, 161, 102, 40, 217, 36, 178, 118, 91, 162, 73, - 109, 139, 209, 37, 114, 248, 246, 100, 134, 104, 152, 22, 212, 164, - 92, 204, 93, 101, 182, 146, 108, 112, 72, 80, 253, 237, 185, 218, 94, - 21, 70, 87, 167, 141, 157, 132, 144, 216, 171, 0, 140, 188, 211, 10, - 247, 228, 88, 5, 184, 179, 69, 6, 208, 44, 30, 143, 202, 63, 15, 2, - 193, 175, 189, 3, 1, 19, 138, 107, 58, 145, 17, 65, 79, 103, 220, 234, - 151, 242, 207, 206, 240, 180, 230, 115, 150, 172, 116, 34, 231, 173, - 53, 133, 226, 249, 55, 232, 28, 117, 223, 110, 71, 241, 26, 113, 29, - 41, 197, 137, 111, 183, 98, 14, 170, 24, 190, 27, 252, 86, 62, 75, - 198, 210, 121, 32, 154, 219, 192, 254, 120, 205, 90, 244, 31, 221, - 168, 51, 136, 7, 199, 49, 177, 18, 16, 89, 39, 128, 236, 95, 96, 81, - 127, 169, 25, 181, 74, 13, 45, 229, 122, 159, 147, 201, 156, 239, 160, - 224, 59, 77, 174, 42, 245, 176, 200, 235, 187, 60, 131, 83, 153, 97, - 23, 43, 4, 126, 186, 119, 214, 38, 225, 105, 20, 99, 85, 33, 12, 125, - ], - M = [ - 3328402341, 4168907908, 4000806809, 4135287693, 4294111757, - 3597364157, 3731845041, 2445657428, 1613770832, 33620227, 3462883241, - 1445669757, 3892248089, 3050821474, 1303096294, 3967186586, - 2412431941, 528646813, 2311702848, 4202528135, 4026202645, 2992200171, - 2387036105, 4226871307, 1101901292, 3017069671, 1604494077, - 1169141738, 597466303, 1403299063, 3832705686, 2613100635, 1974974402, - 3791519004, 1033081774, 1277568618, 1815492186, 2118074177, - 4126668546, 2211236943, 1748251740, 1369810420, 3521504564, - 4193382664, 3799085459, 2883115123, 1647391059, 706024767, 134480908, - 2512897874, 1176707941, 2646852446, 806885416, 932615841, 168101135, - 798661301, 235341577, 605164086, 461406363, 3756188221, 3454790438, - 1311188841, 2142417613, 3933566367, 302582043, 495158174, 1479289972, - 874125870, 907746093, 3698224818, 3025820398, 1537253627, 2756858614, - 1983593293, 3084310113, 2108928974, 1378429307, 3722699582, - 1580150641, 327451799, 2790478837, 3117535592, 0, 3253595436, - 1075847264, 3825007647, 2041688520, 3059440621, 3563743934, - 2378943302, 1740553945, 1916352843, 2487896798, 2555137236, - 2958579944, 2244988746, 3151024235, 3320835882, 1336584933, - 3992714006, 2252555205, 2588757463, 1714631509, 293963156, 2319795663, - 3925473552, 67240454, 4269768577, 2689618160, 2017213508, 631218106, - 1269344483, 2723238387, 1571005438, 2151694528, 93294474, 1066570413, - 563977660, 1882732616, 4059428100, 1673313503, 2008463041, 2950355573, - 1109467491, 537923632, 3858759450, 4260623118, 3218264685, 2177748300, - 403442708, 638784309, 3287084079, 3193921505, 899127202, 2286175436, - 773265209, 2479146071, 1437050866, 4236148354, 2050833735, 3362022572, - 3126681063, 840505643, 3866325909, 3227541664, 427917720, 2655997905, - 2749160575, 1143087718, 1412049534, 999329963, 193497219, 2353415882, - 3354324521, 1807268051, 672404540, 2816401017, 3160301282, 369822493, - 2916866934, 3688947771, 1681011286, 1949973070, 336202270, 2454276571, - 201721354, 1210328172, 3093060836, 2680341085, 3184776046, 1135389935, - 3294782118, 965841320, 831886756, 3554993207, 4068047243, 3588745010, - 2345191491, 1849112409, 3664604599, 26054028, 2983581028, 2622377682, - 1235855840, 3630984372, 2891339514, 4092916743, 3488279077, - 3395642799, 4101667470, 1202630377, 268961816, 1874508501, 4034427016, - 1243948399, 1546530418, 941366308, 1470539505, 1941222599, 2546386513, - 3421038627, 2715671932, 3899946140, 1042226977, 2521517021, - 1639824860, 227249030, 260737669, 3765465232, 2084453954, 1907733956, - 3429263018, 2420656344, 100860677, 4160157185, 470683154, 3261161891, - 1781871967, 2924959737, 1773779408, 394692241, 2579611992, 974986535, - 664706745, 3655459128, 3958962195, 731420851, 571543859, 3530123707, - 2849626480, 126783113, 865375399, 765172662, 1008606754, 361203602, - 3387549984, 2278477385, 2857719295, 1344809080, 2782912378, 59542671, - 1503764984, 160008576, 437062935, 1707065306, 3622233649, 2218934982, - 3496503480, 2185314755, 697932208, 1512910199, 504303377, 2075177163, - 2824099068, 1841019862, 739644986, - ], - k = [ - 2781242211, 2230877308, 2582542199, 2381740923, 234877682, 3184946027, - 2984144751, 1418839493, 1348481072, 50462977, 2848876391, 2102799147, - 434634494, 1656084439, 3863849899, 2599188086, 1167051466, 2636087938, - 1082771913, 2281340285, 368048890, 3954334041, 3381544775, 201060592, - 3963727277, 1739838676, 4250903202, 3930435503, 3206782108, - 4149453988, 2531553906, 1536934080, 3262494647, 484572669, 2923271059, - 1783375398, 1517041206, 1098792767, 49674231, 1334037708, 1550332980, - 4098991525, 886171109, 150598129, 2481090929, 1940642008, 1398944049, - 1059722517, 201851908, 1385547719, 1699095331, 1587397571, 674240536, - 2704774806, 252314885, 3039795866, 151914247, 908333586, 2602270848, - 1038082786, 651029483, 1766729511, 3447698098, 2682942837, 454166793, - 2652734339, 1951935532, 775166490, 758520603, 3000790638, 4004797018, - 4217086112, 4137964114, 1299594043, 1639438038, 3464344499, - 2068982057, 1054729187, 1901997871, 2534638724, 4121318227, - 1757008337, 0, 750906861, 1614815264, 535035132, 3363418545, - 3988151131, 3201591914, 1183697867, 3647454910, 1265776953, - 3734260298, 3566750796, 3903871064, 1250283471, 1807470800, 717615087, - 3847203498, 384695291, 3313910595, 3617213773, 1432761139, 2484176261, - 3481945413, 283769337, 100925954, 2180939647, 4037038160, 1148730428, - 3123027871, 3813386408, 4087501137, 4267549603, 3229630528, - 2315620239, 2906624658, 3156319645, 1215313976, 82966005, 3747855548, - 3245848246, 1974459098, 1665278241, 807407632, 451280895, 251524083, - 1841287890, 1283575245, 337120268, 891687699, 801369324, 3787349855, - 2721421207, 3431482436, 959321879, 1469301956, 4065699751, 2197585534, - 1199193405, 2898814052, 3887750493, 724703513, 2514908019, 2696962144, - 2551808385, 3516813135, 2141445340, 1715741218, 2119445034, - 2872807568, 2198571144, 3398190662, 700968686, 3547052216, 1009259540, - 2041044702, 3803995742, 487983883, 1991105499, 1004265696, 1449407026, - 1316239930, 504629770, 3683797321, 168560134, 1816667172, 3837287516, - 1570751170, 1857934291, 4014189740, 2797888098, 2822345105, - 2754712981, 936633572, 2347923833, 852879335, 1133234376, 1500395319, - 3084545389, 2348912013, 1689376213, 3533459022, 3762923945, - 3034082412, 4205598294, 133428468, 634383082, 2949277029, 2398386810, - 3913789102, 403703816, 3580869306, 2297460856, 1867130149, 1918643758, - 607656988, 4049053350, 3346248884, 1368901318, 600565992, 2090982877, - 2632479860, 557719327, 3717614411, 3697393085, 2249034635, 2232388234, - 2430627952, 1115438654, 3295786421, 2865522278, 3633334344, 84280067, - 33027830, 303828494, 2747425121, 1600795957, 4188952407, 3496589753, - 2434238086, 1486471617, 658119965, 3106381470, 953803233, 334231800, - 3005978776, 857870609, 3151128937, 1890179545, 2298973838, 2805175444, - 3056442267, 574365214, 2450884487, 550103529, 1233637070, 4289353045, - 2018519080, 2057691103, 2399374476, 4166623649, 2148108681, 387583245, - 3664101311, 836232934, 3330556482, 3100665960, 3280093505, 2955516313, - 2002398509, 287182607, 3413881008, 4238890068, 3597515707, 975967766, - ], - O = [ - 1671808611, 2089089148, 2006576759, 2072901243, 4061003762, - 1807603307, 1873927791, 3310653893, 810573872, 16974337, 1739181671, - 729634347, 4263110654, 3613570519, 2883997099, 1989864566, 3393556426, - 2191335298, 3376449993, 2106063485, 4195741690, 1508618841, - 1204391495, 4027317232, 2917941677, 3563566036, 2734514082, - 2951366063, 2629772188, 2767672228, 1922491506, 3227229120, - 3082974647, 4246528509, 2477669779, 644500518, 911895606, 1061256767, - 4144166391, 3427763148, 878471220, 2784252325, 3845444069, 4043897329, - 1905517169, 3631459288, 827548209, 356461077, 67897348, 3344078279, - 593839651, 3277757891, 405286936, 2527147926, 84871685, 2595565466, - 118033927, 305538066, 2157648768, 3795705826, 3945188843, 661212711, - 2999812018, 1973414517, 152769033, 2208177539, 745822252, 439235610, - 455947803, 1857215598, 1525593178, 2700827552, 1391895634, 994932283, - 3596728278, 3016654259, 695947817, 3812548067, 795958831, 2224493444, - 1408607827, 3513301457, 0, 3979133421, 543178784, 4229948412, - 2982705585, 1542305371, 1790891114, 3410398667, 3201918910, 961245753, - 1256100938, 1289001036, 1491644504, 3477767631, 3496721360, - 4012557807, 2867154858, 4212583931, 1137018435, 1305975373, 861234739, - 2241073541, 1171229253, 4178635257, 33948674, 2139225727, 1357946960, - 1011120188, 2679776671, 2833468328, 1374921297, 2751356323, - 1086357568, 2408187279, 2460827538, 2646352285, 944271416, 4110742005, - 3168756668, 3066132406, 3665145818, 560153121, 271589392, 4279952895, - 4077846003, 3530407890, 3444343245, 202643468, 322250259, 3962553324, - 1608629855, 2543990167, 1154254916, 389623319, 3294073796, 2817676711, - 2122513534, 1028094525, 1689045092, 1575467613, 422261273, 1939203699, - 1621147744, 2174228865, 1339137615, 3699352540, 577127458, 712922154, - 2427141008, 2290289544, 1187679302, 3995715566, 3100863416, 339486740, - 3732514782, 1591917662, 186455563, 3681988059, 3762019296, 844522546, - 978220090, 169743370, 1239126601, 101321734, 611076132, 1558493276, - 3260915650, 3547250131, 2901361580, 1655096418, 2443721105, - 2510565781, 3828863972, 2039214713, 3878868455, 3359869896, 928607799, - 1840765549, 2374762893, 3580146133, 1322425422, 2850048425, - 1823791212, 1459268694, 4094161908, 3928346602, 1706019429, - 2056189050, 2934523822, 135794696, 3134549946, 2022240376, 628050469, - 779246638, 472135708, 2800834470, 3032970164, 3327236038, 3894660072, - 3715932637, 1956440180, 522272287, 1272813131, 3185336765, 2340818315, - 2323976074, 1888542832, 1044544574, 3049550261, 1722469478, - 1222152264, 50660867, 4127324150, 236067854, 1638122081, 895445557, - 1475980887, 3117443513, 2257655686, 3243809217, 489110045, 2662934430, - 3778599393, 4162055160, 2561878936, 288563729, 1773916777, 3648039385, - 2391345038, 2493985684, 2612407707, 505560094, 2274497927, 3911240169, - 3460925390, 1442818645, 678973480, 3749357023, 2358182796, 2717407649, - 2306869641, 219617805, 3218761151, 3862026214, 1120306242, 1756942440, - 1103331905, 2578459033, 762796589, 252780047, 2966125488, 1425844308, - 3151392187, 372911126, - ], - D = [ - 1667474886, 2088535288, 2004326894, 2071694838, 4075949567, - 1802223062, 1869591006, 3318043793, 808472672, 16843522, 1734846926, - 724270422, 4278065639, 3621216949, 2880169549, 1987484396, 3402253711, - 2189597983, 3385409673, 2105378810, 4210693615, 1499065266, - 1195886990, 4042263547, 2913856577, 3570689971, 2728590687, - 2947541573, 2627518243, 2762274643, 1920112356, 3233831835, - 3082273397, 4261223649, 2475929149, 640051788, 909531756, 1061110142, - 4160160501, 3435941763, 875846760, 2779116625, 3857003729, 4059105529, - 1903268834, 3638064043, 825316194, 353713962, 67374088, 3351728789, - 589522246, 3284360861, 404236336, 2526454071, 84217610, 2593830191, - 117901582, 303183396, 2155911963, 3806477791, 3958056653, 656894286, - 2998062463, 1970642922, 151591698, 2206440989, 741110872, 437923380, - 454765878, 1852748508, 1515908788, 2694904667, 1381168804, 993742198, - 3604373943, 3014905469, 690584402, 3823320797, 791638366, 2223281939, - 1398011302, 3520161977, 0, 3991743681, 538992704, 4244381667, - 2981218425, 1532751286, 1785380564, 3419096717, 3200178535, 960056178, - 1246420628, 1280103576, 1482221744, 3486468741, 3503319995, - 4025428677, 2863326543, 4227536621, 1128514950, 1296947098, 859002214, - 2240123921, 1162203018, 4193849577, 33687044, 2139062782, 1347481760, - 1010582648, 2678045221, 2829640523, 1364325282, 2745433693, - 1077985408, 2408548869, 2459086143, 2644360225, 943212656, 4126475505, - 3166494563, 3065430391, 3671750063, 555836226, 269496352, 4294908645, - 4092792573, 3537006015, 3452783745, 202118168, 320025894, 3974901699, - 1600119230, 2543297077, 1145359496, 387397934, 3301201811, 2812801621, - 2122220284, 1027426170, 1684319432, 1566435258, 421079858, 1936954854, - 1616945344, 2172753945, 1330631070, 3705438115, 572679748, 707427924, - 2425400123, 2290647819, 1179044492, 4008585671, 3099120491, 336870440, - 3739122087, 1583276732, 185277718, 3688593069, 3772791771, 842159716, - 976899700, 168435220, 1229577106, 101059084, 606366792, 1549591736, - 3267517855, 3553849021, 2897014595, 1650632388, 2442242105, - 2509612081, 3840161747, 2038008818, 3890688725, 3368567691, 926374254, - 1835907034, 2374863873, 3587531953, 1313788572, 2846482505, - 1819063512, 1448540844, 4109633523, 3941213647, 1701162954, - 2054852340, 2930698567, 134748176, 3132806511, 2021165296, 623210314, - 774795868, 471606328, 2795958615, 3031746419, 3334885783, 3907527627, - 3722280097, 1953799400, 522133822, 1263263126, 3183336545, 2341176845, - 2324333839, 1886425312, 1044267644, 3048588401, 1718004428, - 1212733584, 50529542, 4143317495, 235803164, 1633788866, 892690282, - 1465383342, 3115962473, 2256965911, 3250673817, 488449850, 2661202215, - 3789633753, 4177007595, 2560144171, 286339874, 1768537042, 3654906025, - 2391705863, 2492770099, 2610673197, 505291324, 2273808917, 3924369609, - 3469625735, 1431699370, 673740880, 3755965093, 2358021891, 2711746649, - 2307489801, 218961690, 3217021541, 3873845719, 1111672452, 1751693520, - 1094828930, 2576986153, 757954394, 252645662, 2964376443, 1414855848, - 3149649517, 370555436, - ], - F = [ - 1374988112, 2118214995, 437757123, 975658646, 1001089995, 530400753, - 2902087851, 1273168787, 540080725, 2910219766, 2295101073, 4110568485, - 1340463100, 3307916247, 641025152, 3043140495, 3736164937, 632953703, - 1172967064, 1576976609, 3274667266, 2169303058, 2370213795, - 1809054150, 59727847, 361929877, 3211623147, 2505202138, 3569255213, - 1484005843, 1239443753, 2395588676, 1975683434, 4102977912, - 2572697195, 666464733, 3202437046, 4035489047, 3374361702, 2110667444, - 1675577880, 3843699074, 2538681184, 1649639237, 2976151520, - 3144396420, 4269907996, 4178062228, 1883793496, 2403728665, - 2497604743, 1383856311, 2876494627, 1917518562, 3810496343, - 1716890410, 3001755655, 800440835, 2261089178, 3543599269, 807962610, - 599762354, 33778362, 3977675356, 2328828971, 2809771154, 4077384432, - 1315562145, 1708848333, 101039829, 3509871135, 3299278474, 875451293, - 2733856160, 92987698, 2767645557, 193195065, 1080094634, 1584504582, - 3178106961, 1042385657, 2531067453, 3711829422, 1306967366, - 2438237621, 1908694277, 67556463, 1615861247, 429456164, 3602770327, - 2302690252, 1742315127, 2968011453, 126454664, 3877198648, 2043211483, - 2709260871, 2084704233, 4169408201, 0, 159417987, 841739592, - 504459436, 1817866830, 4245618683, 260388950, 1034867998, 908933415, - 168810852, 1750902305, 2606453969, 607530554, 202008497, 2472011535, - 3035535058, 463180190, 2160117071, 1641816226, 1517767529, 470948374, - 3801332234, 3231722213, 1008918595, 303765277, 235474187, 4069246893, - 766945465, 337553864, 1475418501, 2943682380, 4003061179, 2743034109, - 4144047775, 1551037884, 1147550661, 1543208500, 2336434550, - 3408119516, 3069049960, 3102011747, 3610369226, 1113818384, 328671808, - 2227573024, 2236228733, 3535486456, 2935566865, 3341394285, 496906059, - 3702665459, 226906860, 2009195472, 733156972, 2842737049, 294930682, - 1206477858, 2835123396, 2700099354, 1451044056, 573804783, 2269728455, - 3644379585, 2362090238, 2564033334, 2801107407, 2776292904, - 3669462566, 1068351396, 742039012, 1350078989, 1784663195, 1417561698, - 4136440770, 2430122216, 775550814, 2193862645, 2673705150, 1775276924, - 1876241833, 3475313331, 3366754619, 270040487, 3902563182, 3678124923, - 3441850377, 1851332852, 3969562369, 2203032232, 3868552805, - 2868897406, 566021896, 4011190502, 3135740889, 1248802510, 3936291284, - 699432150, 832877231, 708780849, 3332740144, 899835584, 1951317047, - 4236429990, 3767586992, 866637845, 4043610186, 1106041591, 2144161806, - 395441711, 1984812685, 1139781709, 3433712980, 3835036895, 2664543715, - 1282050075, 3240894392, 1181045119, 2640243204, 25965917, 4203181171, - 4211818798, 3009879386, 2463879762, 3910161971, 1842759443, - 2597806476, 933301370, 1509430414, 3943906441, 3467192302, 3076639029, - 3776767469, 2051518780, 2631065433, 1441952575, 404016761, 1942435775, - 1408749034, 1610459739, 3745345300, 2017778566, 3400528769, - 3110650942, 941896748, 3265478751, 371049330, 3168937228, 675039627, - 4279080257, 967311729, 135050206, 3635733660, 1683407248, 2076935265, - 3576870512, 1215061108, 3501741890, - ], - N = [ - 1347548327, 1400783205, 3273267108, 2520393566, 3409685355, - 4045380933, 2880240216, 2471224067, 1428173050, 4138563181, - 2441661558, 636813900, 4233094615, 3620022987, 2149987652, 2411029155, - 1239331162, 1730525723, 2554718734, 3781033664, 46346101, 310463728, - 2743944855, 3328955385, 3875770207, 2501218972, 3955191162, - 3667219033, 768917123, 3545789473, 692707433, 1150208456, 1786102409, - 2029293177, 1805211710, 3710368113, 3065962831, 401639597, 1724457132, - 3028143674, 409198410, 2196052529, 1620529459, 1164071807, 3769721975, - 2226875310, 486441376, 2499348523, 1483753576, 428819965, 2274680428, - 3075636216, 598438867, 3799141122, 1474502543, 711349675, 129166120, - 53458370, 2592523643, 2782082824, 4063242375, 2988687269, 3120694122, - 1559041666, 730517276, 2460449204, 4042459122, 2706270690, 3446004468, - 3573941694, 533804130, 2328143614, 2637442643, 2695033685, 839224033, - 1973745387, 957055980, 2856345839, 106852767, 1371368976, 4181598602, - 1033297158, 2933734917, 1179510461, 3046200461, 91341917, 1862534868, - 4284502037, 605657339, 2547432937, 3431546947, 2003294622, 3182487618, - 2282195339, 954669403, 3682191598, 1201765386, 3917234703, 3388507166, - 0, 2198438022, 1211247597, 2887651696, 1315723890, 4227665663, - 1443857720, 507358933, 657861945, 1678381017, 560487590, 3516619604, - 975451694, 2970356327, 261314535, 3535072918, 2652609425, 1333838021, - 2724322336, 1767536459, 370938394, 182621114, 3854606378, 1128014560, - 487725847, 185469197, 2918353863, 3106780840, 3356761769, 2237133081, - 1286567175, 3152976349, 4255350624, 2683765030, 3160175349, - 3309594171, 878443390, 1988838185, 3704300486, 1756818940, 1673061617, - 3403100636, 272786309, 1075025698, 545572369, 2105887268, 4174560061, - 296679730, 1841768865, 1260232239, 4091327024, 3960309330, 3497509347, - 1814803222, 2578018489, 4195456072, 575138148, 3299409036, 446754879, - 3629546796, 4011996048, 3347532110, 3252238545, 4270639778, 915985419, - 3483825537, 681933534, 651868046, 2755636671, 3828103837, 223377554, - 2607439820, 1649704518, 3270937875, 3901806776, 1580087799, - 4118987695, 3198115200, 2087309459, 2842678573, 3016697106, - 1003007129, 2802849917, 1860738147, 2077965243, 164439672, 4100872472, - 32283319, 2827177882, 1709610350, 2125135846, 136428751, 3874428392, - 3652904859, 3460984630, 3572145929, 3593056380, 2939266226, 824852259, - 818324884, 3224740454, 930369212, 2801566410, 2967507152, 355706840, - 1257309336, 4148292826, 243256656, 790073846, 2373340630, 1296297904, - 1422699085, 3756299780, 3818836405, 457992840, 3099667487, 2135319889, - 77422314, 1560382517, 1945798516, 788204353, 1521706781, 1385356242, - 870912086, 325965383, 2358957921, 2050466060, 2388260884, 2313884476, - 4006521127, 901210569, 3990953189, 1014646705, 1503449823, 1062597235, - 2031621326, 3212035895, 3931371469, 1533017514, 350174575, 2256028891, - 2177544179, 1052338372, 741876788, 1606591296, 1914052035, 213705253, - 2334669897, 1107234197, 1899603969, 3725069491, 2631447780, - 2422494913, 1635502980, 1893020342, 1950903388, 1120974935, - ], - q = [ - 2807058932, 1699970625, 2764249623, 1586903591, 1808481195, - 1173430173, 1487645946, 59984867, 4199882800, 1844882806, 1989249228, - 1277555970, 3623636965, 3419915562, 1149249077, 2744104290, - 1514790577, 459744698, 244860394, 3235995134, 1963115311, 4027744588, - 2544078150, 4190530515, 1608975247, 2627016082, 2062270317, - 1507497298, 2200818878, 567498868, 1764313568, 3359936201, 2305455554, - 2037970062, 1047239e3, 1910319033, 1337376481, 2904027272, 2892417312, - 984907214, 1243112415, 830661914, 861968209, 2135253587, 2011214180, - 2927934315, 2686254721, 731183368, 1750626376, 4246310725, 1820824798, - 4172763771, 3542330227, 48394827, 2404901663, 2871682645, 671593195, - 3254988725, 2073724613, 145085239, 2280796200, 2779915199, 1790575107, - 2187128086, 472615631, 3029510009, 4075877127, 3802222185, 4107101658, - 3201631749, 1646252340, 4270507174, 1402811438, 1436590835, - 3778151818, 3950355702, 3963161475, 4020912224, 2667994737, 273792366, - 2331590177, 104699613, 95345982, 3175501286, 2377486676, 1560637892, - 3564045318, 369057872, 4213447064, 3919042237, 1137477952, 2658625497, - 1119727848, 2340947849, 1530455833, 4007360968, 172466556, 266959938, - 516552836, 0, 2256734592, 3980931627, 1890328081, 1917742170, - 4294704398, 945164165, 3575528878, 958871085, 3647212047, 2787207260, - 1423022939, 775562294, 1739656202, 3876557655, 2530391278, 2443058075, - 3310321856, 547512796, 1265195639, 437656594, 3121275539, 719700128, - 3762502690, 387781147, 218828297, 3350065803, 2830708150, 2848461854, - 428169201, 122466165, 3720081049, 1627235199, 648017665, 4122762354, - 1002783846, 2117360635, 695634755, 3336358691, 4234721005, 4049844452, - 3704280881, 2232435299, 574624663, 287343814, 612205898, 1039717051, - 840019705, 2708326185, 793451934, 821288114, 1391201670, 3822090177, - 376187827, 3113855344, 1224348052, 1679968233, 2361698556, 1058709744, - 752375421, 2431590963, 1321699145, 3519142200, 2734591178, 188127444, - 2177869557, 3727205754, 2384911031, 3215212461, 2648976442, - 2450346104, 3432737375, 1180849278, 331544205, 3102249176, 4150144569, - 2952102595, 2159976285, 2474404304, 766078933, 313773861, 2570832044, - 2108100632, 1668212892, 3145456443, 2013908262, 418672217, 3070356634, - 2594734927, 1852171925, 3867060991, 3473416636, 3907448597, - 2614737639, 919489135, 164948639, 2094410160, 2997825956, 590424639, - 2486224549, 1723872674, 3157750862, 3399941250, 3501252752, - 3625268135, 2555048196, 3673637356, 1343127501, 4130281361, - 3599595085, 2957853679, 1297403050, 81781910, 3051593425, 2283490410, - 532201772, 1367295589, 3926170974, 895287692, 1953757831, 1093597963, - 492483431, 3528626907, 1446242576, 1192455638, 1636604631, 209336225, - 344873464, 1015671571, 669961897, 3375740769, 3857572124, 2973530695, - 3747192018, 1933530610, 3464042516, 935293895, 3454686199, 2858115069, - 1863638845, 3683022916, 4085369519, 3292445032, 875313188, 1080017571, - 3279033885, 621591778, 1233856572, 2504130317, 24197544, 3017672716, - 3835484340, 3247465558, 2220981195, 3060847922, 1551124588, - 1463996600, - ], - z = [ - 4104605777, 1097159550, 396673818, 660510266, 2875968315, 2638606623, - 4200115116, 3808662347, 821712160, 1986918061, 3430322568, 38544885, - 3856137295, 718002117, 893681702, 1654886325, 2975484382, 3122358053, - 3926825029, 4274053469, 796197571, 1290801793, 1184342925, 3556361835, - 2405426947, 2459735317, 1836772287, 1381620373, 3196267988, - 1948373848, 3764988233, 3385345166, 3263785589, 2390325492, - 1480485785, 3111247143, 3780097726, 2293045232, 548169417, 3459953789, - 3746175075, 439452389, 1362321559, 1400849762, 1685577905, 1806599355, - 2174754046, 137073913, 1214797936, 1174215055, 3731654548, 2079897426, - 1943217067, 1258480242, 529487843, 1437280870, 3945269170, 3049390895, - 3313212038, 923313619, 679998e3, 3215307299, 57326082, 377642221, - 3474729866, 2041877159, 133361907, 1776460110, 3673476453, 96392454, - 878845905, 2801699524, 777231668, 4082475170, 2330014213, 4142626212, - 2213296395, 1626319424, 1906247262, 1846563261, 562755902, 3708173718, - 1040559837, 3871163981, 1418573201, 3294430577, 114585348, 1343618912, - 2566595609, 3186202582, 1078185097, 3651041127, 3896688048, - 2307622919, 425408743, 3371096953, 2081048481, 1108339068, 2216610296, - 0, 2156299017, 736970802, 292596766, 1517440620, 251657213, - 2235061775, 2933202493, 758720310, 265905162, 1554391400, 1532285339, - 908999204, 174567692, 1474760595, 4002861748, 2610011675, 3234156416, - 3693126241, 2001430874, 303699484, 2478443234, 2687165888, 585122620, - 454499602, 151849742, 2345119218, 3064510765, 514443284, 4044981591, - 1963412655, 2581445614, 2137062819, 19308535, 1928707164, 1715193156, - 4219352155, 1126790795, 600235211, 3992742070, 3841024952, 836553431, - 1669664834, 2535604243, 3323011204, 1243905413, 3141400786, - 4180808110, 698445255, 2653899549, 2989552604, 2253581325, 3252932727, - 3004591147, 1891211689, 2487810577, 3915653703, 4237083816, - 4030667424, 2100090966, 865136418, 1229899655, 953270745, 3399679628, - 3557504664, 4118925222, 2061379749, 3079546586, 2915017791, 983426092, - 2022837584, 1607244650, 2118541908, 2366882550, 3635996816, 972512814, - 3283088770, 1568718495, 3499326569, 3576539503, 621982671, 2895723464, - 410887952, 2623762152, 1002142683, 645401037, 1494807662, 2595684844, - 1335535747, 2507040230, 4293295786, 3167684641, 367585007, 3885750714, - 1865862730, 2668221674, 2960971305, 2763173681, 1059270954, - 2777952454, 2724642869, 1320957812, 2194319100, 2429595872, - 2815956275, 77089521, 3973773121, 3444575871, 2448830231, 1305906550, - 4021308739, 2857194700, 2516901860, 3518358430, 1787304780, 740276417, - 1699839814, 1592394909, 2352307457, 2272556026, 188821243, 1729977011, - 3687994002, 274084841, 3594982253, 3613494426, 2701949495, 4162096729, - 322734571, 2837966542, 1640576439, 484830689, 1202797690, 3537852828, - 4067639125, 349075736, 3342319475, 4157467219, 4255800159, 1030690015, - 1155237496, 2951971274, 1757691577, 607398968, 2738905026, 499347990, - 3794078908, 1011452712, 227885567, 2818666809, 213114376, 3034881240, - 1455525988, 3414450555, 850817237, 1817998408, 3092726480, - ], - H = [ - 0, 235474187, 470948374, 303765277, 941896748, 908933415, 607530554, - 708780849, 1883793496, 2118214995, 1817866830, 1649639237, 1215061108, - 1181045119, 1417561698, 1517767529, 3767586992, 4003061179, - 4236429990, 4069246893, 3635733660, 3602770327, 3299278474, - 3400528769, 2430122216, 2664543715, 2362090238, 2193862645, - 2835123396, 2801107407, 3035535058, 3135740889, 3678124923, - 3576870512, 3341394285, 3374361702, 3810496343, 3977675356, - 4279080257, 4043610186, 2876494627, 2776292904, 3076639029, - 3110650942, 2472011535, 2640243204, 2403728665, 2169303058, - 1001089995, 899835584, 666464733, 699432150, 59727847, 226906860, - 530400753, 294930682, 1273168787, 1172967064, 1475418501, 1509430414, - 1942435775, 2110667444, 1876241833, 1641816226, 2910219766, - 2743034109, 2976151520, 3211623147, 2505202138, 2606453969, - 2302690252, 2269728455, 3711829422, 3543599269, 3240894392, - 3475313331, 3843699074, 3943906441, 4178062228, 4144047775, - 1306967366, 1139781709, 1374988112, 1610459739, 1975683434, - 2076935265, 1775276924, 1742315127, 1034867998, 866637845, 566021896, - 800440835, 92987698, 193195065, 429456164, 395441711, 1984812685, - 2017778566, 1784663195, 1683407248, 1315562145, 1080094634, - 1383856311, 1551037884, 101039829, 135050206, 437757123, 337553864, - 1042385657, 807962610, 573804783, 742039012, 2531067453, 2564033334, - 2328828971, 2227573024, 2935566865, 2700099354, 3001755655, - 3168937228, 3868552805, 3902563182, 4203181171, 4102977912, - 3736164937, 3501741890, 3265478751, 3433712980, 1106041591, - 1340463100, 1576976609, 1408749034, 2043211483, 2009195472, - 1708848333, 1809054150, 832877231, 1068351396, 766945465, 599762354, - 159417987, 126454664, 361929877, 463180190, 2709260871, 2943682380, - 3178106961, 3009879386, 2572697195, 2538681184, 2236228733, - 2336434550, 3509871135, 3745345300, 3441850377, 3274667266, - 3910161971, 3877198648, 4110568485, 4211818798, 2597806476, - 2497604743, 2261089178, 2295101073, 2733856160, 2902087851, - 3202437046, 2968011453, 3936291284, 3835036895, 4136440770, - 4169408201, 3535486456, 3702665459, 3467192302, 3231722213, - 2051518780, 1951317047, 1716890410, 1750902305, 1113818384, - 1282050075, 1584504582, 1350078989, 168810852, 67556463, 371049330, - 404016761, 841739592, 1008918595, 775550814, 540080725, 3969562369, - 3801332234, 4035489047, 4269907996, 3569255213, 3669462566, - 3366754619, 3332740144, 2631065433, 2463879762, 2160117071, - 2395588676, 2767645557, 2868897406, 3102011747, 3069049960, 202008497, - 33778362, 270040487, 504459436, 875451293, 975658646, 675039627, - 641025152, 2084704233, 1917518562, 1615861247, 1851332852, 1147550661, - 1248802510, 1484005843, 1451044056, 933301370, 967311729, 733156972, - 632953703, 260388950, 25965917, 328671808, 496906059, 1206477858, - 1239443753, 1543208500, 1441952575, 2144161806, 1908694277, - 1675577880, 1842759443, 3610369226, 3644379585, 3408119516, - 3307916247, 4011190502, 3776767469, 4077384432, 4245618683, - 2809771154, 2842737049, 3144396420, 3043140495, 2673705150, - 2438237621, 2203032232, 2370213795, - ], - Z = [ - 0, 185469197, 370938394, 487725847, 741876788, 657861945, 975451694, - 824852259, 1483753576, 1400783205, 1315723890, 1164071807, 1950903388, - 2135319889, 1649704518, 1767536459, 2967507152, 3152976349, - 2801566410, 2918353863, 2631447780, 2547432937, 2328143614, - 2177544179, 3901806776, 3818836405, 4270639778, 4118987695, - 3299409036, 3483825537, 3535072918, 3652904859, 2077965243, - 1893020342, 1841768865, 1724457132, 1474502543, 1559041666, - 1107234197, 1257309336, 598438867, 681933534, 901210569, 1052338372, - 261314535, 77422314, 428819965, 310463728, 3409685355, 3224740454, - 3710368113, 3593056380, 3875770207, 3960309330, 4045380933, - 4195456072, 2471224067, 2554718734, 2237133081, 2388260884, - 3212035895, 3028143674, 2842678573, 2724322336, 4138563181, - 4255350624, 3769721975, 3955191162, 3667219033, 3516619604, - 3431546947, 3347532110, 2933734917, 2782082824, 3099667487, - 3016697106, 2196052529, 2313884476, 2499348523, 2683765030, - 1179510461, 1296297904, 1347548327, 1533017514, 1786102409, - 1635502980, 2087309459, 2003294622, 507358933, 355706840, 136428751, - 53458370, 839224033, 957055980, 605657339, 790073846, 2373340630, - 2256028891, 2607439820, 2422494913, 2706270690, 2856345839, - 3075636216, 3160175349, 3573941694, 3725069491, 3273267108, - 3356761769, 4181598602, 4063242375, 4011996048, 3828103837, - 1033297158, 915985419, 730517276, 545572369, 296679730, 446754879, - 129166120, 213705253, 1709610350, 1860738147, 1945798516, 2029293177, - 1239331162, 1120974935, 1606591296, 1422699085, 4148292826, - 4233094615, 3781033664, 3931371469, 3682191598, 3497509347, - 3446004468, 3328955385, 2939266226, 2755636671, 3106780840, - 2988687269, 2198438022, 2282195339, 2501218972, 2652609425, - 1201765386, 1286567175, 1371368976, 1521706781, 1805211710, - 1620529459, 2105887268, 1988838185, 533804130, 350174575, 164439672, - 46346101, 870912086, 954669403, 636813900, 788204353, 2358957921, - 2274680428, 2592523643, 2441661558, 2695033685, 2880240216, - 3065962831, 3182487618, 3572145929, 3756299780, 3270937875, - 3388507166, 4174560061, 4091327024, 4006521127, 3854606378, - 1014646705, 930369212, 711349675, 560487590, 272786309, 457992840, - 106852767, 223377554, 1678381017, 1862534868, 1914052035, 2031621326, - 1211247597, 1128014560, 1580087799, 1428173050, 32283319, 182621114, - 401639597, 486441376, 768917123, 651868046, 1003007129, 818324884, - 1503449823, 1385356242, 1333838021, 1150208456, 1973745387, - 2125135846, 1673061617, 1756818940, 2970356327, 3120694122, - 2802849917, 2887651696, 2637442643, 2520393566, 2334669897, - 2149987652, 3917234703, 3799141122, 4284502037, 4100872472, - 3309594171, 3460984630, 3545789473, 3629546796, 2050466060, - 1899603969, 1814803222, 1730525723, 1443857720, 1560382517, - 1075025698, 1260232239, 575138148, 692707433, 878443390, 1062597235, - 243256656, 91341917, 409198410, 325965383, 3403100636, 3252238545, - 3704300486, 3620022987, 3874428392, 3990953189, 4042459122, - 4227665663, 2460449204, 2578018489, 2226875310, 2411029155, - 3198115200, 3046200461, 2827177882, 2743944855, - ], - $ = [ - 0, 218828297, 437656594, 387781147, 875313188, 958871085, 775562294, - 590424639, 1750626376, 1699970625, 1917742170, 2135253587, 1551124588, - 1367295589, 1180849278, 1265195639, 3501252752, 3720081049, - 3399941250, 3350065803, 3835484340, 3919042237, 4270507174, - 4085369519, 3102249176, 3051593425, 2734591178, 2952102595, - 2361698556, 2177869557, 2530391278, 2614737639, 3145456443, - 3060847922, 2708326185, 2892417312, 2404901663, 2187128086, - 2504130317, 2555048196, 3542330227, 3727205754, 3375740769, - 3292445032, 3876557655, 3926170974, 4246310725, 4027744588, - 1808481195, 1723872674, 1910319033, 2094410160, 1608975247, - 1391201670, 1173430173, 1224348052, 59984867, 244860394, 428169201, - 344873464, 935293895, 984907214, 766078933, 547512796, 1844882806, - 1627235199, 2011214180, 2062270317, 1507497298, 1423022939, - 1137477952, 1321699145, 95345982, 145085239, 532201772, 313773861, - 830661914, 1015671571, 731183368, 648017665, 3175501286, 2957853679, - 2807058932, 2858115069, 2305455554, 2220981195, 2474404304, - 2658625497, 3575528878, 3625268135, 3473416636, 3254988725, - 3778151818, 3963161475, 4213447064, 4130281361, 3599595085, - 3683022916, 3432737375, 3247465558, 3802222185, 4020912224, - 4172763771, 4122762354, 3201631749, 3017672716, 2764249623, - 2848461854, 2331590177, 2280796200, 2431590963, 2648976442, 104699613, - 188127444, 472615631, 287343814, 840019705, 1058709744, 671593195, - 621591778, 1852171925, 1668212892, 1953757831, 2037970062, 1514790577, - 1463996600, 1080017571, 1297403050, 3673637356, 3623636965, - 3235995134, 3454686199, 4007360968, 3822090177, 4107101658, - 4190530515, 2997825956, 3215212461, 2830708150, 2779915199, - 2256734592, 2340947849, 2627016082, 2443058075, 172466556, 122466165, - 273792366, 492483431, 1047239e3, 861968209, 612205898, 695634755, - 1646252340, 1863638845, 2013908262, 1963115311, 1446242576, - 1530455833, 1277555970, 1093597963, 1636604631, 1820824798, - 2073724613, 1989249228, 1436590835, 1487645946, 1337376481, - 1119727848, 164948639, 81781910, 331544205, 516552836, 1039717051, - 821288114, 669961897, 719700128, 2973530695, 3157750862, 2871682645, - 2787207260, 2232435299, 2283490410, 2667994737, 2450346104, - 3647212047, 3564045318, 3279033885, 3464042516, 3980931627, - 3762502690, 4150144569, 4199882800, 3070356634, 3121275539, - 2904027272, 2686254721, 2200818878, 2384911031, 2570832044, - 2486224549, 3747192018, 3528626907, 3310321856, 3359936201, - 3950355702, 3867060991, 4049844452, 4234721005, 1739656202, - 1790575107, 2108100632, 1890328081, 1402811438, 1586903591, - 1233856572, 1149249077, 266959938, 48394827, 369057872, 418672217, - 1002783846, 919489135, 567498868, 752375421, 209336225, 24197544, - 376187827, 459744698, 945164165, 895287692, 574624663, 793451934, - 1679968233, 1764313568, 2117360635, 1933530610, 1343127501, - 1560637892, 1243112415, 1192455638, 3704280881, 3519142200, - 3336358691, 3419915562, 3907448597, 3857572124, 4075877127, - 4294704398, 3029510009, 3113855344, 2927934315, 2744104290, - 2159976285, 2377486676, 2594734927, 2544078150, - ], - ue = [ - 0, 151849742, 303699484, 454499602, 607398968, 758720310, 908999204, - 1059270954, 1214797936, 1097159550, 1517440620, 1400849762, - 1817998408, 1699839814, 2118541908, 2001430874, 2429595872, - 2581445614, 2194319100, 2345119218, 3034881240, 3186202582, - 2801699524, 2951971274, 3635996816, 3518358430, 3399679628, - 3283088770, 4237083816, 4118925222, 4002861748, 3885750714, - 1002142683, 850817237, 698445255, 548169417, 529487843, 377642221, - 227885567, 77089521, 1943217067, 2061379749, 1640576439, 1757691577, - 1474760595, 1592394909, 1174215055, 1290801793, 2875968315, - 2724642869, 3111247143, 2960971305, 2405426947, 2253581325, - 2638606623, 2487810577, 3808662347, 3926825029, 4044981591, - 4162096729, 3342319475, 3459953789, 3576539503, 3693126241, - 1986918061, 2137062819, 1685577905, 1836772287, 1381620373, - 1532285339, 1078185097, 1229899655, 1040559837, 923313619, 740276417, - 621982671, 439452389, 322734571, 137073913, 19308535, 3871163981, - 4021308739, 4104605777, 4255800159, 3263785589, 3414450555, - 3499326569, 3651041127, 2933202493, 2815956275, 3167684641, - 3049390895, 2330014213, 2213296395, 2566595609, 2448830231, - 1305906550, 1155237496, 1607244650, 1455525988, 1776460110, - 1626319424, 2079897426, 1928707164, 96392454, 213114376, 396673818, - 514443284, 562755902, 679998e3, 865136418, 983426092, 3708173718, - 3557504664, 3474729866, 3323011204, 4180808110, 4030667424, - 3945269170, 3794078908, 2507040230, 2623762152, 2272556026, - 2390325492, 2975484382, 3092726480, 2738905026, 2857194700, - 3973773121, 3856137295, 4274053469, 4157467219, 3371096953, - 3252932727, 3673476453, 3556361835, 2763173681, 2915017791, - 3064510765, 3215307299, 2156299017, 2307622919, 2459735317, - 2610011675, 2081048481, 1963412655, 1846563261, 1729977011, - 1480485785, 1362321559, 1243905413, 1126790795, 878845905, 1030690015, - 645401037, 796197571, 274084841, 425408743, 38544885, 188821243, - 3613494426, 3731654548, 3313212038, 3430322568, 4082475170, - 4200115116, 3780097726, 3896688048, 2668221674, 2516901860, - 2366882550, 2216610296, 3141400786, 2989552604, 2837966542, - 2687165888, 1202797690, 1320957812, 1437280870, 1554391400, - 1669664834, 1787304780, 1906247262, 2022837584, 265905162, 114585348, - 499347990, 349075736, 736970802, 585122620, 972512814, 821712160, - 2595684844, 2478443234, 2293045232, 2174754046, 3196267988, - 3079546586, 2895723464, 2777952454, 3537852828, 3687994002, - 3234156416, 3385345166, 4142626212, 4293295786, 3841024952, - 3992742070, 174567692, 57326082, 410887952, 292596766, 777231668, - 660510266, 1011452712, 893681702, 1108339068, 1258480242, 1343618912, - 1494807662, 1715193156, 1865862730, 1948373848, 2100090966, - 2701949495, 2818666809, 3004591147, 3122358053, 2235061775, - 2352307457, 2535604243, 2653899549, 3915653703, 3764988233, - 4219352155, 4067639125, 3444575871, 3294430577, 3746175075, - 3594982253, 836553431, 953270745, 600235211, 718002117, 367585007, - 484830689, 133361907, 251657213, 2041877159, 1891211689, 1806599355, - 1654886325, 1568718495, 1418573201, 1335535747, 1184342925, - ]; - function te(f) { - for (var x = [], C = 0; C < f.length; C += 4) - x.push((f[C] << 24) | (f[C + 1] << 16) | (f[C + 2] << 8) | f[C + 3]); - return x; - } - var ne = function (f) { - if (!(this instanceof ne)) - throw Error("AES must be instanitated with `new`"); - Object.defineProperty(this, "key", { value: n(f, !0) }), - this._prepare(); - }; - (ne.prototype._prepare = function () { - var f = c[this.key.length]; - if (f == null) - throw new Error("invalid key size (must be 16, 24 or 32 bytes)"); - (this._Ke = []), (this._Kd = []); - for (var x = 0; x <= f; x++) - this._Ke.push([0, 0, 0, 0]), this._Kd.push([0, 0, 0, 0]); - for ( - var C = (f + 1) * 4, - E = this.key.length / 4, - B = te(this.key), - G, - x = 0; - x < E; - x++ - ) - (G = x >> 2), - (this._Ke[G][x % 4] = B[x]), - (this._Kd[f - G][x % 4] = B[x]); - for (var L = 0, ee = E, ge; ee < C; ) { - if ( - ((ge = B[E - 1]), - (B[0] ^= - (h[(ge >> 16) & 255] << 24) ^ - (h[(ge >> 8) & 255] << 16) ^ - (h[ge & 255] << 8) ^ - h[(ge >> 24) & 255] ^ - (u[L] << 24)), - (L += 1), - E != 8) - ) - for (var x = 1; x < E; x++) B[x] ^= B[x - 1]; - else { - for (var x = 1; x < E / 2; x++) B[x] ^= B[x - 1]; - (ge = B[E / 2 - 1]), - (B[E / 2] ^= - h[ge & 255] ^ - (h[(ge >> 8) & 255] << 8) ^ - (h[(ge >> 16) & 255] << 16) ^ - (h[(ge >> 24) & 255] << 24)); - for (var x = E / 2 + 1; x < E; x++) B[x] ^= B[x - 1]; - } - for (var x = 0, fe, V; x < E && ee < C; ) - (fe = ee >> 2), - (V = ee % 4), - (this._Ke[fe][V] = B[x]), - (this._Kd[f - fe][V] = B[x++]), - ee++; - } - for (var fe = 1; fe < f; fe++) - for (var V = 0; V < 4; V++) - (ge = this._Kd[fe][V]), - (this._Kd[fe][V] = - H[(ge >> 24) & 255] ^ - Z[(ge >> 16) & 255] ^ - $[(ge >> 8) & 255] ^ - ue[ge & 255]); - }), - (ne.prototype.encrypt = function (f) { - if (f.length != 16) - throw new Error("invalid plaintext size (must be 16 bytes)"); - for ( - var x = this._Ke.length - 1, C = [0, 0, 0, 0], E = te(f), B = 0; - B < 4; - B++ - ) - E[B] ^= this._Ke[0][B]; - for (var G = 1; G < x; G++) { - for (var B = 0; B < 4; B++) - C[B] = - M[(E[B] >> 24) & 255] ^ - k[(E[(B + 1) % 4] >> 16) & 255] ^ - O[(E[(B + 2) % 4] >> 8) & 255] ^ - D[E[(B + 3) % 4] & 255] ^ - this._Ke[G][B]; - E = C.slice(); - } - for (var L = i(16), ee, B = 0; B < 4; B++) - (ee = this._Ke[x][B]), - (L[4 * B] = (h[(E[B] >> 24) & 255] ^ (ee >> 24)) & 255), - (L[4 * B + 1] = - (h[(E[(B + 1) % 4] >> 16) & 255] ^ (ee >> 16)) & 255), - (L[4 * B + 2] = - (h[(E[(B + 2) % 4] >> 8) & 255] ^ (ee >> 8)) & 255), - (L[4 * B + 3] = (h[E[(B + 3) % 4] & 255] ^ ee) & 255); - return L; - }), - (ne.prototype.decrypt = function (f) { - if (f.length != 16) - throw new Error("invalid ciphertext size (must be 16 bytes)"); - for ( - var x = this._Kd.length - 1, C = [0, 0, 0, 0], E = te(f), B = 0; - B < 4; - B++ - ) - E[B] ^= this._Kd[0][B]; - for (var G = 1; G < x; G++) { - for (var B = 0; B < 4; B++) - C[B] = - F[(E[B] >> 24) & 255] ^ - N[(E[(B + 3) % 4] >> 16) & 255] ^ - q[(E[(B + 2) % 4] >> 8) & 255] ^ - z[E[(B + 1) % 4] & 255] ^ - this._Kd[G][B]; - E = C.slice(); - } - for (var L = i(16), ee, B = 0; B < 4; B++) - (ee = this._Kd[x][B]), - (L[4 * B] = (w[(E[B] >> 24) & 255] ^ (ee >> 24)) & 255), - (L[4 * B + 1] = - (w[(E[(B + 3) % 4] >> 16) & 255] ^ (ee >> 16)) & 255), - (L[4 * B + 2] = - (w[(E[(B + 2) % 4] >> 8) & 255] ^ (ee >> 8)) & 255), - (L[4 * B + 3] = (w[E[(B + 1) % 4] & 255] ^ ee) & 255); - return L; - }); - var A = function (f) { - if (!(this instanceof A)) - throw Error("AES must be instanitated with `new`"); - (this.description = "Electronic Code Block"), - (this.name = "ecb"), - (this._aes = new ne(f)); - }; - (A.prototype.encrypt = function (f) { - if (((f = n(f)), f.length % 16 !== 0)) - throw new Error( - "invalid plaintext size (must be multiple of 16 bytes)" - ); - for (var x = i(f.length), C = i(16), E = 0; E < f.length; E += 16) - o(f, C, 0, E, E + 16), (C = this._aes.encrypt(C)), o(C, x, E); - return x; - }), - (A.prototype.decrypt = function (f) { - if (((f = n(f)), f.length % 16 !== 0)) - throw new Error( - "invalid ciphertext size (must be multiple of 16 bytes)" - ); - for (var x = i(f.length), C = i(16), E = 0; E < f.length; E += 16) - o(f, C, 0, E, E + 16), (C = this._aes.decrypt(C)), o(C, x, E); - return x; - }); - var l = function (f, x) { - if (!(this instanceof l)) - throw Error("AES must be instanitated with `new`"); - if ( - ((this.description = "Cipher Block Chaining"), - (this.name = "cbc"), - !x) - ) - x = i(16); - else if (x.length != 16) - throw new Error( - "invalid initialation vector size (must be 16 bytes)" - ); - (this._lastCipherblock = n(x, !0)), (this._aes = new ne(f)); - }; - (l.prototype.encrypt = function (f) { - if (((f = n(f)), f.length % 16 !== 0)) - throw new Error( - "invalid plaintext size (must be multiple of 16 bytes)" - ); - for (var x = i(f.length), C = i(16), E = 0; E < f.length; E += 16) { - o(f, C, 0, E, E + 16); - for (var B = 0; B < 16; B++) C[B] ^= this._lastCipherblock[B]; - (this._lastCipherblock = this._aes.encrypt(C)), - o(this._lastCipherblock, x, E); - } - return x; - }), - (l.prototype.decrypt = function (f) { - if (((f = n(f)), f.length % 16 !== 0)) - throw new Error( - "invalid ciphertext size (must be multiple of 16 bytes)" - ); - for (var x = i(f.length), C = i(16), E = 0; E < f.length; E += 16) { - o(f, C, 0, E, E + 16), (C = this._aes.decrypt(C)); - for (var B = 0; B < 16; B++) - x[E + B] = C[B] ^ this._lastCipherblock[B]; - o(f, this._lastCipherblock, 0, E, E + 16); - } - return x; - }); - var p = function (f, x, C) { - if (!(this instanceof p)) - throw Error("AES must be instanitated with `new`"); - if (((this.description = "Cipher Feedback"), (this.name = "cfb"), !x)) - x = i(16); - else if (x.length != 16) - throw new Error("invalid initialation vector size (must be 16 size)"); - C || (C = 1), - (this.segmentSize = C), - (this._shiftRegister = n(x, !0)), - (this._aes = new ne(f)); - }; - (p.prototype.encrypt = function (f) { - if (f.length % this.segmentSize != 0) - throw new Error("invalid plaintext size (must be segmentSize bytes)"); - for (var x = n(f, !0), C, E = 0; E < x.length; E += this.segmentSize) { - C = this._aes.encrypt(this._shiftRegister); - for (var B = 0; B < this.segmentSize; B++) x[E + B] ^= C[B]; - o(this._shiftRegister, this._shiftRegister, 0, this.segmentSize), - o( - x, - this._shiftRegister, - 16 - this.segmentSize, - E, - E + this.segmentSize - ); - } - return x; - }), - (p.prototype.decrypt = function (f) { - if (f.length % this.segmentSize != 0) - throw new Error( - "invalid ciphertext size (must be segmentSize bytes)" - ); - for ( - var x = n(f, !0), C, E = 0; - E < x.length; - E += this.segmentSize - ) { - C = this._aes.encrypt(this._shiftRegister); - for (var B = 0; B < this.segmentSize; B++) x[E + B] ^= C[B]; - o(this._shiftRegister, this._shiftRegister, 0, this.segmentSize), - o( - f, - this._shiftRegister, - 16 - this.segmentSize, - E, - E + this.segmentSize - ); - } - return x; - }); - var y = function (f, x) { - if (!(this instanceof y)) - throw Error("AES must be instanitated with `new`"); - if (((this.description = "Output Feedback"), (this.name = "ofb"), !x)) - x = i(16); - else if (x.length != 16) - throw new Error( - "invalid initialation vector size (must be 16 bytes)" - ); - (this._lastPrecipher = n(x, !0)), - (this._lastPrecipherIndex = 16), - (this._aes = new ne(f)); - }; - (y.prototype.encrypt = function (f) { - for (var x = n(f, !0), C = 0; C < x.length; C++) - this._lastPrecipherIndex === 16 && - ((this._lastPrecipher = this._aes.encrypt(this._lastPrecipher)), - (this._lastPrecipherIndex = 0)), - (x[C] ^= this._lastPrecipher[this._lastPrecipherIndex++]); - return x; - }), - (y.prototype.decrypt = y.prototype.encrypt); - var d = function (f) { - if (!(this instanceof d)) - throw Error("Counter must be instanitated with `new`"); - f !== 0 && !f && (f = 1), - typeof f == "number" - ? ((this._counter = i(16)), this.setValue(f)) - : this.setBytes(f); - }; - (d.prototype.setValue = function (f) { - if (typeof f != "number" || parseInt(f) != f) - throw new Error("invalid counter value (must be an integer)"); - for (var x = 15; x >= 0; --x) - (this._counter[x] = f % 256), (f = f >> 8); - }), - (d.prototype.setBytes = function (f) { - if (((f = n(f, !0)), f.length != 16)) - throw new Error("invalid counter bytes size (must be 16 bytes)"); - this._counter = f; - }), - (d.prototype.increment = function () { - for (var f = 15; f >= 0; f--) - if (this._counter[f] === 255) this._counter[f] = 0; - else { - this._counter[f]++; - break; - } - }); - var v = function (f, x) { - if (!(this instanceof v)) - throw Error("AES must be instanitated with `new`"); - (this.description = "Counter"), - (this.name = "ctr"), - x instanceof d || (x = new d(x)), - (this._counter = x), - (this._remainingCounter = null), - (this._remainingCounterIndex = 16), - (this._aes = new ne(f)); - }; - (v.prototype.encrypt = function (f) { - for (var x = n(f, !0), C = 0; C < x.length; C++) - this._remainingCounterIndex === 16 && - ((this._remainingCounter = this._aes.encrypt( - this._counter._counter - )), - (this._remainingCounterIndex = 0), - this._counter.increment()), - (x[C] ^= this._remainingCounter[this._remainingCounterIndex++]); - return x; - }), - (v.prototype.decrypt = v.prototype.encrypt); - function _(f) { - f = n(f, !0); - var x = 16 - (f.length % 16), - C = i(f.length + x); - o(f, C); - for (var E = f.length; E < C.length; E++) C[E] = x; - return C; - } - function S(f) { - if (((f = n(f, !0)), f.length < 16)) - throw new Error("PKCS#7 invalid length"); - var x = f[f.length - 1]; - if (x > 16) throw new Error("PKCS#7 padding byte out of range"); - for (var C = f.length - x, E = 0; E < x; E++) - if (f[C + E] !== x) throw new Error("PKCS#7 invalid padding byte"); - var B = i(C); - return o(f, B, 0, 0, C), B; - } - var b = { - AES: ne, - Counter: d, - ModeOfOperation: { ecb: A, cbc: l, cfb: p, ofb: y, ctr: v }, - utils: { hex: s, utf8: a }, - padding: { pkcs7: { pad: _, strip: S } }, - _arrayTest: { coerceArray: n, createArray: i, copyArray: o }, - }; - typeof rEe < "u" - ? (fft.exports = b) - : typeof define == "function" && define.amd - ? define(b) - : (t.aesjs && (b._aesjs = t.aesjs), (t.aesjs = b)); - })(rEe); - }); - var iEe = I((dne) => { - "use strict"; - m(); - g(); - Object.defineProperty(dne, "__esModule", { value: !0 }); - dne.version = void 0; - dne.version = "json-wallets/5.7.0"; - }); - var oEe = I((zy) => { - "use strict"; - m(); - g(); - Object.defineProperty(zy, "__esModule", { value: !0 }); - zy.uuidV4 = - zy.searchPath = - zy.getPassword = - zy.zpad = - zy.looseArrayify = - void 0; - var hne = Ar(), - dft = Eo(); - function F_r(t) { - return ( - typeof t == "string" && t.substring(0, 2) !== "0x" && (t = "0x" + t), - (0, hne.arrayify)(t) - ); - } - zy.looseArrayify = F_r; - function L_r(t, e) { - for (t = String(t); t.length < e; ) t = "0" + t; - return t; - } - zy.zpad = L_r; - function q_r(t) { - return typeof t == "string" - ? (0, dft.toUtf8Bytes)(t, dft.UnicodeNormalizationForm.NFKC) - : (0, hne.arrayify)(t); - } - zy.getPassword = q_r; - function z_r(t, e) { - for ( - var r = t, n = e.toLowerCase().split("/"), i = 0; - i < n.length; - i++ - ) { - var o = null; - for (var a in r) - if (a.toLowerCase() === n[i]) { - o = r[a]; - break; - } - if (o === null) return null; - r = o; - } - return r; - } - zy.searchPath = z_r; - function j_r(t) { - var e = (0, hne.arrayify)(t); - (e[6] = (e[6] & 15) | 64), (e[8] = (e[8] & 63) | 128); - var r = (0, hne.hexlify)(e); - return [ - r.substring(2, 10), - r.substring(10, 14), - r.substring(14, 18), - r.substring(18, 22), - r.substring(22, 34), - ].join("-"); - } - zy.uuidV4 = j_r; - }); - var mft = I((gb) => { - "use strict"; - m(); - g(); - var U_r = - (gb && gb.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(), - K_r = - (gb && gb.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(gb, "__esModule", { value: !0 }); - gb.decrypt = gb.CrowdsaleAccount = void 0; - var hft = K_r(nEe()), - H_r = Vh(), - pft = Ar(), - V_r = Hh(), - W_r = Xre(), - G_r = Eo(), - J_r = $r(), - $_r = rr(), - Z_r = iEe(), - X_r = new $_r.Logger(Z_r.version), - pne = oEe(), - yft = (function (t) { - U_r(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.prototype.isCrowdsaleAccount = function (r) { - return !!(r && r._isCrowdsaleAccount); - }), - e - ); - })(J_r.Description); - gb.CrowdsaleAccount = yft; - function Y_r(t, e) { - var r = JSON.parse(t); - e = (0, pne.getPassword)(e); - var n = (0, H_r.getAddress)((0, pne.searchPath)(r, "ethaddr")), - i = (0, pne.looseArrayify)((0, pne.searchPath)(r, "encseed")); - (!i || i.length % 16 !== 0) && - X_r.throwArgumentError("invalid encseed", "json", t); - for ( - var o = (0, pft.arrayify)( - (0, W_r.pbkdf2)(e, e, 2e3, 32, "sha256") - ).slice(0, 16), - a = i.slice(0, 16), - s = i.slice(16), - c = new hft.default.ModeOfOperation.cbc(o, a), - u = hft.default.padding.pkcs7.strip((0, pft.arrayify)(c.decrypt(s))), - h = "", - w = 0; - w < u.length; - w++ - ) - h += String.fromCharCode(u[w]); - var M = (0, G_r.toUtf8Bytes)(h), - k = (0, V_r.keccak256)(M); - return new yft({ _isCrowdsaleAccount: !0, address: n, privateKey: k }); - } - gb.decrypt = Y_r; - }); - var wft = I((qA) => { - "use strict"; - m(); - g(); - Object.defineProperty(qA, "__esModule", { value: !0 }); - qA.getJsonWalletAddress = - qA.isKeystoreWallet = - qA.isCrowdsaleWallet = - void 0; - var gft = Vh(); - function vft(t) { - var e = null; - try { - e = JSON.parse(t); - } catch { - return !1; - } - return e.encseed && e.ethaddr; - } - qA.isCrowdsaleWallet = vft; - function bft(t) { - var e = null; - try { - e = JSON.parse(t); - } catch { - return !1; - } - return !( - !e.version || - parseInt(e.version) !== e.version || - parseInt(e.version) !== 3 - ); - } - qA.isKeystoreWallet = bft; - function Q_r(t) { - if (vft(t)) - try { - return (0, gft.getAddress)(JSON.parse(t).ethaddr); - } catch { - return null; - } - if (bft(t)) - try { - return (0, gft.getAddress)(JSON.parse(t).address); - } catch { - return null; - } - return null; - } - qA.getJsonWalletAddress = Q_r; - }); - var xft = I((aEe, _ft) => { - "use strict"; - m(); - g(); - (function (t) { - function r(k) { - let O = new Uint32Array([ - 1116352408, 1899447441, 3049323471, 3921009573, 961987163, - 1508970993, 2453635748, 2870763221, 3624381080, 310598401, - 607225278, 1426881987, 1925078388, 2162078206, 2614888103, - 3248222580, 3835390401, 4022224774, 264347078, 604807628, 770255983, - 1249150122, 1555081692, 1996064986, 2554220882, 2821834349, - 2952996808, 3210313671, 3336571891, 3584528711, 113926993, - 338241895, 666307205, 773529912, 1294757372, 1396182291, 1695183700, - 1986661051, 2177026350, 2456956037, 2730485921, 2820302411, - 3259730800, 3345764771, 3516065817, 3600352804, 4094571909, - 275423344, 430227734, 506948616, 659060556, 883997877, 958139571, - 1322822218, 1537002063, 1747873779, 1955562222, 2024104815, - 2227730452, 2361852424, 2428436474, 2756734187, 3204031479, - 3329325298, - ]), - D = 1779033703, - F = 3144134277, - N = 1013904242, - q = 2773480762, - z = 1359893119, - H = 2600822924, - Z = 528734635, - $ = 1541459225, - ue = new Uint32Array(64); - function te(v) { - let _ = 0, - S = v.length; - for (; S >= 64; ) { - let b = D, - f = F, - x = N, - C = q, - E = z, - B = H, - G = Z, - L = $, - ee, - ge, - fe, - V, - ye; - for (ge = 0; ge < 16; ge++) - (fe = _ + ge * 4), - (ue[ge] = - ((v[fe] & 255) << 24) | - ((v[fe + 1] & 255) << 16) | - ((v[fe + 2] & 255) << 8) | - (v[fe + 3] & 255)); - for (ge = 16; ge < 64; ge++) - (ee = ue[ge - 2]), - (V = - ((ee >>> 17) | (ee << (32 - 17))) ^ - ((ee >>> 19) | (ee << (32 - 19))) ^ - (ee >>> 10)), - (ee = ue[ge - 15]), - (ye = - ((ee >>> 7) | (ee << (32 - 7))) ^ - ((ee >>> 18) | (ee << (32 - 18))) ^ - (ee >>> 3)), - (ue[ge] = - (((V + ue[ge - 7]) | 0) + ((ye + ue[ge - 16]) | 0)) | 0); - for (ge = 0; ge < 64; ge++) - (V = - ((((((E >>> 6) | (E << (32 - 6))) ^ - ((E >>> 11) | (E << (32 - 11))) ^ - ((E >>> 25) | (E << (32 - 25)))) + - ((E & B) ^ (~E & G))) | - 0) + - ((L + ((O[ge] + ue[ge]) | 0)) | 0)) | - 0), - (ye = - ((((b >>> 2) | (b << (32 - 2))) ^ - ((b >>> 13) | (b << (32 - 13))) ^ - ((b >>> 22) | (b << (32 - 22)))) + - ((b & f) ^ (b & x) ^ (f & x))) | - 0), - (L = G), - (G = B), - (B = E), - (E = (C + V) | 0), - (C = x), - (x = f), - (f = b), - (b = (V + ye) | 0); - (D = (D + b) | 0), - (F = (F + f) | 0), - (N = (N + x) | 0), - (q = (q + C) | 0), - (z = (z + E) | 0), - (H = (H + B) | 0), - (Z = (Z + G) | 0), - ($ = ($ + L) | 0), - (_ += 64), - (S -= 64); - } - } - te(k); - let ne, - A = k.length % 64, - l = (k.length / 536870912) | 0, - p = k.length << 3, - y = A < 56 ? 56 : 120, - d = k.slice(k.length - A, k.length); - for (d.push(128), ne = A + 1; ne < y; ne++) d.push(0); - return ( - d.push((l >>> 24) & 255), - d.push((l >>> 16) & 255), - d.push((l >>> 8) & 255), - d.push((l >>> 0) & 255), - d.push((p >>> 24) & 255), - d.push((p >>> 16) & 255), - d.push((p >>> 8) & 255), - d.push((p >>> 0) & 255), - te(d), - [ - (D >>> 24) & 255, - (D >>> 16) & 255, - (D >>> 8) & 255, - (D >>> 0) & 255, - (F >>> 24) & 255, - (F >>> 16) & 255, - (F >>> 8) & 255, - (F >>> 0) & 255, - (N >>> 24) & 255, - (N >>> 16) & 255, - (N >>> 8) & 255, - (N >>> 0) & 255, - (q >>> 24) & 255, - (q >>> 16) & 255, - (q >>> 8) & 255, - (q >>> 0) & 255, - (z >>> 24) & 255, - (z >>> 16) & 255, - (z >>> 8) & 255, - (z >>> 0) & 255, - (H >>> 24) & 255, - (H >>> 16) & 255, - (H >>> 8) & 255, - (H >>> 0) & 255, - (Z >>> 24) & 255, - (Z >>> 16) & 255, - (Z >>> 8) & 255, - (Z >>> 0) & 255, - ($ >>> 24) & 255, - ($ >>> 16) & 255, - ($ >>> 8) & 255, - ($ >>> 0) & 255, - ] - ); - } - function n(k, O, D) { - k = k.length <= 64 ? k : r(k); - let F = 64 + O.length + 4, - N = new Array(F), - q = new Array(64), - z, - H = []; - for (z = 0; z < 64; z++) N[z] = 54; - for (z = 0; z < k.length; z++) N[z] ^= k[z]; - for (z = 0; z < O.length; z++) N[64 + z] = O[z]; - for (z = F - 4; z < F; z++) N[z] = 0; - for (z = 0; z < 64; z++) q[z] = 92; - for (z = 0; z < k.length; z++) q[z] ^= k[z]; - function Z() { - for (let $ = F - 1; $ >= F - 4; $--) { - if ((N[$]++, N[$] <= 255)) return; - N[$] = 0; - } - } - for (; D >= 32; ) Z(), (H = H.concat(r(q.concat(r(N))))), (D -= 32); - return D > 0 && (Z(), (H = H.concat(r(q.concat(r(N))).slice(0, D)))), H; - } - function i(k, O, D, F, N) { - let q; - for (c(k, (2 * D - 1) * 16, N, 0, 16), q = 0; q < 2 * D; q++) - s(k, q * 16, N, 16), a(N, F), c(N, 0, k, O + q * 16, 16); - for (q = 0; q < D; q++) c(k, O + q * 2 * 16, k, q * 16, 16); - for (q = 0; q < D; q++) c(k, O + (q * 2 + 1) * 16, k, (q + D) * 16, 16); - } - function o(k, O) { - return (k << O) | (k >>> (32 - O)); - } - function a(k, O) { - c(k, 0, O, 0, 16); - for (let D = 8; D > 0; D -= 2) - (O[4] ^= o(O[0] + O[12], 7)), - (O[8] ^= o(O[4] + O[0], 9)), - (O[12] ^= o(O[8] + O[4], 13)), - (O[0] ^= o(O[12] + O[8], 18)), - (O[9] ^= o(O[5] + O[1], 7)), - (O[13] ^= o(O[9] + O[5], 9)), - (O[1] ^= o(O[13] + O[9], 13)), - (O[5] ^= o(O[1] + O[13], 18)), - (O[14] ^= o(O[10] + O[6], 7)), - (O[2] ^= o(O[14] + O[10], 9)), - (O[6] ^= o(O[2] + O[14], 13)), - (O[10] ^= o(O[6] + O[2], 18)), - (O[3] ^= o(O[15] + O[11], 7)), - (O[7] ^= o(O[3] + O[15], 9)), - (O[11] ^= o(O[7] + O[3], 13)), - (O[15] ^= o(O[11] + O[7], 18)), - (O[1] ^= o(O[0] + O[3], 7)), - (O[2] ^= o(O[1] + O[0], 9)), - (O[3] ^= o(O[2] + O[1], 13)), - (O[0] ^= o(O[3] + O[2], 18)), - (O[6] ^= o(O[5] + O[4], 7)), - (O[7] ^= o(O[6] + O[5], 9)), - (O[4] ^= o(O[7] + O[6], 13)), - (O[5] ^= o(O[4] + O[7], 18)), - (O[11] ^= o(O[10] + O[9], 7)), - (O[8] ^= o(O[11] + O[10], 9)), - (O[9] ^= o(O[8] + O[11], 13)), - (O[10] ^= o(O[9] + O[8], 18)), - (O[12] ^= o(O[15] + O[14], 7)), - (O[13] ^= o(O[12] + O[15], 9)), - (O[14] ^= o(O[13] + O[12], 13)), - (O[15] ^= o(O[14] + O[13], 18)); - for (let D = 0; D < 16; ++D) k[D] += O[D]; - } - function s(k, O, D, F) { - for (let N = 0; N < F; N++) D[N] ^= k[O + N]; - } - function c(k, O, D, F, N) { - for (; N--; ) D[F++] = k[O++]; - } - function u(k) { - if (!k || typeof k.length != "number") return !1; - for (let O = 0; O < k.length; O++) { - let D = k[O]; - if (typeof D != "number" || D % 1 || D < 0 || D >= 256) return !1; - } - return !0; - } - function h(k, O) { - if (typeof k != "number" || k % 1) throw new Error("invalid " + O); - return k; - } - function w(k, O, D, F, N, q, z) { - if ( - ((D = h(D, "N")), - (F = h(F, "r")), - (N = h(N, "p")), - (q = h(q, "dkLen")), - D === 0 || (D & (D - 1)) !== 0) - ) - throw new Error("N must be power of 2"); - if (D > 2147483647 / 128 / F) throw new Error("N too large"); - if (F > 2147483647 / 128 / N) throw new Error("r too large"); - if (!u(k)) throw new Error("password must be an array or buffer"); - if (((k = Array.prototype.slice.call(k)), !u(O))) - throw new Error("salt must be an array or buffer"); - O = Array.prototype.slice.call(O); - let H = n(k, O, N * 128 * F), - Z = new Uint32Array(N * 32 * F); - for (let E = 0; E < Z.length; E++) { - let B = E * 4; - Z[E] = - ((H[B + 3] & 255) << 24) | - ((H[B + 2] & 255) << 16) | - ((H[B + 1] & 255) << 8) | - ((H[B + 0] & 255) << 0); - } - let $ = new Uint32Array(64 * F), - ue = new Uint32Array(32 * F * D), - te = 32 * F, - ne = new Uint32Array(16), - A = new Uint32Array(16), - l = N * D * 2, - p = 0, - y = null, - d = !1, - v = 0, - _ = 0, - S, - b, - f = z ? parseInt(1e3 / F) : 4294967295, - x = typeof setImmediate < "u" ? setImmediate : setTimeout, - C = function () { - if (d) return z(new Error("cancelled"), p / l); - let E; - switch (v) { - case 0: - (b = _ * 32 * F), c(Z, b, $, 0, te), (v = 1), (S = 0); - case 1: - (E = D - S), E > f && (E = f); - for (let G = 0; G < E; G++) - c($, 0, ue, (S + G) * te, te), i($, te, F, ne, A); - if (((S += E), (p += E), z)) { - let G = parseInt((1e3 * p) / l); - if (G !== y) { - if (((d = z(null, p / l)), d)) break; - y = G; - } - } - if (S < D) break; - (S = 0), (v = 2); - case 2: - (E = D - S), E > f && (E = f); - for (let G = 0; G < E; G++) { - let L = (2 * F - 1) * 16, - ee = $[L] & (D - 1); - s(ue, ee * te, $, te), i($, te, F, ne, A); - } - if (((S += E), (p += E), z)) { - let G = parseInt((1e3 * p) / l); - if (G !== y) { - if (((d = z(null, p / l)), d)) break; - y = G; - } - } - if (S < D) break; - if ((c($, 0, Z, b, te), _++, _ < N)) { - v = 0; - break; - } - H = []; - for (let G = 0; G < Z.length; G++) - H.push((Z[G] >> 0) & 255), - H.push((Z[G] >> 8) & 255), - H.push((Z[G] >> 16) & 255), - H.push((Z[G] >> 24) & 255); - let B = n(k, H, q); - return z && z(null, 1, B), B; - } - z && x(C); - }; - if (!z) - for (;;) { - let E = C(); - if (E != null) return E; - } - C(); - } - let M = { - scrypt: function (k, O, D, F, N, q, z) { - return new Promise(function (H, Z) { - let $ = 0; - z && z(0), - w(k, O, D, F, N, q, function (ue, te, ne) { - if (ue) Z(ue); - else if (ne) z && $ !== 1 && z(1), H(new Uint8Array(ne)); - else if (z && te !== $) return ($ = te), z(te); - }); - }); - }, - syncScrypt: function (k, O, D, F, N, q) { - return new Uint8Array(w(k, O, D, F, N, q)); - }, - }; - typeof aEe < "u" - ? (_ft.exports = M) - : typeof define == "function" && define.amd - ? define(M) - : t && (t.scrypt && (t._scrypt = t.scrypt), (t.scrypt = M)); - })(aEe); - }); - var Ift = I((Du) => { - "use strict"; - m(); - g(); - var exr = - (Du && Du.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(), - txr = - (Du && Du.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - rxr = - (Du && Du.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }, - Aft = - (Du && Du.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Du, "__esModule", { value: !0 }); - Du.encrypt = Du.decrypt = Du.decryptSync = Du.KeystoreAccount = void 0; - var zA = Aft(nEe()), - cEe = Aft(xft()), - Eft = Vh(), - As = Ar(), - u6 = aK(), - Mft = Hh(), - nxr = Xre(), - yne = s6(), - ixr = $r(), - Tft = e0(), - Ti = oEe(), - sEe = rr(), - oxr = iEe(), - uEe = new sEe.Logger(oxr.version); - function Sft(t) { - return t != null && t.mnemonic && t.mnemonic.phrase; - } - var kft = (function (t) { - exr(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.prototype.isKeystoreAccount = function (r) { - return !!(r && r._isKeystoreAccount); - }), - e - ); - })(ixr.Description); - Du.KeystoreAccount = kft; - function axr(t, e, r) { - var n = (0, Ti.searchPath)(t, "crypto/cipher"); - if (n === "aes-128-ctr") { - var i = (0, Ti.looseArrayify)( - (0, Ti.searchPath)(t, "crypto/cipherparams/iv") - ), - o = new zA.default.Counter(i), - a = new zA.default.ModeOfOperation.ctr(e, o); - return (0, As.arrayify)(a.decrypt(r)); - } - return null; - } - function Pft(t, e) { - var r = (0, Ti.looseArrayify)((0, Ti.searchPath)(t, "crypto/ciphertext")), - n = (0, As.hexlify)( - (0, Mft.keccak256)((0, As.concat)([e.slice(16, 32), r])) - ).substring(2); - if (n !== (0, Ti.searchPath)(t, "crypto/mac").toLowerCase()) - throw new Error("invalid password"); - var i = axr(t, e.slice(0, 16), r); - i || - uEe.throwError( - "unsupported cipher", - sEe.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "decrypt" } - ); - var o = e.slice(32, 64), - a = (0, Tft.computeAddress)(i); - if (t.address) { - var s = t.address.toLowerCase(); - if ( - (s.substring(0, 2) !== "0x" && (s = "0x" + s), - (0, Eft.getAddress)(s) !== a) - ) - throw new Error("address mismatch"); - } - var c = { - _isKeystoreAccount: !0, - address: a, - privateKey: (0, As.hexlify)(i), - }; - if ((0, Ti.searchPath)(t, "x-ethers/version") === "0.1") { - var u = (0, Ti.looseArrayify)( - (0, Ti.searchPath)(t, "x-ethers/mnemonicCiphertext") - ), - h = (0, Ti.looseArrayify)( - (0, Ti.searchPath)(t, "x-ethers/mnemonicCounter") - ), - w = new zA.default.Counter(h), - M = new zA.default.ModeOfOperation.ctr(o, w), - k = (0, Ti.searchPath)(t, "x-ethers/path") || u6.defaultPath, - O = (0, Ti.searchPath)(t, "x-ethers/locale") || "en", - D = (0, As.arrayify)(M.decrypt(u)); - try { - var F = (0, u6.entropyToMnemonic)(D, O), - N = u6.HDNode.fromMnemonic(F, null, O).derivePath(k); - if (N.privateKey != c.privateKey) - throw new Error("mnemonic mismatch"); - c.mnemonic = N.mnemonic; - } catch (q) { - if ( - q.code !== sEe.Logger.errors.INVALID_ARGUMENT || - q.argument !== "wordlist" - ) - throw q; - } - } - return new kft(c); - } - function Oft(t, e, r, n, i) { - return (0, As.arrayify)((0, nxr.pbkdf2)(t, e, r, n, i)); - } - function sxr(t, e, r, n, i) { - return Promise.resolve(Oft(t, e, r, n, i)); - } - function Bft(t, e, r, n, i) { - var o = (0, Ti.getPassword)(e), - a = (0, Ti.searchPath)(t, "crypto/kdf"); - if (a && typeof a == "string") { - var s = function (F, N) { - return uEe.throwArgumentError( - "invalid key-derivation function parameters", - F, - N - ); - }; - if (a.toLowerCase() === "scrypt") { - var c = (0, Ti.looseArrayify)( - (0, Ti.searchPath)(t, "crypto/kdfparams/salt") - ), - u = parseInt((0, Ti.searchPath)(t, "crypto/kdfparams/n")), - h = parseInt((0, Ti.searchPath)(t, "crypto/kdfparams/r")), - w = parseInt((0, Ti.searchPath)(t, "crypto/kdfparams/p")); - (!u || !h || !w) && s("kdf", a), (u & (u - 1)) !== 0 && s("N", u); - var M = parseInt((0, Ti.searchPath)(t, "crypto/kdfparams/dklen")); - return M !== 32 && s("dklen", M), n(o, c, u, h, w, 64, i); - } else if (a.toLowerCase() === "pbkdf2") { - var c = (0, Ti.looseArrayify)( - (0, Ti.searchPath)(t, "crypto/kdfparams/salt") - ), - k = null, - O = (0, Ti.searchPath)(t, "crypto/kdfparams/prf"); - O === "hmac-sha256" - ? (k = "sha256") - : O === "hmac-sha512" - ? (k = "sha512") - : s("prf", O); - var D = parseInt((0, Ti.searchPath)(t, "crypto/kdfparams/c")), - M = parseInt((0, Ti.searchPath)(t, "crypto/kdfparams/dklen")); - return M !== 32 && s("dklen", M), r(o, c, D, M, k); - } - } - return uEe.throwArgumentError( - "unsupported key-derivation function", - "kdf", - a - ); - } - function uxr(t, e) { - var r = JSON.parse(t), - n = Bft(r, e, Oft, cEe.default.syncScrypt); - return Pft(r, n); - } - Du.decryptSync = uxr; - function cxr(t, e, r) { - return txr(this, void 0, void 0, function () { - var n, i; - return rxr(this, function (o) { - switch (o.label) { - case 0: - return ( - (n = JSON.parse(t)), [4, Bft(n, e, sxr, cEe.default.scrypt, r)] - ); - case 1: - return (i = o.sent()), [2, Pft(n, i)]; - } - }); - }); - } - Du.decrypt = cxr; - function lxr(t, e, r, n) { - try { - if ( - (0, Eft.getAddress)(t.address) !== - (0, Tft.computeAddress)(t.privateKey) - ) - throw new Error("address/privateKey mismatch"); - if (Sft(t)) { - var i = t.mnemonic, - o = u6.HDNode.fromMnemonic(i.phrase, null, i.locale).derivePath( - i.path || u6.defaultPath - ); - if (o.privateKey != t.privateKey) - throw new Error("mnemonic mismatch"); - } - } catch (z) { - return Promise.reject(z); - } - typeof r == "function" && !n && ((n = r), (r = {})), r || (r = {}); - var a = (0, As.arrayify)(t.privateKey), - s = (0, Ti.getPassword)(e), - c = null, - u = null, - h = null; - if (Sft(t)) { - var w = t.mnemonic; - (c = (0, As.arrayify)( - (0, u6.mnemonicToEntropy)(w.phrase, w.locale || "en") - )), - (u = w.path || u6.defaultPath), - (h = w.locale || "en"); - } - var M = r.client; - M || (M = "ethers.js"); - var k = null; - r.salt ? (k = (0, As.arrayify)(r.salt)) : (k = (0, yne.randomBytes)(32)); - var O = null; - if (r.iv) { - if (((O = (0, As.arrayify)(r.iv)), O.length !== 16)) - throw new Error("invalid iv"); - } else O = (0, yne.randomBytes)(16); - var D = null; - if (r.uuid) { - if (((D = (0, As.arrayify)(r.uuid)), D.length !== 16)) - throw new Error("invalid uuid"); - } else D = (0, yne.randomBytes)(16); - var F = 1 << 17, - N = 8, - q = 1; - return ( - r.scrypt && - (r.scrypt.N && (F = r.scrypt.N), - r.scrypt.r && (N = r.scrypt.r), - r.scrypt.p && (q = r.scrypt.p)), - cEe.default.scrypt(s, k, F, N, q, 64, n).then(function (z) { - z = (0, As.arrayify)(z); - var H = z.slice(0, 16), - Z = z.slice(16, 32), - $ = z.slice(32, 64), - ue = new zA.default.Counter(O), - te = new zA.default.ModeOfOperation.ctr(H, ue), - ne = (0, As.arrayify)(te.encrypt(a)), - A = (0, Mft.keccak256)((0, As.concat)([Z, ne])), - l = { - address: t.address.substring(2).toLowerCase(), - id: (0, Ti.uuidV4)(D), - version: 3, - crypto: { - cipher: "aes-128-ctr", - cipherparams: { iv: (0, As.hexlify)(O).substring(2) }, - ciphertext: (0, As.hexlify)(ne).substring(2), - kdf: "scrypt", - kdfparams: { - salt: (0, As.hexlify)(k).substring(2), - n: F, - dklen: 32, - p: q, - r: N, - }, - mac: A.substring(2), - }, - }; - if (c) { - var p = (0, yne.randomBytes)(16), - y = new zA.default.Counter(p), - d = new zA.default.ModeOfOperation.ctr($, y), - v = (0, As.arrayify)(d.encrypt(c)), - _ = new Date(), - S = - _.getUTCFullYear() + - "-" + - (0, Ti.zpad)(_.getUTCMonth() + 1, 2) + - "-" + - (0, Ti.zpad)(_.getUTCDate(), 2) + - "T" + - (0, Ti.zpad)(_.getUTCHours(), 2) + - "-" + - (0, Ti.zpad)(_.getUTCMinutes(), 2) + - "-" + - (0, Ti.zpad)(_.getUTCSeconds(), 2) + - ".0Z"; - l["x-ethers"] = { - client: M, - gethFilename: "UTC--" + S + "--" + l.address, - mnemonicCounter: (0, As.hexlify)(p).substring(2), - mnemonicCiphertext: (0, As.hexlify)(v).substring(2), - path: u, - locale: h, - version: "0.1", - }; - } - return JSON.stringify(l); - }) - ); - } - Du.encrypt = lxr; - }); - var mne = I((Es) => { - "use strict"; - m(); - g(); - Object.defineProperty(Es, "__esModule", { value: !0 }); - Es.decryptJsonWalletSync = - Es.decryptJsonWallet = - Es.getJsonWalletAddress = - Es.isKeystoreWallet = - Es.isCrowdsaleWallet = - Es.encryptKeystore = - Es.decryptKeystoreSync = - Es.decryptKeystore = - Es.decryptCrowdsale = - void 0; - var lEe = mft(); - Object.defineProperty(Es, "decryptCrowdsale", { - enumerable: !0, - get: function () { - return lEe.decrypt; - }, - }); - var c6 = wft(); - Object.defineProperty(Es, "getJsonWalletAddress", { - enumerable: !0, - get: function () { - return c6.getJsonWalletAddress; - }, - }); - Object.defineProperty(Es, "isCrowdsaleWallet", { - enumerable: !0, - get: function () { - return c6.isCrowdsaleWallet; - }, - }); - Object.defineProperty(Es, "isKeystoreWallet", { - enumerable: !0, - get: function () { - return c6.isKeystoreWallet; - }, - }); - var sK = Ift(); - Object.defineProperty(Es, "decryptKeystore", { - enumerable: !0, - get: function () { - return sK.decrypt; - }, - }); - Object.defineProperty(Es, "decryptKeystoreSync", { - enumerable: !0, - get: function () { - return sK.decryptSync; - }, - }); - Object.defineProperty(Es, "encryptKeystore", { - enumerable: !0, - get: function () { - return sK.encrypt; - }, - }); - function fxr(t, e, r) { - if ((0, c6.isCrowdsaleWallet)(t)) { - r && r(0); - var n = (0, lEe.decrypt)(t, e); - return r && r(1), Promise.resolve(n); - } - return (0, c6.isKeystoreWallet)(t) - ? (0, sK.decrypt)(t, e, r) - : Promise.reject(new Error("invalid JSON wallet")); - } - Es.decryptJsonWallet = fxr; - function dxr(t, e) { - if ((0, c6.isCrowdsaleWallet)(t)) return (0, lEe.decrypt)(t, e); - if ((0, c6.isKeystoreWallet)(t)) return (0, sK.decryptSync)(t, e); - throw new Error("invalid JSON wallet"); - } - Es.decryptJsonWalletSync = dxr; - }); - var Cft = I((gne) => { - "use strict"; - m(); - g(); - Object.defineProperty(gne, "__esModule", { value: !0 }); - gne.version = void 0; - gne.version = "wallet/5.7.0"; - }); - var lK = I((Wh) => { - "use strict"; - m(); - g(); - var hxr = - (Wh && Wh.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(), - Rft = - (Wh && Wh.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - Nft = - (Wh && Wh.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(Wh, "__esModule", { value: !0 }); - Wh.verifyTypedData = Wh.verifyMessage = Wh.Wallet = void 0; - var Dft = Vh(), - pxr = vx(), - yxr = r6(), - t7 = Ar(), - cK = db(), - uK = aK(), - Fft = Hh(), - vb = $r(), - mxr = s6(), - fEe = qR(), - dEe = mne(), - l6 = e0(), - Lft = rr(), - gxr = Cft(), - e7 = new Lft.Logger(gxr.version); - function vxr(t) { - return ( - t != null && (0, t7.isHexString)(t.privateKey, 32) && t.address != null - ); - } - function bxr(t) { - var e = t.mnemonic; - return e && e.phrase; - } - var wxr = (function (t) { - hxr(e, t); - function e(r, n) { - var i = t.call(this) || this; - if (vxr(r)) { - var o = new fEe.SigningKey(r.privateKey); - if ( - ((0, vb.defineReadOnly)(i, "_signingKey", function () { - return o; - }), - (0, vb.defineReadOnly)( - i, - "address", - (0, l6.computeAddress)(i.publicKey) - ), - i.address !== (0, Dft.getAddress)(r.address) && - e7.throwArgumentError( - "privateKey/address mismatch", - "privateKey", - "[REDACTED]" - ), - bxr(r)) - ) { - var a = r.mnemonic; - (0, vb.defineReadOnly)(i, "_mnemonic", function () { - return { - phrase: a.phrase, - path: a.path || uK.defaultPath, - locale: a.locale || "en", - }; - }); - var s = i.mnemonic, - c = uK.HDNode.fromMnemonic(s.phrase, null, s.locale).derivePath( - s.path - ); - (0, l6.computeAddress)(c.privateKey) !== i.address && - e7.throwArgumentError( - "mnemonic/address mismatch", - "privateKey", - "[REDACTED]" - ); - } else - (0, vb.defineReadOnly)(i, "_mnemonic", function () { - return null; - }); - } else { - if (fEe.SigningKey.isSigningKey(r)) - r.curve !== "secp256k1" && - e7.throwArgumentError( - "unsupported curve; must be secp256k1", - "privateKey", - "[REDACTED]" - ), - (0, vb.defineReadOnly)(i, "_signingKey", function () { - return r; - }); - else { - typeof r == "string" && - r.match(/^[0-9a-f]*$/i) && - r.length === 64 && - (r = "0x" + r); - var u = new fEe.SigningKey(r); - (0, vb.defineReadOnly)(i, "_signingKey", function () { - return u; - }); - } - (0, vb.defineReadOnly)(i, "_mnemonic", function () { - return null; - }), - (0, vb.defineReadOnly)( - i, - "address", - (0, l6.computeAddress)(i.publicKey) - ); - } - return ( - n && - !pxr.Provider.isProvider(n) && - e7.throwArgumentError("invalid provider", "provider", n), - (0, vb.defineReadOnly)(i, "provider", n || null), - i - ); - } - return ( - Object.defineProperty(e.prototype, "mnemonic", { - get: function () { - return this._mnemonic(); - }, - enumerable: !1, - configurable: !0, - }), - Object.defineProperty(e.prototype, "privateKey", { - get: function () { - return this._signingKey().privateKey; - }, - enumerable: !1, - configurable: !0, - }), - Object.defineProperty(e.prototype, "publicKey", { - get: function () { - return this._signingKey().publicKey; - }, - enumerable: !1, - configurable: !0, - }), - (e.prototype.getAddress = function () { - return Promise.resolve(this.address); - }), - (e.prototype.connect = function (r) { - return new e(this, r); - }), - (e.prototype.signTransaction = function (r) { - var n = this; - return (0, vb.resolveProperties)(r).then(function (i) { - i.from != null && - ((0, Dft.getAddress)(i.from) !== n.address && - e7.throwArgumentError( - "transaction from address mismatch", - "transaction.from", - r.from - ), - delete i.from); - var o = n - ._signingKey() - .signDigest((0, Fft.keccak256)((0, l6.serialize)(i))); - return (0, l6.serialize)(i, o); - }); - }), - (e.prototype.signMessage = function (r) { - return Rft(this, void 0, void 0, function () { - return Nft(this, function (n) { - return [ - 2, - (0, t7.joinSignature)( - this._signingKey().signDigest((0, cK.hashMessage)(r)) - ), - ]; - }); - }); - }), - (e.prototype._signTypedData = function (r, n, i) { - return Rft(this, void 0, void 0, function () { - var o, - a = this; - return Nft(this, function (s) { - switch (s.label) { - case 0: - return [ - 4, - cK._TypedDataEncoder.resolveNames(r, n, i, function (c) { - return ( - a.provider == null && - e7.throwError( - "cannot resolve ENS names without a provider", - Lft.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "resolveName", value: c } - ), - a.provider.resolveName(c) - ); - }), - ]; - case 1: - return ( - (o = s.sent()), - [ - 2, - (0, t7.joinSignature)( - this._signingKey().signDigest( - cK._TypedDataEncoder.hash(o.domain, n, o.value) - ) - ), - ] - ); - } - }); - }); - }), - (e.prototype.encrypt = function (r, n, i) { - if ( - (typeof n == "function" && !i && ((i = n), (n = {})), - i && typeof i != "function") - ) - throw new Error("invalid callback"); - return n || (n = {}), (0, dEe.encryptKeystore)(this, r, n, i); - }), - (e.createRandom = function (r) { - var n = (0, mxr.randomBytes)(16); - r || (r = {}), - r.extraEntropy && - (n = (0, t7.arrayify)( - (0, t7.hexDataSlice)( - (0, Fft.keccak256)((0, t7.concat)([n, r.extraEntropy])), - 0, - 16 - ) - )); - var i = (0, uK.entropyToMnemonic)(n, r.locale); - return e.fromMnemonic(i, r.path, r.locale); - }), - (e.fromEncryptedJson = function (r, n, i) { - return (0, dEe.decryptJsonWallet)(r, n, i).then(function (o) { - return new e(o); - }); - }), - (e.fromEncryptedJsonSync = function (r, n) { - return new e((0, dEe.decryptJsonWalletSync)(r, n)); - }), - (e.fromMnemonic = function (r, n, i) { - return ( - n || (n = uK.defaultPath), - new e(uK.HDNode.fromMnemonic(r, null, i).derivePath(n)) - ); - }), - e - ); - })(yxr.Signer); - Wh.Wallet = wxr; - function _xr(t, e) { - return (0, l6.recoverAddress)((0, cK.hashMessage)(t), e); - } - Wh.verifyMessage = _xr; - function xxr(t, e, r, n) { - return (0, l6.recoverAddress)(cK._TypedDataEncoder.hash(t, e, r), n); - } - Wh.verifyTypedData = xxr; - }); - var qft = I((vne) => { - "use strict"; - m(); - g(); - Object.defineProperty(vne, "__esModule", { value: !0 }); - vne.version = void 0; - vne.version = "networks/5.7.0"; - }); - var hEe = I((_ne) => { - "use strict"; - m(); - g(); - Object.defineProperty(_ne, "__esModule", { value: !0 }); - _ne.getNetwork = void 0; - var Sxr = rr(), - Axr = qft(), - zft = new Sxr.Logger(Axr.version); - function Exr(t) { - return t && typeof t.renetwork == "function"; - } - function jA(t) { - var e = function (r, n) { - n == null && (n = {}); - var i = []; - if (r.InfuraProvider && n.infura !== "-") - try { - i.push(new r.InfuraProvider(t, n.infura)); - } catch {} - if (r.EtherscanProvider && n.etherscan !== "-") - try { - i.push(new r.EtherscanProvider(t, n.etherscan)); - } catch {} - if (r.AlchemyProvider && n.alchemy !== "-") - try { - i.push(new r.AlchemyProvider(t, n.alchemy)); - } catch {} - if (r.PocketProvider && n.pocket !== "-") { - var o = ["goerli", "ropsten", "rinkeby"]; - try { - var a = new r.PocketProvider(t, n.pocket); - a.network && o.indexOf(a.network.name) === -1 && i.push(a); - } catch {} - } - if (r.CloudflareProvider && n.cloudflare !== "-") - try { - i.push(new r.CloudflareProvider(t)); - } catch {} - if (r.AnkrProvider && n.ankr !== "-") - try { - var o = ["ropsten"], - a = new r.AnkrProvider(t, n.ankr); - a.network && o.indexOf(a.network.name) === -1 && i.push(a); - } catch {} - if (i.length === 0) return null; - if (r.FallbackProvider) { - var s = 1; - return ( - n.quorum != null ? (s = n.quorum) : t === "homestead" && (s = 2), - new r.FallbackProvider(i, s) - ); - } - return i[0]; - }; - return ( - (e.renetwork = function (r) { - return jA(r); - }), - e - ); - } - function wne(t, e) { - var r = function (n, i) { - return n.JsonRpcProvider ? new n.JsonRpcProvider(t, e) : null; - }; - return ( - (r.renetwork = function (n) { - return wne(t, n); - }), - r - ); - } - var jft = { - chainId: 1, - ensAddress: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e", - name: "homestead", - _defaultProvider: jA("homestead"), - }, - Uft = { - chainId: 3, - ensAddress: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e", - name: "ropsten", - _defaultProvider: jA("ropsten"), - }, - Kft = { - chainId: 63, - name: "classicMordor", - _defaultProvider: wne( - "https://www.ethercluster.com/mordor", - "classicMordor" - ), - }, - bne = { - unspecified: { chainId: 0, name: "unspecified" }, - homestead: jft, - mainnet: jft, - morden: { chainId: 2, name: "morden" }, - ropsten: Uft, - testnet: Uft, - rinkeby: { - chainId: 4, - ensAddress: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e", - name: "rinkeby", - _defaultProvider: jA("rinkeby"), - }, - kovan: { chainId: 42, name: "kovan", _defaultProvider: jA("kovan") }, - goerli: { - chainId: 5, - ensAddress: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e", - name: "goerli", - _defaultProvider: jA("goerli"), - }, - kintsugi: { chainId: 1337702, name: "kintsugi" }, - classic: { - chainId: 61, - name: "classic", - _defaultProvider: wne("https://www.ethercluster.com/etc", "classic"), - }, - classicMorden: { chainId: 62, name: "classicMorden" }, - classicMordor: Kft, - classicTestnet: Kft, - classicKotti: { - chainId: 6, - name: "classicKotti", - _defaultProvider: wne( - "https://www.ethercluster.com/kotti", - "classicKotti" - ), - }, - xdai: { chainId: 100, name: "xdai" }, - matic: { chainId: 137, name: "matic", _defaultProvider: jA("matic") }, - maticmum: { chainId: 80001, name: "maticmum" }, - optimism: { - chainId: 10, - name: "optimism", - _defaultProvider: jA("optimism"), - }, - "optimism-kovan": { chainId: 69, name: "optimism-kovan" }, - "optimism-goerli": { chainId: 420, name: "optimism-goerli" }, - arbitrum: { chainId: 42161, name: "arbitrum" }, - "arbitrum-rinkeby": { chainId: 421611, name: "arbitrum-rinkeby" }, - "arbitrum-goerli": { chainId: 421613, name: "arbitrum-goerli" }, - bnb: { chainId: 56, name: "bnb" }, - bnbt: { chainId: 97, name: "bnbt" }, - }; - function Mxr(t) { - if (t == null) return null; - if (typeof t == "number") { - for (var e in bne) { - var r = bne[e]; - if (r.chainId === t) - return { - name: r.name, - chainId: r.chainId, - ensAddress: r.ensAddress || null, - _defaultProvider: r._defaultProvider || null, - }; - } - return { chainId: t, name: "unknown" }; - } - if (typeof t == "string") { - var n = bne[t]; - return n == null - ? null - : { - name: n.name, - chainId: n.chainId, - ensAddress: n.ensAddress, - _defaultProvider: n._defaultProvider || null, - }; - } - var i = bne[t.name]; - if (!i) - return ( - typeof t.chainId != "number" && - zft.throwArgumentError("invalid network chainId", "network", t), - t - ); - t.chainId !== 0 && - t.chainId !== i.chainId && - zft.throwArgumentError("network chainId mismatch", "network", t); - var o = t._defaultProvider || null; - return ( - o == null && - i._defaultProvider && - (Exr(i._defaultProvider) - ? (o = i._defaultProvider.renetwork(t)) - : (o = i._defaultProvider)), - { - name: t.name, - chainId: i.chainId, - ensAddress: t.ensAddress || i.ensAddress || null, - _defaultProvider: o, - } - ); - } - _ne.getNetwork = Mxr; - }); - var Hft = I((xne) => { - "use strict"; - m(); - g(); - Object.defineProperty(xne, "__esModule", { value: !0 }); - xne.version = void 0; - xne.version = "web/5.7.0"; - }); - var Vft = I((UA) => { - "use strict"; - m(); - g(); - var Txr = - (UA && UA.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - kxr = - (UA && UA.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(UA, "__esModule", { value: !0 }); - UA.getUrl = void 0; - var Pxr = Ar(); - function Oxr(t, e) { - return Txr(this, void 0, void 0, function () { - var r, n, i, o, a; - return kxr(this, function (s) { - switch (s.label) { - case 0: - return ( - e == null && (e = {}), - (r = { - method: e.method || "GET", - headers: e.headers || {}, - body: e.body || void 0, - }), - e.skipFetchSetup !== !0 && - ((r.mode = "cors"), - (r.cache = "no-cache"), - (r.credentials = "same-origin"), - (r.redirect = "follow"), - (r.referrer = "client")), - e.fetchOptions != null && - ((n = e.fetchOptions), - n.mode && (r.mode = n.mode), - n.cache && (r.cache = n.cache), - n.credentials && (r.credentials = n.credentials), - n.redirect && (r.redirect = n.redirect), - n.referrer && (r.referrer = n.referrer)), - [4, fetch(t, r)] - ); - case 1: - return (i = s.sent()), [4, i.arrayBuffer()]; - case 2: - return ( - (o = s.sent()), - (a = {}), - i.headers.forEach - ? i.headers.forEach(function (c, u) { - a[u.toLowerCase()] = c; - }) - : i.headers.keys().forEach(function (c) { - a[c.toLowerCase()] = i.headers.get(c); - }), - [ - 2, - { - headers: a, - statusCode: i.status, - statusMessage: i.statusText, - body: (0, Pxr.arrayify)(new Uint8Array(o)), - }, - ] - ); - } - }); - }); - } - UA.getUrl = Oxr; - }); - var r7 = I((jy) => { - "use strict"; - m(); - g(); - var Bxr = - (jy && jy.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - Ixr = - (jy && jy.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(jy, "__esModule", { value: !0 }); - jy.poll = jy.fetchJson = jy._fetchData = void 0; - var Wft = lb(), - Gft = Ar(), - Sne = $r(), - Ane = Eo(), - wx = rr(), - Cxr = Hft(), - mg = new wx.Logger(Cxr.version), - Rxr = Vft(); - function Jft(t) { - return new Promise(function (e) { - setTimeout(e, t); - }); - } - function KA(t, e) { - if (t == null) return null; - if (typeof t == "string") return t; - if ((0, Gft.isBytesLike)(t)) { - if ( - e && - (e.split("/")[0] === "text" || - e.split(";")[0].trim() === "application/json") - ) - try { - return (0, Ane.toUtf8String)(t); - } catch {} - return (0, Gft.hexlify)(t); - } - return t; - } - function $ft(t, e, r) { - var n = - typeof t == "object" && t.throttleLimit != null ? t.throttleLimit : 12; - mg.assertArgument( - n > 0 && n % 1 === 0, - "invalid connection throttle limit", - "connection.throttleLimit", - n - ); - var i = typeof t == "object" ? t.throttleCallback : null, - o = - typeof t == "object" && typeof t.throttleSlotInterval == "number" - ? t.throttleSlotInterval - : 100; - mg.assertArgument( - o > 0 && o % 1 === 0, - "invalid connection throttle slot interval", - "connection.throttleSlotInterval", - o - ); - var a = typeof t == "object" ? !!t.errorPassThrough : !1, - s = {}, - c = null, - u = { method: "GET" }, - h = !1, - w = 2 * 60 * 1e3; - if (typeof t == "string") c = t; - else if (typeof t == "object") { - if ( - ((t == null || t.url == null) && - mg.throwArgumentError("missing URL", "connection.url", t), - (c = t.url), - typeof t.timeout == "number" && t.timeout > 0 && (w = t.timeout), - t.headers) - ) - for (var M in t.headers) - (s[M.toLowerCase()] = { key: M, value: String(t.headers[M]) }), - ["if-none-match", "if-modified-since"].indexOf(M.toLowerCase()) >= - 0 && (h = !0); - if ( - ((u.allowGzip = !!t.allowGzip), t.user != null && t.password != null) - ) { - c.substring(0, 6) !== "https:" && - t.allowInsecureAuthentication !== !0 && - mg.throwError( - "basic authentication requires a secure https url", - wx.Logger.errors.INVALID_ARGUMENT, - { argument: "url", url: c, user: t.user, password: "[REDACTED]" } - ); - var k = t.user + ":" + t.password; - s.authorization = { - key: "Authorization", - value: "Basic " + (0, Wft.encode)((0, Ane.toUtf8Bytes)(k)), - }; - } - t.skipFetchSetup != null && (u.skipFetchSetup = !!t.skipFetchSetup), - t.fetchOptions != null && - (u.fetchOptions = (0, Sne.shallowCopy)(t.fetchOptions)); - } - var O = new RegExp("^data:([a-z0-9-]+/[a-z0-9-]+);base64,(.*)$", "i"), - D = c ? c.match(O) : null; - if (D) - try { - var F = { - statusCode: 200, - statusMessage: "OK", - headers: { "content-type": D[1] }, - body: (0, Wft.decode)(D[2]), - }, - N = F.body; - return r && (N = r(F.body, F)), Promise.resolve(N); - } catch (Z) { - mg.throwError( - "processing response error", - wx.Logger.errors.SERVER_ERROR, - { - body: KA(D[1], D[2]), - error: Z, - requestBody: null, - requestMethod: "GET", - url: c, - } - ); - } - e && - ((u.method = "POST"), - (u.body = e), - s["content-type"] == null && - (s["content-type"] = { - key: "Content-Type", - value: "application/octet-stream", - }), - s["content-length"] == null && - (s["content-length"] = { - key: "Content-Length", - value: String(e.length), - })); - var q = {}; - Object.keys(s).forEach(function (Z) { - var $ = s[Z]; - q[$.key] = $.value; - }), - (u.headers = q); - var z = (function () { - var Z = null, - $ = new Promise(function (te, ne) { - w && - (Z = setTimeout(function () { - Z != null && - ((Z = null), - ne( - mg.makeError("timeout", wx.Logger.errors.TIMEOUT, { - requestBody: KA(u.body, q["content-type"]), - requestMethod: u.method, - timeout: w, - url: c, - }) - )); - }, w)); - }), - ue = function () { - Z != null && (clearTimeout(Z), (Z = null)); - }; - return { promise: $, cancel: ue }; - })(), - H = (function () { - return Bxr(this, void 0, void 0, function () { - var Z, $, ue, d, te, ne, A, l, p, y, d, v; - return Ixr(this, function (_) { - switch (_.label) { - case 0: - (Z = 0), (_.label = 1); - case 1: - if (!(Z < n)) return [3, 20]; - ($ = null), (_.label = 2); - case 2: - return _.trys.push([2, 9, , 10]), [4, (0, Rxr.getUrl)(c, u)]; - case 3: - return ( - ($ = _.sent()), - Z < n - ? $.statusCode === 301 || $.statusCode === 302 - ? ((ue = $.headers.location || ""), - u.method === "GET" && ue.match(/^https:/) - ? ((c = $.headers.location), [3, 19]) - : [3, 8]) - : [3, 4] - : [3, 8] - ); - case 4: - return $.statusCode !== 429 - ? [3, 8] - : ((d = !0), i ? [4, i(Z, c)] : [3, 6]); - case 5: - (d = _.sent()), (_.label = 6); - case 6: - return d - ? ((te = 0), - (ne = $.headers["retry-after"]), - typeof ne == "string" && ne.match(/^[1-9][0-9]*$/) - ? (te = parseInt(ne) * 1e3) - : (te = - o * - parseInt(String(Math.random() * Math.pow(2, Z)))), - [4, Jft(te)]) - : [3, 8]; - case 7: - return _.sent(), [3, 19]; - case 8: - return [3, 10]; - case 9: - return ( - (A = _.sent()), - ($ = A.response), - $ == null && - (z.cancel(), - mg.throwError( - "missing response", - wx.Logger.errors.SERVER_ERROR, - { - requestBody: KA(u.body, q["content-type"]), - requestMethod: u.method, - serverError: A, - url: c, - } - )), - [3, 10] - ); - case 10: - if ( - ((l = $.body), - h && $.statusCode === 304 - ? (l = null) - : !a && - ($.statusCode < 200 || $.statusCode >= 300) && - (z.cancel(), - mg.throwError( - "bad response", - wx.Logger.errors.SERVER_ERROR, - { - status: $.statusCode, - headers: $.headers, - body: KA( - l, - $.headers ? $.headers["content-type"] : null - ), - requestBody: KA(u.body, q["content-type"]), - requestMethod: u.method, - url: c, - } - )), - !r) - ) - return [3, 18]; - _.label = 11; - case 11: - return _.trys.push([11, 13, , 18]), [4, r(l, $)]; - case 12: - return (p = _.sent()), z.cancel(), [2, p]; - case 13: - return ( - (y = _.sent()), - y.throttleRetry && Z < n - ? ((d = !0), i ? [4, i(Z, c)] : [3, 15]) - : [3, 17] - ); - case 14: - (d = _.sent()), (_.label = 15); - case 15: - return d - ? ((v = - o * parseInt(String(Math.random() * Math.pow(2, Z)))), - [4, Jft(v)]) - : [3, 17]; - case 16: - return _.sent(), [3, 19]; - case 17: - return ( - z.cancel(), - mg.throwError( - "processing response error", - wx.Logger.errors.SERVER_ERROR, - { - body: KA( - l, - $.headers ? $.headers["content-type"] : null - ), - error: y, - requestBody: KA(u.body, q["content-type"]), - requestMethod: u.method, - url: c, - } - ), - [3, 18] - ); - case 18: - return z.cancel(), [2, l]; - case 19: - return Z++, [3, 1]; - case 20: - return [ - 2, - mg.throwError( - "failed response", - wx.Logger.errors.SERVER_ERROR, - { - requestBody: KA(u.body, q["content-type"]), - requestMethod: u.method, - url: c, - } - ), - ]; - } - }); - }); - })(); - return Promise.race([z.promise, H]); - } - jy._fetchData = $ft; - function Nxr(t, e, r) { - var n = function (s, c) { - var u = null; - if (s != null) - try { - u = JSON.parse((0, Ane.toUtf8String)(s)); - } catch (h) { - mg.throwError("invalid JSON", wx.Logger.errors.SERVER_ERROR, { - body: s, - error: h, - }); - } - return r && (u = r(u, c)), u; - }, - i = null; - if (e != null) { - i = (0, Ane.toUtf8Bytes)(e); - var o = typeof t == "string" ? { url: t } : (0, Sne.shallowCopy)(t); - if (o.headers) { - var a = - Object.keys(o.headers).filter(function (s) { - return s.toLowerCase() === "content-type"; - }).length !== 0; - a || - ((o.headers = (0, Sne.shallowCopy)(o.headers)), - (o.headers["content-type"] = "application/json")); - } else o.headers = { "content-type": "application/json" }; - t = o; - } - return $ft(t, i, n); - } - jy.fetchJson = Nxr; - function Dxr(t, e) { - return ( - e || (e = {}), - (e = (0, Sne.shallowCopy)(e)), - e.floor == null && (e.floor = 0), - e.ceiling == null && (e.ceiling = 1e4), - e.interval == null && (e.interval = 250), - new Promise(function (r, n) { - var i = null, - o = !1, - a = function () { - return o ? !1 : ((o = !0), i && clearTimeout(i), !0); - }; - e.timeout && - (i = setTimeout(function () { - a() && n(new Error("timeout")); - }, e.timeout)); - var s = e.retryLimit, - c = 0; - function u() { - return t().then( - function (h) { - if (h !== void 0) a() && r(h); - else if (e.oncePoll) e.oncePoll.once("poll", u); - else if (e.onceBlock) e.onceBlock.once("block", u); - else if (!o) { - if ((c++, c > s)) { - a() && n(new Error("retry limit reached")); - return; - } - var w = - e.interval * - parseInt(String(Math.random() * Math.pow(2, c))); - w < e.floor && (w = e.floor), - w > e.ceiling && (w = e.ceiling), - setTimeout(u, w); - } - return null; - }, - function (h) { - a() && n(h); - } - ); - } - u(); - }) - ); - } - jy.poll = Dxr; - }); - var yEe = I((Ygn, Yft) => { - "use strict"; - m(); - g(); - var Mne = "qpzry9x8gf2tvdw0s3jn54khce6mua7l", - pEe = {}; - for (fK = 0; fK < Mne.length; fK++) { - if (((Ene = Mne.charAt(fK)), pEe[Ene] !== void 0)) - throw new TypeError(Ene + " is ambiguous"); - pEe[Ene] = fK; - } - var Ene, fK; - function n7(t) { - var e = t >> 25; - return ( - ((t & 33554431) << 5) ^ - (-((e >> 0) & 1) & 996825010) ^ - (-((e >> 1) & 1) & 642813549) ^ - (-((e >> 2) & 1) & 513874426) ^ - (-((e >> 3) & 1) & 1027748829) ^ - (-((e >> 4) & 1) & 705979059) - ); - } - function Zft(t) { - for (var e = 1, r = 0; r < t.length; ++r) { - var n = t.charCodeAt(r); - if (n < 33 || n > 126) return "Invalid prefix (" + t + ")"; - e = n7(e) ^ (n >> 5); - } - for (e = n7(e), r = 0; r < t.length; ++r) { - var i = t.charCodeAt(r); - e = n7(e) ^ (i & 31); - } - return e; - } - function Fxr(t, e, r) { - if (((r = r || 90), t.length + 7 + e.length > r)) - throw new TypeError("Exceeds length limit"); - t = t.toLowerCase(); - var n = Zft(t); - if (typeof n == "string") throw new Error(n); - for (var i = t + "1", o = 0; o < e.length; ++o) { - var a = e[o]; - if (a >> 5 !== 0) throw new Error("Non 5-bit word"); - (n = n7(n) ^ a), (i += Mne.charAt(a)); - } - for (o = 0; o < 6; ++o) n = n7(n); - for (n ^= 1, o = 0; o < 6; ++o) { - var s = (n >> ((5 - o) * 5)) & 31; - i += Mne.charAt(s); - } - return i; - } - function Xft(t, e) { - if (((e = e || 90), t.length < 8)) return t + " too short"; - if (t.length > e) return "Exceeds length limit"; - var r = t.toLowerCase(), - n = t.toUpperCase(); - if (t !== r && t !== n) return "Mixed-case string " + t; - t = r; - var i = t.lastIndexOf("1"); - if (i === -1) return "No separator character for " + t; - if (i === 0) return "Missing prefix for " + t; - var o = t.slice(0, i), - a = t.slice(i + 1); - if (a.length < 6) return "Data too short"; - var s = Zft(o); - if (typeof s == "string") return s; - for (var c = [], u = 0; u < a.length; ++u) { - var h = a.charAt(u), - w = pEe[h]; - if (w === void 0) return "Unknown character " + h; - (s = n7(s) ^ w), !(u + 6 >= a.length) && c.push(w); - } - return s !== 1 ? "Invalid checksum for " + t : { prefix: o, words: c }; - } - function Lxr() { - var t = Xft.apply(null, arguments); - if (typeof t == "object") return t; - } - function qxr(t) { - var e = Xft.apply(null, arguments); - if (typeof e == "object") return e; - throw new Error(e); - } - function Tne(t, e, r, n) { - for (var i = 0, o = 0, a = (1 << r) - 1, s = [], c = 0; c < t.length; ++c) - for (i = (i << e) | t[c], o += e; o >= r; ) - (o -= r), s.push((i >> o) & a); - if (n) o > 0 && s.push((i << (r - o)) & a); - else { - if (o >= e) return "Excess padding"; - if ((i << (r - o)) & a) return "Non-zero padding"; - } - return s; - } - function zxr(t) { - var e = Tne(t, 8, 5, !0); - if (Array.isArray(e)) return e; - } - function jxr(t) { - var e = Tne(t, 8, 5, !0); - if (Array.isArray(e)) return e; - throw new Error(e); - } - function Uxr(t) { - var e = Tne(t, 5, 8, !1); - if (Array.isArray(e)) return e; - } - function Kxr(t) { - var e = Tne(t, 5, 8, !1); - if (Array.isArray(e)) return e; - throw new Error(e); - } - Yft.exports = { - decodeUnsafe: Lxr, - decode: qxr, - encode: Fxr, - toWordsUnsafe: zxr, - toWords: jxr, - fromWordsUnsafe: Uxr, - fromWords: Kxr, - }; - }); - var pc = I((kne) => { - "use strict"; - m(); - g(); - Object.defineProperty(kne, "__esModule", { value: !0 }); - kne.version = void 0; - kne.version = "providers/5.7.2"; - }); - var HA = I((wb) => { - "use strict"; - m(); - g(); - Object.defineProperty(wb, "__esModule", { value: !0 }); - wb.showThrottleMessage = - wb.isCommunityResource = - wb.isCommunityResourcable = - wb.Formatter = - void 0; - var mEe = Vh(), - _x = Ro(), - bb = Ar(), - Hxr = ub(), - Vxr = $r(), - Qft = e0(), - Wxr = rr(), - Gxr = pc(), - dK = new Wxr.Logger(Gxr.version), - Jxr = (function () { - function t() { - this.formats = this.getDefaultFormats(); - } - return ( - (t.prototype.getDefaultFormats = function () { - var e = this, - r = {}, - n = this.address.bind(this), - i = this.bigNumber.bind(this), - o = this.blockTag.bind(this), - a = this.data.bind(this), - s = this.hash.bind(this), - c = this.hex.bind(this), - u = this.number.bind(this), - h = this.type.bind(this), - w = function (M) { - return e.data(M, !0); - }; - return ( - (r.transaction = { - hash: s, - type: h, - accessList: t.allowNull(this.accessList.bind(this), null), - blockHash: t.allowNull(s, null), - blockNumber: t.allowNull(u, null), - transactionIndex: t.allowNull(u, null), - confirmations: t.allowNull(u, null), - from: n, - gasPrice: t.allowNull(i), - maxPriorityFeePerGas: t.allowNull(i), - maxFeePerGas: t.allowNull(i), - gasLimit: i, - to: t.allowNull(n, null), - value: i, - nonce: u, - data: a, - r: t.allowNull(this.uint256), - s: t.allowNull(this.uint256), - v: t.allowNull(u), - creates: t.allowNull(n, null), - raw: t.allowNull(a), - }), - (r.transactionRequest = { - from: t.allowNull(n), - nonce: t.allowNull(u), - gasLimit: t.allowNull(i), - gasPrice: t.allowNull(i), - maxPriorityFeePerGas: t.allowNull(i), - maxFeePerGas: t.allowNull(i), - to: t.allowNull(n), - value: t.allowNull(i), - data: t.allowNull(w), - type: t.allowNull(u), - accessList: t.allowNull(this.accessList.bind(this), null), - }), - (r.receiptLog = { - transactionIndex: u, - blockNumber: u, - transactionHash: s, - address: n, - topics: t.arrayOf(s), - data: a, - logIndex: u, - blockHash: s, - }), - (r.receipt = { - to: t.allowNull(this.address, null), - from: t.allowNull(this.address, null), - contractAddress: t.allowNull(n, null), - transactionIndex: u, - root: t.allowNull(c), - gasUsed: i, - logsBloom: t.allowNull(a), - blockHash: s, - transactionHash: s, - logs: t.arrayOf(this.receiptLog.bind(this)), - blockNumber: u, - confirmations: t.allowNull(u, null), - cumulativeGasUsed: i, - effectiveGasPrice: t.allowNull(i), - status: t.allowNull(u), - type: h, - }), - (r.block = { - hash: t.allowNull(s), - parentHash: s, - number: u, - timestamp: u, - nonce: t.allowNull(c), - difficulty: this.difficulty.bind(this), - gasLimit: i, - gasUsed: i, - miner: t.allowNull(n), - extraData: a, - transactions: t.allowNull(t.arrayOf(s)), - baseFeePerGas: t.allowNull(i), - }), - (r.blockWithTransactions = (0, Vxr.shallowCopy)(r.block)), - (r.blockWithTransactions.transactions = t.allowNull( - t.arrayOf(this.transactionResponse.bind(this)) - )), - (r.filter = { - fromBlock: t.allowNull(o, void 0), - toBlock: t.allowNull(o, void 0), - blockHash: t.allowNull(s, void 0), - address: t.allowNull(n, void 0), - topics: t.allowNull(this.topics.bind(this), void 0), - }), - (r.filterLog = { - blockNumber: t.allowNull(u), - blockHash: t.allowNull(s), - transactionIndex: u, - removed: t.allowNull(this.boolean.bind(this)), - address: n, - data: t.allowFalsish(a, "0x"), - topics: t.arrayOf(s), - transactionHash: s, - logIndex: u, - }), - r - ); - }), - (t.prototype.accessList = function (e) { - return (0, Qft.accessListify)(e || []); - }), - (t.prototype.number = function (e) { - return e === "0x" ? 0 : _x.BigNumber.from(e).toNumber(); - }), - (t.prototype.type = function (e) { - return e === "0x" || e == null - ? 0 - : _x.BigNumber.from(e).toNumber(); - }), - (t.prototype.bigNumber = function (e) { - return _x.BigNumber.from(e); - }), - (t.prototype.boolean = function (e) { - if (typeof e == "boolean") return e; - if (typeof e == "string") { - if (((e = e.toLowerCase()), e === "true")) return !0; - if (e === "false") return !1; - } - throw new Error("invalid boolean - " + e); - }), - (t.prototype.hex = function (e, r) { - return typeof e == "string" && - (!r && e.substring(0, 2) !== "0x" && (e = "0x" + e), - (0, bb.isHexString)(e)) - ? e.toLowerCase() - : dK.throwArgumentError("invalid hash", "value", e); - }), - (t.prototype.data = function (e, r) { - var n = this.hex(e, r); - if (n.length % 2 !== 0) - throw new Error("invalid data; odd-length - " + e); - return n; - }), - (t.prototype.address = function (e) { - return (0, mEe.getAddress)(e); - }), - (t.prototype.callAddress = function (e) { - if (!(0, bb.isHexString)(e, 32)) return null; - var r = (0, mEe.getAddress)((0, bb.hexDataSlice)(e, 12)); - return r === Hxr.AddressZero ? null : r; - }), - (t.prototype.contractAddress = function (e) { - return (0, mEe.getContractAddress)(e); - }), - (t.prototype.blockTag = function (e) { - if (e == null) return "latest"; - if (e === "earliest") return "0x0"; - switch (e) { - case "earliest": - return "0x0"; - case "latest": - case "pending": - case "safe": - case "finalized": - return e; - } - if (typeof e == "number" || (0, bb.isHexString)(e)) - return (0, bb.hexValue)(e); - throw new Error("invalid blockTag"); - }), - (t.prototype.hash = function (e, r) { - var n = this.hex(e, r); - return (0, bb.hexDataLength)(n) !== 32 - ? dK.throwArgumentError("invalid hash", "value", e) - : n; - }), - (t.prototype.difficulty = function (e) { - if (e == null) return null; - var r = _x.BigNumber.from(e); - try { - return r.toNumber(); - } catch {} - return null; - }), - (t.prototype.uint256 = function (e) { - if (!(0, bb.isHexString)(e)) throw new Error("invalid uint256"); - return (0, bb.hexZeroPad)(e, 32); - }), - (t.prototype._block = function (e, r) { - e.author != null && e.miner == null && (e.miner = e.author); - var n = e._difficulty != null ? e._difficulty : e.difficulty, - i = t.check(r, e); - return (i._difficulty = n == null ? null : _x.BigNumber.from(n)), i; - }), - (t.prototype.block = function (e) { - return this._block(e, this.formats.block); - }), - (t.prototype.blockWithTransactions = function (e) { - return this._block(e, this.formats.blockWithTransactions); - }), - (t.prototype.transactionRequest = function (e) { - return t.check(this.formats.transactionRequest, e); - }), - (t.prototype.transactionResponse = function (e) { - e.gas != null && e.gasLimit == null && (e.gasLimit = e.gas), - e.to && - _x.BigNumber.from(e.to).isZero() && - (e.to = "0x0000000000000000000000000000000000000000"), - e.input != null && e.data == null && (e.data = e.input), - e.to == null && - e.creates == null && - (e.creates = this.contractAddress(e)), - (e.type === 1 || e.type === 2) && - e.accessList == null && - (e.accessList = []); - var r = t.check(this.formats.transaction, e); - if (e.chainId != null) { - var n = e.chainId; - (0, bb.isHexString)(n) && (n = _x.BigNumber.from(n).toNumber()), - (r.chainId = n); - } else { - var n = e.networkId; - n == null && r.v == null && (n = e.chainId), - (0, bb.isHexString)(n) && (n = _x.BigNumber.from(n).toNumber()), - typeof n != "number" && - r.v != null && - ((n = (r.v - 35) / 2), n < 0 && (n = 0), (n = parseInt(n))), - typeof n != "number" && (n = 0), - (r.chainId = n); - } - return ( - r.blockHash && - r.blockHash.replace(/0/g, "") === "x" && - (r.blockHash = null), - r - ); - }), - (t.prototype.transaction = function (e) { - return (0, Qft.parse)(e); - }), - (t.prototype.receiptLog = function (e) { - return t.check(this.formats.receiptLog, e); - }), - (t.prototype.receipt = function (e) { - var r = t.check(this.formats.receipt, e); - if (r.root != null) - if (r.root.length <= 4) { - var n = _x.BigNumber.from(r.root).toNumber(); - n === 0 || n === 1 - ? (r.status != null && - r.status !== n && - dK.throwArgumentError( - "alt-root-status/status mismatch", - "value", - { root: r.root, status: r.status } - ), - (r.status = n), - delete r.root) - : dK.throwArgumentError( - "invalid alt-root-status", - "value.root", - r.root - ); - } else - r.root.length !== 66 && - dK.throwArgumentError( - "invalid root hash", - "value.root", - r.root - ); - return r.status != null && (r.byzantium = !0), r; - }), - (t.prototype.topics = function (e) { - var r = this; - return Array.isArray(e) - ? e.map(function (n) { - return r.topics(n); - }) - : e != null - ? this.hash(e, !0) - : null; - }), - (t.prototype.filter = function (e) { - return t.check(this.formats.filter, e); - }), - (t.prototype.filterLog = function (e) { - return t.check(this.formats.filterLog, e); - }), - (t.check = function (e, r) { - var n = {}; - for (var i in e) - try { - var o = e[i](r[i]); - o !== void 0 && (n[i] = o); - } catch (a) { - throw ((a.checkKey = i), (a.checkValue = r[i]), a); - } - return n; - }), - (t.allowNull = function (e, r) { - return function (n) { - return n == null ? r : e(n); - }; - }), - (t.allowFalsish = function (e, r) { - return function (n) { - return n ? e(n) : r; - }; - }), - (t.arrayOf = function (e) { - return function (r) { - if (!Array.isArray(r)) throw new Error("not an array"); - var n = []; - return ( - r.forEach(function (i) { - n.push(e(i)); - }), - n - ); - }; - }), - t - ); - })(); - wb.Formatter = Jxr; - function tdt(t) { - return t && typeof t.isCommunityResource == "function"; - } - wb.isCommunityResourcable = tdt; - function $xr(t) { - return tdt(t) && t.isCommunityResource(); - } - wb.isCommunityResource = $xr; - var edt = !1; - function Zxr() { - edt || - ((edt = !0), - console.log("========= NOTICE ========="), - console.log( - "Request-Rate Exceeded (this message will not be repeated)" - ), - console.log(""), - console.log( - "The default API keys for each service are provided as a highly-throttled," - ), - console.log( - "community resource for low-traffic projects and early prototyping." - ), - console.log(""), - console.log( - "While your application will continue to function, we highly recommended" - ), - console.log( - "signing up for your own API keys to improve performance, increase your" - ), - console.log( - "request rate/limit and enable other perks, such as metrics and advanced APIs." - ), - console.log(""), - console.log("For more details: https://docs.ethers.io/api-keys/"), - console.log("==========================")); - } - wb.showThrottleMessage = Zxr; - }); - var mK = I((al) => { - "use strict"; - m(); - g(); - var Xxr = - (al && al.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(), - en = - (al && al.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - tn = - (al && al.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }, - Yxr = - (al && al.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(al, "__esModule", { value: !0 }); - al.BaseProvider = al.Resolver = al.Event = void 0; - var fdt = vx(), - Qxr = lb(), - wEe = jR(), - ol = Ro(), - Wr = Ar(), - eSr = ub(), - pK = db(), - tSr = hEe(), - as = $r(), - rdt = pb(), - _Ee = Eo(), - o7 = r7(), - ndt = Yxr(yEe()), - Qn = rr(), - rSr = pc(), - Ln = new Qn.Logger(rSr.version), - idt = HA(), - nSr = 10; - function odt(t) { - return t == null - ? "null" - : ((0, Wr.hexDataLength)(t) !== 32 && - Ln.throwArgumentError("invalid topic", "topic", t), - t.toLowerCase()); - } - function adt(t) { - for (t = t.slice(); t.length > 0 && t[t.length - 1] == null; ) t.pop(); - return t - .map(function (e) { - if (Array.isArray(e)) { - var r = {}; - e.forEach(function (i) { - r[odt(i)] = !0; - }); - var n = Object.keys(r); - return n.sort(), n.join("|"); - } else return odt(e); - }) - .join("&"); - } - function iSr(t) { - return t === "" - ? [] - : t.split(/&/g).map(function (e) { - if (e === "") return []; - var r = e.split("|").map(function (n) { - return n === "null" ? null : n; - }); - return r.length === 1 ? r[0] : r; - }); - } - function i7(t) { - if (typeof t == "string") { - if (((t = t.toLowerCase()), (0, Wr.hexDataLength)(t) === 32)) - return "tx:" + t; - if (t.indexOf(":") === -1) return t; - } else { - if (Array.isArray(t)) return "filter:*:" + adt(t); - if (fdt.ForkEvent.isForkEvent(t)) - throw (Ln.warn("not implemented"), new Error("not implemented")); - if (t && typeof t == "object") - return "filter:" + (t.address || "*") + ":" + adt(t.topics || []); - } - throw new Error("invalid event - " + t); - } - function hK() { - return new Date().getTime(); - } - function sdt(t) { - return new Promise(function (e) { - setTimeout(e, t); - }); - } - var oSr = ["block", "network", "pending", "poll"], - ddt = (function () { - function t(e, r, n) { - (0, as.defineReadOnly)(this, "tag", e), - (0, as.defineReadOnly)(this, "listener", r), - (0, as.defineReadOnly)(this, "once", n), - (this._lastBlockNumber = -2), - (this._inflight = !1); - } - return ( - Object.defineProperty(t.prototype, "event", { - get: function () { - switch (this.type) { - case "tx": - return this.hash; - case "filter": - return this.filter; - } - return this.tag; - }, - enumerable: !1, - configurable: !0, - }), - Object.defineProperty(t.prototype, "type", { - get: function () { - return this.tag.split(":")[0]; - }, - enumerable: !1, - configurable: !0, - }), - Object.defineProperty(t.prototype, "hash", { - get: function () { - var e = this.tag.split(":"); - return e[0] !== "tx" ? null : e[1]; - }, - enumerable: !1, - configurable: !0, - }), - Object.defineProperty(t.prototype, "filter", { - get: function () { - var e = this.tag.split(":"); - if (e[0] !== "filter") return null; - var r = e[1], - n = iSr(e[2]), - i = {}; - return ( - n.length > 0 && (i.topics = n), - r && r !== "*" && (i.address = r), - i - ); - }, - enumerable: !1, - configurable: !0, - }), - (t.prototype.pollable = function () { - return this.tag.indexOf(":") >= 0 || oSr.indexOf(this.tag) >= 0; - }), - t - ); - })(); - al.Event = ddt; - var aSr = { - 0: { symbol: "btc", p2pkh: 0, p2sh: 5, prefix: "bc" }, - 2: { symbol: "ltc", p2pkh: 48, p2sh: 50, prefix: "ltc" }, - 3: { symbol: "doge", p2pkh: 30, p2sh: 22 }, - 60: { symbol: "eth", ilk: "eth" }, - 61: { symbol: "etc", ilk: "eth" }, - 700: { symbol: "xdai", ilk: "eth" }, - }; - function gEe(t) { - return (0, Wr.hexZeroPad)(ol.BigNumber.from(t).toHexString(), 32); - } - function udt(t) { - return wEe.Base58.encode( - (0, Wr.concat)([ - t, - (0, Wr.hexDataSlice)((0, rdt.sha256)((0, rdt.sha256)(t)), 0, 4), - ]) - ); - } - var hdt = new RegExp("^(ipfs)://(.*)$", "i"), - cdt = [ - new RegExp("^(https)://(.*)$", "i"), - new RegExp("^(data):(.*)$", "i"), - hdt, - new RegExp("^eip155:[0-9]+/(erc[0-9]+):(.*)$", "i"), - ]; - function Pne(t, e) { - try { - return (0, _Ee.toUtf8String)(yK(t, e)); - } catch {} - return null; - } - function yK(t, e) { - if (t === "0x") return null; - var r = ol.BigNumber.from((0, Wr.hexDataSlice)(t, e, e + 32)).toNumber(), - n = ol.BigNumber.from((0, Wr.hexDataSlice)(t, r, r + 32)).toNumber(); - return (0, Wr.hexDataSlice)(t, r + 32, r + 32 + n); - } - function vEe(t) { - return ( - t.match(/^ipfs:\/\/ipfs\//i) - ? (t = t.substring(12)) - : t.match(/^ipfs:\/\//i) - ? (t = t.substring(7)) - : Ln.throwArgumentError("unsupported IPFS format", "link", t), - "https://gateway.ipfs.io/ipfs/" + t - ); - } - function ldt(t) { - var e = (0, Wr.arrayify)(t); - if (e.length > 32) throw new Error("internal; should not happen"); - var r = new Uint8Array(32); - return r.set(e, 32 - e.length), r; - } - function sSr(t) { - if (t.length % 32 === 0) return t; - var e = new Uint8Array(Math.ceil(t.length / 32) * 32); - return e.set(t), e; - } - function pdt(t) { - for (var e = [], r = 0, n = 0; n < t.length; n++) e.push(null), (r += 32); - for (var n = 0; n < t.length; n++) { - var i = (0, Wr.arrayify)(t[n]); - (e[n] = ldt(r)), - e.push(ldt(i.length)), - e.push(sSr(i)), - (r += 32 + Math.ceil(i.length / 32) * 32); - } - return (0, Wr.hexConcat)(e); - } - var xEe = (function () { - function t(e, r, n, i) { - (0, as.defineReadOnly)(this, "provider", e), - (0, as.defineReadOnly)(this, "name", n), - (0, as.defineReadOnly)(this, "address", e.formatter.address(r)), - (0, as.defineReadOnly)(this, "_resolvedAddress", i); - } - return ( - (t.prototype.supportsWildcard = function () { - var e = this; - return ( - this._supportsEip2544 || - (this._supportsEip2544 = this.provider - .call({ - to: this.address, - data: "0x01ffc9a79061b92300000000000000000000000000000000000000000000000000000000", - }) - .then(function (r) { - return ol.BigNumber.from(r).eq(1); - }) - .catch(function (r) { - if (r.code === Qn.Logger.errors.CALL_EXCEPTION) return !1; - throw ((e._supportsEip2544 = null), r); - })), - this._supportsEip2544 - ); - }), - (t.prototype._fetch = function (e, r) { - return en(this, void 0, void 0, function () { - var n, i, o, a; - return tn(this, function (s) { - switch (s.label) { - case 0: - return ( - (n = { - to: this.address, - ccipReadEnabled: !0, - data: (0, Wr.hexConcat)([ - e, - (0, pK.namehash)(this.name), - r || "0x", - ]), - }), - (i = !1), - [4, this.supportsWildcard()] - ); - case 1: - s.sent() && - ((i = !0), - (n.data = (0, Wr.hexConcat)([ - "0x9061b923", - pdt([(0, pK.dnsEncode)(this.name), n.data]), - ]))), - (s.label = 2); - case 2: - return s.trys.push([2, 4, , 5]), [4, this.provider.call(n)]; - case 3: - return ( - (o = s.sent()), - (0, Wr.arrayify)(o).length % 32 === 4 && - Ln.throwError( - "resolver threw error", - Qn.Logger.errors.CALL_EXCEPTION, - { transaction: n, data: o } - ), - i && (o = yK(o, 0)), - [2, o] - ); - case 4: - if ( - ((a = s.sent()), a.code === Qn.Logger.errors.CALL_EXCEPTION) - ) - return [2, null]; - throw a; - case 5: - return [2]; - } - }); - }); - }), - (t.prototype._fetchBytes = function (e, r) { - return en(this, void 0, void 0, function () { - var n; - return tn(this, function (i) { - switch (i.label) { - case 0: - return [4, this._fetch(e, r)]; - case 1: - return (n = i.sent()), n != null ? [2, yK(n, 0)] : [2, null]; - } - }); - }); - }), - (t.prototype._getAddress = function (e, r) { - var n = aSr[String(e)]; - if ( - (n == null && - Ln.throwError( - "unsupported coin type: " + e, - Qn.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "getAddress(" + e + ")" } - ), - n.ilk === "eth") - ) - return this.provider.formatter.address(r); - var i = (0, Wr.arrayify)(r); - if (n.p2pkh != null) { - var o = r.match(/^0x76a9([0-9a-f][0-9a-f])([0-9a-f]*)88ac$/); - if (o) { - var a = parseInt(o[1], 16); - if (o[2].length === a * 2 && a >= 1 && a <= 75) - return udt((0, Wr.concat)([[n.p2pkh], "0x" + o[2]])); - } - } - if (n.p2sh != null) { - var s = r.match(/^0xa9([0-9a-f][0-9a-f])([0-9a-f]*)87$/); - if (s) { - var c = parseInt(s[1], 16); - if (s[2].length === c * 2 && c >= 1 && c <= 75) - return udt((0, Wr.concat)([[n.p2sh], "0x" + s[2]])); - } - } - if (n.prefix != null) { - var u = i[1], - h = i[0]; - if ( - (h === 0 ? u !== 20 && u !== 32 && (h = -1) : (h = -1), - h >= 0 && i.length === 2 + u && u >= 1 && u <= 75) - ) { - var w = ndt.default.toWords(i.slice(2)); - return w.unshift(h), ndt.default.encode(n.prefix, w); - } - } - return null; - }), - (t.prototype.getAddress = function (e) { - return en(this, void 0, void 0, function () { - var r, n, i, o; - return tn(this, function (a) { - switch (a.label) { - case 0: - if ((e == null && (e = 60), e !== 60)) return [3, 4]; - a.label = 1; - case 1: - return ( - a.trys.push([1, 3, , 4]), [4, this._fetch("0x3b3b57de")] - ); - case 2: - return ( - (r = a.sent()), - r === "0x" || r === eSr.HashZero - ? [2, null] - : [2, this.provider.formatter.callAddress(r)] - ); - case 3: - if ( - ((n = a.sent()), n.code === Qn.Logger.errors.CALL_EXCEPTION) - ) - return [2, null]; - throw n; - case 4: - return [4, this._fetchBytes("0xf1cb7e06", gEe(e))]; - case 5: - return ( - (i = a.sent()), - i == null || i === "0x" - ? [2, null] - : ((o = this._getAddress(e, i)), - o == null && - Ln.throwError( - "invalid or unsupported coin data", - Qn.Logger.errors.UNSUPPORTED_OPERATION, - { - operation: "getAddress(" + e + ")", - coinType: e, - data: i, - } - ), - [2, o]) - ); - } - }); - }); - }), - (t.prototype.getAvatar = function () { - return en(this, void 0, void 0, function () { - var e, - r, - n, - i, - o, - a, - s, - c, - u, - h, - w, - M, - k, - O, - D, - F, - N, - q, - z, - H, - Z, - $, - ue, - te, - ne; - return tn(this, function (A) { - switch (A.label) { - case 0: - (e = [{ type: "name", content: this.name }]), (A.label = 1); - case 1: - return ( - A.trys.push([1, 19, , 20]), [4, this.getText("avatar")] - ); - case 2: - if (((r = A.sent()), r == null)) return [2, null]; - (n = 0), (A.label = 3); - case 3: - if (!(n < cdt.length)) return [3, 18]; - if (((i = r.match(cdt[n])), i == null)) return [3, 17]; - switch (((o = i[1].toLowerCase()), (a = o), a)) { - case "https": - return [3, 4]; - case "data": - return [3, 5]; - case "ipfs": - return [3, 6]; - case "erc721": - return [3, 7]; - case "erc1155": - return [3, 7]; - } - return [3, 17]; - case 4: - return ( - e.push({ type: "url", content: r }), - [2, { linkage: e, url: r }] - ); - case 5: - return ( - e.push({ type: "data", content: r }), - [2, { linkage: e, url: r }] - ); - case 6: - return ( - e.push({ type: "ipfs", content: r }), - [2, { linkage: e, url: vEe(r) }] - ); - case 7: - return ( - (s = o === "erc721" ? "0xc87b56dd" : "0x0e89341c"), - e.push({ type: o, content: r }), - (u = this._resolvedAddress), - u ? [3, 9] : [4, this.getAddress()] - ); - case 8: - (u = A.sent()), (A.label = 9); - case 9: - return ( - (c = u), - (h = (i[2] || "").split("/")), - h.length !== 2 - ? [2, null] - : [4, this.provider.formatter.address(h[0])] - ); - case 10: - return ( - (w = A.sent()), - (M = (0, Wr.hexZeroPad)( - ol.BigNumber.from(h[1]).toHexString(), - 32 - )), - o !== "erc721" - ? [3, 12] - : ((D = (O = this.provider.formatter).callAddress), - [ - 4, - this.provider.call({ - to: w, - data: (0, Wr.hexConcat)(["0x6352211e", M]), - }), - ]) - ); - case 11: - return ( - (k = D.apply(O, [A.sent()])), - c !== k - ? [2, null] - : (e.push({ type: "owner", content: k }), [3, 14]) - ); - case 12: - return o !== "erc1155" - ? [3, 14] - : ((q = (N = ol.BigNumber).from), - [ - 4, - this.provider.call({ - to: w, - data: (0, Wr.hexConcat)([ - "0x00fdd58e", - (0, Wr.hexZeroPad)(c, 32), - M, - ]), - }), - ]); - case 13: - if (((F = q.apply(N, [A.sent()])), F.isZero())) - return [2, null]; - e.push({ type: "balance", content: F.toString() }), - (A.label = 14); - case 14: - return ( - (z = { - to: this.provider.formatter.address(h[0]), - data: (0, Wr.hexConcat)([s, M]), - }), - (Z = Pne), - [4, this.provider.call(z)] - ); - case 15: - return ( - (H = Z.apply(void 0, [A.sent(), 0])), - H == null - ? [2, null] - : (e.push({ type: "metadata-url-base", content: H }), - o === "erc1155" && - ((H = H.replace("{id}", M.substring(2))), - e.push({ - type: "metadata-url-expanded", - content: H, - })), - H.match(/^ipfs:/i) && (H = vEe(H)), - e.push({ type: "metadata-url", content: H }), - [4, (0, o7.fetchJson)(H)]) - ); - case 16: - if ((($ = A.sent()), !$)) return [2, null]; - if ( - (e.push({ type: "metadata", content: JSON.stringify($) }), - (ue = $.image), - typeof ue != "string") - ) - return [2, null]; - if (!ue.match(/^(https:\/\/|data:)/i)) { - if (((te = ue.match(hdt)), te == null)) return [2, null]; - e.push({ type: "url-ipfs", content: ue }), (ue = vEe(ue)); - } - return ( - e.push({ type: "url", content: ue }), - [2, { linkage: e, url: ue }] - ); - case 17: - return n++, [3, 3]; - case 18: - return [3, 20]; - case 19: - return (ne = A.sent()), [3, 20]; - case 20: - return [2, null]; - } - }); - }); - }), - (t.prototype.getContentHash = function () { - return en(this, void 0, void 0, function () { - var e, r, n, i, o, a, s, c, u; - return tn(this, function (h) { - switch (h.label) { - case 0: - return [4, this._fetchBytes("0xbc1c58d1")]; - case 1: - return ( - (e = h.sent()), - e == null || e === "0x" - ? [2, null] - : ((r = e.match( - /^0xe3010170(([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])([0-9a-f]*))$/ - )), - r && ((n = parseInt(r[3], 16)), r[4].length === n * 2) - ? [2, "ipfs://" + wEe.Base58.encode("0x" + r[1])] - : ((i = e.match( - /^0xe5010172(([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])([0-9a-f]*))$/ - )), - i && - ((o = parseInt(i[3], 16)), i[4].length === o * 2) - ? [2, "ipns://" + wEe.Base58.encode("0x" + i[1])] - : ((a = e.match(/^0xe40101fa011b20([0-9a-f]*)$/)), - a && a[1].length === 32 * 2 - ? [2, "bzz://" + a[1]] - : ((s = e.match(/^0x90b2c605([0-9a-f]*)$/)), - s && s[1].length === 34 * 2 - ? ((c = { "=": "", "+": "-", "/": "_" }), - (u = (0, Qxr.encode)( - "0x" + s[1] - ).replace(/[=+\/]/g, function (w) { - return c[w]; - })), - [2, "sia://" + u]) - : [ - 2, - Ln.throwError( - "invalid or unsupported content hash data", - Qn.Logger.errors - .UNSUPPORTED_OPERATION, - { - operation: "getContentHash()", - data: e, - } - ), - ])))) - ); - } - }); - }); - }), - (t.prototype.getText = function (e) { - return en(this, void 0, void 0, function () { - var r, n; - return tn(this, function (i) { - switch (i.label) { - case 0: - return ( - (r = (0, _Ee.toUtf8Bytes)(e)), - (r = (0, Wr.concat)([gEe(64), gEe(r.length), r])), - r.length % 32 !== 0 && - (r = (0, Wr.concat)([ - r, - (0, Wr.hexZeroPad)("0x", 32 - (e.length % 32)), - ])), - [4, this._fetchBytes("0x59d1d43c", (0, Wr.hexlify)(r))] - ); - case 1: - return ( - (n = i.sent()), - n == null || n === "0x" - ? [2, null] - : [2, (0, _Ee.toUtf8String)(n)] - ); - } - }); - }); - }), - t - ); - })(); - al.Resolver = xEe; - var bEe = null, - uSr = 1, - cSr = (function (t) { - Xxr(e, t); - function e(r) { - var n = this.constructor, - i = t.call(this) || this; - if ( - ((i._events = []), - (i._emitted = { block: -2 }), - (i.disableCcipRead = !1), - (i.formatter = n.getFormatter()), - (0, as.defineReadOnly)(i, "anyNetwork", r === "any"), - i.anyNetwork && (r = i.detectNetwork()), - r instanceof Promise) - ) - (i._networkPromise = r), - r.catch(function (a) {}), - i._ready().catch(function (a) {}); - else { - var o = (0, as.getStatic)(n, "getNetwork")(r); - o - ? ((0, as.defineReadOnly)(i, "_network", o), - i.emit("network", o, null)) - : Ln.throwArgumentError("invalid network", "network", r); - } - return ( - (i._maxInternalBlockNumber = -1024), - (i._lastBlockNumber = -2), - (i._maxFilterBlockRange = 10), - (i._pollingInterval = 4e3), - (i._fastQueryDate = 0), - i - ); - } - return ( - (e.prototype._ready = function () { - return en(this, void 0, void 0, function () { - var r, n; - return tn(this, function (i) { - switch (i.label) { - case 0: - if (this._network != null) return [3, 7]; - if (((r = null), !this._networkPromise)) return [3, 4]; - i.label = 1; - case 1: - return i.trys.push([1, 3, , 4]), [4, this._networkPromise]; - case 2: - return (r = i.sent()), [3, 4]; - case 3: - return (n = i.sent()), [3, 4]; - case 4: - return r != null ? [3, 6] : [4, this.detectNetwork()]; - case 5: - (r = i.sent()), (i.label = 6); - case 6: - r || - Ln.throwError( - "no network detected", - Qn.Logger.errors.UNKNOWN_ERROR, - {} - ), - this._network == null && - (this.anyNetwork - ? (this._network = r) - : (0, as.defineReadOnly)(this, "_network", r), - this.emit("network", r, null)), - (i.label = 7); - case 7: - return [2, this._network]; - } - }); - }); - }), - Object.defineProperty(e.prototype, "ready", { - get: function () { - var r = this; - return (0, o7.poll)(function () { - return r._ready().then( - function (n) { - return n; - }, - function (n) { - if ( - !( - n.code === Qn.Logger.errors.NETWORK_ERROR && - n.event === "noNetwork" - ) - ) - throw n; - } - ); - }); - }, - enumerable: !1, - configurable: !0, - }), - (e.getFormatter = function () { - return bEe == null && (bEe = new idt.Formatter()), bEe; - }), - (e.getNetwork = function (r) { - return (0, tSr.getNetwork)(r ?? "homestead"); - }), - (e.prototype.ccipReadFetch = function (r, n, i) { - return en(this, void 0, void 0, function () { - var o, a, s, c, u, h, w, M, k; - return tn(this, function (O) { - switch (O.label) { - case 0: - if (this.disableCcipRead || i.length === 0) - return [2, null]; - (o = r.to.toLowerCase()), - (a = n.toLowerCase()), - (s = []), - (c = 0), - (O.label = 1); - case 1: - return c < i.length - ? ((u = i[c]), - (h = u.replace("{sender}", o).replace("{data}", a)), - (w = - u.indexOf("{data}") >= 0 - ? null - : JSON.stringify({ data: a, sender: o })), - [ - 4, - (0, o7.fetchJson)( - { url: h, errorPassThrough: !0 }, - w, - function (D, F) { - return (D.status = F.statusCode), D; - } - ), - ]) - : [3, 4]; - case 2: - if (((M = O.sent()), M.data)) return [2, M.data]; - if ( - ((k = M.message || "unknown error"), - M.status >= 400 && M.status < 500) - ) - return [ - 2, - Ln.throwError( - "response not found during CCIP fetch: " + k, - Qn.Logger.errors.SERVER_ERROR, - { url: u, errorMessage: k } - ), - ]; - s.push(k), (O.label = 3); - case 3: - return c++, [3, 1]; - case 4: - return [ - 2, - Ln.throwError( - "error encountered during CCIP fetch: " + - s - .map(function (D) { - return JSON.stringify(D); - }) - .join(", "), - Qn.Logger.errors.SERVER_ERROR, - { urls: i, errorMessages: s } - ), - ]; - } - }); - }); - }), - (e.prototype._getInternalBlockNumber = function (r) { - return en(this, void 0, void 0, function () { - var n, - i, - o, - a, - s, - c = this; - return tn(this, function (u) { - switch (u.label) { - case 0: - return [4, this._ready()]; - case 1: - if ((u.sent(), !(r > 0))) return [3, 7]; - u.label = 2; - case 2: - if (!this._internalBlockNumber) return [3, 7]; - (n = this._internalBlockNumber), (u.label = 3); - case 3: - return u.trys.push([3, 5, , 6]), [4, n]; - case 4: - return ( - (i = u.sent()), - hK() - i.respTime <= r ? [2, i.blockNumber] : [3, 7] - ); - case 5: - return ( - (o = u.sent()), - this._internalBlockNumber === n ? [3, 7] : [3, 6] - ); - case 6: - return [3, 2]; - case 7: - return ( - (a = hK()), - (s = (0, as.resolveProperties)({ - blockNumber: this.perform("getBlockNumber", {}), - networkError: this.getNetwork().then( - function (h) { - return null; - }, - function (h) { - return h; - } - ), - }).then(function (h) { - var w = h.blockNumber, - M = h.networkError; - if (M) - throw ( - (c._internalBlockNumber === s && - (c._internalBlockNumber = null), - M) - ); - var k = hK(); - return ( - (w = ol.BigNumber.from(w).toNumber()), - w < c._maxInternalBlockNumber && - (w = c._maxInternalBlockNumber), - (c._maxInternalBlockNumber = w), - c._setFastBlockNumber(w), - { blockNumber: w, reqTime: a, respTime: k } - ); - })), - (this._internalBlockNumber = s), - s.catch(function (h) { - c._internalBlockNumber === s && - (c._internalBlockNumber = null); - }), - [4, s] - ); - case 8: - return [2, u.sent().blockNumber]; - } - }); - }); - }), - (e.prototype.poll = function () { - return en(this, void 0, void 0, function () { - var r, - n, - i, - o, - a, - s = this; - return tn(this, function (c) { - switch (c.label) { - case 0: - (r = uSr++), (n = []), (i = null), (c.label = 1); - case 1: - return ( - c.trys.push([1, 3, , 4]), - [ - 4, - this._getInternalBlockNumber( - 100 + this.pollingInterval / 2 - ), - ] - ); - case 2: - return (i = c.sent()), [3, 4]; - case 3: - return (o = c.sent()), this.emit("error", o), [2]; - case 4: - if ( - (this._setFastBlockNumber(i), - this.emit("poll", r, i), - i === this._lastBlockNumber) - ) - return this.emit("didPoll", r), [2]; - if ( - (this._emitted.block === -2 && - (this._emitted.block = i - 1), - Math.abs(this._emitted.block - i) > 1e3) - ) - Ln.warn( - "network block skew detected; skipping block events (emitted=" + - this._emitted.block + - " blockNumber" + - i + - ")" - ), - this.emit( - "error", - Ln.makeError( - "network block skew detected", - Qn.Logger.errors.NETWORK_ERROR, - { - blockNumber: i, - event: "blockSkew", - previousBlockNumber: this._emitted.block, - } - ) - ), - this.emit("block", i); - else - for (a = this._emitted.block + 1; a <= i; a++) - this.emit("block", a); - return ( - this._emitted.block !== i && - ((this._emitted.block = i), - Object.keys(this._emitted).forEach(function (u) { - if (u !== "block") { - var h = s._emitted[u]; - h !== "pending" && - i - h > 12 && - delete s._emitted[u]; - } - })), - this._lastBlockNumber === -2 && - (this._lastBlockNumber = i - 1), - this._events.forEach(function (u) { - switch (u.type) { - case "tx": { - var h = u.hash, - w = s - .getTransactionReceipt(h) - .then(function (O) { - return ( - !O || - O.blockNumber == null || - ((s._emitted["t:" + h] = O.blockNumber), - s.emit(h, O)), - null - ); - }) - .catch(function (O) { - s.emit("error", O); - }); - n.push(w); - break; - } - case "filter": { - if (!u._inflight) { - (u._inflight = !0), - u._lastBlockNumber === -2 && - (u._lastBlockNumber = i - 1); - var M = u.filter; - (M.fromBlock = u._lastBlockNumber + 1), - (M.toBlock = i); - var k = M.toBlock - s._maxFilterBlockRange; - k > M.fromBlock && (M.fromBlock = k), - M.fromBlock < 0 && (M.fromBlock = 0); - var w = s - .getLogs(M) - .then(function (D) { - (u._inflight = !1), - D.length !== 0 && - D.forEach(function (F) { - F.blockNumber > u._lastBlockNumber && - (u._lastBlockNumber = F.blockNumber), - (s._emitted["b:" + F.blockHash] = - F.blockNumber), - (s._emitted[ - "t:" + F.transactionHash - ] = F.blockNumber), - s.emit(M, F); - }); - }) - .catch(function (D) { - s.emit("error", D), (u._inflight = !1); - }); - n.push(w); - } - break; - } - } - }), - (this._lastBlockNumber = i), - Promise.all(n) - .then(function () { - s.emit("didPoll", r); - }) - .catch(function (u) { - s.emit("error", u); - }), - [2] - ); - } - }); - }); - }), - (e.prototype.resetEventsBlock = function (r) { - (this._lastBlockNumber = r - 1), this.polling && this.poll(); - }), - Object.defineProperty(e.prototype, "network", { - get: function () { - return this._network; - }, - enumerable: !1, - configurable: !0, - }), - (e.prototype.detectNetwork = function () { - return en(this, void 0, void 0, function () { - return tn(this, function (r) { - return [ - 2, - Ln.throwError( - "provider does not support network detection", - Qn.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "provider.detectNetwork" } - ), - ]; - }); - }); - }), - (e.prototype.getNetwork = function () { - return en(this, void 0, void 0, function () { - var r, n, i; - return tn(this, function (o) { - switch (o.label) { - case 0: - return [4, this._ready()]; - case 1: - return (r = o.sent()), [4, this.detectNetwork()]; - case 2: - return ( - (n = o.sent()), - r.chainId === n.chainId - ? [3, 5] - : this.anyNetwork - ? ((this._network = n), - (this._lastBlockNumber = -2), - (this._fastBlockNumber = null), - (this._fastBlockNumberPromise = null), - (this._fastQueryDate = 0), - (this._emitted.block = -2), - (this._maxInternalBlockNumber = -1024), - (this._internalBlockNumber = null), - this.emit("network", n, r), - [4, sdt(0)]) - : [3, 4] - ); - case 3: - return o.sent(), [2, this._network]; - case 4: - throw ( - ((i = Ln.makeError( - "underlying network changed", - Qn.Logger.errors.NETWORK_ERROR, - { event: "changed", network: r, detectedNetwork: n } - )), - this.emit("error", i), - i) - ); - case 5: - return [2, r]; - } - }); - }); - }), - Object.defineProperty(e.prototype, "blockNumber", { - get: function () { - var r = this; - return ( - this._getInternalBlockNumber( - 100 + this.pollingInterval / 2 - ).then( - function (n) { - r._setFastBlockNumber(n); - }, - function (n) {} - ), - this._fastBlockNumber != null ? this._fastBlockNumber : -1 - ); - }, - enumerable: !1, - configurable: !0, - }), - Object.defineProperty(e.prototype, "polling", { - get: function () { - return this._poller != null; - }, - set: function (r) { - var n = this; - r && !this._poller - ? ((this._poller = setInterval(function () { - n.poll(); - }, this.pollingInterval)), - this._bootstrapPoll || - (this._bootstrapPoll = setTimeout(function () { - n.poll(), - (n._bootstrapPoll = setTimeout(function () { - n._poller || n.poll(), (n._bootstrapPoll = null); - }, n.pollingInterval)); - }, 0))) - : !r && - this._poller && - (clearInterval(this._poller), (this._poller = null)); - }, - enumerable: !1, - configurable: !0, - }), - Object.defineProperty(e.prototype, "pollingInterval", { - get: function () { - return this._pollingInterval; - }, - set: function (r) { - var n = this; - if (typeof r != "number" || r <= 0 || parseInt(String(r)) != r) - throw new Error("invalid polling interval"); - (this._pollingInterval = r), - this._poller && - (clearInterval(this._poller), - (this._poller = setInterval(function () { - n.poll(); - }, this._pollingInterval))); - }, - enumerable: !1, - configurable: !0, - }), - (e.prototype._getFastBlockNumber = function () { - var r = this, - n = hK(); - return ( - n - this._fastQueryDate > 2 * this._pollingInterval && - ((this._fastQueryDate = n), - (this._fastBlockNumberPromise = this.getBlockNumber().then( - function (i) { - return ( - (r._fastBlockNumber == null || i > r._fastBlockNumber) && - (r._fastBlockNumber = i), - r._fastBlockNumber - ); - } - ))), - this._fastBlockNumberPromise - ); - }), - (e.prototype._setFastBlockNumber = function (r) { - (this._fastBlockNumber != null && r < this._fastBlockNumber) || - ((this._fastQueryDate = hK()), - (this._fastBlockNumber == null || r > this._fastBlockNumber) && - ((this._fastBlockNumber = r), - (this._fastBlockNumberPromise = Promise.resolve(r)))); - }), - (e.prototype.waitForTransaction = function (r, n, i) { - return en(this, void 0, void 0, function () { - return tn(this, function (o) { - return [2, this._waitForTransaction(r, n ?? 1, i || 0, null)]; - }); - }); - }), - (e.prototype._waitForTransaction = function (r, n, i, o) { - return en(this, void 0, void 0, function () { - var a, - s = this; - return tn(this, function (c) { - switch (c.label) { - case 0: - return [4, this.getTransactionReceipt(r)]; - case 1: - return ( - (a = c.sent()), - (a ? a.confirmations : 0) >= n - ? [2, a] - : [ - 2, - new Promise(function (u, h) { - var w = [], - M = !1, - k = function () { - return M - ? !0 - : ((M = !0), - w.forEach(function (z) { - z(); - }), - !1); - }, - O = function (z) { - z.confirmations < n || k() || u(z); - }; - if ( - (s.on(r, O), - w.push(function () { - s.removeListener(r, O); - }), - o) - ) { - var D = o.startBlock, - F = null, - N = function (z) { - return en(s, void 0, void 0, function () { - var H = this; - return tn(this, function (Z) { - switch (Z.label) { - case 0: - return M ? [2] : [4, sdt(1e3)]; - case 1: - return ( - Z.sent(), - this.getTransactionCount( - o.from - ).then( - function ($) { - return en( - H, - void 0, - void 0, - function () { - var ue, te, ne, A, l, p; - return tn( - this, - function (y) { - switch (y.label) { - case 0: - return M - ? [2] - : $ <= o.nonce - ? ((D = z), - [3, 9]) - : [3, 1]; - case 1: - return [ - 4, - this.getTransaction( - r - ), - ]; - case 2: - if ( - ((ue = - y.sent()), - ue && - ue.blockNumber != - null) - ) - return [2]; - F == null && - ((F = D - 3), - F < - o.startBlock && - (F = - o.startBlock)), - (y.label = 3); - case 3: - return F <= z - ? M - ? [2] - : [ - 4, - this.getBlockWithTransactions( - F - ), - ] - : [3, 9]; - case 4: - (te = y.sent()), - (ne = 0), - (y.label = 5); - case 5: - return ne < - te.transactions - .length - ? ((A = - te - .transactions[ - ne - ]), - A.hash === r - ? [2] - : A.from === - o.from && - A.nonce === - o.nonce - ? M - ? [2] - : [ - 4, - this.waitForTransaction( - A.hash, - n - ), - ] - : [3, 7]) - : [3, 8]; - case 6: - return ( - (l = y.sent()), - k() - ? [2] - : ((p = - "replaced"), - A.data === - o.data && - A.to === - o.to && - A.value.eq( - o.value - ) - ? (p = - "repriced") - : A.data === - "0x" && - A.from === - A.to && - A.value.isZero() && - (p = - "cancelled"), - h( - Ln.makeError( - "transaction was replaced", - Qn - .Logger - .errors - .TRANSACTION_REPLACED, - { - cancelled: - p === - "replaced" || - p === - "cancelled", - reason: - p, - replacement: - this._wrapTransaction( - A - ), - hash: r, - receipt: - l, - } - ) - ), - [2]) - ); - case 7: - return ( - ne++, [3, 5] - ); - case 8: - return ( - F++, [3, 3] - ); - case 9: - return M - ? [2] - : (this.once( - "block", - N - ), - [2]); - } - } - ); - } - ); - }, - function ($) { - M || H.once("block", N); - } - ), - [2] - ); - } - }); - }); - }; - if (M) return; - s.once("block", N), - w.push(function () { - s.removeListener("block", N); - }); - } - if (typeof i == "number" && i > 0) { - var q = setTimeout(function () { - k() || - h( - Ln.makeError( - "timeout exceeded", - Qn.Logger.errors.TIMEOUT, - { timeout: i } - ) - ); - }, i); - q.unref && q.unref(), - w.push(function () { - clearTimeout(q); - }); - } - }), - ] - ); - } - }); - }); - }), - (e.prototype.getBlockNumber = function () { - return en(this, void 0, void 0, function () { - return tn(this, function (r) { - return [2, this._getInternalBlockNumber(0)]; - }); - }); - }), - (e.prototype.getGasPrice = function () { - return en(this, void 0, void 0, function () { - var r; - return tn(this, function (n) { - switch (n.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return n.sent(), [4, this.perform("getGasPrice", {})]; - case 2: - r = n.sent(); - try { - return [2, ol.BigNumber.from(r)]; - } catch (i) { - return [ - 2, - Ln.throwError( - "bad result from backend", - Qn.Logger.errors.SERVER_ERROR, - { method: "getGasPrice", result: r, error: i } - ), - ]; - } - return [2]; - } - }); - }); - }), - (e.prototype.getBalance = function (r, n) { - return en(this, void 0, void 0, function () { - var i, o; - return tn(this, function (a) { - switch (a.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return ( - a.sent(), - [ - 4, - (0, as.resolveProperties)({ - address: this._getAddress(r), - blockTag: this._getBlockTag(n), - }), - ] - ); - case 2: - return (i = a.sent()), [4, this.perform("getBalance", i)]; - case 3: - o = a.sent(); - try { - return [2, ol.BigNumber.from(o)]; - } catch (s) { - return [ - 2, - Ln.throwError( - "bad result from backend", - Qn.Logger.errors.SERVER_ERROR, - { - method: "getBalance", - params: i, - result: o, - error: s, - } - ), - ]; - } - return [2]; - } - }); - }); - }), - (e.prototype.getTransactionCount = function (r, n) { - return en(this, void 0, void 0, function () { - var i, o; - return tn(this, function (a) { - switch (a.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return ( - a.sent(), - [ - 4, - (0, as.resolveProperties)({ - address: this._getAddress(r), - blockTag: this._getBlockTag(n), - }), - ] - ); - case 2: - return ( - (i = a.sent()), - [4, this.perform("getTransactionCount", i)] - ); - case 3: - o = a.sent(); - try { - return [2, ol.BigNumber.from(o).toNumber()]; - } catch (s) { - return [ - 2, - Ln.throwError( - "bad result from backend", - Qn.Logger.errors.SERVER_ERROR, - { - method: "getTransactionCount", - params: i, - result: o, - error: s, - } - ), - ]; - } - return [2]; - } - }); - }); - }), - (e.prototype.getCode = function (r, n) { - return en(this, void 0, void 0, function () { - var i, o; - return tn(this, function (a) { - switch (a.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return ( - a.sent(), - [ - 4, - (0, as.resolveProperties)({ - address: this._getAddress(r), - blockTag: this._getBlockTag(n), - }), - ] - ); - case 2: - return (i = a.sent()), [4, this.perform("getCode", i)]; - case 3: - o = a.sent(); - try { - return [2, (0, Wr.hexlify)(o)]; - } catch (s) { - return [ - 2, - Ln.throwError( - "bad result from backend", - Qn.Logger.errors.SERVER_ERROR, - { method: "getCode", params: i, result: o, error: s } - ), - ]; - } - return [2]; - } - }); - }); - }), - (e.prototype.getStorageAt = function (r, n, i) { - return en(this, void 0, void 0, function () { - var o, a; - return tn(this, function (s) { - switch (s.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return ( - s.sent(), - [ - 4, - (0, as.resolveProperties)({ - address: this._getAddress(r), - blockTag: this._getBlockTag(i), - position: Promise.resolve(n).then(function (c) { - return (0, Wr.hexValue)(c); - }), - }), - ] - ); - case 2: - return (o = s.sent()), [4, this.perform("getStorageAt", o)]; - case 3: - a = s.sent(); - try { - return [2, (0, Wr.hexlify)(a)]; - } catch (c) { - return [ - 2, - Ln.throwError( - "bad result from backend", - Qn.Logger.errors.SERVER_ERROR, - { - method: "getStorageAt", - params: o, - result: a, - error: c, - } - ), - ]; - } - return [2]; - } - }); - }); - }), - (e.prototype._wrapTransaction = function (r, n, i) { - var o = this; - if (n != null && (0, Wr.hexDataLength)(n) !== 32) - throw new Error("invalid response - sendTransaction"); - var a = r; - return ( - n != null && - r.hash !== n && - Ln.throwError( - "Transaction hash mismatch from Provider.sendTransaction.", - Qn.Logger.errors.UNKNOWN_ERROR, - { expectedHash: r.hash, returnedHash: n } - ), - (a.wait = function (s, c) { - return en(o, void 0, void 0, function () { - var u, h; - return tn(this, function (w) { - switch (w.label) { - case 0: - return ( - s == null && (s = 1), - c == null && (c = 0), - (u = void 0), - s !== 0 && - i != null && - (u = { - data: r.data, - from: r.from, - nonce: r.nonce, - to: r.to, - value: r.value, - startBlock: i, - }), - [4, this._waitForTransaction(r.hash, s, c, u)] - ); - case 1: - return ( - (h = w.sent()), - h == null && s === 0 - ? [2, null] - : ((this._emitted["t:" + r.hash] = h.blockNumber), - h.status === 0 && - Ln.throwError( - "transaction failed", - Qn.Logger.errors.CALL_EXCEPTION, - { - transactionHash: r.hash, - transaction: r, - receipt: h, - } - ), - [2, h]) - ); - } - }); - }); - }), - a - ); - }), - (e.prototype.sendTransaction = function (r) { - return en(this, void 0, void 0, function () { - var n, i, o, a, s; - return tn(this, function (c) { - switch (c.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return ( - c.sent(), - [ - 4, - Promise.resolve(r).then(function (u) { - return (0, Wr.hexlify)(u); - }), - ] - ); - case 2: - return ( - (n = c.sent()), - (i = this.formatter.transaction(r)), - i.confirmations == null && (i.confirmations = 0), - [ - 4, - this._getInternalBlockNumber( - 100 + 2 * this.pollingInterval - ), - ] - ); - case 3: - (o = c.sent()), (c.label = 4); - case 4: - return ( - c.trys.push([4, 6, , 7]), - [ - 4, - this.perform("sendTransaction", { - signedTransaction: n, - }), - ] - ); - case 5: - return (a = c.sent()), [2, this._wrapTransaction(i, a, o)]; - case 6: - throw ( - ((s = c.sent()), - (s.transaction = i), - (s.transactionHash = i.hash), - s) - ); - case 7: - return [2]; - } - }); - }); - }), - (e.prototype._getTransactionRequest = function (r) { - return en(this, void 0, void 0, function () { - var n, - i, - o, - a, - s = this; - return tn(this, function (c) { - switch (c.label) { - case 0: - return [4, r]; - case 1: - return ( - (n = c.sent()), - (i = {}), - ["from", "to"].forEach(function (u) { - n[u] != null && - (i[u] = Promise.resolve(n[u]).then(function (h) { - return h ? s._getAddress(h) : null; - })); - }), - [ - "gasLimit", - "gasPrice", - "maxFeePerGas", - "maxPriorityFeePerGas", - "value", - ].forEach(function (u) { - n[u] != null && - (i[u] = Promise.resolve(n[u]).then(function (h) { - return h ? ol.BigNumber.from(h) : null; - })); - }), - ["type"].forEach(function (u) { - n[u] != null && - (i[u] = Promise.resolve(n[u]).then(function (h) { - return h ?? null; - })); - }), - n.accessList && - (i.accessList = this.formatter.accessList( - n.accessList - )), - ["data"].forEach(function (u) { - n[u] != null && - (i[u] = Promise.resolve(n[u]).then(function (h) { - return h ? (0, Wr.hexlify)(h) : null; - })); - }), - (a = (o = this.formatter).transactionRequest), - [4, (0, as.resolveProperties)(i)] - ); - case 2: - return [2, a.apply(o, [c.sent()])]; - } - }); - }); - }), - (e.prototype._getFilter = function (r) { - return en(this, void 0, void 0, function () { - var n, - i, - o, - a = this; - return tn(this, function (s) { - switch (s.label) { - case 0: - return [4, r]; - case 1: - return ( - (r = s.sent()), - (n = {}), - r.address != null && - (n.address = this._getAddress(r.address)), - ["blockHash", "topics"].forEach(function (c) { - r[c] != null && (n[c] = r[c]); - }), - ["fromBlock", "toBlock"].forEach(function (c) { - r[c] != null && (n[c] = a._getBlockTag(r[c])); - }), - (o = (i = this.formatter).filter), - [4, (0, as.resolveProperties)(n)] - ); - case 2: - return [2, o.apply(i, [s.sent()])]; - } - }); - }); - }), - (e.prototype._call = function (r, n, i) { - return en(this, void 0, void 0, function () { - var o, a, s, c, u, h, w, M, k, O, D, F, N, q, z, H; - return tn(this, function (Z) { - switch (Z.label) { - case 0: - return ( - i >= nSr && - Ln.throwError( - "CCIP read exceeded maximum redirections", - Qn.Logger.errors.SERVER_ERROR, - { redirects: i, transaction: r } - ), - (o = r.to), - [4, this.perform("call", { transaction: r, blockTag: n })] - ); - case 1: - if ( - ((a = Z.sent()), - !( - i >= 0 && - n === "latest" && - o != null && - a.substring(0, 10) === "0x556f1830" && - (0, Wr.hexDataLength)(a) % 32 === 4 - )) - ) - return [3, 5]; - Z.label = 2; - case 2: - for ( - Z.trys.push([2, 4, , 5]), - s = (0, Wr.hexDataSlice)(a, 4), - c = (0, Wr.hexDataSlice)(s, 0, 32), - ol.BigNumber.from(c).eq(o) || - Ln.throwError( - "CCIP Read sender did not match", - Qn.Logger.errors.CALL_EXCEPTION, - { - name: "OffchainLookup", - signature: - "OffchainLookup(address,string[],bytes,bytes4,bytes)", - transaction: r, - data: a, - } - ), - u = [], - h = ol.BigNumber.from( - (0, Wr.hexDataSlice)(s, 32, 64) - ).toNumber(), - w = ol.BigNumber.from( - (0, Wr.hexDataSlice)(s, h, h + 32) - ).toNumber(), - M = (0, Wr.hexDataSlice)(s, h + 32), - k = 0; - k < w; - k++ - ) - (O = Pne(M, k * 32)), - O == null && - Ln.throwError( - "CCIP Read contained corrupt URL string", - Qn.Logger.errors.CALL_EXCEPTION, - { - name: "OffchainLookup", - signature: - "OffchainLookup(address,string[],bytes,bytes4,bytes)", - transaction: r, - data: a, - } - ), - u.push(O); - return ( - (D = yK(s, 64)), - ol.BigNumber.from( - (0, Wr.hexDataSlice)(s, 100, 128) - ).isZero() || - Ln.throwError( - "CCIP Read callback selector included junk", - Qn.Logger.errors.CALL_EXCEPTION, - { - name: "OffchainLookup", - signature: - "OffchainLookup(address,string[],bytes,bytes4,bytes)", - transaction: r, - data: a, - } - ), - (F = (0, Wr.hexDataSlice)(s, 96, 100)), - (N = yK(s, 128)), - [4, this.ccipReadFetch(r, D, u)] - ); - case 3: - return ( - (q = Z.sent()), - q == null && - Ln.throwError( - "CCIP Read disabled or provided no URLs", - Qn.Logger.errors.CALL_EXCEPTION, - { - name: "OffchainLookup", - signature: - "OffchainLookup(address,string[],bytes,bytes4,bytes)", - transaction: r, - data: a, - } - ), - (z = { - to: o, - data: (0, Wr.hexConcat)([F, pdt([q, N])]), - }), - [2, this._call(z, n, i + 1)] - ); - case 4: - if ( - ((H = Z.sent()), H.code === Qn.Logger.errors.SERVER_ERROR) - ) - throw H; - return [3, 5]; - case 5: - try { - return [2, (0, Wr.hexlify)(a)]; - } catch ($) { - return [ - 2, - Ln.throwError( - "bad result from backend", - Qn.Logger.errors.SERVER_ERROR, - { - method: "call", - params: { transaction: r, blockTag: n }, - result: a, - error: $, - } - ), - ]; - } - return [2]; - } - }); - }); - }), - (e.prototype.call = function (r, n) { - return en(this, void 0, void 0, function () { - var i; - return tn(this, function (o) { - switch (o.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return ( - o.sent(), - [ - 4, - (0, as.resolveProperties)({ - transaction: this._getTransactionRequest(r), - blockTag: this._getBlockTag(n), - ccipReadEnabled: Promise.resolve(r.ccipReadEnabled), - }), - ] - ); - case 2: - return ( - (i = o.sent()), - [ - 2, - this._call( - i.transaction, - i.blockTag, - i.ccipReadEnabled ? 0 : -1 - ), - ] - ); - } - }); - }); - }), - (e.prototype.estimateGas = function (r) { - return en(this, void 0, void 0, function () { - var n, i; - return tn(this, function (o) { - switch (o.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return ( - o.sent(), - [ - 4, - (0, as.resolveProperties)({ - transaction: this._getTransactionRequest(r), - }), - ] - ); - case 2: - return (n = o.sent()), [4, this.perform("estimateGas", n)]; - case 3: - i = o.sent(); - try { - return [2, ol.BigNumber.from(i)]; - } catch (a) { - return [ - 2, - Ln.throwError( - "bad result from backend", - Qn.Logger.errors.SERVER_ERROR, - { - method: "estimateGas", - params: n, - result: i, - error: a, - } - ), - ]; - } - return [2]; - } - }); - }); - }), - (e.prototype._getAddress = function (r) { - return en(this, void 0, void 0, function () { - var n; - return tn(this, function (i) { - switch (i.label) { - case 0: - return [4, r]; - case 1: - return ( - (r = i.sent()), - typeof r != "string" && - Ln.throwArgumentError( - "invalid address or ENS name", - "name", - r - ), - [4, this.resolveName(r)] - ); - case 2: - return ( - (n = i.sent()), - n == null && - Ln.throwError( - "ENS name not configured", - Qn.Logger.errors.UNSUPPORTED_OPERATION, - { - operation: "resolveName(" + JSON.stringify(r) + ")", - } - ), - [2, n] - ); - } - }); - }); - }), - (e.prototype._getBlock = function (r, n) { - return en(this, void 0, void 0, function () { - var i, - o, - a, - s, - c = this; - return tn(this, function (u) { - switch (u.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return u.sent(), [4, r]; - case 2: - return ( - (r = u.sent()), - (i = -128), - (o = { includeTransactions: !!n }), - (0, Wr.isHexString)(r, 32) - ? ((o.blockHash = r), [3, 6]) - : [3, 3] - ); - case 3: - return ( - u.trys.push([3, 5, , 6]), - (a = o), - [4, this._getBlockTag(r)] - ); - case 4: - return ( - (a.blockTag = u.sent()), - (0, Wr.isHexString)(o.blockTag) && - (i = parseInt(o.blockTag.substring(2), 16)), - [3, 6] - ); - case 5: - return ( - (s = u.sent()), - Ln.throwArgumentError( - "invalid block hash or block tag", - "blockHashOrBlockTag", - r - ), - [3, 6] - ); - case 6: - return [ - 2, - (0, o7.poll)( - function () { - return en(c, void 0, void 0, function () { - var h, - w, - M, - k, - O, - D, - F = this; - return tn(this, function (N) { - switch (N.label) { - case 0: - return [4, this.perform("getBlock", o)]; - case 1: - if (((h = N.sent()), h == null)) - return o.blockHash != null && - this._emitted["b:" + o.blockHash] == null - ? [2, null] - : o.blockTag != null && - i > this._emitted.block - ? [2, null] - : [2, void 0]; - if (!n) return [3, 8]; - (w = null), (M = 0), (N.label = 2); - case 2: - return M < h.transactions.length - ? ((k = h.transactions[M]), - k.blockNumber != null - ? [3, 3] - : ((k.confirmations = 0), [3, 6])) - : [3, 7]; - case 3: - return k.confirmations != null - ? [3, 6] - : w != null - ? [3, 5] - : [ - 4, - this._getInternalBlockNumber( - 100 + 2 * this.pollingInterval - ), - ]; - case 4: - (w = N.sent()), (N.label = 5); - case 5: - (O = w - k.blockNumber + 1), - O <= 0 && (O = 1), - (k.confirmations = O), - (N.label = 6); - case 6: - return M++, [3, 2]; - case 7: - return ( - (D = - this.formatter.blockWithTransactions(h)), - (D.transactions = D.transactions.map( - function (q) { - return F._wrapTransaction(q); - } - )), - [2, D] - ); - case 8: - return [2, this.formatter.block(h)]; - } - }); - }); - }, - { oncePoll: this } - ), - ]; - } - }); - }); - }), - (e.prototype.getBlock = function (r) { - return this._getBlock(r, !1); - }), - (e.prototype.getBlockWithTransactions = function (r) { - return this._getBlock(r, !0); - }), - (e.prototype.getTransaction = function (r) { - return en(this, void 0, void 0, function () { - var n, - i = this; - return tn(this, function (o) { - switch (o.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return o.sent(), [4, r]; - case 2: - return ( - (r = o.sent()), - (n = { transactionHash: this.formatter.hash(r, !0) }), - [ - 2, - (0, o7.poll)( - function () { - return en(i, void 0, void 0, function () { - var a, s, c, u; - return tn(this, function (h) { - switch (h.label) { - case 0: - return [ - 4, - this.perform("getTransaction", n), - ]; - case 1: - return ( - (a = h.sent()), - a == null - ? this._emitted["t:" + r] == null - ? [2, null] - : [2, void 0] - : ((s = - this.formatter.transactionResponse( - a - )), - s.blockNumber != null - ? [3, 2] - : ((s.confirmations = 0), [3, 4])) - ); - case 2: - return s.confirmations != null - ? [3, 4] - : [ - 4, - this._getInternalBlockNumber( - 100 + 2 * this.pollingInterval - ), - ]; - case 3: - (c = h.sent()), - (u = c - s.blockNumber + 1), - u <= 0 && (u = 1), - (s.confirmations = u), - (h.label = 4); - case 4: - return [2, this._wrapTransaction(s)]; - } - }); - }); - }, - { oncePoll: this } - ), - ] - ); - } - }); - }); - }), - (e.prototype.getTransactionReceipt = function (r) { - return en(this, void 0, void 0, function () { - var n, - i = this; - return tn(this, function (o) { - switch (o.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return o.sent(), [4, r]; - case 2: - return ( - (r = o.sent()), - (n = { transactionHash: this.formatter.hash(r, !0) }), - [ - 2, - (0, o7.poll)( - function () { - return en(i, void 0, void 0, function () { - var a, s, c, u; - return tn(this, function (h) { - switch (h.label) { - case 0: - return [ - 4, - this.perform("getTransactionReceipt", n), - ]; - case 1: - return ( - (a = h.sent()), - a == null - ? this._emitted["t:" + r] == null - ? [2, null] - : [2, void 0] - : a.blockHash == null - ? [2, void 0] - : ((s = this.formatter.receipt(a)), - s.blockNumber != null - ? [3, 2] - : ((s.confirmations = 0), [3, 4])) - ); - case 2: - return s.confirmations != null - ? [3, 4] - : [ - 4, - this._getInternalBlockNumber( - 100 + 2 * this.pollingInterval - ), - ]; - case 3: - (c = h.sent()), - (u = c - s.blockNumber + 1), - u <= 0 && (u = 1), - (s.confirmations = u), - (h.label = 4); - case 4: - return [2, s]; - } - }); - }); - }, - { oncePoll: this } - ), - ] - ); - } - }); - }); - }), - (e.prototype.getLogs = function (r) { - return en(this, void 0, void 0, function () { - var n, i; - return tn(this, function (o) { - switch (o.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return ( - o.sent(), - [ - 4, - (0, as.resolveProperties)({ - filter: this._getFilter(r), - }), - ] - ); - case 2: - return (n = o.sent()), [4, this.perform("getLogs", n)]; - case 3: - return ( - (i = o.sent()), - i.forEach(function (a) { - a.removed == null && (a.removed = !1); - }), - [ - 2, - idt.Formatter.arrayOf( - this.formatter.filterLog.bind(this.formatter) - )(i), - ] - ); - } - }); - }); - }), - (e.prototype.getEtherPrice = function () { - return en(this, void 0, void 0, function () { - return tn(this, function (r) { - switch (r.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return r.sent(), [2, this.perform("getEtherPrice", {})]; - } - }); - }); - }), - (e.prototype._getBlockTag = function (r) { - return en(this, void 0, void 0, function () { - var n; - return tn(this, function (i) { - switch (i.label) { - case 0: - return [4, r]; - case 1: - return ( - (r = i.sent()), - typeof r == "number" && r < 0 - ? (r % 1 && - Ln.throwArgumentError( - "invalid BlockTag", - "blockTag", - r - ), - [ - 4, - this._getInternalBlockNumber( - 100 + 2 * this.pollingInterval - ), - ]) - : [3, 3] - ); - case 2: - return ( - (n = i.sent()), - (n += r), - n < 0 && (n = 0), - [2, this.formatter.blockTag(n)] - ); - case 3: - return [2, this.formatter.blockTag(r)]; - } - }); - }); - }), - (e.prototype.getResolver = function (r) { - return en(this, void 0, void 0, function () { - var n, i, o, a; - return tn(this, function (s) { - switch (s.label) { - case 0: - (n = r), (s.label = 1); - case 1: - return n === "" || n === "." - ? [2, null] - : r !== "eth" && n === "eth" - ? [2, null] - : [4, this._getResolver(n, "getResolver")]; - case 2: - return ( - (i = s.sent()), - i == null - ? [3, 5] - : ((o = new xEe(this, i, r)), - (a = n !== r), - a ? [4, o.supportsWildcard()] : [3, 4]) - ); - case 3: - (a = !s.sent()), (s.label = 4); - case 4: - return a ? [2, null] : [2, o]; - case 5: - return (n = n.split(".").slice(1).join(".")), [3, 1]; - case 6: - return [2]; - } - }); - }); - }), - (e.prototype._getResolver = function (r, n) { - return en(this, void 0, void 0, function () { - var i, o, a; - return tn(this, function (s) { - switch (s.label) { - case 0: - return n == null && (n = "ENS"), [4, this.getNetwork()]; - case 1: - (i = s.sent()), - i.ensAddress || - Ln.throwError( - "network does not support ENS", - Qn.Logger.errors.UNSUPPORTED_OPERATION, - { operation: n, network: i.name } - ), - (s.label = 2); - case 2: - return ( - s.trys.push([2, 4, , 5]), - [ - 4, - this.call({ - to: i.ensAddress, - data: "0x0178b8bf" + (0, pK.namehash)(r).substring(2), - }), - ] - ); - case 3: - return (o = s.sent()), [2, this.formatter.callAddress(o)]; - case 4: - return (a = s.sent()), [3, 5]; - case 5: - return [2, null]; - } - }); - }); - }), - (e.prototype.resolveName = function (r) { - return en(this, void 0, void 0, function () { - var n; - return tn(this, function (i) { - switch (i.label) { - case 0: - return [4, r]; - case 1: - r = i.sent(); - try { - return [2, Promise.resolve(this.formatter.address(r))]; - } catch (o) { - if ((0, Wr.isHexString)(r)) throw o; - } - return ( - typeof r != "string" && - Ln.throwArgumentError("invalid ENS name", "name", r), - [4, this.getResolver(r)] - ); - case 2: - return (n = i.sent()), n ? [4, n.getAddress()] : [2, null]; - case 3: - return [2, i.sent()]; - } - }); - }); - }), - (e.prototype.lookupAddress = function (r) { - return en(this, void 0, void 0, function () { - var n, i, o, a, s; - return tn(this, function (c) { - switch (c.label) { - case 0: - return [4, r]; - case 1: - return ( - (r = c.sent()), - (r = this.formatter.address(r)), - (n = r.substring(2).toLowerCase() + ".addr.reverse"), - [4, this._getResolver(n, "lookupAddress")] - ); - case 2: - return ( - (i = c.sent()), - i == null - ? [2, null] - : ((a = Pne), - [ - 4, - this.call({ - to: i, - data: - "0x691f3431" + (0, pK.namehash)(n).substring(2), - }), - ]) - ); - case 3: - return ( - (o = a.apply(void 0, [c.sent(), 0])), - [4, this.resolveName(o)] - ); - case 4: - return (s = c.sent()), s != r ? [2, null] : [2, o]; - } - }); - }); - }), - (e.prototype.getAvatar = function (r) { - return en(this, void 0, void 0, function () { - var n, i, o, a, s, c, u, h, w, M; - return tn(this, function (k) { - switch (k.label) { - case 0: - return ( - (n = null), - (0, Wr.isHexString)(r) - ? ((i = this.formatter.address(r)), - (o = i.substring(2).toLowerCase() + ".addr.reverse"), - [4, this._getResolver(o, "getAvatar")]) - : [3, 10] - ); - case 1: - if (((a = k.sent()), !a)) return [2, null]; - (n = new xEe(this, a, o)), (k.label = 2); - case 2: - return k.trys.push([2, 4, , 5]), [4, n.getAvatar()]; - case 3: - return (s = k.sent()), s ? [2, s.url] : [3, 5]; - case 4: - if ( - ((c = k.sent()), - c.code !== Qn.Logger.errors.CALL_EXCEPTION) - ) - throw c; - return [3, 5]; - case 5: - return ( - k.trys.push([5, 8, , 9]), - (h = Pne), - [ - 4, - this.call({ - to: a, - data: "0x691f3431" + (0, pK.namehash)(o).substring(2), - }), - ] - ); - case 6: - return ( - (u = h.apply(void 0, [k.sent(), 0])), - [4, this.getResolver(u)] - ); - case 7: - return (n = k.sent()), [3, 9]; - case 8: - if ( - ((w = k.sent()), - w.code !== Qn.Logger.errors.CALL_EXCEPTION) - ) - throw w; - return [2, null]; - case 9: - return [3, 12]; - case 10: - return [4, this.getResolver(r)]; - case 11: - if (((n = k.sent()), !n)) return [2, null]; - k.label = 12; - case 12: - return [4, n.getAvatar()]; - case 13: - return (M = k.sent()), M == null ? [2, null] : [2, M.url]; - } - }); - }); - }), - (e.prototype.perform = function (r, n) { - return Ln.throwError( - r + " not implemented", - Qn.Logger.errors.NOT_IMPLEMENTED, - { operation: r } - ); - }), - (e.prototype._startEvent = function (r) { - this.polling = - this._events.filter(function (n) { - return n.pollable(); - }).length > 0; - }), - (e.prototype._stopEvent = function (r) { - this.polling = - this._events.filter(function (n) { - return n.pollable(); - }).length > 0; - }), - (e.prototype._addEventListener = function (r, n, i) { - var o = new ddt(i7(r), n, i); - return this._events.push(o), this._startEvent(o), this; - }), - (e.prototype.on = function (r, n) { - return this._addEventListener(r, n, !1); - }), - (e.prototype.once = function (r, n) { - return this._addEventListener(r, n, !0); - }), - (e.prototype.emit = function (r) { - for (var n = this, i = [], o = 1; o < arguments.length; o++) - i[o - 1] = arguments[o]; - var a = !1, - s = [], - c = i7(r); - return ( - (this._events = this._events.filter(function (u) { - return u.tag !== c - ? !0 - : (setTimeout(function () { - u.listener.apply(n, i); - }, 0), - (a = !0), - u.once ? (s.push(u), !1) : !0); - })), - s.forEach(function (u) { - n._stopEvent(u); - }), - a - ); - }), - (e.prototype.listenerCount = function (r) { - if (!r) return this._events.length; - var n = i7(r); - return this._events.filter(function (i) { - return i.tag === n; - }).length; - }), - (e.prototype.listeners = function (r) { - if (r == null) - return this._events.map(function (i) { - return i.listener; - }); - var n = i7(r); - return this._events - .filter(function (i) { - return i.tag === n; - }) - .map(function (i) { - return i.listener; - }); - }), - (e.prototype.off = function (r, n) { - var i = this; - if (n == null) return this.removeAllListeners(r); - var o = [], - a = !1, - s = i7(r); - return ( - (this._events = this._events.filter(function (c) { - return c.tag !== s || c.listener != n || a - ? !0 - : ((a = !0), o.push(c), !1); - })), - o.forEach(function (c) { - i._stopEvent(c); - }), - this - ); - }), - (e.prototype.removeAllListeners = function (r) { - var n = this, - i = []; - if (r == null) (i = this._events), (this._events = []); - else { - var o = i7(r); - this._events = this._events.filter(function (a) { - return a.tag !== o ? !0 : (i.push(a), !1); - }); - } - return ( - i.forEach(function (a) { - n._stopEvent(a); - }), - this - ); - }), - e - ); - })(fdt.Provider); - al.BaseProvider = cSr; - }); - var s7 = I((Uy) => { - "use strict"; - m(); - g(); - var EEe = - (Uy && Uy.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(), - xx = - (Uy && Uy.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - Sx = - (Uy && Uy.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(Uy, "__esModule", { value: !0 }); - Uy.JsonRpcProvider = Uy.JsonRpcSigner = void 0; - var lSr = r6(), - SEe = Ro(), - a7 = Ar(), - ydt = db(), - ss = $r(), - mdt = Eo(), - fSr = e0(), - vdt = r7(), - tu = rr(), - dSr = pc(), - Ms = new tu.Logger(dSr.version), - hSr = mK(), - pSr = ["call", "estimateGas"]; - function vK(t, e) { - if (t == null) return null; - if (typeof t.message == "string" && t.message.match("reverted")) { - var r = (0, a7.isHexString)(t.data) ? t.data : null; - if (!e || r) return { message: t.message, data: r }; - } - if (typeof t == "object") { - for (var n in t) { - var i = vK(t[n], e); - if (i) return i; - } - return null; - } - if (typeof t == "string") - try { - return vK(JSON.parse(t), e); - } catch {} - return null; - } - function bdt(t, e, r) { - var n = r.transaction || r.signedTransaction; - if (t === "call") { - var i = vK(e, !0); - if (i) return i.data; - Ms.throwError( - "missing revert data in call exception; Transaction reverted without a reason string", - tu.Logger.errors.CALL_EXCEPTION, - { data: "0x", transaction: n, error: e } - ); - } - if (t === "estimateGas") { - var i = vK(e.body, !1); - i == null && (i = vK(e, !1)), - i && - Ms.throwError( - "cannot estimate gas; transaction may fail or may require manual gas limit", - tu.Logger.errors.UNPREDICTABLE_GAS_LIMIT, - { reason: i.message, method: t, transaction: n, error: e } - ); - } - var o = e.message; - throw ( - (e.code === tu.Logger.errors.SERVER_ERROR && - e.error && - typeof e.error.message == "string" - ? (o = e.error.message) - : typeof e.body == "string" - ? (o = e.body) - : typeof e.responseText == "string" && (o = e.responseText), - (o = (o || "").toLowerCase()), - o.match( - /insufficient funds|base fee exceeds gas limit|InsufficientFunds/i - ) && - Ms.throwError( - "insufficient funds for intrinsic transaction cost", - tu.Logger.errors.INSUFFICIENT_FUNDS, - { error: e, method: t, transaction: n } - ), - o.match(/nonce (is )?too low/i) && - Ms.throwError( - "nonce has already been used", - tu.Logger.errors.NONCE_EXPIRED, - { error: e, method: t, transaction: n } - ), - o.match( - /replacement transaction underpriced|transaction gas price.*too low/i - ) && - Ms.throwError( - "replacement fee too low", - tu.Logger.errors.REPLACEMENT_UNDERPRICED, - { error: e, method: t, transaction: n } - ), - o.match(/only replay-protected/i) && - Ms.throwError( - "legacy pre-eip-155 transactions not supported", - tu.Logger.errors.UNSUPPORTED_OPERATION, - { error: e, method: t, transaction: n } - ), - pSr.indexOf(t) >= 0 && - o.match( - /gas required exceeds allowance|always failing transaction|execution reverted|revert/ - ) && - Ms.throwError( - "cannot estimate gas; transaction may fail or may require manual gas limit", - tu.Logger.errors.UNPREDICTABLE_GAS_LIMIT, - { error: e, method: t, transaction: n } - ), - e) - ); - } - function gdt(t) { - return new Promise(function (e) { - setTimeout(e, t); - }); - } - function ySr(t) { - if (t.error) { - var e = new Error(t.error.message); - throw ((e.code = t.error.code), (e.data = t.error.data), e); - } - return t.result; - } - function gK(t) { - return t && t.toLowerCase(); - } - var AEe = {}, - MEe = (function (t) { - EEe(e, t); - function e(r, n, i) { - var o = t.call(this) || this; - if (r !== AEe) - throw new Error( - "do not call the JsonRpcSigner constructor directly; use provider.getSigner" - ); - return ( - (0, ss.defineReadOnly)(o, "provider", n), - i == null && (i = 0), - typeof i == "string" - ? ((0, ss.defineReadOnly)( - o, - "_address", - o.provider.formatter.address(i) - ), - (0, ss.defineReadOnly)(o, "_index", null)) - : typeof i == "number" - ? ((0, ss.defineReadOnly)(o, "_index", i), - (0, ss.defineReadOnly)(o, "_address", null)) - : Ms.throwArgumentError( - "invalid address or index", - "addressOrIndex", - i - ), - o - ); - } - return ( - (e.prototype.connect = function (r) { - return Ms.throwError( - "cannot alter JSON-RPC Signer connection", - tu.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "connect" } - ); - }), - (e.prototype.connectUnchecked = function () { - return new mSr(AEe, this.provider, this._address || this._index); - }), - (e.prototype.getAddress = function () { - var r = this; - return this._address - ? Promise.resolve(this._address) - : this.provider.send("eth_accounts", []).then(function (n) { - return ( - n.length <= r._index && - Ms.throwError( - "unknown account #" + r._index, - tu.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "getAddress" } - ), - r.provider.formatter.address(n[r._index]) - ); - }); - }), - (e.prototype.sendUncheckedTransaction = function (r) { - var n = this; - r = (0, ss.shallowCopy)(r); - var i = this.getAddress().then(function (a) { - return a && (a = a.toLowerCase()), a; - }); - if (r.gasLimit == null) { - var o = (0, ss.shallowCopy)(r); - (o.from = i), (r.gasLimit = this.provider.estimateGas(o)); - } - return ( - r.to != null && - (r.to = Promise.resolve(r.to).then(function (a) { - return xx(n, void 0, void 0, function () { - var s; - return Sx(this, function (c) { - switch (c.label) { - case 0: - return a == null - ? [2, null] - : [4, this.provider.resolveName(a)]; - case 1: - return ( - (s = c.sent()), - s == null && - Ms.throwArgumentError( - "provided ENS name resolves to null", - "tx.to", - a - ), - [2, s] - ); - } - }); - }); - })), - (0, ss.resolveProperties)({ - tx: (0, ss.resolveProperties)(r), - sender: i, - }).then(function (a) { - var s = a.tx, - c = a.sender; - s.from != null - ? s.from.toLowerCase() !== c && - Ms.throwArgumentError( - "from address mismatch", - "transaction", - r - ) - : (s.from = c); - var u = n.provider.constructor.hexlifyTransaction(s, { - from: !0, - }); - return n.provider.send("eth_sendTransaction", [u]).then( - function (h) { - return h; - }, - function (h) { - return ( - typeof h.message == "string" && - h.message.match(/user denied/i) && - Ms.throwError( - "user rejected transaction", - tu.Logger.errors.ACTION_REJECTED, - { action: "sendTransaction", transaction: s } - ), - bdt("sendTransaction", h, u) - ); - } - ); - }) - ); - }), - (e.prototype.signTransaction = function (r) { - return Ms.throwError( - "signing transactions is unsupported", - tu.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "signTransaction" } - ); - }), - (e.prototype.sendTransaction = function (r) { - return xx(this, void 0, void 0, function () { - var n, - i, - o, - a = this; - return Sx(this, function (s) { - switch (s.label) { - case 0: - return [ - 4, - this.provider._getInternalBlockNumber( - 100 + 2 * this.provider.pollingInterval - ), - ]; - case 1: - return ( - (n = s.sent()), [4, this.sendUncheckedTransaction(r)] - ); - case 2: - (i = s.sent()), (s.label = 3); - case 3: - return ( - s.trys.push([3, 5, , 6]), - [ - 4, - (0, vdt.poll)( - function () { - return xx(a, void 0, void 0, function () { - var c; - return Sx(this, function (u) { - switch (u.label) { - case 0: - return [4, this.provider.getTransaction(i)]; - case 1: - return ( - (c = u.sent()), - c === null - ? [2, void 0] - : [ - 2, - this.provider._wrapTransaction( - c, - i, - n - ), - ] - ); - } - }); - }); - }, - { oncePoll: this.provider } - ), - ] - ); - case 4: - return [2, s.sent()]; - case 5: - throw ((o = s.sent()), (o.transactionHash = i), o); - case 6: - return [2]; - } - }); - }); - }), - (e.prototype.signMessage = function (r) { - return xx(this, void 0, void 0, function () { - var n, i, o; - return Sx(this, function (a) { - switch (a.label) { - case 0: - return ( - (n = typeof r == "string" ? (0, mdt.toUtf8Bytes)(r) : r), - [4, this.getAddress()] - ); - case 1: - (i = a.sent()), (a.label = 2); - case 2: - return ( - a.trys.push([2, 4, , 5]), - [ - 4, - this.provider.send("personal_sign", [ - (0, a7.hexlify)(n), - i.toLowerCase(), - ]), - ] - ); - case 3: - return [2, a.sent()]; - case 4: - throw ( - ((o = a.sent()), - typeof o.message == "string" && - o.message.match(/user denied/i) && - Ms.throwError( - "user rejected signing", - tu.Logger.errors.ACTION_REJECTED, - { action: "signMessage", from: i, messageData: r } - ), - o) - ); - case 5: - return [2]; - } - }); - }); - }), - (e.prototype._legacySignMessage = function (r) { - return xx(this, void 0, void 0, function () { - var n, i, o; - return Sx(this, function (a) { - switch (a.label) { - case 0: - return ( - (n = typeof r == "string" ? (0, mdt.toUtf8Bytes)(r) : r), - [4, this.getAddress()] - ); - case 1: - (i = a.sent()), (a.label = 2); - case 2: - return ( - a.trys.push([2, 4, , 5]), - [ - 4, - this.provider.send("eth_sign", [ - i.toLowerCase(), - (0, a7.hexlify)(n), - ]), - ] - ); - case 3: - return [2, a.sent()]; - case 4: - throw ( - ((o = a.sent()), - typeof o.message == "string" && - o.message.match(/user denied/i) && - Ms.throwError( - "user rejected signing", - tu.Logger.errors.ACTION_REJECTED, - { - action: "_legacySignMessage", - from: i, - messageData: r, - } - ), - o) - ); - case 5: - return [2]; - } - }); - }); - }), - (e.prototype._signTypedData = function (r, n, i) { - return xx(this, void 0, void 0, function () { - var o, - a, - s, - c = this; - return Sx(this, function (u) { - switch (u.label) { - case 0: - return [ - 4, - ydt._TypedDataEncoder.resolveNames(r, n, i, function (h) { - return c.provider.resolveName(h); - }), - ]; - case 1: - return (o = u.sent()), [4, this.getAddress()]; - case 2: - (a = u.sent()), (u.label = 3); - case 3: - return ( - u.trys.push([3, 5, , 6]), - [ - 4, - this.provider.send("eth_signTypedData_v4", [ - a.toLowerCase(), - JSON.stringify( - ydt._TypedDataEncoder.getPayload( - o.domain, - n, - o.value - ) - ), - ]), - ] - ); - case 4: - return [2, u.sent()]; - case 5: - throw ( - ((s = u.sent()), - typeof s.message == "string" && - s.message.match(/user denied/i) && - Ms.throwError( - "user rejected signing", - tu.Logger.errors.ACTION_REJECTED, - { - action: "_signTypedData", - from: a, - messageData: { - domain: o.domain, - types: n, - value: o.value, - }, - } - ), - s) - ); - case 6: - return [2]; - } - }); - }); - }), - (e.prototype.unlock = function (r) { - return xx(this, void 0, void 0, function () { - var n, i; - return Sx(this, function (o) { - switch (o.label) { - case 0: - return (n = this.provider), [4, this.getAddress()]; - case 1: - return ( - (i = o.sent()), - [ - 2, - n.send("personal_unlockAccount", [ - i.toLowerCase(), - r, - null, - ]), - ] - ); - } - }); - }); - }), - e - ); - })(lSr.Signer); - Uy.JsonRpcSigner = MEe; - var mSr = (function (t) { - EEe(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.prototype.sendTransaction = function (r) { - var n = this; - return this.sendUncheckedTransaction(r).then(function (i) { - return { - hash: i, - nonce: null, - gasLimit: null, - gasPrice: null, - data: null, - value: null, - chainId: null, - confirmations: 0, - from: null, - wait: function (o) { - return n.provider.waitForTransaction(i, o); - }, - }; - }); - }), - e - ); - })(MEe), - gSr = { - chainId: !0, - data: !0, - gasLimit: !0, - gasPrice: !0, - nonce: !0, - to: !0, - value: !0, - type: !0, - accessList: !0, - maxFeePerGas: !0, - maxPriorityFeePerGas: !0, - }, - vSr = (function (t) { - EEe(e, t); - function e(r, n) { - var i = this, - o = n; - return ( - o == null && - (o = new Promise(function (a, s) { - setTimeout(function () { - i.detectNetwork().then( - function (c) { - a(c); - }, - function (c) { - s(c); - } - ); - }, 0); - })), - (i = t.call(this, o) || this), - r || (r = (0, ss.getStatic)(i.constructor, "defaultUrl")()), - typeof r == "string" - ? (0, ss.defineReadOnly)( - i, - "connection", - Object.freeze({ url: r }) - ) - : (0, ss.defineReadOnly)( - i, - "connection", - Object.freeze((0, ss.shallowCopy)(r)) - ), - (i._nextId = 42), - i - ); - } - return ( - Object.defineProperty(e.prototype, "_cache", { - get: function () { - return ( - this._eventLoopCache == null && (this._eventLoopCache = {}), - this._eventLoopCache - ); - }, - enumerable: !1, - configurable: !0, - }), - (e.defaultUrl = function () { - return "http://localhost:8545"; - }), - (e.prototype.detectNetwork = function () { - var r = this; - return ( - this._cache.detectNetwork || - ((this._cache.detectNetwork = this._uncachedDetectNetwork()), - setTimeout(function () { - r._cache.detectNetwork = null; - }, 0)), - this._cache.detectNetwork - ); - }), - (e.prototype._uncachedDetectNetwork = function () { - return xx(this, void 0, void 0, function () { - var r, n, i, o; - return Sx(this, function (a) { - switch (a.label) { - case 0: - return [4, gdt(0)]; - case 1: - a.sent(), (r = null), (a.label = 2); - case 2: - return ( - a.trys.push([2, 4, , 9]), - [4, this.send("eth_chainId", [])] - ); - case 3: - return (r = a.sent()), [3, 9]; - case 4: - (n = a.sent()), (a.label = 5); - case 5: - return ( - a.trys.push([5, 7, , 8]), - [4, this.send("net_version", [])] - ); - case 6: - return (r = a.sent()), [3, 8]; - case 7: - return (i = a.sent()), [3, 8]; - case 8: - return [3, 9]; - case 9: - if (r != null) { - o = (0, ss.getStatic)(this.constructor, "getNetwork"); - try { - return [2, o(SEe.BigNumber.from(r).toNumber())]; - } catch (s) { - return [ - 2, - Ms.throwError( - "could not detect network", - tu.Logger.errors.NETWORK_ERROR, - { - chainId: r, - event: "invalidNetwork", - serverError: s, - } - ), - ]; - } - } - return [ - 2, - Ms.throwError( - "could not detect network", - tu.Logger.errors.NETWORK_ERROR, - { event: "noNetwork" } - ), - ]; - } - }); - }); - }), - (e.prototype.getSigner = function (r) { - return new MEe(AEe, this, r); - }), - (e.prototype.getUncheckedSigner = function (r) { - return this.getSigner(r).connectUnchecked(); - }), - (e.prototype.listAccounts = function () { - var r = this; - return this.send("eth_accounts", []).then(function (n) { - return n.map(function (i) { - return r.formatter.address(i); - }); - }); - }), - (e.prototype.send = function (r, n) { - var i = this, - o = { method: r, params: n, id: this._nextId++, jsonrpc: "2.0" }; - this.emit("debug", { - action: "request", - request: (0, ss.deepCopy)(o), - provider: this, - }); - var a = ["eth_chainId", "eth_blockNumber"].indexOf(r) >= 0; - if (a && this._cache[r]) return this._cache[r]; - var s = (0, vdt.fetchJson)( - this.connection, - JSON.stringify(o), - ySr - ).then( - function (c) { - return ( - i.emit("debug", { - action: "response", - request: o, - response: c, - provider: i, - }), - c - ); - }, - function (c) { - throw ( - (i.emit("debug", { - action: "response", - error: c, - request: o, - provider: i, - }), - c) - ); - } - ); - return ( - a && - ((this._cache[r] = s), - setTimeout(function () { - i._cache[r] = null; - }, 0)), - s - ); - }), - (e.prototype.prepareRequest = function (r, n) { - switch (r) { - case "getBlockNumber": - return ["eth_blockNumber", []]; - case "getGasPrice": - return ["eth_gasPrice", []]; - case "getBalance": - return ["eth_getBalance", [gK(n.address), n.blockTag]]; - case "getTransactionCount": - return ["eth_getTransactionCount", [gK(n.address), n.blockTag]]; - case "getCode": - return ["eth_getCode", [gK(n.address), n.blockTag]]; - case "getStorageAt": - return [ - "eth_getStorageAt", - [ - gK(n.address), - (0, a7.hexZeroPad)(n.position, 32), - n.blockTag, - ], - ]; - case "sendTransaction": - return ["eth_sendRawTransaction", [n.signedTransaction]]; - case "getBlock": - return n.blockTag - ? [ - "eth_getBlockByNumber", - [n.blockTag, !!n.includeTransactions], - ] - : n.blockHash - ? [ - "eth_getBlockByHash", - [n.blockHash, !!n.includeTransactions], - ] - : null; - case "getTransaction": - return ["eth_getTransactionByHash", [n.transactionHash]]; - case "getTransactionReceipt": - return ["eth_getTransactionReceipt", [n.transactionHash]]; - case "call": { - var i = (0, ss.getStatic)( - this.constructor, - "hexlifyTransaction" - ); - return [ - "eth_call", - [i(n.transaction, { from: !0 }), n.blockTag], - ]; - } - case "estimateGas": { - var i = (0, ss.getStatic)( - this.constructor, - "hexlifyTransaction" - ); - return ["eth_estimateGas", [i(n.transaction, { from: !0 })]]; - } - case "getLogs": - return ( - n.filter && - n.filter.address != null && - (n.filter.address = gK(n.filter.address)), - ["eth_getLogs", [n.filter]] - ); - default: - break; - } - return null; - }), - (e.prototype.perform = function (r, n) { - return xx(this, void 0, void 0, function () { - var i, o, a, s; - return Sx(this, function (c) { - switch (c.label) { - case 0: - return r === "call" || r === "estimateGas" - ? ((i = n.transaction), - i && - i.type != null && - SEe.BigNumber.from(i.type).isZero() - ? i.maxFeePerGas == null && - i.maxPriorityFeePerGas == null - ? [4, this.getFeeData()] - : [3, 2] - : [3, 2]) - : [3, 2]; - case 1: - (o = c.sent()), - o.maxFeePerGas == null && - o.maxPriorityFeePerGas == null && - ((n = (0, ss.shallowCopy)(n)), - (n.transaction = (0, ss.shallowCopy)(i)), - delete n.transaction.type), - (c.label = 2); - case 2: - (a = this.prepareRequest(r, n)), - a == null && - Ms.throwError( - r + " not implemented", - tu.Logger.errors.NOT_IMPLEMENTED, - { operation: r } - ), - (c.label = 3); - case 3: - return c.trys.push([3, 5, , 6]), [4, this.send(a[0], a[1])]; - case 4: - return [2, c.sent()]; - case 5: - return (s = c.sent()), [2, bdt(r, s, n)]; - case 6: - return [2]; - } - }); - }); - }), - (e.prototype._startEvent = function (r) { - r.tag === "pending" && this._startPending(), - t.prototype._startEvent.call(this, r); - }), - (e.prototype._startPending = function () { - if (this._pendingFilter == null) { - var r = this, - n = this.send("eth_newPendingTransactionFilter", []); - (this._pendingFilter = n), - n - .then(function (i) { - function o() { - r.send("eth_getFilterChanges", [i]) - .then(function (a) { - if (r._pendingFilter != n) return null; - var s = Promise.resolve(); - return ( - a.forEach(function (c) { - (r._emitted["t:" + c.toLowerCase()] = "pending"), - (s = s.then(function () { - return r.getTransaction(c).then(function (u) { - return r.emit("pending", u), null; - }); - })); - }), - s.then(function () { - return gdt(1e3); - }) - ); - }) - .then(function () { - if (r._pendingFilter != n) { - r.send("eth_uninstallFilter", [i]); - return; - } - return ( - setTimeout(function () { - o(); - }, 0), - null - ); - }) - .catch(function (a) {}); - } - return o(), i; - }) - .catch(function (i) {}); - } - }), - (e.prototype._stopEvent = function (r) { - r.tag === "pending" && - this.listenerCount("pending") === 0 && - (this._pendingFilter = null), - t.prototype._stopEvent.call(this, r); - }), - (e.hexlifyTransaction = function (r, n) { - var i = (0, ss.shallowCopy)(gSr); - if (n) for (var o in n) n[o] && (i[o] = !0); - (0, ss.checkProperties)(r, i); - var a = {}; - return ( - [ - "chainId", - "gasLimit", - "gasPrice", - "type", - "maxFeePerGas", - "maxPriorityFeePerGas", - "nonce", - "value", - ].forEach(function (s) { - if (r[s] != null) { - var c = (0, a7.hexValue)(SEe.BigNumber.from(r[s])); - s === "gasLimit" && (s = "gas"), (a[s] = c); - } - }), - ["from", "to", "data"].forEach(function (s) { - r[s] != null && (a[s] = (0, a7.hexlify)(r[s])); - }), - r.accessList && - (a.accessList = (0, fSr.accessListify)(r.accessList)), - a - ); - }), - e - ); - })(hSr.BaseProvider); - Uy.JsonRpcProvider = vSr; - }); - var xdt = I((u7) => { - "use strict"; - m(); - g(); - Object.defineProperty(u7, "__esModule", { value: !0 }); - u7.WebSocket = void 0; - var wdt = rr(), - bSr = pc(), - One = null; - u7.WebSocket = One; - try { - if (((u7.WebSocket = One = WebSocket), One == null)) - throw new Error("inject please"); - } catch { - (_dt = new wdt.Logger(bSr.version)), - (u7.WebSocket = One = - function () { - _dt.throwError( - "WebSockets not supported in this environment", - wdt.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "new WebSocket()" } - ); - }); - } - var _dt; - }); - var Ine = I((_b) => { - "use strict"; - m(); - g(); - var wSr = - (_b && _b.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(), - TEe = - (_b && _b.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - kEe = - (_b && _b.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(_b, "__esModule", { value: !0 }); - _b.WebSocketProvider = void 0; - var _Sr = Ro(), - VA = $r(), - xSr = s7(), - Sdt = xdt(), - bK = rr(), - SSr = pc(), - Bne = new bK.Logger(SSr.version), - ASr = 1, - ESr = (function (t) { - wSr(e, t); - function e(r, n) { - var i = this; - n === "any" && - Bne.throwError( - "WebSocketProvider does not support 'any' network yet", - bK.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "network:any" } - ), - typeof r == "string" - ? (i = t.call(this, r, n) || this) - : (i = t.call(this, "_websocket", n) || this), - (i._pollingInterval = -1), - (i._wsReady = !1), - typeof r == "string" - ? (0, VA.defineReadOnly)( - i, - "_websocket", - new Sdt.WebSocket(i.connection.url) - ) - : (0, VA.defineReadOnly)(i, "_websocket", r), - (0, VA.defineReadOnly)(i, "_requests", {}), - (0, VA.defineReadOnly)(i, "_subs", {}), - (0, VA.defineReadOnly)(i, "_subIds", {}), - (0, VA.defineReadOnly)( - i, - "_detectNetwork", - t.prototype.detectNetwork.call(i) - ), - (i.websocket.onopen = function () { - (i._wsReady = !0), - Object.keys(i._requests).forEach(function (a) { - i.websocket.send(i._requests[a].payload); - }); - }), - (i.websocket.onmessage = function (a) { - var s = a.data, - c = JSON.parse(s); - if (c.id != null) { - var u = String(c.id), - h = i._requests[u]; - if ((delete i._requests[u], c.result !== void 0)) - h.callback(null, c.result), - i.emit("debug", { - action: "response", - request: JSON.parse(h.payload), - response: c.result, - provider: i, - }); - else { - var w = null; - c.error - ? ((w = new Error(c.error.message || "unknown error")), - (0, VA.defineReadOnly)(w, "code", c.error.code || null), - (0, VA.defineReadOnly)(w, "response", s)) - : (w = new Error("unknown error")), - h.callback(w, void 0), - i.emit("debug", { - action: "response", - error: w, - request: JSON.parse(h.payload), - provider: i, - }); - } - } else if (c.method === "eth_subscription") { - var M = i._subs[c.params.subscription]; - M && M.processFunc(c.params.result); - } else console.warn("this should not happen"); - }); - var o = setInterval(function () { - i.emit("poll"); - }, 1e3); - return o.unref && o.unref(), i; - } - return ( - Object.defineProperty(e.prototype, "websocket", { - get: function () { - return this._websocket; - }, - enumerable: !1, - configurable: !0, - }), - (e.prototype.detectNetwork = function () { - return this._detectNetwork; - }), - Object.defineProperty(e.prototype, "pollingInterval", { - get: function () { - return 0; - }, - set: function (r) { - Bne.throwError( - "cannot set polling interval on WebSocketProvider", - bK.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "setPollingInterval" } - ); - }, - enumerable: !1, - configurable: !0, - }), - (e.prototype.resetEventsBlock = function (r) { - Bne.throwError( - "cannot reset events block on WebSocketProvider", - bK.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "resetEventBlock" } - ); - }), - (e.prototype.poll = function () { - return TEe(this, void 0, void 0, function () { - return kEe(this, function (r) { - return [2, null]; - }); - }); - }), - Object.defineProperty(e.prototype, "polling", { - set: function (r) { - !r || - Bne.throwError( - "cannot set polling on WebSocketProvider", - bK.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "setPolling" } - ); - }, - enumerable: !1, - configurable: !0, - }), - (e.prototype.send = function (r, n) { - var i = this, - o = ASr++; - return new Promise(function (a, s) { - function c(h, w) { - return h ? s(h) : a(w); - } - var u = JSON.stringify({ - method: r, - params: n, - id: o, - jsonrpc: "2.0", - }); - i.emit("debug", { - action: "request", - request: JSON.parse(u), - provider: i, - }), - (i._requests[String(o)] = { callback: c, payload: u }), - i._wsReady && i.websocket.send(u); - }); - }), - (e.defaultUrl = function () { - return "ws://localhost:8546"; - }), - (e.prototype._subscribe = function (r, n, i) { - return TEe(this, void 0, void 0, function () { - var o, - a, - s = this; - return kEe(this, function (c) { - switch (c.label) { - case 0: - return ( - (o = this._subIds[r]), - o == null && - ((o = Promise.all(n).then(function (u) { - return s.send("eth_subscribe", u); - })), - (this._subIds[r] = o)), - [4, o] - ); - case 1: - return ( - (a = c.sent()), - (this._subs[a] = { tag: r, processFunc: i }), - [2] - ); - } - }); - }); - }), - (e.prototype._startEvent = function (r) { - var n = this; - switch (r.type) { - case "block": - this._subscribe("block", ["newHeads"], function (o) { - var a = _Sr.BigNumber.from(o.number).toNumber(); - (n._emitted.block = a), n.emit("block", a); - }); - break; - case "pending": - this._subscribe( - "pending", - ["newPendingTransactions"], - function (o) { - n.emit("pending", o); - } - ); - break; - case "filter": - this._subscribe( - r.tag, - ["logs", this._getFilter(r.filter)], - function (o) { - o.removed == null && (o.removed = !1), - n.emit(r.filter, n.formatter.filterLog(o)); - } - ); - break; - case "tx": { - var i = function (o) { - var a = o.hash; - n.getTransactionReceipt(a).then(function (s) { - !s || n.emit(a, s); - }); - }; - i(r), - this._subscribe("tx", ["newHeads"], function (o) { - n._events - .filter(function (a) { - return a.type === "tx"; - }) - .forEach(i); - }); - break; - } - case "debug": - case "poll": - case "willPoll": - case "didPoll": - case "error": - break; - default: - console.log("unhandled:", r); - break; - } - }), - (e.prototype._stopEvent = function (r) { - var n = this, - i = r.tag; - if (r.type === "tx") { - if ( - this._events.filter(function (a) { - return a.type === "tx"; - }).length - ) - return; - i = "tx"; - } else if (this.listenerCount(r.event)) return; - var o = this._subIds[i]; - !o || - (delete this._subIds[i], - o.then(function (a) { - !n._subs[a] || - (delete n._subs[a], n.send("eth_unsubscribe", [a])); - })); - }), - (e.prototype.destroy = function () { - return TEe(this, void 0, void 0, function () { - var r = this; - return kEe(this, function (n) { - switch (n.label) { - case 0: - return this.websocket.readyState !== - Sdt.WebSocket.CONNECTING - ? [3, 2] - : [ - 4, - new Promise(function (i) { - (r.websocket.onopen = function () { - i(!0); - }), - (r.websocket.onerror = function () { - i(!1); - }); - }), - ]; - case 1: - n.sent(), (n.label = 2); - case 2: - return this.websocket.close(1e3), [2]; - } - }); - }); - }), - e - ); - })(xSr.JsonRpcProvider); - _b.WebSocketProvider = ESr; - }); - var WA = I((Ky) => { - "use strict"; - m(); - g(); - var Adt = - (Ky && Ky.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(), - MSr = - (Ky && Ky.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - TSr = - (Ky && Ky.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(Ky, "__esModule", { value: !0 }); - Ky.UrlJsonRpcProvider = Ky.StaticJsonRpcProvider = void 0; - var c7 = $r(), - Cne = rr(), - kSr = pc(), - wK = new Cne.Logger(kSr.version), - PSr = s7(), - Edt = (function (t) { - Adt(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.prototype.detectNetwork = function () { - return MSr(this, void 0, void 0, function () { - var r; - return TSr(this, function (n) { - switch (n.label) { - case 0: - return ( - (r = this.network), - r != null - ? [3, 2] - : [4, t.prototype.detectNetwork.call(this)] - ); - case 1: - (r = n.sent()), - r || - wK.throwError( - "no network detected", - Cne.Logger.errors.UNKNOWN_ERROR, - {} - ), - this._network == null && - ((0, c7.defineReadOnly)(this, "_network", r), - this.emit("network", r, null)), - (n.label = 2); - case 2: - return [2, r]; - } - }); - }); - }), - e - ); - })(PSr.JsonRpcProvider); - Ky.StaticJsonRpcProvider = Edt; - var OSr = (function (t) { - Adt(e, t); - function e(r, n) { - var i = this.constructor, - o = this; - wK.checkAbstract(i, e), - (r = (0, c7.getStatic)(i, "getNetwork")(r)), - (n = (0, c7.getStatic)(i, "getApiKey")(n)); - var a = (0, c7.getStatic)(i, "getUrl")(r, n); - return ( - (o = t.call(this, a, r) || this), - typeof n == "string" - ? (0, c7.defineReadOnly)(o, "apiKey", n) - : n != null && - Object.keys(n).forEach(function (s) { - (0, c7.defineReadOnly)(o, s, n[s]); - }), - o - ); - } - return ( - (e.prototype._startPending = function () { - wK.warn("WARNING: API provider does not support pending filters"); - }), - (e.prototype.isCommunityResource = function () { - return !1; - }), - (e.prototype.getSigner = function (r) { - return wK.throwError( - "API provider does not support signing", - Cne.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "getSigner" } - ); - }), - (e.prototype.listAccounts = function () { - return Promise.resolve([]); - }), - (e.getApiKey = function (r) { - return r; - }), - (e.getUrl = function (r, n) { - return wK.throwError( - "not implemented; sub-classes must override getUrl", - Cne.Logger.errors.NOT_IMPLEMENTED, - { operation: "getUrl" } - ); - }), - e - ); - })(Edt); - Ky.UrlJsonRpcProvider = OSr; - }); - var Odt = I((GA) => { - "use strict"; - m(); - g(); - var Tdt = - (GA && GA.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(GA, "__esModule", { value: !0 }); - GA.AlchemyProvider = GA.AlchemyWebSocketProvider = void 0; - var BSr = $r(), - ISr = HA(), - CSr = Ine(), - RSr = rr(), - NSr = pc(), - Mdt = new RSr.Logger(NSr.version), - DSr = WA(), - Rne = "_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC", - kdt = (function (t) { - Tdt(e, t); - function e(r, n) { - var i = this, - o = new Pdt(r, n), - a = o.connection.url - .replace(/^http/i, "ws") - .replace(".alchemyapi.", ".ws.alchemyapi."); - return ( - (i = t.call(this, a, o.network) || this), - (0, BSr.defineReadOnly)(i, "apiKey", o.apiKey), - i - ); - } - return ( - (e.prototype.isCommunityResource = function () { - return this.apiKey === Rne; - }), - e - ); - })(CSr.WebSocketProvider); - GA.AlchemyWebSocketProvider = kdt; - var Pdt = (function (t) { - Tdt(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.getWebSocketProvider = function (r, n) { - return new kdt(r, n); - }), - (e.getApiKey = function (r) { - return r == null - ? Rne - : (r && - typeof r != "string" && - Mdt.throwArgumentError("invalid apiKey", "apiKey", r), - r); - }), - (e.getUrl = function (r, n) { - var i = null; - switch (r.name) { - case "homestead": - i = "eth-mainnet.alchemyapi.io/v2/"; - break; - case "goerli": - i = "eth-goerli.g.alchemy.com/v2/"; - break; - case "matic": - i = "polygon-mainnet.g.alchemy.com/v2/"; - break; - case "maticmum": - i = "polygon-mumbai.g.alchemy.com/v2/"; - break; - case "arbitrum": - i = "arb-mainnet.g.alchemy.com/v2/"; - break; - case "arbitrum-goerli": - i = "arb-goerli.g.alchemy.com/v2/"; - break; - case "optimism": - i = "opt-mainnet.g.alchemy.com/v2/"; - break; - case "optimism-goerli": - i = "opt-goerli.g.alchemy.com/v2/"; - break; - default: - Mdt.throwArgumentError( - "unsupported network", - "network", - arguments[0] - ); - } - return { - allowGzip: !0, - url: "https://" + i + n, - throttleCallback: function (o, a) { - return ( - n === Rne && (0, ISr.showThrottleMessage)(), Promise.resolve(!0) - ); - }, - }; - }), - (e.prototype.isCommunityResource = function () { - return this.apiKey === Rne; - }), - e - ); - })(DSr.UrlJsonRpcProvider); - GA.AlchemyProvider = Pdt; - }); - var Bdt = I((l7) => { - "use strict"; - m(); - g(); - var FSr = - (l7 && l7.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(l7, "__esModule", { value: !0 }); - l7.AnkrProvider = void 0; - var LSr = HA(), - qSr = WA(), - zSr = rr(), - jSr = pc(), - USr = new zSr.Logger(jSr.version), - Nne = "9f7d929b018cdffb338517efa06f58359e86ff1ffd350bc889738523659e7972"; - function KSr(t) { - switch (t) { - case "homestead": - return "rpc.ankr.com/eth/"; - case "ropsten": - return "rpc.ankr.com/eth_ropsten/"; - case "rinkeby": - return "rpc.ankr.com/eth_rinkeby/"; - case "goerli": - return "rpc.ankr.com/eth_goerli/"; - case "matic": - return "rpc.ankr.com/polygon/"; - case "arbitrum": - return "rpc.ankr.com/arbitrum/"; - } - return USr.throwArgumentError("unsupported network", "name", t); - } - var HSr = (function (t) { - FSr(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.prototype.isCommunityResource = function () { - return this.apiKey === Nne; - }), - (e.getApiKey = function (r) { - return r ?? Nne; - }), - (e.getUrl = function (r, n) { - n == null && (n = Nne); - var i = { - allowGzip: !0, - url: "https://" + KSr(r.name) + n, - throttleCallback: function (o, a) { - return ( - n.apiKey === Nne && (0, LSr.showThrottleMessage)(), - Promise.resolve(!0) - ); - }, - }; - return ( - n.projectSecret != null && - ((i.user = ""), (i.password = n.projectSecret)), - i - ); - }), - e - ); - })(qSr.UrlJsonRpcProvider); - l7.AnkrProvider = HSr; - }); - var Cdt = I((xb) => { - "use strict"; - m(); - g(); - var VSr = - (xb && xb.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(), - WSr = - (xb && xb.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - GSr = - (xb && xb.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(xb, "__esModule", { value: !0 }); - xb.CloudflareProvider = void 0; - var JSr = WA(), - $Sr = rr(), - ZSr = pc(), - Idt = new $Sr.Logger(ZSr.version), - XSr = (function (t) { - VSr(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.getApiKey = function (r) { - return ( - r != null && - Idt.throwArgumentError( - "apiKey not supported for cloudflare", - "apiKey", - r - ), - null - ); - }), - (e.getUrl = function (r, n) { - var i = null; - switch (r.name) { - case "homestead": - i = "https://cloudflare-eth.com/"; - break; - default: - Idt.throwArgumentError( - "unsupported network", - "network", - arguments[0] - ); - } - return i; - }), - (e.prototype.perform = function (r, n) { - return WSr(this, void 0, void 0, function () { - var i; - return GSr(this, function (o) { - switch (o.label) { - case 0: - return r !== "getBlockNumber" - ? [3, 2] - : [ - 4, - t.prototype.perform.call(this, "getBlock", { - blockTag: "latest", - }), - ]; - case 1: - return (i = o.sent()), [2, i.number]; - case 2: - return [2, t.prototype.perform.call(this, r, n)]; - } - }); - }); - }), - e - ); - })(JSr.UrlJsonRpcProvider); - xb.CloudflareProvider = XSr; - }); - var Fdt = I((Ab) => { - "use strict"; - m(); - g(); - var YSr = - (Ab && Ab.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(), - Dne = - (Ab && Ab.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - Fne = - (Ab && Ab.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(Ab, "__esModule", { value: !0 }); - Ab.EtherscanProvider = void 0; - var Lne = Ar(), - PEe = $r(), - QSr = e0(), - e2r = r7(), - t2r = HA(), - Sb = rr(), - r2r = pc(), - JA = new Sb.Logger(r2r.version), - n2r = mK(); - function Rdt(t) { - var e = {}; - for (var r in t) - if (t[r] != null) { - var n = t[r]; - (r === "type" && n === 0) || - ({ - type: !0, - gasLimit: !0, - gasPrice: !0, - maxFeePerGs: !0, - maxPriorityFeePerGas: !0, - nonce: !0, - value: !0, - }[r] - ? (n = (0, Lne.hexValue)((0, Lne.hexlify)(n))) - : r === "accessList" - ? (n = - "[" + - (0, QSr.accessListify)(n) - .map(function (i) { - return ( - '{address:"' + - i.address + - '",storageKeys:["' + - i.storageKeys.join('","') + - '"]}' - ); - }) - .join(",") + - "]") - : (n = (0, Lne.hexlify)(n)), - (e[r] = n)); - } - return e; - } - function i2r(t) { - if ( - t.status == 0 && - (t.message === "No records found" || - t.message === "No transactions found") - ) - return t.result; - if ( - t.status != 1 || - typeof t.message != "string" || - !t.message.match(/^OK/) - ) { - var e = new Error("invalid response"); - throw ( - ((e.result = JSON.stringify(t)), - (t.result || "").toLowerCase().indexOf("rate limit") >= 0 && - (e.throttleRetry = !0), - e) - ); - } - return t.result; - } - function Ndt(t) { - if ( - t && - t.status == 0 && - t.message == "NOTOK" && - (t.result || "").toLowerCase().indexOf("rate limit") >= 0 - ) { - var e = new Error("throttled response"); - throw ((e.result = JSON.stringify(t)), (e.throttleRetry = !0), e); - } - if (t.jsonrpc != "2.0") { - var e = new Error("invalid response"); - throw ((e.result = JSON.stringify(t)), e); - } - if (t.error) { - var e = new Error(t.error.message || "unknown error"); - throw ( - (t.error.code && (e.code = t.error.code), - t.error.data && (e.data = t.error.data), - e) - ); - } - return t.result; - } - function Ddt(t) { - if (t === "pending") throw new Error("pending not supported"); - return t === "latest" ? t : parseInt(t.substring(2), 16); - } - function OEe(t, e, r) { - if (t === "call" && e.code === Sb.Logger.errors.SERVER_ERROR) { - var n = e.error; - if ( - n && - (n.message.match(/reverted/i) || - n.message.match(/VM execution error/i)) - ) { - var i = n.data; - if ( - (i && (i = "0x" + i.replace(/^.*0x/i, "")), (0, Lne.isHexString)(i)) - ) - return i; - JA.throwError( - "missing revert data in call exception", - Sb.Logger.errors.CALL_EXCEPTION, - { error: e, data: "0x" } - ); - } - } - var o = e.message; - throw ( - (e.code === Sb.Logger.errors.SERVER_ERROR && - (e.error && typeof e.error.message == "string" - ? (o = e.error.message) - : typeof e.body == "string" - ? (o = e.body) - : typeof e.responseText == "string" && (o = e.responseText)), - (o = (o || "").toLowerCase()), - o.match(/insufficient funds/) && - JA.throwError( - "insufficient funds for intrinsic transaction cost", - Sb.Logger.errors.INSUFFICIENT_FUNDS, - { error: e, method: t, transaction: r } - ), - o.match( - /same hash was already imported|transaction nonce is too low|nonce too low/ - ) && - JA.throwError( - "nonce has already been used", - Sb.Logger.errors.NONCE_EXPIRED, - { error: e, method: t, transaction: r } - ), - o.match(/another transaction with same nonce/) && - JA.throwError( - "replacement fee too low", - Sb.Logger.errors.REPLACEMENT_UNDERPRICED, - { error: e, method: t, transaction: r } - ), - o.match(/execution failed due to an exception|execution reverted/) && - JA.throwError( - "cannot estimate gas; transaction may fail or may require manual gas limit", - Sb.Logger.errors.UNPREDICTABLE_GAS_LIMIT, - { error: e, method: t, transaction: r } - ), - e) - ); - } - var o2r = (function (t) { - YSr(e, t); - function e(r, n) { - var i = t.call(this, r) || this; - return ( - (0, PEe.defineReadOnly)(i, "baseUrl", i.getBaseUrl()), - (0, PEe.defineReadOnly)(i, "apiKey", n || null), - i - ); - } - return ( - (e.prototype.getBaseUrl = function () { - switch (this.network ? this.network.name : "invalid") { - case "homestead": - return "https://api.etherscan.io"; - case "goerli": - return "https://api-goerli.etherscan.io"; - case "sepolia": - return "https://api-sepolia.etherscan.io"; - case "matic": - return "https://api.polygonscan.com"; - case "maticmum": - return "https://api-testnet.polygonscan.com"; - case "arbitrum": - return "https://api.arbiscan.io"; - case "arbitrum-goerli": - return "https://api-goerli.arbiscan.io"; - case "optimism": - return "https://api-optimistic.etherscan.io"; - case "optimism-goerli": - return "https://api-goerli-optimistic.etherscan.io"; - default: - } - return JA.throwArgumentError( - "unsupported network", - "network", - this.network.name - ); - }), - (e.prototype.getUrl = function (r, n) { - var i = Object.keys(n).reduce(function (a, s) { - var c = n[s]; - return c != null && (a += "&" + s + "=" + c), a; - }, ""), - o = this.apiKey ? "&apikey=" + this.apiKey : ""; - return this.baseUrl + "/api?module=" + r + i + o; - }), - (e.prototype.getPostUrl = function () { - return this.baseUrl + "/api"; - }), - (e.prototype.getPostData = function (r, n) { - return (n.module = r), (n.apikey = this.apiKey), n; - }), - (e.prototype.fetch = function (r, n, i) { - return Dne(this, void 0, void 0, function () { - var o, - a, - s, - c, - u, - h, - w = this; - return Fne(this, function (M) { - switch (M.label) { - case 0: - return ( - (o = i ? this.getPostUrl() : this.getUrl(r, n)), - (a = i ? this.getPostData(r, n) : null), - (s = r === "proxy" ? Ndt : i2r), - this.emit("debug", { - action: "request", - request: o, - provider: this, - }), - (c = { - url: o, - throttleSlotInterval: 1e3, - throttleCallback: function (k, O) { - return ( - w.isCommunityResource() && - (0, t2r.showThrottleMessage)(), - Promise.resolve(!0) - ); - }, - }), - (u = null), - a && - ((c.headers = { - "content-type": - "application/x-www-form-urlencoded; charset=UTF-8", - }), - (u = Object.keys(a) - .map(function (k) { - return k + "=" + a[k]; - }) - .join("&"))), - [4, (0, e2r.fetchJson)(c, u, s || Ndt)] - ); - case 1: - return ( - (h = M.sent()), - this.emit("debug", { - action: "response", - request: o, - response: (0, PEe.deepCopy)(h), - provider: this, - }), - [2, h] - ); - } - }); - }); - }), - (e.prototype.detectNetwork = function () { - return Dne(this, void 0, void 0, function () { - return Fne(this, function (r) { - return [2, this.network]; - }); - }); - }), - (e.prototype.perform = function (r, n) { - return Dne(this, void 0, void 0, function () { - var i, a, o, a, s, c, u, h, w, M, k, O, D; - return Fne(this, function (F) { - switch (F.label) { - case 0: - switch (((i = r), i)) { - case "getBlockNumber": - return [3, 1]; - case "getGasPrice": - return [3, 2]; - case "getBalance": - return [3, 3]; - case "getTransactionCount": - return [3, 4]; - case "getCode": - return [3, 5]; - case "getStorageAt": - return [3, 6]; - case "sendTransaction": - return [3, 7]; - case "getBlock": - return [3, 8]; - case "getTransaction": - return [3, 9]; - case "getTransactionReceipt": - return [3, 10]; - case "call": - return [3, 11]; - case "estimateGas": - return [3, 15]; - case "getLogs": - return [3, 19]; - case "getEtherPrice": - return [3, 26]; - } - return [3, 28]; - case 1: - return [ - 2, - this.fetch("proxy", { action: "eth_blockNumber" }), - ]; - case 2: - return [2, this.fetch("proxy", { action: "eth_gasPrice" })]; - case 3: - return [ - 2, - this.fetch("account", { - action: "balance", - address: n.address, - tag: n.blockTag, - }), - ]; - case 4: - return [ - 2, - this.fetch("proxy", { - action: "eth_getTransactionCount", - address: n.address, - tag: n.blockTag, - }), - ]; - case 5: - return [ - 2, - this.fetch("proxy", { - action: "eth_getCode", - address: n.address, - tag: n.blockTag, - }), - ]; - case 6: - return [ - 2, - this.fetch("proxy", { - action: "eth_getStorageAt", - address: n.address, - position: n.position, - tag: n.blockTag, - }), - ]; - case 7: - return [ - 2, - this.fetch( - "proxy", - { - action: "eth_sendRawTransaction", - hex: n.signedTransaction, - }, - !0 - ).catch(function (N) { - return OEe("sendTransaction", N, n.signedTransaction); - }), - ]; - case 8: - if (n.blockTag) - return [ - 2, - this.fetch("proxy", { - action: "eth_getBlockByNumber", - tag: n.blockTag, - boolean: n.includeTransactions ? "true" : "false", - }), - ]; - throw new Error("getBlock by blockHash not implemented"); - case 9: - return [ - 2, - this.fetch("proxy", { - action: "eth_getTransactionByHash", - txhash: n.transactionHash, - }), - ]; - case 10: - return [ - 2, - this.fetch("proxy", { - action: "eth_getTransactionReceipt", - txhash: n.transactionHash, - }), - ]; - case 11: - if (n.blockTag !== "latest") - throw new Error( - "EtherscanProvider does not support blockTag for call" - ); - (a = Rdt(n.transaction)), - (a.module = "proxy"), - (a.action = "eth_call"), - (F.label = 12); - case 12: - return ( - F.trys.push([12, 14, , 15]), [4, this.fetch("proxy", a, !0)] - ); - case 13: - return [2, F.sent()]; - case 14: - return (o = F.sent()), [2, OEe("call", o, n.transaction)]; - case 15: - (a = Rdt(n.transaction)), - (a.module = "proxy"), - (a.action = "eth_estimateGas"), - (F.label = 16); - case 16: - return ( - F.trys.push([16, 18, , 19]), [4, this.fetch("proxy", a, !0)] - ); - case 17: - return [2, F.sent()]; - case 18: - return ( - (s = F.sent()), [2, OEe("estimateGas", s, n.transaction)] - ); - case 19: - return ( - (c = { action: "getLogs" }), - n.filter.fromBlock && - (c.fromBlock = Ddt(n.filter.fromBlock)), - n.filter.toBlock && (c.toBlock = Ddt(n.filter.toBlock)), - n.filter.address && (c.address = n.filter.address), - n.filter.topics && - n.filter.topics.length > 0 && - (n.filter.topics.length > 1 && - JA.throwError( - "unsupported topic count", - Sb.Logger.errors.UNSUPPORTED_OPERATION, - { topics: n.filter.topics } - ), - n.filter.topics.length === 1 && - ((u = n.filter.topics[0]), - (typeof u != "string" || u.length !== 66) && - JA.throwError( - "unsupported topic format", - Sb.Logger.errors.UNSUPPORTED_OPERATION, - { topic0: u } - ), - (c.topic0 = u))), - [4, this.fetch("logs", c)] - ); - case 20: - (h = F.sent()), (w = {}), (M = 0), (F.label = 21); - case 21: - return M < h.length - ? ((k = h[M]), - k.blockHash != null - ? [3, 24] - : w[k.blockNumber] != null - ? [3, 23] - : [4, this.getBlock(k.blockNumber)]) - : [3, 25]; - case 22: - (O = F.sent()), - O && (w[k.blockNumber] = O.hash), - (F.label = 23); - case 23: - (k.blockHash = w[k.blockNumber]), (F.label = 24); - case 24: - return M++, [3, 21]; - case 25: - return [2, h]; - case 26: - return this.network.name !== "homestead" - ? [2, 0] - : ((D = parseFloat), - [4, this.fetch("stats", { action: "ethprice" })]); - case 27: - return [2, D.apply(void 0, [F.sent().ethusd])]; - case 28: - return [3, 29]; - case 29: - return [2, t.prototype.perform.call(this, r, n)]; - } - }); - }); - }), - (e.prototype.getHistory = function (r, n, i) { - return Dne(this, void 0, void 0, function () { - var o, - a, - s, - c = this; - return Fne(this, function (u) { - switch (u.label) { - case 0: - return (s = { action: "txlist" }), [4, this.resolveName(r)]; - case 1: - return ( - (o = - ((s.address = u.sent()), - (s.startblock = n ?? 0), - (s.endblock = i ?? 99999999), - (s.sort = "asc"), - s)), - [4, this.fetch("account", o)] - ); - case 2: - return ( - (a = u.sent()), - [ - 2, - a.map(function (h) { - ["contractAddress", "to"].forEach(function (M) { - h[M] == "" && delete h[M]; - }), - h.creates == null && - h.contractAddress != null && - (h.creates = h.contractAddress); - var w = c.formatter.transactionResponse(h); - return ( - h.timeStamp && (w.timestamp = parseInt(h.timeStamp)), - w - ); - }), - ] - ); - } - }); - }); - }), - (e.prototype.isCommunityResource = function () { - return this.apiKey == null; - }), - e - ); - })(n2r.BaseProvider); - Ab.EtherscanProvider = o2r; - }); - var Udt = I((Mb) => { - "use strict"; - m(); - g(); - var a2r = - (Mb && Mb.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(), - jne = - (Mb && Mb.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - xK = - (Mb && Mb.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(Mb, "__esModule", { value: !0 }); - Mb.FallbackProvider = void 0; - var s2r = vx(), - u2r = Ro(), - f7 = Ar(), - Eb = $r(), - c2r = s6(), - l2r = r7(), - f2r = mK(), - Ldt = HA(), - $A = rr(), - d2r = pc(), - f6 = new $A.Logger(d2r.version); - function qne() { - return new Date().getTime(); - } - function qdt(t) { - for (var e = null, r = 0; r < t.length; r++) { - var n = t[r]; - if (n == null) return null; - e - ? (e.name === n.name && - e.chainId === n.chainId && - (e.ensAddress === n.ensAddress || - (e.ensAddress == null && n.ensAddress == null))) || - f6.throwArgumentError("provider mismatch", "networks", t) - : (e = n); - } - return e; - } - function zdt(t, e) { - t = t.slice().sort(); - var r = Math.floor(t.length / 2); - if (t.length % 2) return t[r]; - var n = t[r - 1], - i = t[r]; - return e != null && Math.abs(n - i) > e ? null : (n + i) / 2; - } - function d7(t) { - if (t === null) return "null"; - if (typeof t == "number" || typeof t == "boolean") - return JSON.stringify(t); - if (typeof t == "string") return t; - if (u2r.BigNumber.isBigNumber(t)) return t.toString(); - if (Array.isArray(t)) - return JSON.stringify( - t.map(function (r) { - return d7(r); - }) - ); - if (typeof t == "object") { - var e = Object.keys(t); - return ( - e.sort(), - "{" + - e - .map(function (r) { - var n = t[r]; - return ( - typeof n == "function" ? (n = "[function]") : (n = d7(n)), - JSON.stringify(r) + ":" + n - ); - }) - .join(",") + - "}" - ); - } - throw new Error("unknown value type: " + typeof t); - } - var h2r = 1; - function jdt(t) { - var e = null, - r = null, - n = new Promise(function (a) { - (e = function () { - r && (clearTimeout(r), (r = null)), a(); - }), - (r = setTimeout(e, t)); - }), - i = function (a) { - return (n = n.then(a)), n; - }; - function o() { - return n; - } - return { cancel: e, getPromise: o, wait: i }; - } - var p2r = [ - $A.Logger.errors.CALL_EXCEPTION, - $A.Logger.errors.INSUFFICIENT_FUNDS, - $A.Logger.errors.NONCE_EXPIRED, - $A.Logger.errors.REPLACEMENT_UNDERPRICED, - $A.Logger.errors.UNPREDICTABLE_GAS_LIMIT, - ], - y2r = [ - "address", - "args", - "errorArgs", - "errorSignature", - "method", - "transaction", - ]; - function zne(t, e) { - var r = { weight: t.weight }; - return ( - Object.defineProperty(r, "provider", { - get: function () { - return t.provider; - }, - }), - t.start && (r.start = t.start), - e && (r.duration = e - t.start), - t.done && - (t.error ? (r.error = t.error) : (r.result = t.result || null)), - r - ); - } - function m2r(t, e) { - return function (r) { - var n = {}; - r.forEach(function (s) { - var c = t(s.result); - n[c] || (n[c] = { count: 0, result: s.result }), n[c].count++; - }); - for (var i = Object.keys(n), o = 0; o < i.length; o++) { - var a = n[i[o]]; - if (a.count >= e) return a.result; - } - }; - } - function g2r(t, e, r) { - var n = d7; - switch (e) { - case "getBlockNumber": - return function (i) { - var o = i.map(function (s) { - return s.result; - }), - a = zdt( - i.map(function (s) { - return s.result; - }), - 2 - ); - if (a != null) - return ( - (a = Math.ceil(a)), - o.indexOf(a + 1) >= 0 && a++, - a >= t._highestBlockNumber && (t._highestBlockNumber = a), - t._highestBlockNumber - ); - }; - case "getGasPrice": - return function (i) { - var o = i.map(function (a) { - return a.result; - }); - return o.sort(), o[Math.floor(o.length / 2)]; - }; - case "getEtherPrice": - return function (i) { - return zdt( - i.map(function (o) { - return o.result; - }) - ); - }; - case "getBalance": - case "getTransactionCount": - case "getCode": - case "getStorageAt": - case "call": - case "estimateGas": - case "getLogs": - break; - case "getTransaction": - case "getTransactionReceipt": - n = function (i) { - return i == null - ? null - : ((i = (0, Eb.shallowCopy)(i)), (i.confirmations = -1), d7(i)); - }; - break; - case "getBlock": - r.includeTransactions - ? (n = function (i) { - return i == null - ? null - : ((i = (0, Eb.shallowCopy)(i)), - (i.transactions = i.transactions.map(function (o) { - return ( - (o = (0, Eb.shallowCopy)(o)), (o.confirmations = -1), o - ); - })), - d7(i)); - }) - : (n = function (i) { - return i == null ? null : d7(i); - }); - break; - default: - throw new Error("unknown method: " + e); - } - return m2r(n, t.quorum); - } - function _K(t, e) { - return jne(this, void 0, void 0, function () { - var r; - return xK(this, function (n) { - return ( - (r = t.provider), - (r.blockNumber != null && r.blockNumber >= e) || e === -1 - ? [2, r] - : [ - 2, - (0, l2r.poll)( - function () { - return new Promise(function (i, o) { - setTimeout(function () { - return r.blockNumber >= e - ? i(r) - : t.cancelled - ? i(null) - : i(void 0); - }, 0); - }); - }, - { oncePoll: r } - ), - ] - ); - }); - }); - } - function v2r(t, e, r, n) { - return jne(this, void 0, void 0, function () { - var i, o, a; - return xK(this, function (s) { - switch (s.label) { - case 0: - switch (((i = t.provider), (o = r), o)) { - case "getBlockNumber": - return [3, 1]; - case "getGasPrice": - return [3, 1]; - case "getEtherPrice": - return [3, 2]; - case "getBalance": - return [3, 3]; - case "getTransactionCount": - return [3, 3]; - case "getCode": - return [3, 3]; - case "getStorageAt": - return [3, 6]; - case "getBlock": - return [3, 9]; - case "call": - return [3, 12]; - case "estimateGas": - return [3, 12]; - case "getTransaction": - return [3, 15]; - case "getTransactionReceipt": - return [3, 15]; - case "getLogs": - return [3, 16]; - } - return [3, 19]; - case 1: - return [2, i[r]()]; - case 2: - return i.getEtherPrice ? [2, i.getEtherPrice()] : [3, 19]; - case 3: - return n.blockTag && (0, f7.isHexString)(n.blockTag) - ? [4, _K(t, e)] - : [3, 5]; - case 4: - (i = s.sent()), (s.label = 5); - case 5: - return [2, i[r](n.address, n.blockTag || "latest")]; - case 6: - return n.blockTag && (0, f7.isHexString)(n.blockTag) - ? [4, _K(t, e)] - : [3, 8]; - case 7: - (i = s.sent()), (s.label = 8); - case 8: - return [ - 2, - i.getStorageAt(n.address, n.position, n.blockTag || "latest"), - ]; - case 9: - return n.blockTag && (0, f7.isHexString)(n.blockTag) - ? [4, _K(t, e)] - : [3, 11]; - case 10: - (i = s.sent()), (s.label = 11); - case 11: - return [ - 2, - i[ - n.includeTransactions - ? "getBlockWithTransactions" - : "getBlock" - ](n.blockTag || n.blockHash), - ]; - case 12: - return n.blockTag && (0, f7.isHexString)(n.blockTag) - ? [4, _K(t, e)] - : [3, 14]; - case 13: - (i = s.sent()), (s.label = 14); - case 14: - return r === "call" && n.blockTag - ? [2, i[r](n.transaction, n.blockTag)] - : [2, i[r](n.transaction)]; - case 15: - return [2, i[r](n.transactionHash)]; - case 16: - return ( - (a = n.filter), - (a.fromBlock && (0, f7.isHexString)(a.fromBlock)) || - (a.toBlock && (0, f7.isHexString)(a.toBlock)) - ? [4, _K(t, e)] - : [3, 18] - ); - case 17: - (i = s.sent()), (s.label = 18); - case 18: - return [2, i.getLogs(a)]; - case 19: - return [ - 2, - f6.throwError( - "unknown method error", - $A.Logger.errors.UNKNOWN_ERROR, - { method: r, params: n } - ), - ]; - } - }); - }); - } - var b2r = (function (t) { - a2r(e, t); - function e(r, n) { - var i = this; - r.length === 0 && - f6.throwArgumentError("missing providers", "providers", r); - var o = r.map(function (c, u) { - if (s2r.Provider.isProvider(c)) { - var h = (0, Ldt.isCommunityResource)(c) ? 2e3 : 750, - w = 1; - return Object.freeze({ - provider: c, - weight: 1, - stallTimeout: h, - priority: w, - }); - } - var M = (0, Eb.shallowCopy)(c); - M.priority == null && (M.priority = 1), - M.stallTimeout == null && - (M.stallTimeout = (0, Ldt.isCommunityResource)(c) ? 2e3 : 750), - M.weight == null && (M.weight = 1); - var k = M.weight; - return ( - (k % 1 || k > 512 || k < 1) && - f6.throwArgumentError( - "invalid weight; must be integer in [1, 512]", - "providers[" + u + "].weight", - k - ), - Object.freeze(M) - ); - }), - a = o.reduce(function (c, u) { - return c + u.weight; - }, 0); - n == null - ? (n = a / 2) - : n > a && - f6.throwArgumentError( - "quorum will always fail; larger than total weight", - "quorum", - n - ); - var s = qdt( - o.map(function (c) { - return c.provider.network; - }) - ); - return ( - s == null && - (s = new Promise(function (c, u) { - setTimeout(function () { - i.detectNetwork().then(c, u); - }, 0); - })), - (i = t.call(this, s) || this), - (0, Eb.defineReadOnly)(i, "providerConfigs", Object.freeze(o)), - (0, Eb.defineReadOnly)(i, "quorum", n), - (i._highestBlockNumber = -1), - i - ); - } - return ( - (e.prototype.detectNetwork = function () { - return jne(this, void 0, void 0, function () { - var r; - return xK(this, function (n) { - switch (n.label) { - case 0: - return [ - 4, - Promise.all( - this.providerConfigs.map(function (i) { - return i.provider.getNetwork(); - }) - ), - ]; - case 1: - return (r = n.sent()), [2, qdt(r)]; - } - }); - }); - }), - (e.prototype.perform = function (r, n) { - return jne(this, void 0, void 0, function () { - var i, - o, - a, - s, - c, - u, - h, - w, - M, - k, - O, - D = this; - return xK(this, function (F) { - switch (F.label) { - case 0: - return r !== "sendTransaction" - ? [3, 2] - : [ - 4, - Promise.all( - this.providerConfigs.map(function (N) { - return N.provider - .sendTransaction(n.signedTransaction) - .then( - function (q) { - return q.hash; - }, - function (q) { - return q; - } - ); - }) - ), - ]; - case 1: - for (i = F.sent(), o = 0; o < i.length; o++) - if (((a = i[o]), typeof a == "string")) return [2, a]; - throw i[0]; - case 2: - return this._highestBlockNumber === -1 && - r !== "getBlockNumber" - ? [4, this.getBlockNumber()] - : [3, 4]; - case 3: - F.sent(), (F.label = 4); - case 4: - (s = g2r(this, r, n)), - (c = (0, c2r.shuffled)( - this.providerConfigs.map(Eb.shallowCopy) - )), - c.sort(function (N, q) { - return N.priority - q.priority; - }), - (u = this._highestBlockNumber), - (h = 0), - (w = !0), - (M = function () { - var N, q, z, H, Z, $, ue; - return xK(this, function (te) { - switch (te.label) { - case 0: - for ( - N = qne(), - q = c - .filter(function (ne) { - return ( - ne.runner && - N - ne.start < ne.stallTimeout - ); - }) - .reduce(function (ne, A) { - return ne + A.weight; - }, 0), - z = function () { - var ne = c[h++], - A = h2r++; - (ne.start = qne()), - (ne.staller = jdt(ne.stallTimeout)), - ne.staller.wait(function () { - ne.staller = null; - }), - (ne.runner = v2r(ne, u, r, n).then( - function (l) { - (ne.done = !0), - (ne.result = l), - D.listenerCount("debug") && - D.emit("debug", { - action: "request", - rid: A, - backend: zne(ne, qne()), - request: { - method: r, - params: (0, Eb.deepCopy)(n), - }, - provider: D, - }); - }, - function (l) { - (ne.done = !0), - (ne.error = l), - D.listenerCount("debug") && - D.emit("debug", { - action: "request", - rid: A, - backend: zne(ne, qne()), - request: { - method: r, - params: (0, Eb.deepCopy)(n), - }, - provider: D, - }); - } - )), - k.listenerCount("debug") && - k.emit("debug", { - action: "request", - rid: A, - backend: zne(ne, null), - request: { - method: r, - params: (0, Eb.deepCopy)(n), - }, - provider: k, - }), - (q += ne.weight); - }; - q < k.quorum && h < c.length; - - ) - z(); - return ( - (H = []), - c.forEach(function (ne) { - ne.done || - !ne.runner || - (H.push(ne.runner), - ne.staller && - H.push(ne.staller.getPromise())); - }), - H.length ? [4, Promise.race(H)] : [3, 2] - ); - case 1: - te.sent(), (te.label = 2); - case 2: - return ( - (Z = c.filter(function (ne) { - return ne.done && ne.error == null; - })), - Z.length >= k.quorum - ? (($ = s(Z)), - $ !== void 0 - ? (c.forEach(function (ne) { - ne.staller && ne.staller.cancel(), - (ne.cancelled = !0); - }), - [2, { value: $ }]) - : w - ? [3, 4] - : [4, jdt(100).getPromise()]) - : [3, 5] - ); - case 3: - te.sent(), (te.label = 4); - case 4: - (w = !1), (te.label = 5); - case 5: - return ( - (ue = c.reduce(function (ne, A) { - if (!A.done || A.error == null) return ne; - var l = A.error.code; - return ( - p2r.indexOf(l) >= 0 && - (ne[l] || - (ne[l] = { error: A.error, weight: 0 }), - (ne[l].weight += A.weight)), - ne - ); - }, {})), - Object.keys(ue).forEach(function (ne) { - var A = ue[ne]; - if (!(A.weight < D.quorum)) { - c.forEach(function (y) { - y.staller && y.staller.cancel(), - (y.cancelled = !0); - }); - var l = A.error, - p = {}; - y2r.forEach(function (y) { - l[y] != null && (p[y] = l[y]); - }), - f6.throwError(l.reason || l.message, ne, p); - } - }), - c.filter(function (ne) { - return !ne.done; - }).length === 0 - ? [2, "break"] - : [2] - ); - } - }); - }), - (k = this), - (F.label = 5); - case 5: - return [5, M()]; - case 6: - return ( - (O = F.sent()), - typeof O == "object" - ? [2, O.value] - : O === "break" - ? [3, 7] - : [3, 5] - ); - case 7: - return ( - c.forEach(function (N) { - N.staller && N.staller.cancel(), (N.cancelled = !0); - }), - [ - 2, - f6.throwError( - "failed to meet quorum", - $A.Logger.errors.SERVER_ERROR, - { - method: r, - params: n, - results: c.map(function (N) { - return zne(N); - }), - provider: this, - } - ), - ] - ); - } - }); - }); - }), - e - ); - })(f2r.BaseProvider); - Mb.FallbackProvider = b2r; - }); - var Kdt = I((Une) => { - "use strict"; - m(); - g(); - Object.defineProperty(Une, "__esModule", { value: !0 }); - Une.IpcProvider = void 0; - var w2r = null; - Une.IpcProvider = w2r; - }); - var Gdt = I((ZA) => { - "use strict"; - m(); - g(); - var Hdt = - (ZA && ZA.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(ZA, "__esModule", { value: !0 }); - ZA.InfuraProvider = ZA.InfuraWebSocketProvider = void 0; - var BEe = $r(), - _2r = Ine(), - x2r = HA(), - IEe = rr(), - S2r = pc(), - Kne = new IEe.Logger(S2r.version), - A2r = WA(), - SK = "84842078b09946638c03157f83405213", - Vdt = (function (t) { - Hdt(e, t); - function e(r, n) { - var i = this, - o = new Wdt(r, n), - a = o.connection; - a.password && - Kne.throwError( - "INFURA WebSocket project secrets unsupported", - IEe.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "InfuraProvider.getWebSocketProvider()" } - ); - var s = a.url.replace(/^http/i, "ws").replace("/v3/", "/ws/v3/"); - return ( - (i = t.call(this, s, r) || this), - (0, BEe.defineReadOnly)(i, "apiKey", o.projectId), - (0, BEe.defineReadOnly)(i, "projectId", o.projectId), - (0, BEe.defineReadOnly)(i, "projectSecret", o.projectSecret), - i - ); - } - return ( - (e.prototype.isCommunityResource = function () { - return this.projectId === SK; - }), - e - ); - })(_2r.WebSocketProvider); - ZA.InfuraWebSocketProvider = Vdt; - var Wdt = (function (t) { - Hdt(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.getWebSocketProvider = function (r, n) { - return new Vdt(r, n); - }), - (e.getApiKey = function (r) { - var n = { apiKey: SK, projectId: SK, projectSecret: null }; - return ( - r == null || - (typeof r == "string" - ? (n.projectId = r) - : r.projectSecret != null - ? (Kne.assertArgument( - typeof r.projectId == "string", - "projectSecret requires a projectId", - "projectId", - r.projectId - ), - Kne.assertArgument( - typeof r.projectSecret == "string", - "invalid projectSecret", - "projectSecret", - "[REDACTED]" - ), - (n.projectId = r.projectId), - (n.projectSecret = r.projectSecret)) - : r.projectId && (n.projectId = r.projectId), - (n.apiKey = n.projectId)), - n - ); - }), - (e.getUrl = function (r, n) { - var i = null; - switch (r ? r.name : "unknown") { - case "homestead": - i = "mainnet.infura.io"; - break; - case "goerli": - i = "goerli.infura.io"; - break; - case "sepolia": - i = "sepolia.infura.io"; - break; - case "matic": - i = "polygon-mainnet.infura.io"; - break; - case "maticmum": - i = "polygon-mumbai.infura.io"; - break; - case "optimism": - i = "optimism-mainnet.infura.io"; - break; - case "optimism-goerli": - i = "optimism-goerli.infura.io"; - break; - case "arbitrum": - i = "arbitrum-mainnet.infura.io"; - break; - case "arbitrum-goerli": - i = "arbitrum-goerli.infura.io"; - break; - default: - Kne.throwError( - "unsupported network", - IEe.Logger.errors.INVALID_ARGUMENT, - { argument: "network", value: r } - ); - } - var o = { - allowGzip: !0, - url: "https://" + i + "/v3/" + n.projectId, - throttleCallback: function (a, s) { - return ( - n.projectId === SK && (0, x2r.showThrottleMessage)(), - Promise.resolve(!0) - ); - }, - }; - return ( - n.projectSecret != null && - ((o.user = ""), (o.password = n.projectSecret)), - o - ); - }), - (e.prototype.isCommunityResource = function () { - return this.projectId === SK; - }), - e - ); - })(A2r.UrlJsonRpcProvider); - ZA.InfuraProvider = Wdt; - }); - var Jdt = I((h7) => { - "use strict"; - m(); - g(); - var E2r = - (h7 && h7.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(h7, "__esModule", { value: !0 }); - h7.JsonRpcBatchProvider = void 0; - var M2r = $r(), - T2r = r7(), - k2r = s7(), - P2r = (function (t) { - E2r(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.prototype.send = function (r, n) { - var i = this, - o = { method: r, params: n, id: this._nextId++, jsonrpc: "2.0" }; - this._pendingBatch == null && (this._pendingBatch = []); - var a = { request: o, resolve: null, reject: null }, - s = new Promise(function (c, u) { - (a.resolve = c), (a.reject = u); - }); - return ( - this._pendingBatch.push(a), - this._pendingBatchAggregator || - (this._pendingBatchAggregator = setTimeout(function () { - var c = i._pendingBatch; - (i._pendingBatch = null), (i._pendingBatchAggregator = null); - var u = c.map(function (h) { - return h.request; - }); - return ( - i.emit("debug", { - action: "requestBatch", - request: (0, M2r.deepCopy)(u), - provider: i, - }), - (0, T2r.fetchJson)(i.connection, JSON.stringify(u)).then( - function (h) { - i.emit("debug", { - action: "response", - request: u, - response: h, - provider: i, - }), - c.forEach(function (w, M) { - var k = h[M]; - if (k.error) { - var O = new Error(k.error.message); - (O.code = k.error.code), - (O.data = k.error.data), - w.reject(O); - } else w.resolve(k.result); - }); - }, - function (h) { - i.emit("debug", { - action: "response", - error: h, - request: u, - provider: i, - }), - c.forEach(function (w) { - w.reject(h); - }); - } - ) - ); - }, 10)), - s - ); - }), - e - ); - })(k2r.JsonRpcProvider); - h7.JsonRpcBatchProvider = P2r; - }); - var $dt = I((p7) => { - "use strict"; - m(); - g(); - var O2r = - (p7 && p7.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(p7, "__esModule", { value: !0 }); - p7.NodesmithProvider = void 0; - var B2r = WA(), - I2r = rr(), - C2r = pc(), - CEe = new I2r.Logger(C2r.version), - R2r = "ETHERS_JS_SHARED", - N2r = (function (t) { - O2r(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.getApiKey = function (r) { - return ( - r && - typeof r != "string" && - CEe.throwArgumentError("invalid apiKey", "apiKey", r), - r || R2r - ); - }), - (e.getUrl = function (r, n) { - CEe.warn( - "NodeSmith will be discontinued on 2019-12-20; please migrate to another platform." - ); - var i = null; - switch (r.name) { - case "homestead": - i = "https://ethereum.api.nodesmith.io/v1/mainnet/jsonrpc"; - break; - case "ropsten": - i = "https://ethereum.api.nodesmith.io/v1/ropsten/jsonrpc"; - break; - case "rinkeby": - i = "https://ethereum.api.nodesmith.io/v1/rinkeby/jsonrpc"; - break; - case "goerli": - i = "https://ethereum.api.nodesmith.io/v1/goerli/jsonrpc"; - break; - case "kovan": - i = "https://ethereum.api.nodesmith.io/v1/kovan/jsonrpc"; - break; - default: - CEe.throwArgumentError( - "unsupported network", - "network", - arguments[0] - ); - } - return i + "?apiKey=" + n; - }), - e - ); - })(B2r.UrlJsonRpcProvider); - p7.NodesmithProvider = N2r; - }); - var Qdt = I((y7) => { - "use strict"; - m(); - g(); - var D2r = - (y7 && y7.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(y7, "__esModule", { value: !0 }); - y7.PocketProvider = void 0; - var Ydt = rr(), - F2r = pc(), - Zdt = new Ydt.Logger(F2r.version), - L2r = WA(), - Xdt = "62e1ad51b37b8e00394bda3b", - q2r = (function (t) { - D2r(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.getApiKey = function (r) { - var n = { - applicationId: null, - loadBalancer: !0, - applicationSecretKey: null, - }; - return ( - r == null - ? (n.applicationId = Xdt) - : typeof r == "string" - ? (n.applicationId = r) - : r.applicationSecretKey != null - ? ((n.applicationId = r.applicationId), - (n.applicationSecretKey = r.applicationSecretKey)) - : r.applicationId - ? (n.applicationId = r.applicationId) - : Zdt.throwArgumentError( - "unsupported PocketProvider apiKey", - "apiKey", - r - ), - n - ); - }), - (e.getUrl = function (r, n) { - var i = null; - switch (r ? r.name : "unknown") { - case "goerli": - i = "eth-goerli.gateway.pokt.network"; - break; - case "homestead": - i = "eth-mainnet.gateway.pokt.network"; - break; - case "kovan": - i = "poa-kovan.gateway.pokt.network"; - break; - case "matic": - i = "poly-mainnet.gateway.pokt.network"; - break; - case "maticmum": - i = "polygon-mumbai-rpc.gateway.pokt.network"; - break; - case "rinkeby": - i = "eth-rinkeby.gateway.pokt.network"; - break; - case "ropsten": - i = "eth-ropsten.gateway.pokt.network"; - break; - default: - Zdt.throwError( - "unsupported network", - Ydt.Logger.errors.INVALID_ARGUMENT, - { argument: "network", value: r } - ); - } - var o = "https://" + i + "/v1/lb/" + n.applicationId, - a = { headers: {}, url: o }; - return ( - n.applicationSecretKey != null && - ((a.user = ""), (a.password = n.applicationSecretKey)), - a - ); - }), - (e.prototype.isCommunityResource = function () { - return this.applicationId === Xdt; - }), - e - ); - })(L2r.UrlJsonRpcProvider); - y7.PocketProvider = q2r; - }); - var rht = I((m7) => { - "use strict"; - m(); - g(); - var z2r = - (m7 && m7.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(m7, "__esModule", { value: !0 }); - m7.Web3Provider = void 0; - var Hne = $r(), - j2r = rr(), - U2r = pc(), - eht = new j2r.Logger(U2r.version), - K2r = s7(), - H2r = 1; - function tht(t, e) { - var r = "Web3LegacyFetcher"; - return function (n, i) { - var o = this, - a = { method: n, params: i, id: H2r++, jsonrpc: "2.0" }; - return new Promise(function (s, c) { - o.emit("debug", { - action: "request", - fetcher: r, - request: (0, Hne.deepCopy)(a), - provider: o, - }), - e(a, function (u, h) { - if (u) - return ( - o.emit("debug", { - action: "response", - fetcher: r, - error: u, - request: a, - provider: o, - }), - c(u) - ); - if ( - (o.emit("debug", { - action: "response", - fetcher: r, - request: a, - response: h, - provider: o, - }), - h.error) - ) { - var w = new Error(h.error.message); - return (w.code = h.error.code), (w.data = h.error.data), c(w); - } - s(h.result); - }); - }); - }; - } - function V2r(t) { - return function (e, r) { - var n = this; - r == null && (r = []); - var i = { method: e, params: r }; - return ( - this.emit("debug", { - action: "request", - fetcher: "Eip1193Fetcher", - request: (0, Hne.deepCopy)(i), - provider: this, - }), - t.request(i).then( - function (o) { - return ( - n.emit("debug", { - action: "response", - fetcher: "Eip1193Fetcher", - request: i, - response: o, - provider: n, - }), - o - ); - }, - function (o) { - throw ( - (n.emit("debug", { - action: "response", - fetcher: "Eip1193Fetcher", - request: i, - error: o, - provider: n, - }), - o) - ); - } - ) - ); - }; - } - var W2r = (function (t) { - z2r(e, t); - function e(r, n) { - var i = this; - r == null && eht.throwArgumentError("missing provider", "provider", r); - var o = null, - a = null, - s = null; - return ( - typeof r == "function" - ? ((o = "unknown:"), (a = r)) - : ((o = r.host || r.path || ""), - !o && r.isMetaMask && (o = "metamask"), - (s = r), - r.request - ? (o === "" && (o = "eip-1193:"), (a = V2r(r))) - : r.sendAsync - ? (a = tht(r, r.sendAsync.bind(r))) - : r.send - ? (a = tht(r, r.send.bind(r))) - : eht.throwArgumentError("unsupported provider", "provider", r), - o || (o = "unknown:")), - (i = t.call(this, o, n) || this), - (0, Hne.defineReadOnly)(i, "jsonRpcFetchFunc", a), - (0, Hne.defineReadOnly)(i, "provider", s), - i - ); - } - return ( - (e.prototype.send = function (r, n) { - return this.jsonRpcFetchFunc(r, n); - }), - e - ); - })(K2r.JsonRpcProvider); - m7.Web3Provider = W2r; - }); - var DEe = I((gr) => { - "use strict"; - m(); - g(); - Object.defineProperty(gr, "__esModule", { value: !0 }); - gr.Formatter = - gr.showThrottleMessage = - gr.isCommunityResourcable = - gr.isCommunityResource = - gr.getNetwork = - gr.getDefaultProvider = - gr.JsonRpcSigner = - gr.IpcProvider = - gr.WebSocketProvider = - gr.Web3Provider = - gr.StaticJsonRpcProvider = - gr.PocketProvider = - gr.NodesmithProvider = - gr.JsonRpcBatchProvider = - gr.JsonRpcProvider = - gr.InfuraWebSocketProvider = - gr.InfuraProvider = - gr.EtherscanProvider = - gr.CloudflareProvider = - gr.AnkrProvider = - gr.AlchemyWebSocketProvider = - gr.AlchemyProvider = - gr.FallbackProvider = - gr.UrlJsonRpcProvider = - gr.Resolver = - gr.BaseProvider = - gr.Provider = - void 0; - var G2r = vx(); - Object.defineProperty(gr, "Provider", { - enumerable: !0, - get: function () { - return G2r.Provider; - }, - }); - var iht = hEe(); - Object.defineProperty(gr, "getNetwork", { - enumerable: !0, - get: function () { - return iht.getNetwork; - }, - }); - var oht = mK(); - Object.defineProperty(gr, "BaseProvider", { - enumerable: !0, - get: function () { - return oht.BaseProvider; - }, - }); - Object.defineProperty(gr, "Resolver", { - enumerable: !0, - get: function () { - return oht.Resolver; - }, - }); - var REe = Odt(); - Object.defineProperty(gr, "AlchemyProvider", { - enumerable: !0, - get: function () { - return REe.AlchemyProvider; - }, - }); - Object.defineProperty(gr, "AlchemyWebSocketProvider", { - enumerable: !0, - get: function () { - return REe.AlchemyWebSocketProvider; - }, - }); - var aht = Bdt(); - Object.defineProperty(gr, "AnkrProvider", { - enumerable: !0, - get: function () { - return aht.AnkrProvider; - }, - }); - var sht = Cdt(); - Object.defineProperty(gr, "CloudflareProvider", { - enumerable: !0, - get: function () { - return sht.CloudflareProvider; - }, - }); - var uht = Fdt(); - Object.defineProperty(gr, "EtherscanProvider", { - enumerable: !0, - get: function () { - return uht.EtherscanProvider; - }, - }); - var cht = Udt(); - Object.defineProperty(gr, "FallbackProvider", { - enumerable: !0, - get: function () { - return cht.FallbackProvider; - }, - }); - var lht = Kdt(); - Object.defineProperty(gr, "IpcProvider", { - enumerable: !0, - get: function () { - return lht.IpcProvider; - }, - }); - var NEe = Gdt(); - Object.defineProperty(gr, "InfuraProvider", { - enumerable: !0, - get: function () { - return NEe.InfuraProvider; - }, - }); - Object.defineProperty(gr, "InfuraWebSocketProvider", { - enumerable: !0, - get: function () { - return NEe.InfuraWebSocketProvider; - }, - }); - var Vne = s7(); - Object.defineProperty(gr, "JsonRpcProvider", { - enumerable: !0, - get: function () { - return Vne.JsonRpcProvider; - }, - }); - Object.defineProperty(gr, "JsonRpcSigner", { - enumerable: !0, - get: function () { - return Vne.JsonRpcSigner; - }, - }); - var J2r = Jdt(); - Object.defineProperty(gr, "JsonRpcBatchProvider", { - enumerable: !0, - get: function () { - return J2r.JsonRpcBatchProvider; - }, - }); - var fht = $dt(); - Object.defineProperty(gr, "NodesmithProvider", { - enumerable: !0, - get: function () { - return fht.NodesmithProvider; - }, - }); - var dht = Qdt(); - Object.defineProperty(gr, "PocketProvider", { - enumerable: !0, - get: function () { - return dht.PocketProvider; - }, - }); - var hht = WA(); - Object.defineProperty(gr, "StaticJsonRpcProvider", { - enumerable: !0, - get: function () { - return hht.StaticJsonRpcProvider; - }, - }); - Object.defineProperty(gr, "UrlJsonRpcProvider", { - enumerable: !0, - get: function () { - return hht.UrlJsonRpcProvider; - }, - }); - var pht = rht(); - Object.defineProperty(gr, "Web3Provider", { - enumerable: !0, - get: function () { - return pht.Web3Provider; - }, - }); - var yht = Ine(); - Object.defineProperty(gr, "WebSocketProvider", { - enumerable: !0, - get: function () { - return yht.WebSocketProvider; - }, - }); - var Wne = HA(); - Object.defineProperty(gr, "Formatter", { - enumerable: !0, - get: function () { - return Wne.Formatter; - }, - }); - Object.defineProperty(gr, "isCommunityResourcable", { - enumerable: !0, - get: function () { - return Wne.isCommunityResourcable; - }, - }); - Object.defineProperty(gr, "isCommunityResource", { - enumerable: !0, - get: function () { - return Wne.isCommunityResource; - }, - }); - Object.defineProperty(gr, "showThrottleMessage", { - enumerable: !0, - get: function () { - return Wne.showThrottleMessage; - }, - }); - var mht = rr(), - $2r = pc(), - nht = new mht.Logger($2r.version); - function Z2r(t, e) { - if ((t == null && (t = "homestead"), typeof t == "string")) { - var r = t.match(/^(ws|http)s?:/i); - if (r) - switch (r[1].toLowerCase()) { - case "http": - case "https": - return new Vne.JsonRpcProvider(t); - case "ws": - case "wss": - return new yht.WebSocketProvider(t); - default: - nht.throwArgumentError("unsupported URL scheme", "network", t); - } - } - var n = (0, iht.getNetwork)(t); - return ( - (!n || !n._defaultProvider) && - nht.throwError( - "unsupported getDefaultProvider network", - mht.Logger.errors.NETWORK_ERROR, - { operation: "getDefaultProvider", network: t } - ), - n._defaultProvider( - { - FallbackProvider: cht.FallbackProvider, - AlchemyProvider: REe.AlchemyProvider, - AnkrProvider: aht.AnkrProvider, - CloudflareProvider: sht.CloudflareProvider, - EtherscanProvider: uht.EtherscanProvider, - InfuraProvider: NEe.InfuraProvider, - JsonRpcProvider: Vne.JsonRpcProvider, - NodesmithProvider: fht.NodesmithProvider, - PocketProvider: dht.PocketProvider, - Web3Provider: pht.Web3Provider, - IpcProvider: lht.IpcProvider, - }, - e - ) - ); - } - gr.getDefaultProvider = Z2r; - }); - var ght = I((Gne) => { - "use strict"; - m(); - g(); - Object.defineProperty(Gne, "__esModule", { value: !0 }); - Gne.version = void 0; - Gne.version = "solidity/5.7.0"; - }); - var LEe = I((XA) => { - "use strict"; - m(); - g(); - Object.defineProperty(XA, "__esModule", { value: !0 }); - XA.sha256 = XA.keccak256 = XA.pack = void 0; - var X2r = Ro(), - gg = Ar(), - Y2r = Hh(), - Q2r = pb(), - eAr = Eo(), - tAr = new RegExp("^bytes([0-9]+)$"), - rAr = new RegExp("^(u?int)([0-9]*)$"), - nAr = new RegExp("^(.*)\\[([0-9]*)\\]$"), - iAr = "0000000000000000000000000000000000000000000000000000000000000000", - oAr = rr(), - aAr = ght(), - g7 = new oAr.Logger(aAr.version); - function vht(t, e, r) { - switch (t) { - case "address": - return r ? (0, gg.zeroPad)(e, 32) : (0, gg.arrayify)(e); - case "string": - return (0, eAr.toUtf8Bytes)(e); - case "bytes": - return (0, gg.arrayify)(e); - case "bool": - return ( - (e = e ? "0x01" : "0x00"), - r ? (0, gg.zeroPad)(e, 32) : (0, gg.arrayify)(e) - ); - } - var n = t.match(rAr); - if (n) { - var i = parseInt(n[2] || "256"); - return ( - ((n[2] && String(i) !== n[2]) || i % 8 !== 0 || i === 0 || i > 256) && - g7.throwArgumentError("invalid number type", "type", t), - r && (i = 256), - (e = X2r.BigNumber.from(e).toTwos(i)), - (0, gg.zeroPad)(e, i / 8) - ); - } - if (((n = t.match(tAr)), n)) { - var i = parseInt(n[1]); - return ( - (String(i) !== n[1] || i === 0 || i > 32) && - g7.throwArgumentError("invalid bytes type", "type", t), - (0, gg.arrayify)(e).byteLength !== i && - g7.throwArgumentError("invalid value for " + t, "value", e), - r ? (0, gg.arrayify)((e + iAr).substring(0, 66)) : e - ); - } - if (((n = t.match(nAr)), n && Array.isArray(e))) { - var o = n[1], - a = parseInt(n[2] || String(e.length)); - a != e.length && - g7.throwArgumentError("invalid array length for " + t, "value", e); - var s = []; - return ( - e.forEach(function (c) { - s.push(vht(o, c, !0)); - }), - (0, gg.concat)(s) - ); - } - return g7.throwArgumentError("invalid type", "type", t); - } - function FEe(t, e) { - t.length != e.length && - g7.throwArgumentError( - "wrong number of values; expected ${ types.length }", - "values", - e - ); - var r = []; - return ( - t.forEach(function (n, i) { - r.push(vht(n, e[i])); - }), - (0, gg.hexlify)((0, gg.concat)(r)) - ); - } - XA.pack = FEe; - function sAr(t, e) { - return (0, Y2r.keccak256)(FEe(t, e)); - } - XA.keccak256 = sAr; - function uAr(t, e) { - return (0, Q2r.sha256)(FEe(t, e)); - } - XA.sha256 = uAr; - }); - var bht = I((Jne) => { - "use strict"; - m(); - g(); - Object.defineProperty(Jne, "__esModule", { value: !0 }); - Jne.version = void 0; - Jne.version = "units/5.7.0"; - }); - var qEe = I((Hy) => { - "use strict"; - m(); - g(); - Object.defineProperty(Hy, "__esModule", { value: !0 }); - Hy.parseEther = - Hy.formatEther = - Hy.parseUnits = - Hy.formatUnits = - Hy.commify = - void 0; - var wht = Ro(), - cAr = rr(), - lAr = bht(), - _ht = new cAr.Logger(lAr.version), - xht = ["wei", "kwei", "mwei", "gwei", "szabo", "finney", "ether"]; - function fAr(t) { - var e = String(t).split("."); - (e.length > 2 || - !e[0].match(/^-?[0-9]*$/) || - (e[1] && !e[1].match(/^[0-9]*$/)) || - t === "." || - t === "-.") && - _ht.throwArgumentError("invalid value", "value", t); - var r = e[0], - n = ""; - for ( - r.substring(0, 1) === "-" && ((n = "-"), (r = r.substring(1))); - r.substring(0, 1) === "0"; - - ) - r = r.substring(1); - r === "" && (r = "0"); - var i = ""; - for ( - e.length === 2 && (i = "." + (e[1] || "0")); - i.length > 2 && i[i.length - 1] === "0"; - - ) - i = i.substring(0, i.length - 1); - for (var o = []; r.length; ) - if (r.length <= 3) { - o.unshift(r); - break; - } else { - var a = r.length - 3; - o.unshift(r.substring(a)), (r = r.substring(0, a)); - } - return n + o.join(",") + i; - } - Hy.commify = fAr; - function Sht(t, e) { - if (typeof e == "string") { - var r = xht.indexOf(e); - r !== -1 && (e = 3 * r); - } - return (0, wht.formatFixed)(t, e ?? 18); - } - Hy.formatUnits = Sht; - function Aht(t, e) { - if ( - (typeof t != "string" && - _ht.throwArgumentError("value must be a string", "value", t), - typeof e == "string") - ) { - var r = xht.indexOf(e); - r !== -1 && (e = 3 * r); - } - return (0, wht.parseFixed)(t, e ?? 18); - } - Hy.parseUnits = Aht; - function dAr(t) { - return Sht(t, 18); - } - Hy.formatEther = dAr; - function hAr(t) { - return Aht(t, 18); - } - Hy.parseEther = hAr; - }); - var Eht = I(($ne) => { - "use strict"; - m(); - g(); - Object.defineProperty($ne, "__esModule", { value: !0 }); - $ne.version = void 0; - $ne.version = "web/5.7.1"; - }); - var Mht = I((YA) => { - "use strict"; - m(); - g(); - var pAr = - (YA && YA.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - yAr = - (YA && YA.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(YA, "__esModule", { value: !0 }); - YA.getUrl = void 0; - var mAr = Ar(); - function gAr(t, e) { - return pAr(this, void 0, void 0, function () { - var r, n, i, o, a; - return yAr(this, function (s) { - switch (s.label) { - case 0: - return ( - e == null && (e = {}), - (r = { - method: e.method || "GET", - headers: e.headers || {}, - body: e.body || void 0, - }), - e.skipFetchSetup !== !0 && - ((r.mode = "cors"), - (r.cache = "no-cache"), - (r.credentials = "same-origin"), - (r.redirect = "follow"), - (r.referrer = "client")), - e.fetchOptions != null && - ((n = e.fetchOptions), - n.mode && (r.mode = n.mode), - n.cache && (r.cache = n.cache), - n.credentials && (r.credentials = n.credentials), - n.redirect && (r.redirect = n.redirect), - n.referrer && (r.referrer = n.referrer)), - [4, fetch(t, r)] - ); - case 1: - return (i = s.sent()), [4, i.arrayBuffer()]; - case 2: - return ( - (o = s.sent()), - (a = {}), - i.headers.forEach - ? i.headers.forEach(function (c, u) { - a[u.toLowerCase()] = c; - }) - : i.headers.keys().forEach(function (c) { - a[c.toLowerCase()] = i.headers.get(c); - }), - [ - 2, - { - headers: a, - statusCode: i.status, - statusMessage: i.statusText, - body: (0, mAr.arrayify)(new Uint8Array(o)), - }, - ] - ); - } - }); - }); - } - YA.getUrl = gAr; - }); - var Bht = I((Vy) => { - "use strict"; - m(); - g(); - var vAr = - (Vy && Vy.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - bAr = - (Vy && Vy.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(Vy, "__esModule", { value: !0 }); - Vy.poll = Vy.fetchJson = Vy._fetchData = void 0; - var Tht = lb(), - kht = Ar(), - Zne = $r(), - AK = Eo(), - Ax = rr(), - wAr = Eht(), - vg = new Ax.Logger(wAr.version), - _Ar = Mht(); - function Pht(t) { - return new Promise(function (e) { - setTimeout(e, t); - }); - } - function QA(t, e) { - if (t == null) return null; - if (typeof t == "string") return t; - if ((0, kht.isBytesLike)(t)) { - if ( - e && - (e.split("/")[0] === "text" || - e.split(";")[0].trim() === "application/json") - ) - try { - return (0, AK.toUtf8String)(t); - } catch {} - return (0, kht.hexlify)(t); - } - return t; - } - function xAr(t) { - return (0, AK.toUtf8Bytes)( - t.replace(/%([0-9a-f][0-9a-f])/gi, function (e, r) { - return String.fromCharCode(parseInt(r, 16)); - }) - ); - } - function Oht(t, e, r) { - var n = - typeof t == "object" && t.throttleLimit != null ? t.throttleLimit : 12; - vg.assertArgument( - n > 0 && n % 1 === 0, - "invalid connection throttle limit", - "connection.throttleLimit", - n - ); - var i = typeof t == "object" ? t.throttleCallback : null, - o = - typeof t == "object" && typeof t.throttleSlotInterval == "number" - ? t.throttleSlotInterval - : 100; - vg.assertArgument( - o > 0 && o % 1 === 0, - "invalid connection throttle slot interval", - "connection.throttleSlotInterval", - o - ); - var a = typeof t == "object" ? !!t.errorPassThrough : !1, - s = {}, - c = null, - u = { method: "GET" }, - h = !1, - w = 2 * 60 * 1e3; - if (typeof t == "string") c = t; - else if (typeof t == "object") { - if ( - ((t == null || t.url == null) && - vg.throwArgumentError("missing URL", "connection.url", t), - (c = t.url), - typeof t.timeout == "number" && t.timeout > 0 && (w = t.timeout), - t.headers) - ) - for (var M in t.headers) - (s[M.toLowerCase()] = { key: M, value: String(t.headers[M]) }), - ["if-none-match", "if-modified-since"].indexOf(M.toLowerCase()) >= - 0 && (h = !0); - if ( - ((u.allowGzip = !!t.allowGzip), t.user != null && t.password != null) - ) { - c.substring(0, 6) !== "https:" && - t.allowInsecureAuthentication !== !0 && - vg.throwError( - "basic authentication requires a secure https url", - Ax.Logger.errors.INVALID_ARGUMENT, - { argument: "url", url: c, user: t.user, password: "[REDACTED]" } - ); - var k = t.user + ":" + t.password; - s.authorization = { - key: "Authorization", - value: "Basic " + (0, Tht.encode)((0, AK.toUtf8Bytes)(k)), - }; - } - t.skipFetchSetup != null && (u.skipFetchSetup = !!t.skipFetchSetup), - t.fetchOptions != null && - (u.fetchOptions = (0, Zne.shallowCopy)(t.fetchOptions)); - } - var O = new RegExp("^data:([^;:]*)?(;base64)?,(.*)$", "i"), - D = c ? c.match(O) : null; - if (D) - try { - var F = { - statusCode: 200, - statusMessage: "OK", - headers: { "content-type": D[1] || "text/plain" }, - body: D[2] ? (0, Tht.decode)(D[3]) : xAr(D[3]), - }, - N = F.body; - return r && (N = r(F.body, F)), Promise.resolve(N); - } catch (Z) { - vg.throwError( - "processing response error", - Ax.Logger.errors.SERVER_ERROR, - { - body: QA(D[1], D[2]), - error: Z, - requestBody: null, - requestMethod: "GET", - url: c, - } - ); - } - e && - ((u.method = "POST"), - (u.body = e), - s["content-type"] == null && - (s["content-type"] = { - key: "Content-Type", - value: "application/octet-stream", - }), - s["content-length"] == null && - (s["content-length"] = { - key: "Content-Length", - value: String(e.length), - })); - var q = {}; - Object.keys(s).forEach(function (Z) { - var $ = s[Z]; - q[$.key] = $.value; - }), - (u.headers = q); - var z = (function () { - var Z = null, - $ = new Promise(function (te, ne) { - w && - (Z = setTimeout(function () { - Z != null && - ((Z = null), - ne( - vg.makeError("timeout", Ax.Logger.errors.TIMEOUT, { - requestBody: QA(u.body, q["content-type"]), - requestMethod: u.method, - timeout: w, - url: c, - }) - )); - }, w)); - }), - ue = function () { - Z != null && (clearTimeout(Z), (Z = null)); - }; - return { promise: $, cancel: ue }; - })(), - H = (function () { - return vAr(this, void 0, void 0, function () { - var Z, $, ue, d, te, ne, A, l, p, y, d, v; - return bAr(this, function (_) { - switch (_.label) { - case 0: - (Z = 0), (_.label = 1); - case 1: - if (!(Z < n)) return [3, 20]; - ($ = null), (_.label = 2); - case 2: - return _.trys.push([2, 9, , 10]), [4, (0, _Ar.getUrl)(c, u)]; - case 3: - return ( - ($ = _.sent()), - Z < n - ? $.statusCode === 301 || $.statusCode === 302 - ? ((ue = $.headers.location || ""), - u.method === "GET" && ue.match(/^https:/) - ? ((c = $.headers.location), [3, 19]) - : [3, 8]) - : [3, 4] - : [3, 8] - ); - case 4: - return $.statusCode !== 429 - ? [3, 8] - : ((d = !0), i ? [4, i(Z, c)] : [3, 6]); - case 5: - (d = _.sent()), (_.label = 6); - case 6: - return d - ? ((te = 0), - (ne = $.headers["retry-after"]), - typeof ne == "string" && ne.match(/^[1-9][0-9]*$/) - ? (te = parseInt(ne) * 1e3) - : (te = - o * - parseInt(String(Math.random() * Math.pow(2, Z)))), - [4, Pht(te)]) - : [3, 8]; - case 7: - return _.sent(), [3, 19]; - case 8: - return [3, 10]; - case 9: - return ( - (A = _.sent()), - ($ = A.response), - $ == null && - (z.cancel(), - vg.throwError( - "missing response", - Ax.Logger.errors.SERVER_ERROR, - { - requestBody: QA(u.body, q["content-type"]), - requestMethod: u.method, - serverError: A, - url: c, - } - )), - [3, 10] - ); - case 10: - if ( - ((l = $.body), - h && $.statusCode === 304 - ? (l = null) - : !a && - ($.statusCode < 200 || $.statusCode >= 300) && - (z.cancel(), - vg.throwError( - "bad response", - Ax.Logger.errors.SERVER_ERROR, - { - status: $.statusCode, - headers: $.headers, - body: QA( - l, - $.headers ? $.headers["content-type"] : null - ), - requestBody: QA(u.body, q["content-type"]), - requestMethod: u.method, - url: c, - } - )), - !r) - ) - return [3, 18]; - _.label = 11; - case 11: - return _.trys.push([11, 13, , 18]), [4, r(l, $)]; - case 12: - return (p = _.sent()), z.cancel(), [2, p]; - case 13: - return ( - (y = _.sent()), - y.throttleRetry && Z < n - ? ((d = !0), i ? [4, i(Z, c)] : [3, 15]) - : [3, 17] - ); - case 14: - (d = _.sent()), (_.label = 15); - case 15: - return d - ? ((v = - o * parseInt(String(Math.random() * Math.pow(2, Z)))), - [4, Pht(v)]) - : [3, 17]; - case 16: - return _.sent(), [3, 19]; - case 17: - return ( - z.cancel(), - vg.throwError( - "processing response error", - Ax.Logger.errors.SERVER_ERROR, - { - body: QA( - l, - $.headers ? $.headers["content-type"] : null - ), - error: y, - requestBody: QA(u.body, q["content-type"]), - requestMethod: u.method, - url: c, - } - ), - [3, 18] - ); - case 18: - return z.cancel(), [2, l]; - case 19: - return Z++, [3, 1]; - case 20: - return [ - 2, - vg.throwError( - "failed response", - Ax.Logger.errors.SERVER_ERROR, - { - requestBody: QA(u.body, q["content-type"]), - requestMethod: u.method, - url: c, - } - ), - ]; - } - }); - }); - })(); - return Promise.race([z.promise, H]); - } - Vy._fetchData = Oht; - function SAr(t, e, r) { - var n = function (s, c) { - var u = null; - if (s != null) - try { - u = JSON.parse((0, AK.toUtf8String)(s)); - } catch (h) { - vg.throwError("invalid JSON", Ax.Logger.errors.SERVER_ERROR, { - body: s, - error: h, - }); - } - return r && (u = r(u, c)), u; - }, - i = null; - if (e != null) { - i = (0, AK.toUtf8Bytes)(e); - var o = typeof t == "string" ? { url: t } : (0, Zne.shallowCopy)(t); - if (o.headers) { - var a = - Object.keys(o.headers).filter(function (s) { - return s.toLowerCase() === "content-type"; - }).length !== 0; - a || - ((o.headers = (0, Zne.shallowCopy)(o.headers)), - (o.headers["content-type"] = "application/json")); - } else o.headers = { "content-type": "application/json" }; - t = o; - } - return Oht(t, i, n); - } - Vy.fetchJson = SAr; - function AAr(t, e) { - return ( - e || (e = {}), - (e = (0, Zne.shallowCopy)(e)), - e.floor == null && (e.floor = 0), - e.ceiling == null && (e.ceiling = 1e4), - e.interval == null && (e.interval = 250), - new Promise(function (r, n) { - var i = null, - o = !1, - a = function () { - return o ? !1 : ((o = !0), i && clearTimeout(i), !0); - }; - e.timeout && - (i = setTimeout(function () { - a() && n(new Error("timeout")); - }, e.timeout)); - var s = e.retryLimit, - c = 0; - function u() { - return t().then( - function (h) { - if (h !== void 0) a() && r(h); - else if (e.oncePoll) e.oncePoll.once("poll", u); - else if (e.onceBlock) e.onceBlock.once("block", u); - else if (!o) { - if ((c++, c > s)) { - a() && n(new Error("retry limit reached")); - return; - } - var w = - e.interval * - parseInt(String(Math.random() * Math.pow(2, c))); - w < e.floor && (w = e.floor), - w > e.ceiling && (w = e.ceiling), - setTimeout(u, w); - } - return null; - }, - function (h) { - a() && n(h); - } - ); - } - u(); - }) - ); - } - Vy.poll = AAr; - }); - var Dht = I((Ge) => { - "use strict"; - m(); - g(); - var EAr = - (Ge && Ge.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - MAr = - (Ge && Ge.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Iht = - (Ge && Ge.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - EAr(e, t, r); - return MAr(e, t), e; - }; - Object.defineProperty(Ge, "__esModule", { value: !0 }); - Ge.formatBytes32String = - Ge.Utf8ErrorFuncs = - Ge.toUtf8String = - Ge.toUtf8CodePoints = - Ge.toUtf8Bytes = - Ge._toEscapedUtf8String = - Ge.nameprep = - Ge.hexDataSlice = - Ge.hexDataLength = - Ge.hexZeroPad = - Ge.hexValue = - Ge.hexStripZeros = - Ge.hexConcat = - Ge.isHexString = - Ge.hexlify = - Ge.base64 = - Ge.base58 = - Ge.TransactionDescription = - Ge.LogDescription = - Ge.Interface = - Ge.SigningKey = - Ge.HDNode = - Ge.defaultPath = - Ge.isBytesLike = - Ge.isBytes = - Ge.zeroPad = - Ge.stripZeros = - Ge.concat = - Ge.arrayify = - Ge.shallowCopy = - Ge.resolveProperties = - Ge.getStatic = - Ge.defineReadOnly = - Ge.deepCopy = - Ge.checkProperties = - Ge.poll = - Ge.fetchJson = - Ge._fetchData = - Ge.RLP = - Ge.Logger = - Ge.checkResultErrors = - Ge.FormatTypes = - Ge.ParamType = - Ge.FunctionFragment = - Ge.EventFragment = - Ge.ErrorFragment = - Ge.ConstructorFragment = - Ge.Fragment = - Ge.defaultAbiCoder = - Ge.AbiCoder = - void 0; - Ge.Indexed = - Ge.Utf8ErrorReason = - Ge.UnicodeNormalizationForm = - Ge.SupportedAlgorithm = - Ge.mnemonicToSeed = - Ge.isValidMnemonic = - Ge.entropyToMnemonic = - Ge.mnemonicToEntropy = - Ge.getAccountPath = - Ge.verifyTypedData = - Ge.verifyMessage = - Ge.recoverPublicKey = - Ge.computePublicKey = - Ge.recoverAddress = - Ge.computeAddress = - Ge.getJsonWalletAddress = - Ge.TransactionTypes = - Ge.serializeTransaction = - Ge.parseTransaction = - Ge.accessListify = - Ge.joinSignature = - Ge.splitSignature = - Ge.soliditySha256 = - Ge.solidityKeccak256 = - Ge.solidityPack = - Ge.shuffled = - Ge.randomBytes = - Ge.sha512 = - Ge.sha256 = - Ge.ripemd160 = - Ge.keccak256 = - Ge.computeHmac = - Ge.commify = - Ge.parseUnits = - Ge.formatUnits = - Ge.parseEther = - Ge.formatEther = - Ge.isAddress = - Ge.getCreate2Address = - Ge.getContractAddress = - Ge.getIcapAddress = - Ge.getAddress = - Ge._TypedDataEncoder = - Ge.id = - Ge.isValidName = - Ge.namehash = - Ge.hashMessage = - Ge.dnsEncode = - Ge.parseBytes32String = - void 0; - var Gh = Ire(); - Object.defineProperty(Ge, "AbiCoder", { - enumerable: !0, - get: function () { - return Gh.AbiCoder; - }, - }); - Object.defineProperty(Ge, "checkResultErrors", { - enumerable: !0, - get: function () { - return Gh.checkResultErrors; - }, - }); - Object.defineProperty(Ge, "ConstructorFragment", { - enumerable: !0, - get: function () { - return Gh.ConstructorFragment; - }, - }); - Object.defineProperty(Ge, "defaultAbiCoder", { - enumerable: !0, - get: function () { - return Gh.defaultAbiCoder; - }, - }); - Object.defineProperty(Ge, "ErrorFragment", { - enumerable: !0, - get: function () { - return Gh.ErrorFragment; - }, - }); - Object.defineProperty(Ge, "EventFragment", { - enumerable: !0, - get: function () { - return Gh.EventFragment; - }, - }); - Object.defineProperty(Ge, "FormatTypes", { - enumerable: !0, - get: function () { - return Gh.FormatTypes; - }, - }); - Object.defineProperty(Ge, "Fragment", { - enumerable: !0, - get: function () { - return Gh.Fragment; - }, - }); - Object.defineProperty(Ge, "FunctionFragment", { - enumerable: !0, - get: function () { - return Gh.FunctionFragment; - }, - }); - Object.defineProperty(Ge, "Indexed", { - enumerable: !0, - get: function () { - return Gh.Indexed; - }, - }); - Object.defineProperty(Ge, "Interface", { - enumerable: !0, - get: function () { - return Gh.Interface; - }, - }); - Object.defineProperty(Ge, "LogDescription", { - enumerable: !0, - get: function () { - return Gh.LogDescription; - }, - }); - Object.defineProperty(Ge, "ParamType", { - enumerable: !0, - get: function () { - return Gh.ParamType; - }, - }); - Object.defineProperty(Ge, "TransactionDescription", { - enumerable: !0, - get: function () { - return Gh.TransactionDescription; - }, - }); - var EK = Vh(); - Object.defineProperty(Ge, "getAddress", { - enumerable: !0, - get: function () { - return EK.getAddress; - }, - }); - Object.defineProperty(Ge, "getCreate2Address", { - enumerable: !0, - get: function () { - return EK.getCreate2Address; - }, - }); - Object.defineProperty(Ge, "getContractAddress", { - enumerable: !0, - get: function () { - return EK.getContractAddress; - }, - }); - Object.defineProperty(Ge, "getIcapAddress", { - enumerable: !0, - get: function () { - return EK.getIcapAddress; - }, - }); - Object.defineProperty(Ge, "isAddress", { - enumerable: !0, - get: function () { - return EK.isAddress; - }, - }); - var TAr = Iht(lb()); - Ge.base64 = TAr; - var kAr = jR(); - Object.defineProperty(Ge, "base58", { - enumerable: !0, - get: function () { - return kAr.Base58; - }, - }); - var sl = Ar(); - Object.defineProperty(Ge, "arrayify", { - enumerable: !0, - get: function () { - return sl.arrayify; - }, - }); - Object.defineProperty(Ge, "concat", { - enumerable: !0, - get: function () { - return sl.concat; - }, - }); - Object.defineProperty(Ge, "hexConcat", { - enumerable: !0, - get: function () { - return sl.hexConcat; - }, - }); - Object.defineProperty(Ge, "hexDataSlice", { - enumerable: !0, - get: function () { - return sl.hexDataSlice; - }, - }); - Object.defineProperty(Ge, "hexDataLength", { - enumerable: !0, - get: function () { - return sl.hexDataLength; - }, - }); - Object.defineProperty(Ge, "hexlify", { - enumerable: !0, - get: function () { - return sl.hexlify; - }, - }); - Object.defineProperty(Ge, "hexStripZeros", { - enumerable: !0, - get: function () { - return sl.hexStripZeros; - }, - }); - Object.defineProperty(Ge, "hexValue", { - enumerable: !0, - get: function () { - return sl.hexValue; - }, - }); - Object.defineProperty(Ge, "hexZeroPad", { - enumerable: !0, - get: function () { - return sl.hexZeroPad; - }, - }); - Object.defineProperty(Ge, "isBytes", { - enumerable: !0, - get: function () { - return sl.isBytes; - }, - }); - Object.defineProperty(Ge, "isBytesLike", { - enumerable: !0, - get: function () { - return sl.isBytesLike; - }, - }); - Object.defineProperty(Ge, "isHexString", { - enumerable: !0, - get: function () { - return sl.isHexString; - }, - }); - Object.defineProperty(Ge, "joinSignature", { - enumerable: !0, - get: function () { - return sl.joinSignature; - }, - }); - Object.defineProperty(Ge, "zeroPad", { - enumerable: !0, - get: function () { - return sl.zeroPad; - }, - }); - Object.defineProperty(Ge, "splitSignature", { - enumerable: !0, - get: function () { - return sl.splitSignature; - }, - }); - Object.defineProperty(Ge, "stripZeros", { - enumerable: !0, - get: function () { - return sl.stripZeros; - }, - }); - var v7 = db(); - Object.defineProperty(Ge, "_TypedDataEncoder", { - enumerable: !0, - get: function () { - return v7._TypedDataEncoder; - }, - }); - Object.defineProperty(Ge, "dnsEncode", { - enumerable: !0, - get: function () { - return v7.dnsEncode; - }, - }); - Object.defineProperty(Ge, "hashMessage", { - enumerable: !0, - get: function () { - return v7.hashMessage; - }, - }); - Object.defineProperty(Ge, "id", { - enumerable: !0, - get: function () { - return v7.id; - }, - }); - Object.defineProperty(Ge, "isValidName", { - enumerable: !0, - get: function () { - return v7.isValidName; - }, - }); - Object.defineProperty(Ge, "namehash", { - enumerable: !0, - get: function () { - return v7.namehash; - }, - }); - var d6 = aK(); - Object.defineProperty(Ge, "defaultPath", { - enumerable: !0, - get: function () { - return d6.defaultPath; - }, - }); - Object.defineProperty(Ge, "entropyToMnemonic", { - enumerable: !0, - get: function () { - return d6.entropyToMnemonic; - }, - }); - Object.defineProperty(Ge, "getAccountPath", { - enumerable: !0, - get: function () { - return d6.getAccountPath; - }, - }); - Object.defineProperty(Ge, "HDNode", { - enumerable: !0, - get: function () { - return d6.HDNode; - }, - }); - Object.defineProperty(Ge, "isValidMnemonic", { - enumerable: !0, - get: function () { - return d6.isValidMnemonic; - }, - }); - Object.defineProperty(Ge, "mnemonicToEntropy", { - enumerable: !0, - get: function () { - return d6.mnemonicToEntropy; - }, - }); - Object.defineProperty(Ge, "mnemonicToSeed", { - enumerable: !0, - get: function () { - return d6.mnemonicToSeed; - }, - }); - var PAr = mne(); - Object.defineProperty(Ge, "getJsonWalletAddress", { - enumerable: !0, - get: function () { - return PAr.getJsonWalletAddress; - }, - }); - var OAr = Hh(); - Object.defineProperty(Ge, "keccak256", { - enumerable: !0, - get: function () { - return OAr.keccak256; - }, - }); - var BAr = rr(); - Object.defineProperty(Ge, "Logger", { - enumerable: !0, - get: function () { - return BAr.Logger; - }, - }); - var Xne = pb(); - Object.defineProperty(Ge, "computeHmac", { - enumerable: !0, - get: function () { - return Xne.computeHmac; - }, - }); - Object.defineProperty(Ge, "ripemd160", { - enumerable: !0, - get: function () { - return Xne.ripemd160; - }, - }); - Object.defineProperty(Ge, "sha256", { - enumerable: !0, - get: function () { - return Xne.sha256; - }, - }); - Object.defineProperty(Ge, "sha512", { - enumerable: !0, - get: function () { - return Xne.sha512; - }, - }); - var zEe = LEe(); - Object.defineProperty(Ge, "solidityKeccak256", { - enumerable: !0, - get: function () { - return zEe.keccak256; - }, - }); - Object.defineProperty(Ge, "solidityPack", { - enumerable: !0, - get: function () { - return zEe.pack; - }, - }); - Object.defineProperty(Ge, "soliditySha256", { - enumerable: !0, - get: function () { - return zEe.sha256; - }, - }); - var Cht = s6(); - Object.defineProperty(Ge, "randomBytes", { - enumerable: !0, - get: function () { - return Cht.randomBytes; - }, - }); - Object.defineProperty(Ge, "shuffled", { - enumerable: !0, - get: function () { - return Cht.shuffled; - }, - }); - var b7 = $r(); - Object.defineProperty(Ge, "checkProperties", { - enumerable: !0, - get: function () { - return b7.checkProperties; - }, - }); - Object.defineProperty(Ge, "deepCopy", { - enumerable: !0, - get: function () { - return b7.deepCopy; - }, - }); - Object.defineProperty(Ge, "defineReadOnly", { - enumerable: !0, - get: function () { - return b7.defineReadOnly; - }, - }); - Object.defineProperty(Ge, "getStatic", { - enumerable: !0, - get: function () { - return b7.getStatic; - }, - }); - Object.defineProperty(Ge, "resolveProperties", { - enumerable: !0, - get: function () { - return b7.resolveProperties; - }, - }); - Object.defineProperty(Ge, "shallowCopy", { - enumerable: !0, - get: function () { - return b7.shallowCopy; - }, - }); - var IAr = Iht(zU()); - Ge.RLP = IAr; - var jEe = qR(); - Object.defineProperty(Ge, "computePublicKey", { - enumerable: !0, - get: function () { - return jEe.computePublicKey; - }, - }); - Object.defineProperty(Ge, "recoverPublicKey", { - enumerable: !0, - get: function () { - return jEe.recoverPublicKey; - }, - }); - Object.defineProperty(Ge, "SigningKey", { - enumerable: !0, - get: function () { - return jEe.SigningKey; - }, - }); - var eE = Eo(); - Object.defineProperty(Ge, "formatBytes32String", { - enumerable: !0, - get: function () { - return eE.formatBytes32String; - }, - }); - Object.defineProperty(Ge, "nameprep", { - enumerable: !0, - get: function () { - return eE.nameprep; - }, - }); - Object.defineProperty(Ge, "parseBytes32String", { - enumerable: !0, - get: function () { - return eE.parseBytes32String; - }, - }); - Object.defineProperty(Ge, "_toEscapedUtf8String", { - enumerable: !0, - get: function () { - return eE._toEscapedUtf8String; - }, - }); - Object.defineProperty(Ge, "toUtf8Bytes", { - enumerable: !0, - get: function () { - return eE.toUtf8Bytes; - }, - }); - Object.defineProperty(Ge, "toUtf8CodePoints", { - enumerable: !0, - get: function () { - return eE.toUtf8CodePoints; - }, - }); - Object.defineProperty(Ge, "toUtf8String", { - enumerable: !0, - get: function () { - return eE.toUtf8String; - }, - }); - Object.defineProperty(Ge, "Utf8ErrorFuncs", { - enumerable: !0, - get: function () { - return eE.Utf8ErrorFuncs; - }, - }); - var w7 = e0(); - Object.defineProperty(Ge, "accessListify", { - enumerable: !0, - get: function () { - return w7.accessListify; - }, - }); - Object.defineProperty(Ge, "computeAddress", { - enumerable: !0, - get: function () { - return w7.computeAddress; - }, - }); - Object.defineProperty(Ge, "parseTransaction", { - enumerable: !0, - get: function () { - return w7.parse; - }, - }); - Object.defineProperty(Ge, "recoverAddress", { - enumerable: !0, - get: function () { - return w7.recoverAddress; - }, - }); - Object.defineProperty(Ge, "serializeTransaction", { - enumerable: !0, - get: function () { - return w7.serialize; - }, - }); - Object.defineProperty(Ge, "TransactionTypes", { - enumerable: !0, - get: function () { - return w7.TransactionTypes; - }, - }); - var MK = qEe(); - Object.defineProperty(Ge, "commify", { - enumerable: !0, - get: function () { - return MK.commify; - }, - }); - Object.defineProperty(Ge, "formatEther", { - enumerable: !0, - get: function () { - return MK.formatEther; - }, - }); - Object.defineProperty(Ge, "parseEther", { - enumerable: !0, - get: function () { - return MK.parseEther; - }, - }); - Object.defineProperty(Ge, "formatUnits", { - enumerable: !0, - get: function () { - return MK.formatUnits; - }, - }); - Object.defineProperty(Ge, "parseUnits", { - enumerable: !0, - get: function () { - return MK.parseUnits; - }, - }); - var Rht = lK(); - Object.defineProperty(Ge, "verifyMessage", { - enumerable: !0, - get: function () { - return Rht.verifyMessage; - }, - }); - Object.defineProperty(Ge, "verifyTypedData", { - enumerable: !0, - get: function () { - return Rht.verifyTypedData; - }, - }); - var UEe = Bht(); - Object.defineProperty(Ge, "_fetchData", { - enumerable: !0, - get: function () { - return UEe._fetchData; - }, - }); - Object.defineProperty(Ge, "fetchJson", { - enumerable: !0, - get: function () { - return UEe.fetchJson; - }, - }); - Object.defineProperty(Ge, "poll", { - enumerable: !0, - get: function () { - return UEe.poll; - }, - }); - var CAr = pb(); - Object.defineProperty(Ge, "SupportedAlgorithm", { - enumerable: !0, - get: function () { - return CAr.SupportedAlgorithm; - }, - }); - var Nht = Eo(); - Object.defineProperty(Ge, "UnicodeNormalizationForm", { - enumerable: !0, - get: function () { - return Nht.UnicodeNormalizationForm; - }, - }); - Object.defineProperty(Ge, "Utf8ErrorReason", { - enumerable: !0, - get: function () { - return Nht.Utf8ErrorReason; - }, - }); - }); - var Fht = I((Yne) => { - "use strict"; - m(); - g(); - Object.defineProperty(Yne, "__esModule", { value: !0 }); - Yne.version = void 0; - Yne.version = "ethers/5.7.2"; - }); - var VEe = I((pn) => { - "use strict"; - m(); - g(); - var RAr = - (pn && pn.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - NAr = - (pn && pn.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - KEe = - (pn && pn.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - RAr(e, t, r); - return NAr(e, t), e; - }; - Object.defineProperty(pn, "__esModule", { value: !0 }); - pn.Wordlist = - pn.version = - pn.wordlists = - pn.utils = - pn.logger = - pn.errors = - pn.constants = - pn.FixedNumber = - pn.BigNumber = - pn.ContractFactory = - pn.Contract = - pn.BaseContract = - pn.providers = - pn.getDefaultProvider = - pn.VoidSigner = - pn.Wallet = - pn.Signer = - void 0; - var HEe = UAe(); - Object.defineProperty(pn, "BaseContract", { - enumerable: !0, - get: function () { - return HEe.BaseContract; - }, - }); - Object.defineProperty(pn, "Contract", { - enumerable: !0, - get: function () { - return HEe.Contract; - }, - }); - Object.defineProperty(pn, "ContractFactory", { - enumerable: !0, - get: function () { - return HEe.ContractFactory; - }, - }); - var Lht = Ro(); - Object.defineProperty(pn, "BigNumber", { - enumerable: !0, - get: function () { - return Lht.BigNumber; - }, - }); - Object.defineProperty(pn, "FixedNumber", { - enumerable: !0, - get: function () { - return Lht.FixedNumber; - }, - }); - var qht = r6(); - Object.defineProperty(pn, "Signer", { - enumerable: !0, - get: function () { - return qht.Signer; - }, - }); - Object.defineProperty(pn, "VoidSigner", { - enumerable: !0, - get: function () { - return qht.VoidSigner; - }, - }); - var DAr = lK(); - Object.defineProperty(pn, "Wallet", { - enumerable: !0, - get: function () { - return DAr.Wallet; - }, - }); - var FAr = KEe(ub()); - pn.constants = FAr; - var LAr = KEe(DEe()); - pn.providers = LAr; - var qAr = DEe(); - Object.defineProperty(pn, "getDefaultProvider", { - enumerable: !0, - get: function () { - return qAr.getDefaultProvider; - }, - }); - var zht = one(); - Object.defineProperty(pn, "Wordlist", { - enumerable: !0, - get: function () { - return zht.Wordlist; - }, - }); - Object.defineProperty(pn, "wordlists", { - enumerable: !0, - get: function () { - return zht.wordlists; - }, - }); - var zAr = KEe(Dht()); - pn.utils = zAr; - var jht = rr(); - Object.defineProperty(pn, "errors", { - enumerable: !0, - get: function () { - return jht.ErrorCode; - }, - }); - var Uht = Fht(); - Object.defineProperty(pn, "version", { - enumerable: !0, - get: function () { - return Uht.version; - }, - }); - var jAr = new jht.Logger(Uht.version); - pn.logger = jAr; - }); - var GEe = I((rn) => { - "use strict"; - m(); - g(); - var UAr = - (rn && rn.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - KAr = - (rn && rn.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - HAr = - (rn && rn.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - UAr(e, t, r); - return KAr(e, t), e; - }; - Object.defineProperty(rn, "__esModule", { value: !0 }); - rn.Wordlist = - rn.version = - rn.wordlists = - rn.utils = - rn.logger = - rn.errors = - rn.constants = - rn.FixedNumber = - rn.BigNumber = - rn.ContractFactory = - rn.Contract = - rn.BaseContract = - rn.providers = - rn.getDefaultProvider = - rn.VoidSigner = - rn.Wallet = - rn.Signer = - rn.ethers = - void 0; - var Kht = HAr(VEe()); - rn.ethers = Kht; - try { - (WEe = window), WEe._ethers == null && (WEe._ethers = Kht); - } catch {} - var WEe, - yc = VEe(); - Object.defineProperty(rn, "Signer", { - enumerable: !0, - get: function () { - return yc.Signer; - }, - }); - Object.defineProperty(rn, "Wallet", { - enumerable: !0, - get: function () { - return yc.Wallet; - }, - }); - Object.defineProperty(rn, "VoidSigner", { - enumerable: !0, - get: function () { - return yc.VoidSigner; - }, - }); - Object.defineProperty(rn, "getDefaultProvider", { - enumerable: !0, - get: function () { - return yc.getDefaultProvider; - }, - }); - Object.defineProperty(rn, "providers", { - enumerable: !0, - get: function () { - return yc.providers; - }, - }); - Object.defineProperty(rn, "BaseContract", { - enumerable: !0, - get: function () { - return yc.BaseContract; - }, - }); - Object.defineProperty(rn, "Contract", { - enumerable: !0, - get: function () { - return yc.Contract; - }, - }); - Object.defineProperty(rn, "ContractFactory", { - enumerable: !0, - get: function () { - return yc.ContractFactory; - }, - }); - Object.defineProperty(rn, "BigNumber", { - enumerable: !0, - get: function () { - return yc.BigNumber; - }, - }); - Object.defineProperty(rn, "FixedNumber", { - enumerable: !0, - get: function () { - return yc.FixedNumber; - }, - }); - Object.defineProperty(rn, "constants", { - enumerable: !0, - get: function () { - return yc.constants; - }, - }); - Object.defineProperty(rn, "errors", { - enumerable: !0, - get: function () { - return yc.errors; - }, - }); - Object.defineProperty(rn, "logger", { - enumerable: !0, - get: function () { - return yc.logger; - }, - }); - Object.defineProperty(rn, "utils", { - enumerable: !0, - get: function () { - return yc.utils; - }, - }); - Object.defineProperty(rn, "wordlists", { - enumerable: !0, - get: function () { - return yc.wordlists; - }, - }); - Object.defineProperty(rn, "version", { - enumerable: !0, - get: function () { - return yc.version; - }, - }); - Object.defineProperty(rn, "Wordlist", { - enumerable: !0, - get: function () { - return yc.Wordlist; - }, - }); - }); - var kK = I((TK) => { - "use strict"; - m(); - g(); - var Hht = - (TK && TK.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(TK, "__esModule", { value: !0 }); - var VAr = Hht(Bst()), - WAr = Hht(W2e()), - JEe = GEe(), - $Ee = class extends VAr.default { - get publicKey() { - return Buffer.from(this.pk, "hex"); - } - constructor(e) { - let r = Buffer.from(e, "hex"), - n = WAr.default.publicKeyCreate(r, !1); - super(e, Buffer.from(n)); - } - sign(e) { - return new JEe.ethers.Wallet(this._key) - .signMessage(e) - .then((n) => Buffer.from(n.slice(2), "hex")); - } - static async verify(e, r, n) { - let i = JEe.ethers.utils.computeAddress(e); - return JEe.ethers.utils.verifyMessage(r, n) === i; - } - }; - TK.default = $Ee; - }); - var YEe = I((PK) => { - "use strict"; - m(); - g(); - var Wht = - (PK && PK.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(PK, "__esModule", { value: !0 }); - var ZEe = Rp(), - GAr = Wht(wT()), - JAr = Wht(ng()), - Vht = KT(), - XEe = class { - constructor(e, r) { - (this._key = e), - (this.pk = r), - (this.signatureType = 1), - (this.ownerLength = Vht.SIG_CONFIG[1].pubLength), - (this.signatureLength = Vht.SIG_CONFIG[1].sigLength), - r || - (this.pk = ZEe.createPublicKey({ - key: e, - type: "pkcs1", - format: "pem", - }) - .export({ format: "pem", type: "pkcs1" }) - .toString()); - } - get publicKey() { - return this._publicKey; - } - sign(e) { - return ZEe.createSign("sha256").update(e).sign({ - key: this._key, - padding: ZEe.constants.RSA_PKCS1_PSS_PADDING, - }); - } - static async verify(e, r, n) { - return await GAr.default.crypto.verify( - Buffer.isBuffer(e) ? JAr.default.encode(e) : e, - r, - n - ); - } - }; - PK.default = XEe; - }); - var ept = I((Wy) => { - "use strict"; - m(); - g(); - var $Ar = - (Wy && Wy.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - ZAr = - (Wy && Wy.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - XAr = - (Wy && Wy.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - $Ar(e, t, r); - return ZAr(e, t), e; - }; - Object.defineProperty(Wy, "__esModule", { value: !0 }); - Wy.jwkTopem = Wy.pemTojwk = void 0; - var Ex = XAr(_X()); - function YAr(t) { - return t.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, ""); - } - function QEe(t) { - return YAr(Buffer.from(t, "hex").toString("base64")); - } - var Ght = Ex.define("RSAPublicKey", function () { - this.seq().obj(this.key("n").int(), this.key("e").int()); - }), - Jht = Ex.define("AlgorithmIdentifier", function () { - this.seq().obj( - this.key("algorithm").objid(), - this.key("parameters").optional().any() - ); - }), - QAr = Ex.define("PublicKeyInfo", function () { - this.seq().obj( - this.key("algorithm").use(Jht), - this.key("publicKey").bitstr() - ); - }), - $ht = Ex.define("Version", function () { - this.int({ 0: "two-prime", 1: "multi" }); - }), - eEr = Ex.define("OtherPrimeInfos", function () { - this.seq().obj( - this.key("ri").int(), - this.key("di").int(), - this.key("ti").int() - ); - }), - Zht = Ex.define("RSAPrivateKey", function () { - this.seq().obj( - this.key("version").use($ht), - this.key("n").int(), - this.key("e").int(), - this.key("d").int(), - this.key("p").int(), - this.key("q").int(), - this.key("dp").int(), - this.key("dq").int(), - this.key("qi").int(), - this.key("other").optional().use(eEr) - ); - }), - tEr = Ex.define("PrivateKeyInfo", function () { - this.seq().obj( - this.key("version").use($ht), - this.key("algorithm").use(Jht), - this.key("privateKey").bitstr() - ); - }); - function Xht(t, e) { - return ( - (e = e || {}), - Object.keys(e).forEach(function (r) { - t[r] = e[r]; - }), - t - ); - } - function e3e(t) { - return t.length % 2 === 1 ? "0" + t : t; - } - function Yht(t, e) { - var r = Ght.decode(t, "der"), - n = e3e(r.e.toString(16)), - i = { kty: "RSA", n: rE(r.n), e: QEe(n) }; - return Xht(i, e); - } - function Qht(t, e) { - var r = Zht.decode(t, "der"), - n = e3e(r.e.toString(16)), - i = { - kty: "RSA", - n: rE(r.n), - e: QEe(n), - d: rE(r.d), - p: rE(r.p), - q: rE(r.q), - dp: rE(r.dp), - dq: rE(r.dq), - qi: rE(r.qi), - }; - return Xht(i, e); - } - function rEr(t, e) { - var r = QAr.decode(t, "der"); - return Yht(r.publicKey.data, e); - } - function nEr(t, e) { - var r = tEr.decode(t, "der"); - return Qht(r.privateKey.data, e); - } - function iEr(t) { - var e = /^-----BEGIN (RSA )?(PUBLIC|PRIVATE) KEY-----$/.exec(t); - if (!e) return null; - var r = !!e[1], - n = e[2] === "PRIVATE"; - return n ? (r ? Qht : nEr) : r ? Yht : rEr; - } - function oEr(t) { - return { - n: tE(t.n), - e: tE(t.e), - d: t.d && tE(t.d), - p: t.p && tE(t.p), - q: t.q && tE(t.q), - dp: t.dp && tE(t.dp), - dq: t.dq && tE(t.dq), - qi: t.qi && tE(t.qi), - }; - } - function rE(t) { - return QEe(e3e(t.toString(16))); - } - function aEr(t) { - return new Ex.bignum(Buffer.from(t, "base64")); - } - function tE(t) { - return /^[0-9]+$/.test(t) ? new Ex.bignum(t, 10) : aEr(t); - } - function sEr(t, e) { - var r = t.toString().split(/(\r\n|\r|\n)+/g); - r = r.filter(function (i) { - return i.trim().length !== 0; - }); - var n = iEr(r[0]); - return ( - (r = r.slice(1, -1).join("")), - n(Buffer.from(r.replace(/[^\w\d\+\/=]+/g, ""), "base64"), e) - ); - } - Wy.pemTojwk = sEr; - function uEr(t) { - var e = oEr(t), - r = !!e.d, - n = r ? "PRIVATE" : "PUBLIC", - i = - "-----BEGIN RSA " + - n + - ` KEY----- -`, - o = - ` ------END RSA ` + - n + - ` KEY----- -`, - a = Buffer.alloc(0); - r - ? ((e.version = "two-prime"), (a = Zht.encode(e, "der"))) - : (a = Ght.encode(e, "der")); - var s = a.toString("base64").match(/.{1,64}/g).join(` -`); - return i + s + o; - } - Wy.jwkTopem = uEr; - }); - var rpt = I((OK) => { - "use strict"; - m(); - g(); - var r3e = - (OK && OK.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(OK, "__esModule", { value: !0 }); - var cEr = r3e(YEe()), - lEr = ept(), - fEr = r3e(ng()), - tpt = r3e(wT()), - t3e = class extends cEr.default { - constructor(e) { - super(lEr.jwkTopem(e), e.n), (this.jwk = e); - } - get publicKey() { - return fEr.default.toBuffer(this.pk); - } - sign(e) { - return tpt.default.crypto.sign(this.jwk, e); - } - static async verify(e, r, n) { - return await tpt.default.crypto.verify(e, r, n); - } - }; - OK.default = t3e; - }); - var npt = I((BK) => { - "use strict"; - m(); - g(); - var dEr = - (BK && BK.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(BK, "__esModule", { value: !0 }); - var hEr = dEr(kK()), - n3e = class extends hEr.default {}; - BK.default = n3e; - }); - var RK = I((CK) => { - "use strict"; - m(); - g(); - var ipt = - (CK && CK.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(CK, "__esModule", { value: !0 }); - var pEr = ipt(qte()), - IK = ipt(xv()), - i3e = class extends pEr.default { - get publicKey() { - return IK.default.decode(this.pk); - } - get key() { - return IK.default.decode(this._key); - } - constructor(e) { - let r = IK.default.decode(e); - super( - IK.default.encode(r.subarray(0, 32)), - IK.default.encode(r.subarray(32, 64)) - ); - } - }; - CK.default = i3e; - }); - var opt = I((a3e) => { - "use strict"; - m(); - g(); - Object.defineProperty(a3e, "__esModule", { value: !0 }); - var _7 = GEe(), - NK = KT(), - o3e = class { - constructor(e) { - (this.ownerLength = - NK.SIG_CONFIG[NK.SignatureConfig.ETHEREUM].pubLength), - (this.signatureLength = - NK.SIG_CONFIG[NK.SignatureConfig.ETHEREUM].sigLength), - (this.signatureType = NK.SignatureConfig.ETHEREUM), - (this.signer = e.getSigner()); - } - async setPublicKey() { - let e = "sign this message to connect to Bundlr.Network", - r = await this.signer.signMessage(e), - n = await _7.ethers.utils.hashMessage(e), - i = _7.ethers.utils.recoverPublicKey( - _7.ethers.utils.arrayify(n), - r - ); - this.publicKey = Buffer.from(_7.ethers.utils.arrayify(i)); - } - async sign(e) { - this.publicKey || (await this.setPublicKey()); - let r = await this.signer.signMessage(e); - return Buffer.from(r.slice(2), "hex"); - } - static verify(e, r, n) { - let i = _7.ethers.utils.computeAddress(e); - return _7.ethers.utils.verifyMessage(r, n) === i; - } - }; - a3e.default = o3e; - }); - var u3e = I((bg) => { - "use strict"; - m(); - g(); - var yEr = - (bg && bg.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - mEr = - (bg && bg.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - gEr = - (bg && bg.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - yEr(e, t, r); - return mEr(e, t), e; - }, - vEr = - (bg && bg.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(bg, "__esModule", { value: !0 }); - var bEr = gEr(CX()), - wEr = vEr(ng()), - apt = KT(), - s3e = class { - constructor(e) { - (this.ownerLength = apt.SIG_CONFIG[2].pubLength), - (this.signatureLength = apt.SIG_CONFIG[2].sigLength), - (this.signatureType = 2), - (this.provider = e), - (this._publicKey = this.provider.publicKey.toBuffer()); - } - get publicKey() { - return this._publicKey; - } - async sign(e) { - if (!this.provider.signMessage) - throw new Error("Selected Wallet does not support message signing"); - return await this.provider.signMessage(e); - } - static async verify(e, r, n) { - let i = e; - return ( - typeof e == "string" && (i = wEr.default.toBuffer(e)), - bEr.verify(Buffer.from(n), Buffer.from(r), Buffer.from(i)) - ); - } - }; - bg.default = s3e; - }); - var spt = I((DK) => { - "use strict"; - m(); - g(); - var _Er = - (DK && DK.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(DK, "__esModule", { value: !0 }); - var xEr = _Er(RK()), - c3e = class extends xEr.default { - constructor(e) { - super(e.replace("ed25519:", "")); - } - }; - DK.default = c3e; - }); - var upt = I((FK) => { - "use strict"; - m(); - g(); - var SEr = - (FK && FK.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(FK, "__esModule", { value: !0 }); - var AEr = SEr(qte()), - l3e = class extends AEr.default { - get publicKey() { - return Buffer.from(this.pk); - } - get key() { - return Buffer.from(this._key); - } - constructor(e, r) { - super(e.subarray(0, 32), r); - } - }; - FK.default = l3e; - }); - var cpt = I((LK) => { - "use strict"; - m(); - g(); - var EEr = - (LK && LK.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(LK, "__esModule", { value: !0 }); - var MEr = EEr(u3e()), - f3e = class extends MEr.default { - constructor(e) { - super(e), (this.signatureType = 4); - } - async sign(e) { - return super.sign(Buffer.from(Buffer.from(e).toString("hex"))); - } - static async verify(e, r, n) { - return super.verify( - e, - Buffer.from(Buffer.from(r).toString("hex")), - n - ); - } - }; - LK.default = f3e; - }); - var lpt = I((qK) => { - "use strict"; - m(); - g(); - var TEr = - (qK && qK.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(qK, "__esModule", { value: !0 }); - var kEr = TEr(RK()), - d3e = class extends kEr.default { - constructor(e) { - super(e), (this.signatureType = 4); - } - async sign(e) { - return super.sign(Buffer.from(Buffer.from(e).toString("hex"))); - } - static async verify(e, r, n) { - return super.verify( - e, - Buffer.from(Buffer.from(r).toString("hex")), - n - ); - } - }; - qK.default = d3e; - }); - var h3e = I((No) => { - "use strict"; - m(); - g(); - var PEr = - (No && No.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - fpt = - (No && No.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - PEr(e, t, r); - }, - nE = - (No && No.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(No, "__esModule", { value: !0 }); - No.HexSolanaSigner = - No.HexInjectedSolanaSigner = - No.AlgorandSigner = - No.NearSigner = - No.InjectedEthereumSigner = - No.PolygonSigner = - No.ArweaveSigner = - No.InjectedSolanaSigner = - void 0; - var OEr = nE(rpt()); - No.ArweaveSigner = OEr.default; - fpt(kK(), No); - var BEr = nE(npt()); - No.PolygonSigner = BEr.default; - fpt(RK(), No); - var IEr = nE(opt()); - No.InjectedEthereumSigner = IEr.default; - var CEr = u3e(); - Object.defineProperty(No, "InjectedSolanaSigner", { - enumerable: !0, - get: function () { - return nE(CEr).default; - }, - }); - var REr = spt(); - Object.defineProperty(No, "NearSigner", { - enumerable: !0, - get: function () { - return nE(REr).default; - }, - }); - var NEr = upt(); - Object.defineProperty(No, "AlgorandSigner", { - enumerable: !0, - get: function () { - return nE(NEr).default; - }, - }); - var DEr = cpt(); - Object.defineProperty(No, "HexInjectedSolanaSigner", { - enumerable: !0, - get: function () { - return nE(DEr).default; - }, - }); - var FEr = lpt(); - Object.defineProperty(No, "HexSolanaSigner", { - enumerable: !0, - get: function () { - return nE(FEr).default; - }, - }); - }); - var ppt = I((x7) => { - "use strict"; - m(); - g(); - var hpt = - (x7 && x7.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(x7, "__esModule", { value: !0 }); - x7.indexToType = void 0; - var LEr = hpt(qte()), - qEr = hpt(kK()), - dpt = h3e(); - x7.indexToType = { - 1: dpt.ArweaveSigner, - 2: LEr.default, - 3: qEr.default, - 4: dpt.HexInjectedSolanaSigner, - }; - }); - var ypt = I((h6) => { - "use strict"; - m(); - g(); - var zEr = - (h6 && h6.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - jEr = - (h6 && h6.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - zEr(e, t, r); - }; - Object.defineProperty(h6, "__esModule", { value: !0 }); - jEr(YEe(), h6); - }); - var S7 = I((Tb) => { - "use strict"; - m(); - g(); - var UEr = - (Tb && Tb.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Qne = - (Tb && Tb.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - UEr(e, t, r); - }; - Object.defineProperty(Tb, "__esModule", { value: !0 }); - Qne(rst(), Tb); - Qne(ppt(), Tb); - Qne(ypt(), Tb); - Qne(h3e(), Tb); - }); - var p3e = I((Vvn, mpt) => { - "use strict"; - m(); - g(); - mpt.exports = function (e, r) { - return function () { - for (var i = new Array(arguments.length), o = 0; o < i.length; o++) - i[o] = arguments[o]; - return e.apply(r, i); - }; - }; - }); - var Jh = I((Wvn, bpt) => { - "use strict"; - m(); - g(); - var KEr = p3e(), - p6 = Object.prototype.toString; - function g3e(t) { - return p6.call(t) === "[object Array]"; - } - function y3e(t) { - return typeof t > "u"; - } - function HEr(t) { - return ( - t !== null && - !y3e(t) && - t.constructor !== null && - !y3e(t.constructor) && - typeof t.constructor.isBuffer == "function" && - t.constructor.isBuffer(t) - ); - } - function VEr(t) { - return p6.call(t) === "[object ArrayBuffer]"; - } - function WEr(t) { - return typeof FormData < "u" && t instanceof FormData; - } - function GEr(t) { - var e; - return ( - typeof ArrayBuffer < "u" && ArrayBuffer.isView - ? (e = ArrayBuffer.isView(t)) - : (e = t && t.buffer && t.buffer instanceof ArrayBuffer), - e - ); - } - function JEr(t) { - return typeof t == "string"; - } - function $Er(t) { - return typeof t == "number"; - } - function gpt(t) { - return t !== null && typeof t == "object"; - } - function eie(t) { - if (p6.call(t) !== "[object Object]") return !1; - var e = Object.getPrototypeOf(t); - return e === null || e === Object.prototype; - } - function ZEr(t) { - return p6.call(t) === "[object Date]"; - } - function XEr(t) { - return p6.call(t) === "[object File]"; - } - function YEr(t) { - return p6.call(t) === "[object Blob]"; - } - function vpt(t) { - return p6.call(t) === "[object Function]"; - } - function QEr(t) { - return gpt(t) && vpt(t.pipe); - } - function e3r(t) { - return typeof URLSearchParams < "u" && t instanceof URLSearchParams; - } - function t3r(t) { - return t.trim ? t.trim() : t.replace(/^\s+|\s+$/g, ""); - } - function r3r() { - return typeof navigator < "u" && - (navigator.product === "ReactNative" || - navigator.product === "NativeScript" || - navigator.product === "NS") - ? !1 - : typeof window < "u" && typeof document < "u"; - } - function v3e(t, e) { - if (!(t === null || typeof t > "u")) - if ((typeof t != "object" && (t = [t]), g3e(t))) - for (var r = 0, n = t.length; r < n; r++) e.call(null, t[r], r, t); - else - for (var i in t) - Object.prototype.hasOwnProperty.call(t, i) && - e.call(null, t[i], i, t); - } - function m3e() { - var t = {}; - function e(i, o) { - eie(t[o]) && eie(i) - ? (t[o] = m3e(t[o], i)) - : eie(i) - ? (t[o] = m3e({}, i)) - : g3e(i) - ? (t[o] = i.slice()) - : (t[o] = i); - } - for (var r = 0, n = arguments.length; r < n; r++) v3e(arguments[r], e); - return t; - } - function n3r(t, e, r) { - return ( - v3e(e, function (i, o) { - r && typeof i == "function" ? (t[o] = KEr(i, r)) : (t[o] = i); - }), - t - ); - } - function i3r(t) { - return t.charCodeAt(0) === 65279 && (t = t.slice(1)), t; - } - bpt.exports = { - isArray: g3e, - isArrayBuffer: VEr, - isBuffer: HEr, - isFormData: WEr, - isArrayBufferView: GEr, - isString: JEr, - isNumber: $Er, - isObject: gpt, - isPlainObject: eie, - isUndefined: y3e, - isDate: ZEr, - isFile: XEr, - isBlob: YEr, - isFunction: vpt, - isStream: QEr, - isURLSearchParams: e3r, - isStandardBrowserEnv: r3r, - forEach: v3e, - merge: m3e, - extend: n3r, - trim: t3r, - stripBOM: i3r, - }; - }); - var b3e = I((Gvn, _pt) => { - "use strict"; - m(); - g(); - var A7 = Jh(); - function wpt(t) { - return encodeURIComponent(t) - .replace(/%3A/gi, ":") - .replace(/%24/g, "$") - .replace(/%2C/gi, ",") - .replace(/%20/g, "+") - .replace(/%5B/gi, "[") - .replace(/%5D/gi, "]"); - } - _pt.exports = function (e, r, n) { - if (!r) return e; - var i; - if (n) i = n(r); - else if (A7.isURLSearchParams(r)) i = r.toString(); - else { - var o = []; - A7.forEach(r, function (c, u) { - c === null || - typeof c > "u" || - (A7.isArray(c) ? (u = u + "[]") : (c = [c]), - A7.forEach(c, function (w) { - A7.isDate(w) - ? (w = w.toISOString()) - : A7.isObject(w) && (w = JSON.stringify(w)), - o.push(wpt(u) + "=" + wpt(w)); - })); - }), - (i = o.join("&")); - } - if (i) { - var a = e.indexOf("#"); - a !== -1 && (e = e.slice(0, a)), - (e += (e.indexOf("?") === -1 ? "?" : "&") + i); - } - return e; - }; - }); - var Spt = I((Jvn, xpt) => { - "use strict"; - m(); - g(); - var o3r = Jh(); - function tie() { - this.handlers = []; - } - tie.prototype.use = function (e, r, n) { - return ( - this.handlers.push({ - fulfilled: e, - rejected: r, - synchronous: n ? n.synchronous : !1, - runWhen: n ? n.runWhen : null, - }), - this.handlers.length - 1 - ); - }; - tie.prototype.eject = function (e) { - this.handlers[e] && (this.handlers[e] = null); - }; - tie.prototype.forEach = function (e) { - o3r.forEach(this.handlers, function (n) { - n !== null && e(n); - }); - }; - xpt.exports = tie; - }); - var Ept = I(($vn, Apt) => { - "use strict"; - m(); - g(); - var a3r = Jh(); - Apt.exports = function (e, r) { - a3r.forEach(e, function (i, o) { - o !== r && - o.toUpperCase() === r.toUpperCase() && - ((e[r] = i), delete e[o]); - }); - }; - }); - var w3e = I((Zvn, Mpt) => { - "use strict"; - m(); - g(); - Mpt.exports = function (e, r, n, i, o) { - return ( - (e.config = r), - n && (e.code = n), - (e.request = i), - (e.response = o), - (e.isAxiosError = !0), - (e.toJSON = function () { - return { - message: this.message, - name: this.name, - description: this.description, - number: this.number, - fileName: this.fileName, - lineNumber: this.lineNumber, - columnNumber: this.columnNumber, - stack: this.stack, - config: this.config, - code: this.code, - }; - }), - e - ); - }; - }); - var _3e = I((Xvn, Tpt) => { - "use strict"; - m(); - g(); - var s3r = w3e(); - Tpt.exports = function (e, r, n, i, o) { - var a = new Error(e); - return s3r(a, r, n, i, o); - }; - }); - var Ppt = I((Yvn, kpt) => { - "use strict"; - m(); - g(); - var u3r = _3e(); - kpt.exports = function (e, r, n) { - var i = n.config.validateStatus; - !n.status || !i || i(n.status) - ? e(n) - : r( - u3r( - "Request failed with status code " + n.status, - n.config, - null, - n.request, - n - ) - ); - }; - }); - var Bpt = I((Qvn, Opt) => { - "use strict"; - m(); - g(); - var rie = Jh(); - Opt.exports = rie.isStandardBrowserEnv() - ? (function () { - return { - write: function (r, n, i, o, a, s) { - var c = []; - c.push(r + "=" + encodeURIComponent(n)), - rie.isNumber(i) && - c.push("expires=" + new Date(i).toGMTString()), - rie.isString(o) && c.push("path=" + o), - rie.isString(a) && c.push("domain=" + a), - s === !0 && c.push("secure"), - (document.cookie = c.join("; ")); - }, - read: function (r) { - var n = document.cookie.match( - new RegExp("(^|;\\s*)(" + r + ")=([^;]*)") - ); - return n ? decodeURIComponent(n[3]) : null; - }, - remove: function (r) { - this.write(r, "", Date.now() - 864e5); - }, - }; - })() - : (function () { - return { - write: function () {}, - read: function () { - return null; - }, - remove: function () {}, - }; - })(); - }); - var Cpt = I((ebn, Ipt) => { - "use strict"; - m(); - g(); - Ipt.exports = function (e) { - return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(e); - }; - }); - var Npt = I((tbn, Rpt) => { - "use strict"; - m(); - g(); - Rpt.exports = function (e, r) { - return r ? e.replace(/\/+$/, "") + "/" + r.replace(/^\/+/, "") : e; - }; - }); - var Fpt = I((rbn, Dpt) => { - "use strict"; - m(); - g(); - var c3r = Cpt(), - l3r = Npt(); - Dpt.exports = function (e, r) { - return e && !c3r(r) ? l3r(e, r) : r; - }; - }); - var qpt = I((nbn, Lpt) => { - "use strict"; - m(); - g(); - var x3e = Jh(), - f3r = [ - "age", - "authorization", - "content-length", - "content-type", - "etag", - "expires", - "from", - "host", - "if-modified-since", - "if-unmodified-since", - "last-modified", - "location", - "max-forwards", - "proxy-authorization", - "referer", - "retry-after", - "user-agent", - ]; - Lpt.exports = function (e) { - var r = {}, - n, - i, - o; - return ( - e && - x3e.forEach( - e.split(` -`), - function (s) { - if ( - ((o = s.indexOf(":")), - (n = x3e.trim(s.substr(0, o)).toLowerCase()), - (i = x3e.trim(s.substr(o + 1))), - n) - ) { - if (r[n] && f3r.indexOf(n) >= 0) return; - n === "set-cookie" - ? (r[n] = (r[n] ? r[n] : []).concat([i])) - : (r[n] = r[n] ? r[n] + ", " + i : i); - } - } - ), - r - ); - }; - }); - var Upt = I((ibn, jpt) => { - "use strict"; - m(); - g(); - var zpt = Jh(); - jpt.exports = zpt.isStandardBrowserEnv() - ? (function () { - var e = /(msie|trident)/i.test(navigator.userAgent), - r = document.createElement("a"), - n; - function i(o) { - var a = o; - return ( - e && (r.setAttribute("href", a), (a = r.href)), - r.setAttribute("href", a), - { - href: r.href, - protocol: r.protocol ? r.protocol.replace(/:$/, "") : "", - host: r.host, - search: r.search ? r.search.replace(/^\?/, "") : "", - hash: r.hash ? r.hash.replace(/^#/, "") : "", - hostname: r.hostname, - port: r.port, - pathname: - r.pathname.charAt(0) === "/" ? r.pathname : "/" + r.pathname, - } - ); - } - return ( - (n = i(window.location.href)), - function (a) { - var s = zpt.isString(a) ? i(a) : a; - return s.protocol === n.protocol && s.host === n.host; - } - ); - })() - : (function () { - return function () { - return !0; - }; - })(); - }); - var A3e = I((obn, Kpt) => { - "use strict"; - m(); - g(); - var nie = Jh(), - d3r = Ppt(), - h3r = Bpt(), - p3r = b3e(), - y3r = Fpt(), - m3r = qpt(), - g3r = Upt(), - S3e = _3e(); - Kpt.exports = function (e) { - return new Promise(function (n, i) { - var o = e.data, - a = e.headers, - s = e.responseType; - nie.isFormData(o) && delete a["Content-Type"]; - var c = new XMLHttpRequest(); - if (e.auth) { - var u = e.auth.username || "", - h = e.auth.password - ? unescape(encodeURIComponent(e.auth.password)) - : ""; - a.Authorization = "Basic " + btoa(u + ":" + h); - } - var w = y3r(e.baseURL, e.url); - c.open( - e.method.toUpperCase(), - p3r(w, e.params, e.paramsSerializer), - !0 - ), - (c.timeout = e.timeout); - function M() { - if (!!c) { - var O = - "getAllResponseHeaders" in c - ? m3r(c.getAllResponseHeaders()) - : null, - D = - !s || s === "text" || s === "json" - ? c.responseText - : c.response, - F = { - data: D, - status: c.status, - statusText: c.statusText, - headers: O, - config: e, - request: c, - }; - d3r(n, i, F), (c = null); - } - } - if ( - ("onloadend" in c - ? (c.onloadend = M) - : (c.onreadystatechange = function () { - !c || - c.readyState !== 4 || - (c.status === 0 && - !(c.responseURL && c.responseURL.indexOf("file:") === 0)) || - setTimeout(M); - }), - (c.onabort = function () { - !c || (i(S3e("Request aborted", e, "ECONNABORTED", c)), (c = null)); - }), - (c.onerror = function () { - i(S3e("Network Error", e, null, c)), (c = null); - }), - (c.ontimeout = function () { - var D = "timeout of " + e.timeout + "ms exceeded"; - e.timeoutErrorMessage && (D = e.timeoutErrorMessage), - i( - S3e( - D, - e, - e.transitional && e.transitional.clarifyTimeoutError - ? "ETIMEDOUT" - : "ECONNABORTED", - c - ) - ), - (c = null); - }), - nie.isStandardBrowserEnv()) - ) { - var k = - (e.withCredentials || g3r(w)) && e.xsrfCookieName - ? h3r.read(e.xsrfCookieName) - : void 0; - k && (a[e.xsrfHeaderName] = k); - } - "setRequestHeader" in c && - nie.forEach(a, function (D, F) { - typeof o > "u" && F.toLowerCase() === "content-type" - ? delete a[F] - : c.setRequestHeader(F, D); - }), - nie.isUndefined(e.withCredentials) || - (c.withCredentials = !!e.withCredentials), - s && s !== "json" && (c.responseType = e.responseType), - typeof e.onDownloadProgress == "function" && - c.addEventListener("progress", e.onDownloadProgress), - typeof e.onUploadProgress == "function" && - c.upload && - c.upload.addEventListener("progress", e.onUploadProgress), - e.cancelToken && - e.cancelToken.promise.then(function (D) { - !c || (c.abort(), i(D), (c = null)); - }), - o || (o = null), - c.send(o); - }); - }; - }); - var oie = I((abn, Wpt) => { - "use strict"; - m(); - g(); - var mc = Jh(), - Hpt = Ept(), - v3r = w3e(), - b3r = { "Content-Type": "application/x-www-form-urlencoded" }; - function Vpt(t, e) { - !mc.isUndefined(t) && - mc.isUndefined(t["Content-Type"]) && - (t["Content-Type"] = e); - } - function w3r() { - var t; - return ( - typeof XMLHttpRequest < "u" - ? (t = A3e()) - : typeof process < "u" && - Object.prototype.toString.call(process) === "[object process]" && - (t = A3e()), - t - ); - } - function _3r(t, e, r) { - if (mc.isString(t)) - try { - return (e || JSON.parse)(t), mc.trim(t); - } catch (n) { - if (n.name !== "SyntaxError") throw n; - } - return (r || JSON.stringify)(t); - } - var iie = { - transitional: { - silentJSONParsing: !0, - forcedJSONParsing: !0, - clarifyTimeoutError: !1, - }, - adapter: w3r(), - transformRequest: [ - function (e, r) { - return ( - Hpt(r, "Accept"), - Hpt(r, "Content-Type"), - mc.isFormData(e) || - mc.isArrayBuffer(e) || - mc.isBuffer(e) || - mc.isStream(e) || - mc.isFile(e) || - mc.isBlob(e) - ? e - : mc.isArrayBufferView(e) - ? e.buffer - : mc.isURLSearchParams(e) - ? (Vpt(r, "application/x-www-form-urlencoded;charset=utf-8"), - e.toString()) - : mc.isObject(e) || - (r && r["Content-Type"] === "application/json") - ? (Vpt(r, "application/json"), _3r(e)) - : e - ); - }, - ], - transformResponse: [ - function (e) { - var r = this.transitional, - n = r && r.silentJSONParsing, - i = r && r.forcedJSONParsing, - o = !n && this.responseType === "json"; - if (o || (i && mc.isString(e) && e.length)) - try { - return JSON.parse(e); - } catch (a) { - if (o) - throw a.name === "SyntaxError" - ? v3r(a, this, "E_JSON_PARSE") - : a; - } - return e; - }, - ], - timeout: 0, - xsrfCookieName: "XSRF-TOKEN", - xsrfHeaderName: "X-XSRF-TOKEN", - maxContentLength: -1, - maxBodyLength: -1, - validateStatus: function (e) { - return e >= 200 && e < 300; - }, - }; - iie.headers = { common: { Accept: "application/json, text/plain, */*" } }; - mc.forEach(["delete", "get", "head"], function (e) { - iie.headers[e] = {}; - }); - mc.forEach(["post", "put", "patch"], function (e) { - iie.headers[e] = mc.merge(b3r); - }); - Wpt.exports = iie; - }); - var Jpt = I((sbn, Gpt) => { - "use strict"; - m(); - g(); - var x3r = Jh(), - S3r = oie(); - Gpt.exports = function (e, r, n) { - var i = this || S3r; - return ( - x3r.forEach(n, function (a) { - e = a.call(i, e, r); - }), - e - ); - }; - }); - var E3e = I((ubn, $pt) => { - "use strict"; - m(); - g(); - $pt.exports = function (e) { - return !!(e && e.__CANCEL__); - }; - }); - var Ypt = I((cbn, Xpt) => { - "use strict"; - m(); - g(); - var Zpt = Jh(), - M3e = Jpt(), - A3r = E3e(), - E3r = oie(); - function T3e(t) { - t.cancelToken && t.cancelToken.throwIfRequested(); - } - Xpt.exports = function (e) { - T3e(e), - (e.headers = e.headers || {}), - (e.data = M3e.call(e, e.data, e.headers, e.transformRequest)), - (e.headers = Zpt.merge( - e.headers.common || {}, - e.headers[e.method] || {}, - e.headers - )), - Zpt.forEach( - ["delete", "get", "head", "post", "put", "patch", "common"], - function (i) { - delete e.headers[i]; - } - ); - var r = e.adapter || E3r.adapter; - return r(e).then( - function (i) { - return ( - T3e(e), - (i.data = M3e.call(e, i.data, i.headers, e.transformResponse)), - i - ); - }, - function (i) { - return ( - A3r(i) || - (T3e(e), - i && - i.response && - (i.response.data = M3e.call( - e, - i.response.data, - i.response.headers, - e.transformResponse - ))), - Promise.reject(i) - ); - } - ); - }; - }); - var k3e = I((lbn, Qpt) => { - "use strict"; - m(); - g(); - var ul = Jh(); - Qpt.exports = function (e, r) { - r = r || {}; - var n = {}, - i = ["url", "method", "data"], - o = ["headers", "auth", "proxy", "params"], - a = [ - "baseURL", - "transformRequest", - "transformResponse", - "paramsSerializer", - "timeout", - "timeoutMessage", - "withCredentials", - "adapter", - "responseType", - "xsrfCookieName", - "xsrfHeaderName", - "onUploadProgress", - "onDownloadProgress", - "decompress", - "maxContentLength", - "maxBodyLength", - "maxRedirects", - "transport", - "httpAgent", - "httpsAgent", - "cancelToken", - "socketPath", - "responseEncoding", - ], - s = ["validateStatus"]; - function c(M, k) { - return ul.isPlainObject(M) && ul.isPlainObject(k) - ? ul.merge(M, k) - : ul.isPlainObject(k) - ? ul.merge({}, k) - : ul.isArray(k) - ? k.slice() - : k; - } - function u(M) { - ul.isUndefined(r[M]) - ? ul.isUndefined(e[M]) || (n[M] = c(void 0, e[M])) - : (n[M] = c(e[M], r[M])); - } - ul.forEach(i, function (k) { - ul.isUndefined(r[k]) || (n[k] = c(void 0, r[k])); - }), - ul.forEach(o, u), - ul.forEach(a, function (k) { - ul.isUndefined(r[k]) - ? ul.isUndefined(e[k]) || (n[k] = c(void 0, e[k])) - : (n[k] = c(void 0, r[k])); - }), - ul.forEach(s, function (k) { - k in r ? (n[k] = c(e[k], r[k])) : k in e && (n[k] = c(void 0, e[k])); - }); - var h = i.concat(o).concat(a).concat(s), - w = Object.keys(e) - .concat(Object.keys(r)) - .filter(function (k) { - return h.indexOf(k) === -1; - }); - return ul.forEach(w, u), n; - }; - }); - var e0t = I((fbn, M3r) => { - M3r.exports = { - name: "axios", - version: "0.21.4", - description: "Promise based HTTP client for the browser and node.js", - main: "index.js", - scripts: { - test: "grunt test", - start: "node ./sandbox/server.js", - build: "NODE_ENV=production grunt build", - preversion: "npm test", - version: - "npm run build && grunt version && git add -A dist && git add CHANGELOG.md bower.json package.json", - postversion: "git push && git push --tags", - examples: "node ./examples/server.js", - coveralls: - "cat coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js", - fix: "eslint --fix lib/**/*.js", - }, - repository: { type: "git", url: "https://github.com/axios/axios.git" }, - keywords: ["xhr", "http", "ajax", "promise", "node"], - author: "Matt Zabriskie", - license: "MIT", - bugs: { url: "https://github.com/axios/axios/issues" }, - homepage: "https://axios-http.com", - devDependencies: { - coveralls: "^3.0.0", - "es6-promise": "^4.2.4", - grunt: "^1.3.0", - "grunt-banner": "^0.6.0", - "grunt-cli": "^1.2.0", - "grunt-contrib-clean": "^1.1.0", - "grunt-contrib-watch": "^1.0.0", - "grunt-eslint": "^23.0.0", - "grunt-karma": "^4.0.0", - "grunt-mocha-test": "^0.13.3", - "grunt-ts": "^6.0.0-beta.19", - "grunt-webpack": "^4.0.2", - "istanbul-instrumenter-loader": "^1.0.0", - "jasmine-core": "^2.4.1", - karma: "^6.3.2", - "karma-chrome-launcher": "^3.1.0", - "karma-firefox-launcher": "^2.1.0", - "karma-jasmine": "^1.1.1", - "karma-jasmine-ajax": "^0.1.13", - "karma-safari-launcher": "^1.0.0", - "karma-sauce-launcher": "^4.3.6", - "karma-sinon": "^1.0.5", - "karma-sourcemap-loader": "^0.3.8", - "karma-webpack": "^4.0.2", - "load-grunt-tasks": "^3.5.2", - minimist: "^1.2.0", - mocha: "^8.2.1", - sinon: "^4.5.0", - "terser-webpack-plugin": "^4.2.3", - typescript: "^4.0.5", - "url-search-params": "^0.10.0", - webpack: "^4.44.2", - "webpack-dev-server": "^3.11.0", - }, - browser: { "./lib/adapters/http.js": "./lib/adapters/xhr.js" }, - jsdelivr: "dist/axios.min.js", - unpkg: "dist/axios.min.js", - typings: "./index.d.ts", - dependencies: { "follow-redirects": "^1.14.0" }, - bundlesize: [{ path: "./dist/axios.min.js", threshold: "5kB" }], - }; - }); - var o0t = I((dbn, i0t) => { - "use strict"; - m(); - g(); - var r0t = e0t(), - P3e = {}; - ["object", "boolean", "number", "function", "string", "symbol"].forEach( - function (t, e) { - P3e[t] = function (n) { - return typeof n === t || "a" + (e < 1 ? "n " : " ") + t; - }; - } - ); - var t0t = {}, - T3r = r0t.version.split("."); - function n0t(t, e) { - for ( - var r = e ? e.split(".") : T3r, n = t.split("."), i = 0; - i < 3; - i++ - ) { - if (r[i] > n[i]) return !0; - if (r[i] < n[i]) return !1; - } - return !1; - } - P3e.transitional = function (e, r, n) { - var i = r && n0t(r); - function o(a, s) { - return ( - "[Axios v" + - r0t.version + - "] Transitional option '" + - a + - "'" + - s + - (n ? ". " + n : "") - ); - } - return function (a, s, c) { - if (e === !1) throw new Error(o(s, " has been removed in " + r)); - return ( - i && - !t0t[s] && - ((t0t[s] = !0), - console.warn( - o( - s, - " has been deprecated since v" + - r + - " and will be removed in the near future" - ) - )), - e ? e(a, s, c) : !0 - ); - }; - }; - function k3r(t, e, r) { - if (typeof t != "object") - throw new TypeError("options must be an object"); - for (var n = Object.keys(t), i = n.length; i-- > 0; ) { - var o = n[i], - a = e[o]; - if (a) { - var s = t[o], - c = s === void 0 || a(s, o, t); - if (c !== !0) throw new TypeError("option " + o + " must be " + c); - continue; - } - if (r !== !0) throw Error("Unknown option " + o); - } - } - i0t.exports = { isOlderVersion: n0t, assertOptions: k3r, validators: P3e }; - }); - var f0t = I((hbn, l0t) => { - "use strict"; - m(); - g(); - var u0t = Jh(), - P3r = b3e(), - a0t = Spt(), - s0t = Ypt(), - aie = k3e(), - c0t = o0t(), - E7 = c0t.validators; - function zK(t) { - (this.defaults = t), - (this.interceptors = { request: new a0t(), response: new a0t() }); - } - zK.prototype.request = function (e) { - typeof e == "string" - ? ((e = arguments[1] || {}), (e.url = arguments[0])) - : (e = e || {}), - (e = aie(this.defaults, e)), - e.method - ? (e.method = e.method.toLowerCase()) - : this.defaults.method - ? (e.method = this.defaults.method.toLowerCase()) - : (e.method = "get"); - var r = e.transitional; - r !== void 0 && - c0t.assertOptions( - r, - { - silentJSONParsing: E7.transitional(E7.boolean, "1.0.0"), - forcedJSONParsing: E7.transitional(E7.boolean, "1.0.0"), - clarifyTimeoutError: E7.transitional(E7.boolean, "1.0.0"), - }, - !1 - ); - var n = [], - i = !0; - this.interceptors.request.forEach(function (M) { - (typeof M.runWhen == "function" && M.runWhen(e) === !1) || - ((i = i && M.synchronous), n.unshift(M.fulfilled, M.rejected)); - }); - var o = []; - this.interceptors.response.forEach(function (M) { - o.push(M.fulfilled, M.rejected); - }); - var a; - if (!i) { - var s = [s0t, void 0]; - for ( - Array.prototype.unshift.apply(s, n), - s = s.concat(o), - a = Promise.resolve(e); - s.length; - - ) - a = a.then(s.shift(), s.shift()); - return a; - } - for (var c = e; n.length; ) { - var u = n.shift(), - h = n.shift(); - try { - c = u(c); - } catch (w) { - h(w); - break; - } - } - try { - a = s0t(c); - } catch (w) { - return Promise.reject(w); - } - for (; o.length; ) a = a.then(o.shift(), o.shift()); - return a; - }; - zK.prototype.getUri = function (e) { - return ( - (e = aie(this.defaults, e)), - P3r(e.url, e.params, e.paramsSerializer).replace(/^\?/, "") - ); - }; - u0t.forEach(["delete", "get", "head", "options"], function (e) { - zK.prototype[e] = function (r, n) { - return this.request( - aie(n || {}, { method: e, url: r, data: (n || {}).data }) - ); - }; - }); - u0t.forEach(["post", "put", "patch"], function (e) { - zK.prototype[e] = function (r, n, i) { - return this.request(aie(i || {}, { method: e, url: r, data: n })); - }; - }); - l0t.exports = zK; - }); - var B3e = I((pbn, d0t) => { - "use strict"; - m(); - g(); - function O3e(t) { - this.message = t; - } - O3e.prototype.toString = function () { - return "Cancel" + (this.message ? ": " + this.message : ""); - }; - O3e.prototype.__CANCEL__ = !0; - d0t.exports = O3e; - }); - var p0t = I((ybn, h0t) => { - "use strict"; - m(); - g(); - var O3r = B3e(); - function sie(t) { - if (typeof t != "function") - throw new TypeError("executor must be a function."); - var e; - this.promise = new Promise(function (i) { - e = i; - }); - var r = this; - t(function (i) { - r.reason || ((r.reason = new O3r(i)), e(r.reason)); - }); - } - sie.prototype.throwIfRequested = function () { - if (this.reason) throw this.reason; - }; - sie.source = function () { - var e, - r = new sie(function (i) { - e = i; - }); - return { token: r, cancel: e }; - }; - h0t.exports = sie; - }); - var m0t = I((mbn, y0t) => { - "use strict"; - m(); - g(); - y0t.exports = function (e) { - return function (n) { - return e.apply(null, n); - }; - }; - }); - var v0t = I((gbn, g0t) => { - "use strict"; - m(); - g(); - g0t.exports = function (e) { - return typeof e == "object" && e.isAxiosError === !0; - }; - }); - var _0t = I((vbn, I3e) => { - "use strict"; - m(); - g(); - var b0t = Jh(), - B3r = p3e(), - uie = f0t(), - I3r = k3e(), - C3r = oie(); - function w0t(t) { - var e = new uie(t), - r = B3r(uie.prototype.request, e); - return b0t.extend(r, uie.prototype, e), b0t.extend(r, e), r; - } - var wg = w0t(C3r); - wg.Axios = uie; - wg.create = function (e) { - return w0t(I3r(wg.defaults, e)); - }; - wg.Cancel = B3e(); - wg.CancelToken = p0t(); - wg.isCancel = E3e(); - wg.all = function (e) { - return Promise.all(e); - }; - wg.spread = m0t(); - wg.isAxiosError = v0t(); - I3e.exports = wg; - I3e.exports.default = wg; - }); - var S0t = I((bbn, x0t) => { - m(); - g(); - x0t.exports = _0t(); - }); - var cie = I(($h) => { - "use strict"; - m(); - g(); - var R3r = - ($h && $h.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - N3r = - ($h && $h.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - D3r = - ($h && $h.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - R3r(e, t, r); - return N3r(e, t), e; - }, - C3e = - ($h && $h.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty($h, "__esModule", { value: !0 }); - $h.MIN_BINARY_SIZE = void 0; - var iE = VC(), - A0t = K2e(), - kb = C3e(ng()), - jK = Qr(), - F3r = R3e(), - L3r = S7(), - E0t = DSe(), - q3r = C3e(S0t()), - M7 = KT(), - z3r = D3r(Rp()), - j3r = C3e(wT()); - $h.MIN_BINARY_SIZE = 80; - var T7 = class { - constructor(e) { - this.binary = e; - } - static isDataItem(e) { - return e.binary !== void 0; - } - get signatureType() { - let e = iE.byteArrayToLong(this.binary.subarray(0, 2)); - switch (e) { - case 1: - return M7.SignatureConfig.ARWEAVE; - case 2: - return M7.SignatureConfig.ED25519; - case 3: - return M7.SignatureConfig.ETHEREUM; - case 4: - return M7.SignatureConfig.SOLANA; - default: - throw new Error("Unknown signature type: " + e); - } - } - async isValid() { - return T7.verify(this.binary); - } - get id() { - return kb.default.encode(this.rawId); - } - set id(e) { - this._id = kb.default.toBuffer(e); - } - get rawId() { - return z3r.createHash("sha256").update(this.rawSignature).digest(); - } - set rawId(e) { - this._id = e; - } - get rawSignature() { - return this.binary.subarray(2, 2 + this.signatureLength); - } - get signature() { - return kb.default.encode(this.rawSignature); - } - get signatureLength() { - return M7.SIG_CONFIG[this.signatureType].sigLength; - } - get rawOwner() { - return this.binary.subarray( - 2 + this.signatureLength, - 2 + this.signatureLength + this.ownerLength - ); - } - get owner() { - return kb.default.encode(this.rawOwner); - } - get ownerLength() { - return M7.SIG_CONFIG[this.signatureType].pubLength; - } - get rawTarget() { - let e = this.getTargetStart(); - return this.binary[e] == 1 - ? this.binary.subarray(e + 1, e + 33) - : jK.Buffer.alloc(0); - } - get target() { - return kb.default.encode(this.rawTarget); - } - get rawAnchor() { - let e = this.getAnchorStart(); - return this.binary[e] == 1 - ? this.binary.subarray(e + 1, e + 33) - : jK.Buffer.alloc(0); - } - get anchor() { - return this.rawAnchor.toString(); - } - get rawTags() { - let e = this.getTagsStart(), - r = iE.byteArrayToLong(this.binary.subarray(e + 8, e + 16)); - return this.binary.subarray(e + 16, e + 16 + r); - } - get tags() { - let e = this.getTagsStart(); - if (iE.byteArrayToLong(this.binary.subarray(e, e + 8)) == 0) return []; - let n = iE.byteArrayToLong(this.binary.subarray(e + 8, e + 16)); - return A0t.tagsParser.fromBuffer( - jK.Buffer.from(this.binary.subarray(e + 16, e + 16 + n)) - ); - } - get tagsB64Url() { - return this.tags.map((r) => ({ - name: kb.default.encode(r.name), - value: kb.default.encode(r.value), - })); - } - getStartOfData() { - let e = this.getTagsStart(), - r = this.binary.subarray(e + 8, e + 16), - n = iE.byteArrayToLong(r); - return e + 16 + n; - } - get rawData() { - let e = this.getTagsStart(), - r = this.binary.subarray(e + 8, e + 16), - n = iE.byteArrayToLong(r), - i = e + 16 + n; - return this.binary.subarray(i, this.binary.length); - } - get data() { - return kb.default.encode(this.rawData); - } - getRaw() { - return this.binary; - } - async sign(e) { - return (this._id = await F3r.sign(this, e)), this.rawId; - } - async setSignature(e) { - this.binary.set(e, 2), - (this._id = jK.Buffer.from(await j3r.default.crypto.hash(e))); - } - isSigned() { - var e, r; - return ( - ((r = (e = this._id) === null || e === void 0 ? void 0 : e.length) !== - null && r !== void 0 - ? r - : 0) > 0 - ); - } - toJSON() { - return { - signature: this.signature, - owner: this.owner, - target: this.target, - tags: this.tags.map((e) => ({ - name: kb.default.encode(e.name), - value: kb.default.encode(e.value), - })), - data: this.data, - }; - } - async sendToBundler(e) { - let r = { "Content-Type": "application/octet-stream" }; - if (!this.isSigned()) - throw new Error("You must sign before sending to bundler"); - let n = await q3r.default.post(`${e}/tx`, this.getRaw(), { - headers: r, - timeout: 1e5, - maxBodyLength: 1 / 0, - validateStatus: (i) => (i > 200 && i < 300) || i !== 402, - }); - if (n.status === 402) throw new Error("Not enough funds to send data"); - return n; - } - static async verify(e) { - if (e.byteLength < $h.MIN_BINARY_SIZE) return !1; - let r = new T7(e), - n = r.signatureType, - i = r.getTagsStart(), - o = iE.byteArrayToLong(e.subarray(i, i + 8)), - a = e.subarray(i + 8, i + 16), - s = iE.byteArrayToLong(a); - if (s > 4096) return !1; - if (o > 0) - try { - if ( - A0t.tagsParser.fromBuffer( - jK.Buffer.from(e.subarray(i + 16, i + 16 + s)) - ).length !== o - ) - return !1; - } catch { - return !1; - } - let c = L3r.indexToType[n], - u = await E0t.getSignatureData(r); - return await c.verify(r.rawOwner, u, r.rawSignature); - } - async getSignatureData() { - return E0t.getSignatureData(this); - } - getTagsStart() { - let e = this.getTargetStart(), - r = this.binary[e] == 1, - n = e + (r ? 33 : 1); - return (n += this.binary[n] == 1 ? 33 : 1), n; - } - getTargetStart() { - return 2 + this.signatureLength + this.ownerLength; - } - getAnchorStart() { - let e = this.getTargetStart() + 1; - return (e += this.binary[this.getTargetStart()] == 1 ? 32 : 0), e; - } - }; - $h.default = T7; - }); - var F3e = I((UK) => { - "use strict"; - m(); - g(); - var M0t = - (UK && UK.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(UK, "__esModule", { value: !0 }); - var lie = M0t(ng()), - y6 = VC(), - N3e = M0t(cie()), - U3r = Rp(), - Pb = 32, - D3e = class { - constructor(e) { - (this.binary = e), - (this.length = this.getDataItemCount()), - (this.items = this.getItems()); - } - getRaw() { - return this.binary; - } - get(e) { - if (typeof e == "number") { - if (e >= this.length) throw new RangeError("Index out of range"); - return this.getByIndex(e); - } else return this.getById(e); - } - getSizes() { - let e = []; - for (let r = Pb; r < Pb + 64 * this.length; r += 64) - e.push(y6.byteArrayToLong(this.binary.subarray(r, r + 32))); - return e; - } - getIds() { - let e = []; - for (let r = Pb; r < Pb + 64 * this.length; r += 64) - e.push(lie.default.encode(this.binary.subarray(r + 32, r + 64))); - return e; - } - getIdBy(e) { - if (e > this.length - 1) - throw new RangeError("Index of bundle out of range"); - let r = 64 + 64 * e; - return lie.default.encode(this.binary.subarray(r, r + 32)); - } - async toTransaction(e, r, n) { - let i = await r.createTransaction({ data: this.binary, ...e }, n); - return ( - i.addTag("Bundle-Format", "binary"), - i.addTag("Bundle-Version", "2.0.0"), - i - ); - } - async verify() { - for (let e of this.items) { - let r = await e.isValid(), - n = lie.default( - U3r.createHash("sha256").update(e.rawSignature).digest() - ); - if (!(r && e.id === n)) return !1; - } - return !0; - } - getOffset(e) { - let r = 0; - for (let n = Pb; n < Pb + 64 * this.length; n += 64) { - let i = y6.byteArrayToLong(this.binary.subarray(n, n + 32)); - r += i; - let o = this.binary.subarray(n + 32, n + 64); - if (y6.arraybufferEqual(o, e)) return { startOffset: r, size: i }; - } - return { startOffset: -1, size: -1 }; - } - getByIndex(e) { - let r = 0, - n = 32 + 64 * e, - i = y6.byteArrayToLong(this.binary.subarray(n, n + 32)), - o = 0; - for (let h = Pb; h < Pb + 64 * this.length && o != e; h += 64) - (r += y6.byteArrayToLong(this.binary.subarray(h, h + 32))), o++; - let s = this.getBundleStart() + r, - c = this.binary.subarray(s, s + i + 200), - u = new N3e.default(c); - return (u.rawId = this.binary.slice(32 + 64 * e, 64 + 64 * e)), u; - } - getById(e) { - let r = lie.default.toBuffer(e), - n = this.getOffset(r); - if (n.startOffset === -1) throw new Error("Transaction not found"); - let o = this.getBundleStart() + n.startOffset; - return new N3e.default(this.binary.subarray(o, o + n.size)); - } - getDataItemCount() { - return y6.byteArrayToLong(this.binary.subarray(0, 32)); - } - getBundleStart() { - return 32 + 64 * this.length; - } - getItems() { - let e = new Array(this.length), - r = 0, - n = this.getBundleStart(), - i = 0; - for (let o = Pb; o < Pb + 64 * this.length; o += 64) { - let a = y6.byteArrayToLong(this.binary.subarray(o, o + 32)), - s = this.binary.subarray(o + 32, o + 64), - c = n + r, - u = this.binary.subarray(c, c + a); - r += a; - let h = new N3e.default(u); - (h.rawId = s), (e[i] = h), i++; - } - return e; - } - }; - UK.default = D3e; - }); - var R3e = I((Gy) => { - "use strict"; - m(); - g(); - var k0t = - (Gy && Gy.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Gy, "__esModule", { value: !0 }); - Gy.sign = - Gy.getSignatureAndId = - Gy.bundleAndSignData = - Gy.unbundleData = - void 0; - var K3r = DSe(), - T0t = VC(), - H3r = k0t(wT()), - P0t = k0t(F3e()); - function V3r(t) { - return new P0t.default(t); - } - Gy.unbundleData = V3r; - async function W3r(t, e) { - let r = new Uint8Array(64 * t.length), - n = await Promise.all( - t.map(async (o, a) => { - let s = o.isSigned() ? o.rawId : await B0t(o, e), - c = new Uint8Array(64); - return ( - c.set(T0t.longTo32ByteArray(o.getRaw().byteLength), 0), - c.set(s, 32), - r.set(c, 64 * a), - o.getRaw() - ); - }) - ).then((o) => Buffer.concat(o)), - i = Buffer.concat([T0t.longTo32ByteArray(t.length), r, n]); - return new P0t.default(i); - } - Gy.bundleAndSignData = W3r; - async function O0t(t, e) { - let r = await K3r.getSignatureData(t), - n = await e.sign(r), - i = await H3r.default.crypto.hash(n); - return { signature: Buffer.from(n), id: Buffer.from(i) }; - } - Gy.getSignatureAndId = O0t; - async function B0t(t, e) { - let { signature: r, id: n } = await O0t(t, e); - return t.getRaw().set(r, 2), n; - } - Gy.sign = B0t; - }); - var I0t = I((k7) => { - "use strict"; - m(); - g(); - var z3e = - (k7 && k7.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(k7, "__esModule", { value: !0 }); - k7.createData = void 0; - var L3e = z3e(Dr()), - G3r = z3e(ng()), - q3e = VC(), - J3r = z3e(cie()), - $3r = K2e(); - function Z3r(t, e, r) { - var n, i, o, a, s, c, u; - let h = e.publicKey, - w = r?.target ? G3r.default.toBuffer(r.target) : null, - M = 1 + ((n = w?.byteLength) !== null && n !== void 0 ? n : 0), - k = r?.anchor ? Buffer.from(r.anchor) : null, - O = 1 + ((i = k?.byteLength) !== null && i !== void 0 ? i : 0), - D = - ((a = (o = r?.tags) === null || o === void 0 ? void 0 : o.length) !== - null && a !== void 0 - ? a - : 0) > 0 - ? $3r.serializeTags(r.tags) - : null, - F = 16 + (D ? D.byteLength : 0), - N = typeof t == "string" ? Buffer.from(t) : Buffer.from(t), - q = N.byteLength, - z = 2 + e.signatureLength + e.ownerLength + M + O + F + q, - H = Buffer.alloc(z); - H.set(q3e.shortTo2ByteArray(e.signatureType), 0), - H.set(new Uint8Array(e.signatureLength).fill(0), 2), - L3e.default( - h.byteLength == e.ownerLength, - new Error( - `Owner must be ${e.ownerLength} bytes, but was incorrectly ${h.byteLength}` - ) - ), - H.set(h, 2 + e.signatureLength); - let Z = 2 + e.signatureLength + e.ownerLength; - (H[Z] = w ? 1 : 0), - w && - (L3e.default( - w.byteLength == 32, - new Error( - "Target must be 32 bytes but was incorrectly ${_target.byteLength}" - ) - ), - H.set(w, Z + 1)); - let $ = Z + M, - ue = $ + 1; - (H[$] = k ? 1 : 0), - k && - ((ue += k.byteLength), - L3e.default(k.byteLength == 32, new Error("Anchor must be 32 bytes")), - H.set(k, $ + 1)), - H.set( - q3e.longTo8ByteArray( - (c = (s = r?.tags) === null || s === void 0 ? void 0 : s.length) !== - null && c !== void 0 - ? c - : 0 - ), - ue - ); - let te = q3e.longTo8ByteArray( - (u = D?.byteLength) !== null && u !== void 0 ? u : 0 - ); - H.set(te, ue + 8), D && H.set(D, ue + 16); - let ne = ue + F; - return H.set(N, ne), new J3r.default(H); - } - k7.createData = Z3r; - }); - var KK = I((Do) => { - "use strict"; - m(); - g(); - var X3r = - (Do && Do.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Y3r = - (Do && Do.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Q3r = - (Do && Do.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - X3r(e, t, r); - return Y3r(e, t), e; - }, - j3e = - (Do && Do.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Do, "__esModule", { value: !0 }); - Do.signers = - Do.deepHash = - Do.unbundleData = - Do.bundleAndSignData = - Do.createData = - Do.DataItem = - Do.Bundle = - Do.MIN_BINARY_SIZE = - void 0; - var C0t = R3e(); - Object.defineProperty(Do, "bundleAndSignData", { - enumerable: !0, - get: function () { - return C0t.bundleAndSignData; - }, - }); - Object.defineProperty(Do, "unbundleData", { - enumerable: !0, - get: function () { - return C0t.unbundleData; - }, - }); - var eMr = j3e(F3e()); - Do.Bundle = eMr.default; - var R0t = Q3r(cie()); - Do.DataItem = R0t.default; - Object.defineProperty(Do, "MIN_BINARY_SIZE", { - enumerable: !0, - get: function () { - return R0t.MIN_BINARY_SIZE; - }, - }); - var tMr = NSe(); - Object.defineProperty(Do, "deepHash", { - enumerable: !0, - get: function () { - return tMr.deepHash; - }, - }); - var rMr = I0t(); - Object.defineProperty(Do, "createData", { - enumerable: !0, - get: function () { - return rMr.createData; - }, - }); - var nMr = S7(), - iMr = j3e(RK()), - oMr = j3e(kK()), - aMr = { - ArweaveSigner: nMr.ArweaveSigner, - SolanaSigner: iMr.default, - EthereumSigner: oMr.default, - }; - Do.signers = aMr; - }); - var m6 = I((aE) => { - "use strict"; - m(); - g(); - var sMr = - (aE && aE.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(aE, "__esModule", { value: !0 }); - aE.sleep = void 0; - var fie = sMr(Sy()); - fie.default.set({ DECIMAL_PLACES: 50 }); - var uMr = (t) => new Promise((e) => setTimeout(e, t)); - aE.sleep = uMr; - var oE = class { - constructor(e, r, n) { - (this.api = e), (this.currency = r), (this.currencyConfig = n); - } - static checkAndThrow(e, r, n) { - if (e?.status && !(n ?? []).includes(e.status) && e.status != 200) - throw new Error( - `HTTP Error: ${r}: ${e.status} ${ - typeof e.data != "string" ? e.statusText : e.data - }` - ); - } - async getNonce() { - let e = await this.api.get( - `/account/withdrawals/${this.currency}?address=${this.currencyConfig.address}` - ); - return oE.checkAndThrow(e, "Getting withdrawal nonce"), e.data; - } - async getBalance(e) { - let r = await this.api.get( - `/account/balance/${this.currency}?address=${e}` - ); - return ( - oE.checkAndThrow(r, "Getting balance"), - new fie.default(r.data.balance) - ); - } - async getBundlerAddress(e) { - let r = await this.api.get("/info"); - oE.checkAndThrow(r, "Getting Bundler address"); - let n = r.data.addresses[e]; - if (!n) - throw new Error(`Specified bundler does not support currency ${e}`); - return n; - } - async getPrice(e, r) { - let n = await this.api.get(`/price/${e}/${r}`); - return ( - oE.checkAndThrow(n, "Getting storage cost"), new fie.default(n.data) - ); - } - async confirmationPoll(e) { - if (!this.currencyConfig.isSlow) { - for (let r = 0; r < 30; r++) - if ( - (await (0, aE.sleep)(1e3), - await this.currencyConfig - .getTx(e) - .then((n) => n?.confirmed) - .catch((n) => !1)) - ) - return; - console.warn(`Tx ${e} didn't finalize after 30 seconds`); - } - } - unitConverter(e) { - return new fie.default(e).dividedBy(this.currencyConfig.base[1]); - } - }; - aE.default = oE; - }); - var D0t = I((B7) => { - "use strict"; - m(); - g(); - var U3e = - (B7 && B7.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(B7, "__esModule", { value: !0 }); - B7.withdrawBalance = void 0; - var N0t = KK(), - P7 = Dxe(), - cMr = U3e(m6()), - lMr = U3e(Sy()), - O7 = U3e(ng()); - async function fMr(t, e, r) { - let n = t.currencyConfig, - o = { - publicKey: await n.getPublicKey(), - currency: t.currency, - amount: new lMr.default(r).toString(), - nonce: await t.getNonce(), - signature: void 0, - sigType: n.getSigner().signatureType, - }, - a = await (0, N0t.deepHash)([ - (0, P7.stringToBuffer)(o.currency), - (0, P7.stringToBuffer)(o.amount.toString()), - (0, P7.stringToBuffer)(o.nonce.toString()), - ]); - Buffer.isBuffer(o.publicKey) || (o.publicKey = Buffer.from(o.publicKey)), - (o.signature = await n.sign(a)); - let s = await n.verify(o.publicKey, a, o.signature); - (o.publicKey = O7.default.encode(o.publicKey)), - (o.signature = O7.default.encode(o.signature)); - let c = O7.default.toBuffer(o.publicKey), - u = O7.default.toBuffer(o.signature), - h = await (0, N0t.deepHash)([ - (0, P7.stringToBuffer)(o.currency), - (0, P7.stringToBuffer)(o.amount.toString()), - (0, P7.stringToBuffer)(o.nonce.toString()), - ]), - w = await n.verify(c, h, u), - M = - n.ownerToAddress( - n.name == "arweave" - ? O7.default.decode(o.publicKey) - : O7.default.toBuffer(o.publicKey) - ) === n.address; - if (!(s || w || M)) - throw new Error(`Internal withdrawal validation failed - please report this! -Debug Info:${JSON.stringify(o)}`); - let k = await e.post("/account/withdraw", o); - return cMr.default.checkAndThrow(k, "Withdrawing balance"), k; - } - B7.withdrawBalance = fMr; - }); - var L0t = I((HK) => { - "use strict"; - m(); - g(); - var dMr = - (HK && HK.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(HK, "__esModule", { value: !0 }); - var F0t = KK(), - hMr = dMr(Rp()), - K3e = class extends F0t.DataItem { - constructor(e, r, n) { - var i; - super( - (0, F0t.createData)(e, r.currencyConfig.getSigner(), { - ...n, - anchor: - (i = n?.anchor) !== null && i !== void 0 - ? i - : hMr.default.randomBytes(32).toString("base64").slice(0, 32), - }).getRaw() - ), - (this.bundlr = r), - (this.signer = r.currencyConfig.getSigner()); - } - sign() { - return super.sign(this.signer); - } - get size() { - return this.getRaw().length; - } - async upload() { - return this.bundlr.uploader.transactionUploader(this); - } - }; - HK.default = K3e; - }); - var q0t = I((VK) => { - "use strict"; - m(); - g(); - var pMr = - (VK && VK.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(VK, "__esModule", { value: !0 }); - var yMr = D0t(), - mMr = pMr(L0t()), - H3e = class { - constructor() {} - get signer() { - return this.currencyConfig.getSigner(); - } - async withdrawBalance(e) { - return await (0, yMr.withdrawBalance)(this.utils, this.api, e); - } - async getLoadedBalance() { - return this.utils.getBalance(this.address); - } - async getBalance(e) { - return this.utils.getBalance(e); - } - async fund(e, r) { - return this.funder.fund(e, r); - } - async getPrice(e) { - return this.utils.getPrice(this.currency, e); - } - createTransaction(e, r) { - return new mMr.default(e, this, r); - } - getSigner() { - return this.currencyConfig.getSigner(); - } - }; - VK.default = H3e; - }); - var j0t = I((Pbn, z0t) => { - m(); - g(); - function Jy(t, e) { - typeof e == "boolean" && (e = { forever: e }), - (this._originalTimeouts = JSON.parse(JSON.stringify(t))), - (this._timeouts = t), - (this._options = e || {}), - (this._maxRetryTime = (e && e.maxRetryTime) || 1 / 0), - (this._fn = null), - (this._errors = []), - (this._attempts = 1), - (this._operationTimeout = null), - (this._operationTimeoutCb = null), - (this._timeout = null), - (this._operationStart = null), - (this._timer = null), - this._options.forever && - (this._cachedTimeouts = this._timeouts.slice(0)); - } - z0t.exports = Jy; - Jy.prototype.reset = function () { - (this._attempts = 1), (this._timeouts = this._originalTimeouts.slice(0)); - }; - Jy.prototype.stop = function () { - this._timeout && clearTimeout(this._timeout), - this._timer && clearTimeout(this._timer), - (this._timeouts = []), - (this._cachedTimeouts = null); - }; - Jy.prototype.retry = function (t) { - if ((this._timeout && clearTimeout(this._timeout), !t)) return !1; - var e = new Date().getTime(); - if (t && e - this._operationStart >= this._maxRetryTime) - return ( - this._errors.push(t), - this._errors.unshift(new Error("RetryOperation timeout occurred")), - !1 - ); - this._errors.push(t); - var r = this._timeouts.shift(); - if (r === void 0) - if (this._cachedTimeouts) - this._errors.splice(0, this._errors.length - 1), - (r = this._cachedTimeouts.slice(-1)); - else return !1; - var n = this; - return ( - (this._timer = setTimeout(function () { - n._attempts++, - n._operationTimeoutCb && - ((n._timeout = setTimeout(function () { - n._operationTimeoutCb(n._attempts); - }, n._operationTimeout)), - n._options.unref && n._timeout.unref()), - n._fn(n._attempts); - }, r)), - this._options.unref && this._timer.unref(), - !0 - ); - }; - Jy.prototype.attempt = function (t, e) { - (this._fn = t), - e && - (e.timeout && (this._operationTimeout = e.timeout), - e.cb && (this._operationTimeoutCb = e.cb)); - var r = this; - this._operationTimeoutCb && - (this._timeout = setTimeout(function () { - r._operationTimeoutCb(); - }, r._operationTimeout)), - (this._operationStart = new Date().getTime()), - this._fn(this._attempts); - }; - Jy.prototype.try = function (t) { - console.log("Using RetryOperation.try() is deprecated"), this.attempt(t); - }; - Jy.prototype.start = function (t) { - console.log("Using RetryOperation.start() is deprecated"), - this.attempt(t); - }; - Jy.prototype.start = Jy.prototype.try; - Jy.prototype.errors = function () { - return this._errors; - }; - Jy.prototype.attempts = function () { - return this._attempts; - }; - Jy.prototype.mainError = function () { - if (this._errors.length === 0) return null; - for (var t = {}, e = null, r = 0, n = 0; n < this._errors.length; n++) { - var i = this._errors[n], - o = i.message, - a = (t[o] || 0) + 1; - (t[o] = a), a >= r && ((e = i), (r = a)); - } - return e; - }; - }); - var U0t = I((g6) => { - m(); - g(); - var gMr = j0t(); - g6.operation = function (t) { - var e = g6.timeouts(t); - return new gMr(e, { - forever: t && (t.forever || t.retries === 1 / 0), - unref: t && t.unref, - maxRetryTime: t && t.maxRetryTime, - }); - }; - g6.timeouts = function (t) { - if (t instanceof Array) return [].concat(t); - var e = { - retries: 10, - factor: 2, - minTimeout: 1 * 1e3, - maxTimeout: 1 / 0, - randomize: !1, - }; - for (var r in t) e[r] = t[r]; - if (e.minTimeout > e.maxTimeout) - throw new Error("minTimeout is greater than maxTimeout"); - for (var n = [], i = 0; i < e.retries; i++) - n.push(this.createTimeout(i, e)); - return ( - t && t.forever && !n.length && n.push(this.createTimeout(i, e)), - n.sort(function (o, a) { - return o - a; - }), - n - ); - }; - g6.createTimeout = function (t, e) { - var r = e.randomize ? Math.random() + 1 : 1, - n = Math.round(r * Math.max(e.minTimeout, 1) * Math.pow(e.factor, t)); - return (n = Math.min(n, e.maxTimeout)), n; - }; - g6.wrap = function (t, e, r) { - if ((e instanceof Array && ((r = e), (e = null)), !r)) { - r = []; - for (var n in t) typeof t[n] == "function" && r.push(n); - } - for (var i = 0; i < r.length; i++) { - var o = r[i], - a = t[o]; - (t[o] = function (c) { - var u = g6.operation(e), - h = Array.prototype.slice.call(arguments, 1), - w = h.pop(); - h.push(function (M) { - u.retry(M) || - (M && (arguments[0] = u.mainError()), w.apply(this, arguments)); - }), - u.attempt(function () { - c.apply(t, h); - }); - }.bind(t, a)), - (t[o].options = e); - } - }; - }); - var H0t = I((Bbn, K0t) => { - m(); - g(); - K0t.exports = U0t(); - }); - var WK = I((Ibn, V0t) => { - m(); - g(); - var vMr = H0t(); - function bMr(t, e) { - function r(n, i) { - var o = e || {}, - a; - "randomize" in o || (o.randomize = !0), (a = vMr.operation(o)); - function s(h) { - i(h || new Error("Aborted")); - } - function c(h, w) { - if (h.bail) { - s(h); - return; - } - a.retry(h) ? o.onRetry && o.onRetry(h, w) : i(a.mainError()); - } - function u(h) { - var w; - try { - w = t(s, h); - } catch (M) { - c(M, h); - return; - } - Promise.resolve(w) - .then(n) - .catch(function (k) { - c(k, h); - }); - } - a.attempt(u); - } - return new Promise(r); - } - V0t.exports = bMr; - }); - var G0t = I((GK) => { - "use strict"; - m(); - g(); - var W3e = - (GK && GK.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(GK, "__esModule", { value: !0 }); - var wMr = W3e(WK()), - _Mr = W3e(Sy()), - W0t = W3e(m6()), - V3e = class { - constructor(e) { - this.utils = e; - } - async fund(e, r = 1) { - let n = new _Mr.default(e); - if (!n.isInteger()) - throw new Error("must use an integer for funding amount"); - let i = this.utils.currencyConfig, - o = await this.utils.getBundlerAddress(this.utils.currency), - a = "0"; - i.needsFee && - (a = (await i.getFee(i.base[0] === "winston" ? 0 : n, o)) - .multipliedBy(r) - .toFixed(0) - .toString()); - let s = await i.createTx(n, o, a), - c; - try { - c = await i.sendTx(s.tx); - } catch (h) { - throw h; - } - if ( - (s.txId || (s.txId = c), - W0t.default.checkAndThrow( - c, - `Sending transaction to the ${this.utils.currency} network` - ), - await this.utils.confirmationPoll(s.txId), - !(await (0, wMr.default)( - async (h) => { - let w = await this.utils.api.post( - `/account/balance/${this.utils.currency}`, - { tx_id: s.txId } - ); - return ( - w.status == 400 && - h( - new Error( - `failed to post funding tx - ${s.txId} (keep this id!) - ${w.data}` - ) - ), - W0t.default.checkAndThrow( - w, - `Posting transaction ${s.txId} information to the bundler`, - [202] - ), - w - ); - }, - { retries: 5, maxTimeout: 1e3, minTimeout: 100, randomize: !0 } - ))) - ) - throw new Error( - `failed to post funding tx - ${s.txId} - keep this id!` - ); - return { reward: a, target: o, quantity: n.toString(), id: s.txId }; - } - }; - GK.default = V3e; - }); - var J3e = I((die) => { - "use strict"; - m(); - g(); - Object.defineProperty(die, "__esModule", { value: !0 }); - die.PromisePoolError = void 0; - var G3e = class extends Error { - constructor(e, r) { - super(), - (this.raw = e), - (this.item = r), - (this.name = this.constructor.name), - (this.message = this.messageFrom(e)), - Error.captureStackTrace(this, this.constructor); - } - static createFrom(e, r) { - return new this(e, r); - } - messageFrom(e) { - return e instanceof Error || typeof e == "object" - ? e.message - : typeof e == "string" || typeof e == "number" - ? e.toString() - : ""; - } - }; - die.PromisePoolError = G3e; - }); - var Z3e = I((hie) => { - "use strict"; - m(); - g(); - Object.defineProperty(hie, "__esModule", { value: !0 }); - hie.StopThePromisePoolError = void 0; - var $3e = class extends Error {}; - hie.StopThePromisePoolError = $3e; - }); - var Y3e = I((pie) => { - "use strict"; - m(); - g(); - Object.defineProperty(pie, "__esModule", { value: !0 }); - pie.ValidationError = void 0; - var X3e = class extends Error { - constructor(e) { - super(e), Error.captureStackTrace(this, this.constructor); - } - static createFrom(e) { - return new this(e); - } - }; - pie.ValidationError = X3e; - }); - var $0t = I((yie) => { - "use strict"; - m(); - g(); - Object.defineProperty(yie, "__esModule", { value: !0 }); - yie.PromisePoolExecutor = void 0; - var xMr = J3e(), - J0t = Z3e(), - v6 = Y3e(), - Q3e = class { - constructor() { - (this.meta = { - tasks: [], - items: [], - errors: [], - results: [], - stopped: !1, - concurrency: 10, - processedItems: [], - }), - (this.handler = () => {}), - (this.errorHandler = void 0), - (this.onTaskStartedHandlers = []), - (this.onTaskFinishedHandlers = []); - } - useConcurrency(e) { - if (!this.isValidConcurrency(e)) - throw v6.ValidationError.createFrom( - `"concurrency" must be a number, 1 or up. Received "${e}" (${typeof e})` - ); - return (this.meta.concurrency = e), this; - } - isValidConcurrency(e) { - return typeof e == "number" && e >= 1; - } - concurrency() { - return this.meta.concurrency; - } - for(e) { - return (this.meta.items = e), this; - } - items() { - return this.meta.items; - } - itemsCount() { - return this.items().length; - } - tasks() { - return this.meta.tasks; - } - activeTaskCount() { - return this.activeTasksCount(); - } - activeTasksCount() { - return this.tasks().length; - } - processedItems() { - return this.meta.processedItems; - } - processedCount() { - return this.processedItems().length; - } - processedPercentage() { - return (this.processedCount() / this.itemsCount()) * 100; - } - results() { - return this.meta.results; - } - errors() { - return this.meta.errors; - } - withHandler(e) { - return (this.handler = e), this; - } - hasErrorHandler() { - return !!this.errorHandler; - } - handleError(e) { - return (this.errorHandler = e), this; - } - onTaskStarted(e) { - return (this.onTaskStartedHandlers = e), this; - } - onTaskFinished(e) { - return (this.onTaskFinishedHandlers = e), this; - } - hasReachedConcurrencyLimit() { - return this.activeTasksCount() >= this.concurrency(); - } - stop() { - throw (this.markAsStopped(), new J0t.StopThePromisePoolError()); - } - markAsStopped() { - return (this.meta.stopped = !0), this; - } - isStopped() { - return this.meta.stopped; - } - async start() { - return await this.validateInputs().process(); - } - validateInputs() { - if (typeof this.handler != "function") - throw v6.ValidationError.createFrom( - "The first parameter for the .process(fn) method must be a function" - ); - if (!Array.isArray(this.items())) - throw v6.ValidationError.createFrom( - `"items" must be an array. Received ${typeof this.items()}` - ); - if (this.errorHandler && typeof this.errorHandler != "function") - throw v6.ValidationError.createFrom( - `The error handler must be a function. Received ${typeof this - .errorHandler}` - ); - return ( - this.onTaskStartedHandlers.forEach((e) => { - if (e && typeof e != "function") - throw v6.ValidationError.createFrom( - `The onTaskStarted handler must be a function. Received ${typeof e}` - ); - }), - this.onTaskFinishedHandlers.forEach((e) => { - if (e && typeof e != "function") - throw v6.ValidationError.createFrom( - `The error handler must be a function. Received ${typeof e}` - ); - }), - this - ); - } - async process() { - for (let [e, r] of this.items().entries()) { - if (this.isStopped()) break; - await this.waitForProcessingSlot(), this.startProcessing(r, e); - } - return await this.drained(); - } - async waitForProcessingSlot() { - for (; this.hasReachedConcurrencyLimit(); ) - await Promise.race(this.tasks()); - } - startProcessing(e, r) { - let n = this.createTaskFor(e, r) - .then((i) => { - this.save(i).removeActive(n); - }) - .catch(async (i) => { - await this.handleErrorFor(i, e), this.removeActive(n); - }) - .finally(() => { - this.processedItems().push(e), this.runOnTaskFinishedHandlers(e); - }); - this.tasks().push(n), this.runOnTaskStartedHandlers(e); - } - async createTaskFor(e, r) { - return this.handler(e, r, this); - } - save(e) { - return this.results().push(e), this; - } - removeActive(e) { - return this.tasks().splice(this.tasks().indexOf(e), 1), this; - } - async handleErrorFor(e, r) { - if (!this.isStoppingThePoolError(e)) { - if (this.isValidationError(e)) throw (this.markAsStopped(), e); - this.hasErrorHandler() - ? await this.runErrorHandlerFor(e, r) - : this.saveErrorFor(e, r); - } - } - isStoppingThePoolError(e) { - return e instanceof J0t.StopThePromisePoolError; - } - isValidationError(e) { - return e instanceof v6.ValidationError; - } - async runErrorHandlerFor(e, r) { - var n; - try { - await ((n = this.errorHandler) === null || n === void 0 - ? void 0 - : n.call(this, e, r, this)); - } catch (i) { - this.rethrowIfNotStoppingThePool(i); - } - } - runOnTaskStartedHandlers(e) { - this.onTaskStartedHandlers.forEach((r) => { - r(e, this); - }); - } - runOnTaskFinishedHandlers(e) { - this.onTaskFinishedHandlers.forEach((r) => { - r(e, this); - }); - } - rethrowIfNotStoppingThePool(e) { - if (!this.isStoppingThePoolError(e)) throw e; - } - saveErrorFor(e, r) { - this.errors().push(xMr.PromisePoolError.createFrom(e, r)); - } - async drained() { - return ( - await this.drainActiveTasks(), - { errors: this.errors(), results: this.results() } - ); - } - async drainActiveTasks() { - await Promise.all(this.tasks()); - } - }; - yie.PromisePoolExecutor = Q3e; - }); - var eMe = I((mie) => { - "use strict"; - m(); - g(); - Object.defineProperty(mie, "__esModule", { value: !0 }); - mie.PromisePool = void 0; - var SMr = $0t(), - JK = class { - constructor(e) { - (this.concurrency = 10), - (this.items = e ?? []), - (this.errorHandler = void 0), - (this.onTaskStartedHandlers = []), - (this.onTaskFinishedHandlers = []); - } - withConcurrency(e) { - return (this.concurrency = e), this; - } - static withConcurrency(e) { - return new this().withConcurrency(e); - } - for(e) { - return new JK(e).withConcurrency(this.concurrency); - } - static for(e) { - return new this().for(e); - } - handleError(e) { - return (this.errorHandler = e), this; - } - onTaskStarted(e) { - return this.onTaskStartedHandlers.push(e), this; - } - onTaskFinished(e) { - return this.onTaskFinishedHandlers.push(e), this; - } - async process(e) { - return new SMr.PromisePoolExecutor() - .useConcurrency(this.concurrency) - .withHandler(e) - .handleError(this.errorHandler) - .onTaskStarted(this.onTaskStartedHandlers) - .onTaskFinished(this.onTaskFinishedHandlers) - .for(this.items) - .start(); - } - }; - mie.PromisePool = JK; - }); - var X0t = I((Z0t) => { - "use strict"; - m(); - g(); - Object.defineProperty(Z0t, "__esModule", { value: !0 }); - }); - var Q0t = I((Y0t) => { - "use strict"; - m(); - g(); - Object.defineProperty(Y0t, "__esModule", { value: !0 }); - }); - var eyt = I((r0) => { - "use strict"; - m(); - g(); - var AMr = - (r0 && r0.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - I7 = - (r0 && r0.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - AMr(e, t, r); - }; - Object.defineProperty(r0, "__esModule", { value: !0 }); - var EMr = eMe(); - r0.default = EMr.PromisePool; - I7(X0t(), r0); - I7(eMe(), r0); - I7(J3e(), r0); - I7(Q0t(), r0); - I7(Z3e(), r0); - I7(Y3e(), r0); - }); - var tyt = I((us) => { - "use strict"; - m(); - g(); - Object.defineProperty(us, "__esModule", { value: !0 }); - us.STATES = void 0; - var MMr = Symbol("not readable"), - TMr = Symbol("readable"), - kMr = Symbol("ended"), - PMr = Symbol("errored"); - us.STATES = { notReadable: MMr, readable: TMr, ended: kMr, errored: PMr }; - var tMe = class { - constructor(e, { size: r } = {}) { - (this._state = us.STATES.notReadable), - (this._rejections = new Set()), - (this._stream = e), - (this._size = r); - let n = ["_handleStreamEnd", "_handleStreamError"]; - for (let i of n) - Object.defineProperty(this, i, { - configurable: !0, - writable: !0, - value: this[i].bind(this), - }); - e.once("error", this._handleStreamError), - e.once("end", this._handleStreamEnd), - e.on("readable", () => { - this._state = us.STATES.readable; - }); - } - get closed() { - return this._state === us.STATES.ended; - } - [Symbol.asyncIterator]() { - return this; - } - async next() { - switch (this._state) { - case us.STATES.notReadable: { - let e, r; - try { - (e = this._untilReadable()), - (r = this._untilEnd()), - await Promise.race([e.promise, r.promise]); - } finally { - e?.close(), r?.close(); - } - return this.next(); - } - case us.STATES.ended: - return this.close(), { done: !0, value: void 0 }; - case us.STATES.errored: - throw (this.close(), this._error); - case us.STATES.readable: { - let e = this._size - ? this._stream.read(this._size) - : this._stream.read(); - return e !== null - ? { done: !1, value: e } - : ((this._state = us.STATES.notReadable), - await new Promise((r) => setTimeout((n) => n(!0), 0, r)), - this.next()); - } - } - } - _untilReadable() { - let e, - r = new Promise((i, o) => { - (e = () => { - (this._state = us.STATES.readable), - this._rejections.delete(o), - i(); - }), - this._state, - us.STATES.readable, - this._stream.once("readable", e), - this._rejections.add(o); - }); - return { - close: () => { - e != null && this._stream.removeListener("readable", e); - }, - promise: r, - }; - } - _untilEnd() { - let e, - r = new Promise((i, o) => { - (e = () => { - (this._state = us.STATES.ended), this._rejections.delete(o), i(); - }), - this._stream.once("end", e), - this._rejections.add(o); - }); - return { - close: () => { - e != null && this._stream.removeListener("end", e); - }, - promise: r, - }; - } - return() { - return (this._state = us.STATES.ended), this.next(); - } - throw(e) { - return ( - (this._error = e), (this._state = us.STATES.errored), this.next() - ); - } - close(e) { - this._stream.removeListener("end", this._handleStreamEnd), - this._stream.removeListener("error", this._handleStreamError), - (this._state = us.STATES.ended), - this._stream.destroy(e); - } - _handleStreamError(e) { - (this._error = e), (this._state = us.STATES.errored); - for (let r of this._rejections) r(e); - } - _handleStreamEnd() { - this._state = us.STATES.ended; - } - get state() { - return this._state; - } - }; - us.default = tMe; - }); - var nyt = I((C7) => { - "use strict"; - m(); - g(); - var gie = - (C7 && C7.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(C7, "__esModule", { value: !0 }); - C7.ChunkingUploader = void 0; - var rMe = KK(), - ryt = vM(), - OMr = o5(), - nMe = gie(m6()), - BMr = gie(Rp()), - iMe = rg(), - IMr = gie(WK()), - CMr = gie(tyt()), - oMe = class extends OMr.EventEmitter { - constructor(e, r) { - super({ captureRejections: !0 }), - (this.paused = !1), - (this.isResume = !1), - (this.currencyConfig = e), - (this.api = r), - (this.currency = this.currencyConfig.name), - (this.chunkSize = 25e6), - (this.batchSize = 5), - (this.uploadID = ""); - } - setResumeData(e) { - return e && ((this.uploadID = e), (this.isResume = !0)), this; - } - getResumeData() { - return this.uploadID; - } - setChunkSize(e) { - if (e < 1) throw new Error("Invalid chunk size (must be >=1)"); - return (this.chunkSize = e), this; - } - setBatchSize(e) { - if (e < 1) throw new Error("Invalid batch size (must be >=1)"); - return (this.batchSize = e), this; - } - pause() { - this.emit("pause"), (this.paused = !0); - } - resume() { - (this.paused = !1), this.emit("resume"); - } - async uploadTransaction(e) { - return rMe.DataItem.isDataItem(e) - ? this.runUpload(e.getRaw()) - : this.runUpload(e); - } - async uploadData(e, r) { - return this.runUpload(e, { ...r }); - } - async runUpload(e, r) { - var n, i, o; - let a = this.uploadID, - s = r === void 0, - c = { "x-chunking-version": "2" }, - u; - if (!a) - (u = await this.api.get(`/chunks/${this.currency}/-1/-1`, { - headers: c, - })), - nMe.default.checkAndThrow(u, "Getting upload token"), - (this.uploadID = a = u.data.id); - else { - if ( - ((u = await this.api.get(`/chunks/${this.currency}/${a}/-1`, { - headers: c, - })), - u.status === 404) - ) - throw new Error( - "Upload ID not found - your upload has probably expired." - ); - if ( - (nMe.default.checkAndThrow(u, "Getting upload info"), - this.chunkSize != +u.data.size) - ) - throw new Error( - `Chunk size not equal to that of a previous upload (${+u.data - .size}).` - ); - } - let { max: h, min: w } = u.data; - if (this.chunkSize < +w || this.chunkSize > +h) - throw new Error(`Chunk size out of allowed range: ${w} - ${h}`); - let M = 0, - k = (y, d, v) => - new Promise((_) => { - (0, IMr.default)(async () => { - await this.api - .post(`/chunks/${this.currency}/${a}/${d}`, y, { - headers: { - "Content-Type": "application/octet-stream", - ...c, - }, - maxBodyLength: 1 / 0, - maxContentLength: 1 / 0, - }) - .then((S) => { - if (S?.status >= 300) { - let b = { res: S, id: v, offset: d, size: y.length }; - throw (this.emit("chunkError", b), b); - } - this.emit("chunkUpload", { - id: v, - offset: d, - size: y.length, - totalUploaded: (M += y.length), - }), - _({ o: d, d: S }); - }); - }); - }), - O = (n = u.data.chunks) !== null && n !== void 0 ? n : [], - D = new ryt.PassThrough(), - F = Buffer.alloc(0), - N = !1, - q = !0; - D.on("end", () => (N = !0)), - D.on("error", (y) => { - throw new Error(`Error processing readable: ${y}`); - }); - let z = async (y) => { - for (; !N; ) { - if (F.length >= y) - return (d = Buffer.from(F.slice(0, y))), (F = F.slice(y)), d; - var d = D.read(y); - if (d === null) { - await new Promise((v) => setTimeout((_) => _(!0), 0, v)); - continue; - } - if (d.length === y) return d; - F = Buffer.concat([F, d]); - } - for (; F.length >= y; ) - return (d = Buffer.from(F.slice(0, y))), (F = F.slice(y)), d; - return (q = !1), F; - }, - H; - s || - ((H = (0, rMe.createData)("", this.currencyConfig.getSigner(), { - ...r, - anchor: - (i = r?.anchor) !== null && i !== void 0 - ? i - : BMr.default.randomBytes(32).toString("base64").slice(0, 32), - })), - D.write(H.getRaw()), - (M -= H.getRaw().length)), - Buffer.isBuffer(e) ? (D.write(e), D.end()) : e.pipe(D); - let Z = 0, - $ = [], - ue = 0, - te, - ne, - A; - if (!s) { - ne = new ryt.PassThrough(); - let y = H.getRaw().length; - (te = await z(this.chunkSize)), - ue++, - (Z += te.length), - ne.write(te.slice(y)); - let d = [ - (0, iMe.stringToBuffer)("dataitem"), - (0, iMe.stringToBuffer)("1"), - (0, iMe.stringToBuffer)(H.signatureType.toString()), - H.rawOwner, - H.rawTarget, - H.rawAnchor, - H.rawTags, - new CMr.default(ne), - ]; - A = (0, rMe.deepHash)(d); - } - let l = O.pop(); - for (; q; ) { - if ( - (this.paused && - (await new Promise((d) => this.on("resume", () => d(void 0)))), - l && +l[0] - Z <= this.chunkSize) - ) { - let v = l[1], - _ = await z(v); - s || ne.write(_), (Z += v), (l = O.pop()), ue++, (M += v); - continue; - } - let y = await z(this.chunkSize); - s || ne.write(y), - $.length == this.batchSize && (await Promise.all($), ($ = [])), - $.push(k(y, Z, ++ue)), - (Z += y.length); - } - if ((ne && ne.end(), await Promise.all($), !s)) { - let y = await A, - d = Buffer.from(await this.currencyConfig.getSigner().sign(y)); - te.set(d, 2), await k(te, 0, 0); - } - let p = await this.api.post( - `/chunks/${this.currency}/${a}/-1`, - null, - { - headers: { "Content-Type": "application/octet-stream", ...c }, - timeout: this.api.config.timeout * 10, - } - ); - if (p.status === 402) - throw new Error("Not enough funds to send data"); - return ( - nMe.default.checkAndThrow(p, "Finalising upload", [201]), - p.status === 201 && - (p.data = { - id: - (o = p.statusText.split(" ")) === null || o === void 0 - ? void 0 - : o[1], - }), - this.emit("done", p), - p - ); - } - get completionPromise() { - return new Promise((e) => this.on("done", e)); - } - }; - C7.ChunkingUploader = oMe; - }); - var oyt = I((b6) => { - "use strict"; - m(); - g(); - var iyt = - (b6 && b6.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(b6, "__esModule", { value: !0 }); - b6.sleep = void 0; - var RMr = KK(), - NMr = iyt(eyt()), - DMr = iyt(WK()), - FMr = nyt(), - LMr = (t) => new Promise((e) => setTimeout(e, t)); - b6.sleep = LMr; - var aMe = class { - constructor(e, r, n, i) { - (this.api = e), - (this.currency = n), - (this.currencyConfig = i), - (this.utils = r); - } - async upload(e, r) { - return await this.chunkedUploader.uploadData(e, r); - } - get chunkedUploader() { - return new FMr.ChunkingUploader(this.currencyConfig, this.api); - } - async transactionUploader(e) { - let r, - n = RMr.DataItem.isDataItem(e); - if (this.forceUseChunking || (n && e.getRaw().length > 5e7) || !n) - r = await this.chunkedUploader.uploadTransaction(n ? e.getRaw() : e); - else { - let { - protocol: i, - host: o, - port: a, - timeout: s, - } = this.api.getConfig(); - (r = await this.api.post( - `${i}://${o}:${a}/tx/${this.currency}`, - e.getRaw(), - { - headers: { "Content-Type": "application/octet-stream" }, - timeout: s, - maxBodyLength: 1 / 0, - } - )), - r.status == 201 && (r.data = { id: e.id }); - } - switch (r.status) { - case 402: - throw new Error("Not enough funds to send data"); - default: - if (r.status >= 400) - throw new Error( - `whilst uploading DataItem: ${r.status} ${r.statusText}` - ); - } - return r; - } - async concurrentUploader(e, r = 5, n, i) { - let o = [], - a = await NMr.default - .for(e) - .withConcurrency(r >= 1 ? r : 5) - .handleError(async (s, c) => { - if ((o.push(s), s.message === "Not enough funds to send data")) - throw s; - }) - .process(async (s, c, u) => { - await (0, DMr.default)( - async (h) => { - try { - let w = await this.processItem(s); - return ( - c % r == 0 && (await i(`Processed ${c} Items`)), - n - ? await n({ item: s, res: w, i: c }) - : { item: s, res: w, i: c } - ); - } catch (w) { - throw ( - (w.message === "Not enough funds to send data" && h(w), w) - ); - } - }, - { retries: 3, minTimeout: 1e3, maxTimeout: 1e4 } - ); - }); - return { errors: o, results: a.results }; - } - async processItem(e) { - return ( - typeof e == "string" && (e = Buffer.from(e)), - await this.transactionUploader(e) - ); - } - async generateManifest(e) { - let { items: r, indexFile: n } = e, - i = { manifest: "arweave/paths", version: "0.1.0", paths: {} }; - if (n) { - if (!r.has(n)) throw new Error(`Unable to access item: ${n}`); - i.index = { path: n }; - } - for (let [o, a] of r.entries()) i.paths[o] = { id: a }; - return i; - } - set useChunking(e) { - typeof e == "boolean" && (this.forceUseChunking = e); - } - set contentType(e) { - this.contentTypeOverride = e; - } - }; - b6.default = aMe; - }); - var ayt = I((vie) => { - "use strict"; - m(); - g(); - Object.defineProperty(vie, "__esModule", { value: !0 }); - vie.version = void 0; - vie.version = "networks/5.7.0"; - }); - var sMe = I((_ie) => { - "use strict"; - m(); - g(); - Object.defineProperty(_ie, "__esModule", { value: !0 }); - _ie.getNetwork = void 0; - var qMr = rr(), - zMr = ayt(), - syt = new qMr.Logger(zMr.version); - function jMr(t) { - return t && typeof t.renetwork == "function"; - } - function sE(t) { - var e = function (r, n) { - n == null && (n = {}); - var i = []; - if (r.InfuraProvider && n.infura !== "-") - try { - i.push(new r.InfuraProvider(t, n.infura)); - } catch {} - if (r.EtherscanProvider && n.etherscan !== "-") - try { - i.push(new r.EtherscanProvider(t, n.etherscan)); - } catch {} - if (r.AlchemyProvider && n.alchemy !== "-") - try { - i.push(new r.AlchemyProvider(t, n.alchemy)); - } catch {} - if (r.PocketProvider && n.pocket !== "-") { - var o = ["goerli", "ropsten", "rinkeby"]; - try { - var a = new r.PocketProvider(t, n.pocket); - a.network && o.indexOf(a.network.name) === -1 && i.push(a); - } catch {} - } - if (r.CloudflareProvider && n.cloudflare !== "-") - try { - i.push(new r.CloudflareProvider(t)); - } catch {} - if (r.AnkrProvider && n.ankr !== "-") - try { - var o = ["ropsten"], - a = new r.AnkrProvider(t, n.ankr); - a.network && o.indexOf(a.network.name) === -1 && i.push(a); - } catch {} - if (i.length === 0) return null; - if (r.FallbackProvider) { - var s = 1; - return ( - n.quorum != null ? (s = n.quorum) : t === "homestead" && (s = 2), - new r.FallbackProvider(i, s) - ); - } - return i[0]; - }; - return ( - (e.renetwork = function (r) { - return sE(r); - }), - e - ); - } - function wie(t, e) { - var r = function (n, i) { - return n.JsonRpcProvider ? new n.JsonRpcProvider(t, e) : null; - }; - return ( - (r.renetwork = function (n) { - return wie(t, n); - }), - r - ); - } - var uyt = { - chainId: 1, - ensAddress: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e", - name: "homestead", - _defaultProvider: sE("homestead"), - }, - cyt = { - chainId: 3, - ensAddress: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e", - name: "ropsten", - _defaultProvider: sE("ropsten"), - }, - lyt = { - chainId: 63, - name: "classicMordor", - _defaultProvider: wie( - "https://www.ethercluster.com/mordor", - "classicMordor" - ), - }, - bie = { - unspecified: { chainId: 0, name: "unspecified" }, - homestead: uyt, - mainnet: uyt, - morden: { chainId: 2, name: "morden" }, - ropsten: cyt, - testnet: cyt, - rinkeby: { - chainId: 4, - ensAddress: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e", - name: "rinkeby", - _defaultProvider: sE("rinkeby"), - }, - kovan: { chainId: 42, name: "kovan", _defaultProvider: sE("kovan") }, - goerli: { - chainId: 5, - ensAddress: "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e", - name: "goerli", - _defaultProvider: sE("goerli"), - }, - kintsugi: { chainId: 1337702, name: "kintsugi" }, - classic: { - chainId: 61, - name: "classic", - _defaultProvider: wie("https://www.ethercluster.com/etc", "classic"), - }, - classicMorden: { chainId: 62, name: "classicMorden" }, - classicMordor: lyt, - classicTestnet: lyt, - classicKotti: { - chainId: 6, - name: "classicKotti", - _defaultProvider: wie( - "https://www.ethercluster.com/kotti", - "classicKotti" - ), - }, - xdai: { chainId: 100, name: "xdai" }, - matic: { chainId: 137, name: "matic", _defaultProvider: sE("matic") }, - maticmum: { chainId: 80001, name: "maticmum" }, - optimism: { - chainId: 10, - name: "optimism", - _defaultProvider: sE("optimism"), - }, - "optimism-kovan": { chainId: 69, name: "optimism-kovan" }, - "optimism-goerli": { chainId: 420, name: "optimism-goerli" }, - arbitrum: { chainId: 42161, name: "arbitrum" }, - "arbitrum-rinkeby": { chainId: 421611, name: "arbitrum-rinkeby" }, - "arbitrum-goerli": { chainId: 421613, name: "arbitrum-goerli" }, - bnb: { chainId: 56, name: "bnb" }, - bnbt: { chainId: 97, name: "bnbt" }, - }; - function UMr(t) { - if (t == null) return null; - if (typeof t == "number") { - for (var e in bie) { - var r = bie[e]; - if (r.chainId === t) - return { - name: r.name, - chainId: r.chainId, - ensAddress: r.ensAddress || null, - _defaultProvider: r._defaultProvider || null, - }; - } - return { chainId: t, name: "unknown" }; - } - if (typeof t == "string") { - var n = bie[t]; - return n == null - ? null - : { - name: n.name, - chainId: n.chainId, - ensAddress: n.ensAddress, - _defaultProvider: n._defaultProvider || null, - }; - } - var i = bie[t.name]; - if (!i) - return ( - typeof t.chainId != "number" && - syt.throwArgumentError("invalid network chainId", "network", t), - t - ); - t.chainId !== 0 && - t.chainId !== i.chainId && - syt.throwArgumentError("network chainId mismatch", "network", t); - var o = t._defaultProvider || null; - return ( - o == null && - i._defaultProvider && - (jMr(i._defaultProvider) - ? (o = i._defaultProvider.renetwork(t)) - : (o = i._defaultProvider)), - { - name: t.name, - chainId: i.chainId, - ensAddress: t.ensAddress || i.ensAddress || null, - _defaultProvider: o, - } - ); - } - _ie.getNetwork = UMr; - }); - var fyt = I((xie) => { - "use strict"; - m(); - g(); - Object.defineProperty(xie, "__esModule", { value: !0 }); - xie.version = void 0; - xie.version = "web/5.7.0"; - }); - var dyt = I((uE) => { - "use strict"; - m(); - g(); - var KMr = - (uE && uE.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - HMr = - (uE && uE.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(uE, "__esModule", { value: !0 }); - uE.getUrl = void 0; - var VMr = Ar(); - function WMr(t, e) { - return KMr(this, void 0, void 0, function () { - var r, n, i, o, a; - return HMr(this, function (s) { - switch (s.label) { - case 0: - return ( - e == null && (e = {}), - (r = { - method: e.method || "GET", - headers: e.headers || {}, - body: e.body || void 0, - }), - e.skipFetchSetup !== !0 && - ((r.mode = "cors"), - (r.cache = "no-cache"), - (r.credentials = "same-origin"), - (r.redirect = "follow"), - (r.referrer = "client")), - e.fetchOptions != null && - ((n = e.fetchOptions), - n.mode && (r.mode = n.mode), - n.cache && (r.cache = n.cache), - n.credentials && (r.credentials = n.credentials), - n.redirect && (r.redirect = n.redirect), - n.referrer && (r.referrer = n.referrer)), - [4, fetch(t, r)] - ); - case 1: - return (i = s.sent()), [4, i.arrayBuffer()]; - case 2: - return ( - (o = s.sent()), - (a = {}), - i.headers.forEach - ? i.headers.forEach(function (c, u) { - a[u.toLowerCase()] = c; - }) - : i.headers.keys().forEach(function (c) { - a[c.toLowerCase()] = i.headers.get(c); - }), - [ - 2, - { - headers: a, - statusCode: i.status, - statusMessage: i.statusText, - body: (0, VMr.arrayify)(new Uint8Array(o)), - }, - ] - ); - } - }); - }); - } - uE.getUrl = WMr; - }); - var R7 = I(($y) => { - "use strict"; - m(); - g(); - var GMr = - ($y && $y.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - JMr = - ($y && $y.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty($y, "__esModule", { value: !0 }); - $y.poll = $y.fetchJson = $y._fetchData = void 0; - var hyt = lb(), - pyt = Ar(), - Sie = $r(), - Aie = Eo(), - Mx = rr(), - $Mr = fyt(), - _g = new Mx.Logger($Mr.version), - ZMr = dyt(); - function yyt(t) { - return new Promise(function (e) { - setTimeout(e, t); - }); - } - function cE(t, e) { - if (t == null) return null; - if (typeof t == "string") return t; - if ((0, pyt.isBytesLike)(t)) { - if ( - e && - (e.split("/")[0] === "text" || - e.split(";")[0].trim() === "application/json") - ) - try { - return (0, Aie.toUtf8String)(t); - } catch {} - return (0, pyt.hexlify)(t); - } - return t; - } - function myt(t, e, r) { - var n = - typeof t == "object" && t.throttleLimit != null ? t.throttleLimit : 12; - _g.assertArgument( - n > 0 && n % 1 === 0, - "invalid connection throttle limit", - "connection.throttleLimit", - n - ); - var i = typeof t == "object" ? t.throttleCallback : null, - o = - typeof t == "object" && typeof t.throttleSlotInterval == "number" - ? t.throttleSlotInterval - : 100; - _g.assertArgument( - o > 0 && o % 1 === 0, - "invalid connection throttle slot interval", - "connection.throttleSlotInterval", - o - ); - var a = typeof t == "object" ? !!t.errorPassThrough : !1, - s = {}, - c = null, - u = { method: "GET" }, - h = !1, - w = 2 * 60 * 1e3; - if (typeof t == "string") c = t; - else if (typeof t == "object") { - if ( - ((t == null || t.url == null) && - _g.throwArgumentError("missing URL", "connection.url", t), - (c = t.url), - typeof t.timeout == "number" && t.timeout > 0 && (w = t.timeout), - t.headers) - ) - for (var M in t.headers) - (s[M.toLowerCase()] = { key: M, value: String(t.headers[M]) }), - ["if-none-match", "if-modified-since"].indexOf(M.toLowerCase()) >= - 0 && (h = !0); - if ( - ((u.allowGzip = !!t.allowGzip), t.user != null && t.password != null) - ) { - c.substring(0, 6) !== "https:" && - t.allowInsecureAuthentication !== !0 && - _g.throwError( - "basic authentication requires a secure https url", - Mx.Logger.errors.INVALID_ARGUMENT, - { argument: "url", url: c, user: t.user, password: "[REDACTED]" } - ); - var k = t.user + ":" + t.password; - s.authorization = { - key: "Authorization", - value: "Basic " + (0, hyt.encode)((0, Aie.toUtf8Bytes)(k)), - }; - } - t.skipFetchSetup != null && (u.skipFetchSetup = !!t.skipFetchSetup), - t.fetchOptions != null && - (u.fetchOptions = (0, Sie.shallowCopy)(t.fetchOptions)); - } - var O = new RegExp("^data:([a-z0-9-]+/[a-z0-9-]+);base64,(.*)$", "i"), - D = c ? c.match(O) : null; - if (D) - try { - var F = { - statusCode: 200, - statusMessage: "OK", - headers: { "content-type": D[1] }, - body: (0, hyt.decode)(D[2]), - }, - N = F.body; - return r && (N = r(F.body, F)), Promise.resolve(N); - } catch (Z) { - _g.throwError( - "processing response error", - Mx.Logger.errors.SERVER_ERROR, - { - body: cE(D[1], D[2]), - error: Z, - requestBody: null, - requestMethod: "GET", - url: c, - } - ); - } - e && - ((u.method = "POST"), - (u.body = e), - s["content-type"] == null && - (s["content-type"] = { - key: "Content-Type", - value: "application/octet-stream", - }), - s["content-length"] == null && - (s["content-length"] = { - key: "Content-Length", - value: String(e.length), - })); - var q = {}; - Object.keys(s).forEach(function (Z) { - var $ = s[Z]; - q[$.key] = $.value; - }), - (u.headers = q); - var z = (function () { - var Z = null, - $ = new Promise(function (te, ne) { - w && - (Z = setTimeout(function () { - Z != null && - ((Z = null), - ne( - _g.makeError("timeout", Mx.Logger.errors.TIMEOUT, { - requestBody: cE(u.body, q["content-type"]), - requestMethod: u.method, - timeout: w, - url: c, - }) - )); - }, w)); - }), - ue = function () { - Z != null && (clearTimeout(Z), (Z = null)); - }; - return { promise: $, cancel: ue }; - })(), - H = (function () { - return GMr(this, void 0, void 0, function () { - var Z, $, ue, d, te, ne, A, l, p, y, d, v; - return JMr(this, function (_) { - switch (_.label) { - case 0: - (Z = 0), (_.label = 1); - case 1: - if (!(Z < n)) return [3, 20]; - ($ = null), (_.label = 2); - case 2: - return _.trys.push([2, 9, , 10]), [4, (0, ZMr.getUrl)(c, u)]; - case 3: - return ( - ($ = _.sent()), - Z < n - ? $.statusCode === 301 || $.statusCode === 302 - ? ((ue = $.headers.location || ""), - u.method === "GET" && ue.match(/^https:/) - ? ((c = $.headers.location), [3, 19]) - : [3, 8]) - : [3, 4] - : [3, 8] - ); - case 4: - return $.statusCode !== 429 - ? [3, 8] - : ((d = !0), i ? [4, i(Z, c)] : [3, 6]); - case 5: - (d = _.sent()), (_.label = 6); - case 6: - return d - ? ((te = 0), - (ne = $.headers["retry-after"]), - typeof ne == "string" && ne.match(/^[1-9][0-9]*$/) - ? (te = parseInt(ne) * 1e3) - : (te = - o * - parseInt(String(Math.random() * Math.pow(2, Z)))), - [4, yyt(te)]) - : [3, 8]; - case 7: - return _.sent(), [3, 19]; - case 8: - return [3, 10]; - case 9: - return ( - (A = _.sent()), - ($ = A.response), - $ == null && - (z.cancel(), - _g.throwError( - "missing response", - Mx.Logger.errors.SERVER_ERROR, - { - requestBody: cE(u.body, q["content-type"]), - requestMethod: u.method, - serverError: A, - url: c, - } - )), - [3, 10] - ); - case 10: - if ( - ((l = $.body), - h && $.statusCode === 304 - ? (l = null) - : !a && - ($.statusCode < 200 || $.statusCode >= 300) && - (z.cancel(), - _g.throwError( - "bad response", - Mx.Logger.errors.SERVER_ERROR, - { - status: $.statusCode, - headers: $.headers, - body: cE( - l, - $.headers ? $.headers["content-type"] : null - ), - requestBody: cE(u.body, q["content-type"]), - requestMethod: u.method, - url: c, - } - )), - !r) - ) - return [3, 18]; - _.label = 11; - case 11: - return _.trys.push([11, 13, , 18]), [4, r(l, $)]; - case 12: - return (p = _.sent()), z.cancel(), [2, p]; - case 13: - return ( - (y = _.sent()), - y.throttleRetry && Z < n - ? ((d = !0), i ? [4, i(Z, c)] : [3, 15]) - : [3, 17] - ); - case 14: - (d = _.sent()), (_.label = 15); - case 15: - return d - ? ((v = - o * parseInt(String(Math.random() * Math.pow(2, Z)))), - [4, yyt(v)]) - : [3, 17]; - case 16: - return _.sent(), [3, 19]; - case 17: - return ( - z.cancel(), - _g.throwError( - "processing response error", - Mx.Logger.errors.SERVER_ERROR, - { - body: cE( - l, - $.headers ? $.headers["content-type"] : null - ), - error: y, - requestBody: cE(u.body, q["content-type"]), - requestMethod: u.method, - url: c, - } - ), - [3, 18] - ); - case 18: - return z.cancel(), [2, l]; - case 19: - return Z++, [3, 1]; - case 20: - return [ - 2, - _g.throwError( - "failed response", - Mx.Logger.errors.SERVER_ERROR, - { - requestBody: cE(u.body, q["content-type"]), - requestMethod: u.method, - url: c, - } - ), - ]; - } - }); - }); - })(); - return Promise.race([z.promise, H]); - } - $y._fetchData = myt; - function XMr(t, e, r) { - var n = function (s, c) { - var u = null; - if (s != null) - try { - u = JSON.parse((0, Aie.toUtf8String)(s)); - } catch (h) { - _g.throwError("invalid JSON", Mx.Logger.errors.SERVER_ERROR, { - body: s, - error: h, - }); - } - return r && (u = r(u, c)), u; - }, - i = null; - if (e != null) { - i = (0, Aie.toUtf8Bytes)(e); - var o = typeof t == "string" ? { url: t } : (0, Sie.shallowCopy)(t); - if (o.headers) { - var a = - Object.keys(o.headers).filter(function (s) { - return s.toLowerCase() === "content-type"; - }).length !== 0; - a || - ((o.headers = (0, Sie.shallowCopy)(o.headers)), - (o.headers["content-type"] = "application/json")); - } else o.headers = { "content-type": "application/json" }; - t = o; - } - return myt(t, i, n); - } - $y.fetchJson = XMr; - function YMr(t, e) { - return ( - e || (e = {}), - (e = (0, Sie.shallowCopy)(e)), - e.floor == null && (e.floor = 0), - e.ceiling == null && (e.ceiling = 1e4), - e.interval == null && (e.interval = 250), - new Promise(function (r, n) { - var i = null, - o = !1, - a = function () { - return o ? !1 : ((o = !0), i && clearTimeout(i), !0); - }; - e.timeout && - (i = setTimeout(function () { - a() && n(new Error("timeout")); - }, e.timeout)); - var s = e.retryLimit, - c = 0; - function u() { - return t().then( - function (h) { - if (h !== void 0) a() && r(h); - else if (e.oncePoll) e.oncePoll.once("poll", u); - else if (e.onceBlock) e.onceBlock.once("block", u); - else if (!o) { - if ((c++, c > s)) { - a() && n(new Error("retry limit reached")); - return; - } - var w = - e.interval * - parseInt(String(Math.random() * Math.pow(2, c))); - w < e.floor && (w = e.floor), - w > e.ceiling && (w = e.ceiling), - setTimeout(u, w); - } - return null; - }, - function (h) { - a() && n(h); - } - ); - } - u(); - }) - ); - } - $y.poll = YMr; - }); - var gc = I((Eie) => { - "use strict"; - m(); - g(); - Object.defineProperty(Eie, "__esModule", { value: !0 }); - Eie.version = void 0; - Eie.version = "providers/5.7.2"; - }); - var lE = I((Bb) => { - "use strict"; - m(); - g(); - Object.defineProperty(Bb, "__esModule", { value: !0 }); - Bb.showThrottleMessage = - Bb.isCommunityResource = - Bb.isCommunityResourcable = - Bb.Formatter = - void 0; - var uMe = Vh(), - Tx = Ro(), - Ob = Ar(), - QMr = ub(), - eTr = $r(), - gyt = e0(), - tTr = rr(), - rTr = gc(), - $K = new tTr.Logger(rTr.version), - nTr = (function () { - function t() { - this.formats = this.getDefaultFormats(); - } - return ( - (t.prototype.getDefaultFormats = function () { - var e = this, - r = {}, - n = this.address.bind(this), - i = this.bigNumber.bind(this), - o = this.blockTag.bind(this), - a = this.data.bind(this), - s = this.hash.bind(this), - c = this.hex.bind(this), - u = this.number.bind(this), - h = this.type.bind(this), - w = function (M) { - return e.data(M, !0); - }; - return ( - (r.transaction = { - hash: s, - type: h, - accessList: t.allowNull(this.accessList.bind(this), null), - blockHash: t.allowNull(s, null), - blockNumber: t.allowNull(u, null), - transactionIndex: t.allowNull(u, null), - confirmations: t.allowNull(u, null), - from: n, - gasPrice: t.allowNull(i), - maxPriorityFeePerGas: t.allowNull(i), - maxFeePerGas: t.allowNull(i), - gasLimit: i, - to: t.allowNull(n, null), - value: i, - nonce: u, - data: a, - r: t.allowNull(this.uint256), - s: t.allowNull(this.uint256), - v: t.allowNull(u), - creates: t.allowNull(n, null), - raw: t.allowNull(a), - }), - (r.transactionRequest = { - from: t.allowNull(n), - nonce: t.allowNull(u), - gasLimit: t.allowNull(i), - gasPrice: t.allowNull(i), - maxPriorityFeePerGas: t.allowNull(i), - maxFeePerGas: t.allowNull(i), - to: t.allowNull(n), - value: t.allowNull(i), - data: t.allowNull(w), - type: t.allowNull(u), - accessList: t.allowNull(this.accessList.bind(this), null), - }), - (r.receiptLog = { - transactionIndex: u, - blockNumber: u, - transactionHash: s, - address: n, - topics: t.arrayOf(s), - data: a, - logIndex: u, - blockHash: s, - }), - (r.receipt = { - to: t.allowNull(this.address, null), - from: t.allowNull(this.address, null), - contractAddress: t.allowNull(n, null), - transactionIndex: u, - root: t.allowNull(c), - gasUsed: i, - logsBloom: t.allowNull(a), - blockHash: s, - transactionHash: s, - logs: t.arrayOf(this.receiptLog.bind(this)), - blockNumber: u, - confirmations: t.allowNull(u, null), - cumulativeGasUsed: i, - effectiveGasPrice: t.allowNull(i), - status: t.allowNull(u), - type: h, - }), - (r.block = { - hash: t.allowNull(s), - parentHash: s, - number: u, - timestamp: u, - nonce: t.allowNull(c), - difficulty: this.difficulty.bind(this), - gasLimit: i, - gasUsed: i, - miner: t.allowNull(n), - extraData: a, - transactions: t.allowNull(t.arrayOf(s)), - baseFeePerGas: t.allowNull(i), - }), - (r.blockWithTransactions = (0, eTr.shallowCopy)(r.block)), - (r.blockWithTransactions.transactions = t.allowNull( - t.arrayOf(this.transactionResponse.bind(this)) - )), - (r.filter = { - fromBlock: t.allowNull(o, void 0), - toBlock: t.allowNull(o, void 0), - blockHash: t.allowNull(s, void 0), - address: t.allowNull(n, void 0), - topics: t.allowNull(this.topics.bind(this), void 0), - }), - (r.filterLog = { - blockNumber: t.allowNull(u), - blockHash: t.allowNull(s), - transactionIndex: u, - removed: t.allowNull(this.boolean.bind(this)), - address: n, - data: t.allowFalsish(a, "0x"), - topics: t.arrayOf(s), - transactionHash: s, - logIndex: u, - }), - r - ); - }), - (t.prototype.accessList = function (e) { - return (0, gyt.accessListify)(e || []); - }), - (t.prototype.number = function (e) { - return e === "0x" ? 0 : Tx.BigNumber.from(e).toNumber(); - }), - (t.prototype.type = function (e) { - return e === "0x" || e == null - ? 0 - : Tx.BigNumber.from(e).toNumber(); - }), - (t.prototype.bigNumber = function (e) { - return Tx.BigNumber.from(e); - }), - (t.prototype.boolean = function (e) { - if (typeof e == "boolean") return e; - if (typeof e == "string") { - if (((e = e.toLowerCase()), e === "true")) return !0; - if (e === "false") return !1; - } - throw new Error("invalid boolean - " + e); - }), - (t.prototype.hex = function (e, r) { - return typeof e == "string" && - (!r && e.substring(0, 2) !== "0x" && (e = "0x" + e), - (0, Ob.isHexString)(e)) - ? e.toLowerCase() - : $K.throwArgumentError("invalid hash", "value", e); - }), - (t.prototype.data = function (e, r) { - var n = this.hex(e, r); - if (n.length % 2 !== 0) - throw new Error("invalid data; odd-length - " + e); - return n; - }), - (t.prototype.address = function (e) { - return (0, uMe.getAddress)(e); - }), - (t.prototype.callAddress = function (e) { - if (!(0, Ob.isHexString)(e, 32)) return null; - var r = (0, uMe.getAddress)((0, Ob.hexDataSlice)(e, 12)); - return r === QMr.AddressZero ? null : r; - }), - (t.prototype.contractAddress = function (e) { - return (0, uMe.getContractAddress)(e); - }), - (t.prototype.blockTag = function (e) { - if (e == null) return "latest"; - if (e === "earliest") return "0x0"; - switch (e) { - case "earliest": - return "0x0"; - case "latest": - case "pending": - case "safe": - case "finalized": - return e; - } - if (typeof e == "number" || (0, Ob.isHexString)(e)) - return (0, Ob.hexValue)(e); - throw new Error("invalid blockTag"); - }), - (t.prototype.hash = function (e, r) { - var n = this.hex(e, r); - return (0, Ob.hexDataLength)(n) !== 32 - ? $K.throwArgumentError("invalid hash", "value", e) - : n; - }), - (t.prototype.difficulty = function (e) { - if (e == null) return null; - var r = Tx.BigNumber.from(e); - try { - return r.toNumber(); - } catch {} - return null; - }), - (t.prototype.uint256 = function (e) { - if (!(0, Ob.isHexString)(e)) throw new Error("invalid uint256"); - return (0, Ob.hexZeroPad)(e, 32); - }), - (t.prototype._block = function (e, r) { - e.author != null && e.miner == null && (e.miner = e.author); - var n = e._difficulty != null ? e._difficulty : e.difficulty, - i = t.check(r, e); - return (i._difficulty = n == null ? null : Tx.BigNumber.from(n)), i; - }), - (t.prototype.block = function (e) { - return this._block(e, this.formats.block); - }), - (t.prototype.blockWithTransactions = function (e) { - return this._block(e, this.formats.blockWithTransactions); - }), - (t.prototype.transactionRequest = function (e) { - return t.check(this.formats.transactionRequest, e); - }), - (t.prototype.transactionResponse = function (e) { - e.gas != null && e.gasLimit == null && (e.gasLimit = e.gas), - e.to && - Tx.BigNumber.from(e.to).isZero() && - (e.to = "0x0000000000000000000000000000000000000000"), - e.input != null && e.data == null && (e.data = e.input), - e.to == null && - e.creates == null && - (e.creates = this.contractAddress(e)), - (e.type === 1 || e.type === 2) && - e.accessList == null && - (e.accessList = []); - var r = t.check(this.formats.transaction, e); - if (e.chainId != null) { - var n = e.chainId; - (0, Ob.isHexString)(n) && (n = Tx.BigNumber.from(n).toNumber()), - (r.chainId = n); - } else { - var n = e.networkId; - n == null && r.v == null && (n = e.chainId), - (0, Ob.isHexString)(n) && (n = Tx.BigNumber.from(n).toNumber()), - typeof n != "number" && - r.v != null && - ((n = (r.v - 35) / 2), n < 0 && (n = 0), (n = parseInt(n))), - typeof n != "number" && (n = 0), - (r.chainId = n); - } - return ( - r.blockHash && - r.blockHash.replace(/0/g, "") === "x" && - (r.blockHash = null), - r - ); - }), - (t.prototype.transaction = function (e) { - return (0, gyt.parse)(e); - }), - (t.prototype.receiptLog = function (e) { - return t.check(this.formats.receiptLog, e); - }), - (t.prototype.receipt = function (e) { - var r = t.check(this.formats.receipt, e); - if (r.root != null) - if (r.root.length <= 4) { - var n = Tx.BigNumber.from(r.root).toNumber(); - n === 0 || n === 1 - ? (r.status != null && - r.status !== n && - $K.throwArgumentError( - "alt-root-status/status mismatch", - "value", - { root: r.root, status: r.status } - ), - (r.status = n), - delete r.root) - : $K.throwArgumentError( - "invalid alt-root-status", - "value.root", - r.root - ); - } else - r.root.length !== 66 && - $K.throwArgumentError( - "invalid root hash", - "value.root", - r.root - ); - return r.status != null && (r.byzantium = !0), r; - }), - (t.prototype.topics = function (e) { - var r = this; - return Array.isArray(e) - ? e.map(function (n) { - return r.topics(n); - }) - : e != null - ? this.hash(e, !0) - : null; - }), - (t.prototype.filter = function (e) { - return t.check(this.formats.filter, e); - }), - (t.prototype.filterLog = function (e) { - return t.check(this.formats.filterLog, e); - }), - (t.check = function (e, r) { - var n = {}; - for (var i in e) - try { - var o = e[i](r[i]); - o !== void 0 && (n[i] = o); - } catch (a) { - throw ((a.checkKey = i), (a.checkValue = r[i]), a); - } - return n; - }), - (t.allowNull = function (e, r) { - return function (n) { - return n == null ? r : e(n); - }; - }), - (t.allowFalsish = function (e, r) { - return function (n) { - return n ? e(n) : r; - }; - }), - (t.arrayOf = function (e) { - return function (r) { - if (!Array.isArray(r)) throw new Error("not an array"); - var n = []; - return ( - r.forEach(function (i) { - n.push(e(i)); - }), - n - ); - }; - }), - t - ); - })(); - Bb.Formatter = nTr; - function byt(t) { - return t && typeof t.isCommunityResource == "function"; - } - Bb.isCommunityResourcable = byt; - function iTr(t) { - return byt(t) && t.isCommunityResource(); - } - Bb.isCommunityResource = iTr; - var vyt = !1; - function oTr() { - vyt || - ((vyt = !0), - console.log("========= NOTICE ========="), - console.log( - "Request-Rate Exceeded (this message will not be repeated)" - ), - console.log(""), - console.log( - "The default API keys for each service are provided as a highly-throttled," - ), - console.log( - "community resource for low-traffic projects and early prototyping." - ), - console.log(""), - console.log( - "While your application will continue to function, we highly recommended" - ), - console.log( - "signing up for your own API keys to improve performance, increase your" - ), - console.log( - "request rate/limit and enable other perks, such as metrics and advanced APIs." - ), - console.log(""), - console.log("For more details: https://docs.ethers.io/api-keys/"), - console.log("==========================")); - } - Bb.showThrottleMessage = oTr; - }); - var QK = I((ll) => { - "use strict"; - m(); - g(); - var aTr = - (ll && ll.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(), - nn = - (ll && ll.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - on = - (ll && ll.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }, - sTr = - (ll && ll.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(ll, "__esModule", { value: !0 }); - ll.BaseProvider = ll.Resolver = ll.Event = void 0; - var Pyt = vx(), - uTr = lb(), - dMe = jR(), - cl = Ro(), - Gr = Ar(), - cTr = ub(), - XK = db(), - lTr = sMe(), - cs = $r(), - wyt = pb(), - hMe = Eo(), - D7 = R7(), - _yt = sTr(yEe()), - ei = rr(), - fTr = gc(), - qn = new ei.Logger(fTr.version), - xyt = lE(), - dTr = 10; - function Syt(t) { - return t == null - ? "null" - : ((0, Gr.hexDataLength)(t) !== 32 && - qn.throwArgumentError("invalid topic", "topic", t), - t.toLowerCase()); - } - function Ayt(t) { - for (t = t.slice(); t.length > 0 && t[t.length - 1] == null; ) t.pop(); - return t - .map(function (e) { - if (Array.isArray(e)) { - var r = {}; - e.forEach(function (i) { - r[Syt(i)] = !0; - }); - var n = Object.keys(r); - return n.sort(), n.join("|"); - } else return Syt(e); - }) - .join("&"); - } - function hTr(t) { - return t === "" - ? [] - : t.split(/&/g).map(function (e) { - if (e === "") return []; - var r = e.split("|").map(function (n) { - return n === "null" ? null : n; - }); - return r.length === 1 ? r[0] : r; - }); - } - function N7(t) { - if (typeof t == "string") { - if (((t = t.toLowerCase()), (0, Gr.hexDataLength)(t) === 32)) - return "tx:" + t; - if (t.indexOf(":") === -1) return t; - } else { - if (Array.isArray(t)) return "filter:*:" + Ayt(t); - if (Pyt.ForkEvent.isForkEvent(t)) - throw (qn.warn("not implemented"), new Error("not implemented")); - if (t && typeof t == "object") - return "filter:" + (t.address || "*") + ":" + Ayt(t.topics || []); - } - throw new Error("invalid event - " + t); - } - function ZK() { - return new Date().getTime(); - } - function Eyt(t) { - return new Promise(function (e) { - setTimeout(e, t); - }); - } - var pTr = ["block", "network", "pending", "poll"], - Oyt = (function () { - function t(e, r, n) { - (0, cs.defineReadOnly)(this, "tag", e), - (0, cs.defineReadOnly)(this, "listener", r), - (0, cs.defineReadOnly)(this, "once", n), - (this._lastBlockNumber = -2), - (this._inflight = !1); - } - return ( - Object.defineProperty(t.prototype, "event", { - get: function () { - switch (this.type) { - case "tx": - return this.hash; - case "filter": - return this.filter; - } - return this.tag; - }, - enumerable: !1, - configurable: !0, - }), - Object.defineProperty(t.prototype, "type", { - get: function () { - return this.tag.split(":")[0]; - }, - enumerable: !1, - configurable: !0, - }), - Object.defineProperty(t.prototype, "hash", { - get: function () { - var e = this.tag.split(":"); - return e[0] !== "tx" ? null : e[1]; - }, - enumerable: !1, - configurable: !0, - }), - Object.defineProperty(t.prototype, "filter", { - get: function () { - var e = this.tag.split(":"); - if (e[0] !== "filter") return null; - var r = e[1], - n = hTr(e[2]), - i = {}; - return ( - n.length > 0 && (i.topics = n), - r && r !== "*" && (i.address = r), - i - ); - }, - enumerable: !1, - configurable: !0, - }), - (t.prototype.pollable = function () { - return this.tag.indexOf(":") >= 0 || pTr.indexOf(this.tag) >= 0; - }), - t - ); - })(); - ll.Event = Oyt; - var yTr = { - 0: { symbol: "btc", p2pkh: 0, p2sh: 5, prefix: "bc" }, - 2: { symbol: "ltc", p2pkh: 48, p2sh: 50, prefix: "ltc" }, - 3: { symbol: "doge", p2pkh: 30, p2sh: 22 }, - 60: { symbol: "eth", ilk: "eth" }, - 61: { symbol: "etc", ilk: "eth" }, - 700: { symbol: "xdai", ilk: "eth" }, - }; - function cMe(t) { - return (0, Gr.hexZeroPad)(cl.BigNumber.from(t).toHexString(), 32); - } - function Myt(t) { - return dMe.Base58.encode( - (0, Gr.concat)([ - t, - (0, Gr.hexDataSlice)((0, wyt.sha256)((0, wyt.sha256)(t)), 0, 4), - ]) - ); - } - var Byt = new RegExp("^(ipfs)://(.*)$", "i"), - Tyt = [ - new RegExp("^(https)://(.*)$", "i"), - new RegExp("^(data):(.*)$", "i"), - Byt, - new RegExp("^eip155:[0-9]+/(erc[0-9]+):(.*)$", "i"), - ]; - function Mie(t, e) { - try { - return (0, hMe.toUtf8String)(YK(t, e)); - } catch {} - return null; - } - function YK(t, e) { - if (t === "0x") return null; - var r = cl.BigNumber.from((0, Gr.hexDataSlice)(t, e, e + 32)).toNumber(), - n = cl.BigNumber.from((0, Gr.hexDataSlice)(t, r, r + 32)).toNumber(); - return (0, Gr.hexDataSlice)(t, r + 32, r + 32 + n); - } - function lMe(t) { - return ( - t.match(/^ipfs:\/\/ipfs\//i) - ? (t = t.substring(12)) - : t.match(/^ipfs:\/\//i) - ? (t = t.substring(7)) - : qn.throwArgumentError("unsupported IPFS format", "link", t), - "https://gateway.ipfs.io/ipfs/" + t - ); - } - function kyt(t) { - var e = (0, Gr.arrayify)(t); - if (e.length > 32) throw new Error("internal; should not happen"); - var r = new Uint8Array(32); - return r.set(e, 32 - e.length), r; - } - function mTr(t) { - if (t.length % 32 === 0) return t; - var e = new Uint8Array(Math.ceil(t.length / 32) * 32); - return e.set(t), e; - } - function Iyt(t) { - for (var e = [], r = 0, n = 0; n < t.length; n++) e.push(null), (r += 32); - for (var n = 0; n < t.length; n++) { - var i = (0, Gr.arrayify)(t[n]); - (e[n] = kyt(r)), - e.push(kyt(i.length)), - e.push(mTr(i)), - (r += 32 + Math.ceil(i.length / 32) * 32); - } - return (0, Gr.hexConcat)(e); - } - var pMe = (function () { - function t(e, r, n, i) { - (0, cs.defineReadOnly)(this, "provider", e), - (0, cs.defineReadOnly)(this, "name", n), - (0, cs.defineReadOnly)(this, "address", e.formatter.address(r)), - (0, cs.defineReadOnly)(this, "_resolvedAddress", i); - } - return ( - (t.prototype.supportsWildcard = function () { - var e = this; - return ( - this._supportsEip2544 || - (this._supportsEip2544 = this.provider - .call({ - to: this.address, - data: "0x01ffc9a79061b92300000000000000000000000000000000000000000000000000000000", - }) - .then(function (r) { - return cl.BigNumber.from(r).eq(1); - }) - .catch(function (r) { - if (r.code === ei.Logger.errors.CALL_EXCEPTION) return !1; - throw ((e._supportsEip2544 = null), r); - })), - this._supportsEip2544 - ); - }), - (t.prototype._fetch = function (e, r) { - return nn(this, void 0, void 0, function () { - var n, i, o, a; - return on(this, function (s) { - switch (s.label) { - case 0: - return ( - (n = { - to: this.address, - ccipReadEnabled: !0, - data: (0, Gr.hexConcat)([ - e, - (0, XK.namehash)(this.name), - r || "0x", - ]), - }), - (i = !1), - [4, this.supportsWildcard()] - ); - case 1: - s.sent() && - ((i = !0), - (n.data = (0, Gr.hexConcat)([ - "0x9061b923", - Iyt([(0, XK.dnsEncode)(this.name), n.data]), - ]))), - (s.label = 2); - case 2: - return s.trys.push([2, 4, , 5]), [4, this.provider.call(n)]; - case 3: - return ( - (o = s.sent()), - (0, Gr.arrayify)(o).length % 32 === 4 && - qn.throwError( - "resolver threw error", - ei.Logger.errors.CALL_EXCEPTION, - { transaction: n, data: o } - ), - i && (o = YK(o, 0)), - [2, o] - ); - case 4: - if ( - ((a = s.sent()), a.code === ei.Logger.errors.CALL_EXCEPTION) - ) - return [2, null]; - throw a; - case 5: - return [2]; - } - }); - }); - }), - (t.prototype._fetchBytes = function (e, r) { - return nn(this, void 0, void 0, function () { - var n; - return on(this, function (i) { - switch (i.label) { - case 0: - return [4, this._fetch(e, r)]; - case 1: - return (n = i.sent()), n != null ? [2, YK(n, 0)] : [2, null]; - } - }); - }); - }), - (t.prototype._getAddress = function (e, r) { - var n = yTr[String(e)]; - if ( - (n == null && - qn.throwError( - "unsupported coin type: " + e, - ei.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "getAddress(" + e + ")" } - ), - n.ilk === "eth") - ) - return this.provider.formatter.address(r); - var i = (0, Gr.arrayify)(r); - if (n.p2pkh != null) { - var o = r.match(/^0x76a9([0-9a-f][0-9a-f])([0-9a-f]*)88ac$/); - if (o) { - var a = parseInt(o[1], 16); - if (o[2].length === a * 2 && a >= 1 && a <= 75) - return Myt((0, Gr.concat)([[n.p2pkh], "0x" + o[2]])); - } - } - if (n.p2sh != null) { - var s = r.match(/^0xa9([0-9a-f][0-9a-f])([0-9a-f]*)87$/); - if (s) { - var c = parseInt(s[1], 16); - if (s[2].length === c * 2 && c >= 1 && c <= 75) - return Myt((0, Gr.concat)([[n.p2sh], "0x" + s[2]])); - } - } - if (n.prefix != null) { - var u = i[1], - h = i[0]; - if ( - (h === 0 ? u !== 20 && u !== 32 && (h = -1) : (h = -1), - h >= 0 && i.length === 2 + u && u >= 1 && u <= 75) - ) { - var w = _yt.default.toWords(i.slice(2)); - return w.unshift(h), _yt.default.encode(n.prefix, w); - } - } - return null; - }), - (t.prototype.getAddress = function (e) { - return nn(this, void 0, void 0, function () { - var r, n, i, o; - return on(this, function (a) { - switch (a.label) { - case 0: - if ((e == null && (e = 60), e !== 60)) return [3, 4]; - a.label = 1; - case 1: - return ( - a.trys.push([1, 3, , 4]), [4, this._fetch("0x3b3b57de")] - ); - case 2: - return ( - (r = a.sent()), - r === "0x" || r === cTr.HashZero - ? [2, null] - : [2, this.provider.formatter.callAddress(r)] - ); - case 3: - if ( - ((n = a.sent()), n.code === ei.Logger.errors.CALL_EXCEPTION) - ) - return [2, null]; - throw n; - case 4: - return [4, this._fetchBytes("0xf1cb7e06", cMe(e))]; - case 5: - return ( - (i = a.sent()), - i == null || i === "0x" - ? [2, null] - : ((o = this._getAddress(e, i)), - o == null && - qn.throwError( - "invalid or unsupported coin data", - ei.Logger.errors.UNSUPPORTED_OPERATION, - { - operation: "getAddress(" + e + ")", - coinType: e, - data: i, - } - ), - [2, o]) - ); - } - }); - }); - }), - (t.prototype.getAvatar = function () { - return nn(this, void 0, void 0, function () { - var e, - r, - n, - i, - o, - a, - s, - c, - u, - h, - w, - M, - k, - O, - D, - F, - N, - q, - z, - H, - Z, - $, - ue, - te, - ne; - return on(this, function (A) { - switch (A.label) { - case 0: - (e = [{ type: "name", content: this.name }]), (A.label = 1); - case 1: - return ( - A.trys.push([1, 19, , 20]), [4, this.getText("avatar")] - ); - case 2: - if (((r = A.sent()), r == null)) return [2, null]; - (n = 0), (A.label = 3); - case 3: - if (!(n < Tyt.length)) return [3, 18]; - if (((i = r.match(Tyt[n])), i == null)) return [3, 17]; - switch (((o = i[1].toLowerCase()), (a = o), a)) { - case "https": - return [3, 4]; - case "data": - return [3, 5]; - case "ipfs": - return [3, 6]; - case "erc721": - return [3, 7]; - case "erc1155": - return [3, 7]; - } - return [3, 17]; - case 4: - return ( - e.push({ type: "url", content: r }), - [2, { linkage: e, url: r }] - ); - case 5: - return ( - e.push({ type: "data", content: r }), - [2, { linkage: e, url: r }] - ); - case 6: - return ( - e.push({ type: "ipfs", content: r }), - [2, { linkage: e, url: lMe(r) }] - ); - case 7: - return ( - (s = o === "erc721" ? "0xc87b56dd" : "0x0e89341c"), - e.push({ type: o, content: r }), - (u = this._resolvedAddress), - u ? [3, 9] : [4, this.getAddress()] - ); - case 8: - (u = A.sent()), (A.label = 9); - case 9: - return ( - (c = u), - (h = (i[2] || "").split("/")), - h.length !== 2 - ? [2, null] - : [4, this.provider.formatter.address(h[0])] - ); - case 10: - return ( - (w = A.sent()), - (M = (0, Gr.hexZeroPad)( - cl.BigNumber.from(h[1]).toHexString(), - 32 - )), - o !== "erc721" - ? [3, 12] - : ((D = (O = this.provider.formatter).callAddress), - [ - 4, - this.provider.call({ - to: w, - data: (0, Gr.hexConcat)(["0x6352211e", M]), - }), - ]) - ); - case 11: - return ( - (k = D.apply(O, [A.sent()])), - c !== k - ? [2, null] - : (e.push({ type: "owner", content: k }), [3, 14]) - ); - case 12: - return o !== "erc1155" - ? [3, 14] - : ((q = (N = cl.BigNumber).from), - [ - 4, - this.provider.call({ - to: w, - data: (0, Gr.hexConcat)([ - "0x00fdd58e", - (0, Gr.hexZeroPad)(c, 32), - M, - ]), - }), - ]); - case 13: - if (((F = q.apply(N, [A.sent()])), F.isZero())) - return [2, null]; - e.push({ type: "balance", content: F.toString() }), - (A.label = 14); - case 14: - return ( - (z = { - to: this.provider.formatter.address(h[0]), - data: (0, Gr.hexConcat)([s, M]), - }), - (Z = Mie), - [4, this.provider.call(z)] - ); - case 15: - return ( - (H = Z.apply(void 0, [A.sent(), 0])), - H == null - ? [2, null] - : (e.push({ type: "metadata-url-base", content: H }), - o === "erc1155" && - ((H = H.replace("{id}", M.substring(2))), - e.push({ - type: "metadata-url-expanded", - content: H, - })), - H.match(/^ipfs:/i) && (H = lMe(H)), - e.push({ type: "metadata-url", content: H }), - [4, (0, D7.fetchJson)(H)]) - ); - case 16: - if ((($ = A.sent()), !$)) return [2, null]; - if ( - (e.push({ type: "metadata", content: JSON.stringify($) }), - (ue = $.image), - typeof ue != "string") - ) - return [2, null]; - if (!ue.match(/^(https:\/\/|data:)/i)) { - if (((te = ue.match(Byt)), te == null)) return [2, null]; - e.push({ type: "url-ipfs", content: ue }), (ue = lMe(ue)); - } - return ( - e.push({ type: "url", content: ue }), - [2, { linkage: e, url: ue }] - ); - case 17: - return n++, [3, 3]; - case 18: - return [3, 20]; - case 19: - return (ne = A.sent()), [3, 20]; - case 20: - return [2, null]; - } - }); - }); - }), - (t.prototype.getContentHash = function () { - return nn(this, void 0, void 0, function () { - var e, r, n, i, o, a, s, c, u; - return on(this, function (h) { - switch (h.label) { - case 0: - return [4, this._fetchBytes("0xbc1c58d1")]; - case 1: - return ( - (e = h.sent()), - e == null || e === "0x" - ? [2, null] - : ((r = e.match( - /^0xe3010170(([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])([0-9a-f]*))$/ - )), - r && ((n = parseInt(r[3], 16)), r[4].length === n * 2) - ? [2, "ipfs://" + dMe.Base58.encode("0x" + r[1])] - : ((i = e.match( - /^0xe5010172(([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])([0-9a-f]*))$/ - )), - i && - ((o = parseInt(i[3], 16)), i[4].length === o * 2) - ? [2, "ipns://" + dMe.Base58.encode("0x" + i[1])] - : ((a = e.match(/^0xe40101fa011b20([0-9a-f]*)$/)), - a && a[1].length === 32 * 2 - ? [2, "bzz://" + a[1]] - : ((s = e.match(/^0x90b2c605([0-9a-f]*)$/)), - s && s[1].length === 34 * 2 - ? ((c = { "=": "", "+": "-", "/": "_" }), - (u = (0, uTr.encode)( - "0x" + s[1] - ).replace(/[=+\/]/g, function (w) { - return c[w]; - })), - [2, "sia://" + u]) - : [ - 2, - qn.throwError( - "invalid or unsupported content hash data", - ei.Logger.errors - .UNSUPPORTED_OPERATION, - { - operation: "getContentHash()", - data: e, - } - ), - ])))) - ); - } - }); - }); - }), - (t.prototype.getText = function (e) { - return nn(this, void 0, void 0, function () { - var r, n; - return on(this, function (i) { - switch (i.label) { - case 0: - return ( - (r = (0, hMe.toUtf8Bytes)(e)), - (r = (0, Gr.concat)([cMe(64), cMe(r.length), r])), - r.length % 32 !== 0 && - (r = (0, Gr.concat)([ - r, - (0, Gr.hexZeroPad)("0x", 32 - (e.length % 32)), - ])), - [4, this._fetchBytes("0x59d1d43c", (0, Gr.hexlify)(r))] - ); - case 1: - return ( - (n = i.sent()), - n == null || n === "0x" - ? [2, null] - : [2, (0, hMe.toUtf8String)(n)] - ); - } - }); - }); - }), - t - ); - })(); - ll.Resolver = pMe; - var fMe = null, - gTr = 1, - vTr = (function (t) { - aTr(e, t); - function e(r) { - var n = this.constructor, - i = t.call(this) || this; - if ( - ((i._events = []), - (i._emitted = { block: -2 }), - (i.disableCcipRead = !1), - (i.formatter = n.getFormatter()), - (0, cs.defineReadOnly)(i, "anyNetwork", r === "any"), - i.anyNetwork && (r = i.detectNetwork()), - r instanceof Promise) - ) - (i._networkPromise = r), - r.catch(function (a) {}), - i._ready().catch(function (a) {}); - else { - var o = (0, cs.getStatic)(n, "getNetwork")(r); - o - ? ((0, cs.defineReadOnly)(i, "_network", o), - i.emit("network", o, null)) - : qn.throwArgumentError("invalid network", "network", r); - } - return ( - (i._maxInternalBlockNumber = -1024), - (i._lastBlockNumber = -2), - (i._maxFilterBlockRange = 10), - (i._pollingInterval = 4e3), - (i._fastQueryDate = 0), - i - ); - } - return ( - (e.prototype._ready = function () { - return nn(this, void 0, void 0, function () { - var r, n; - return on(this, function (i) { - switch (i.label) { - case 0: - if (this._network != null) return [3, 7]; - if (((r = null), !this._networkPromise)) return [3, 4]; - i.label = 1; - case 1: - return i.trys.push([1, 3, , 4]), [4, this._networkPromise]; - case 2: - return (r = i.sent()), [3, 4]; - case 3: - return (n = i.sent()), [3, 4]; - case 4: - return r != null ? [3, 6] : [4, this.detectNetwork()]; - case 5: - (r = i.sent()), (i.label = 6); - case 6: - r || - qn.throwError( - "no network detected", - ei.Logger.errors.UNKNOWN_ERROR, - {} - ), - this._network == null && - (this.anyNetwork - ? (this._network = r) - : (0, cs.defineReadOnly)(this, "_network", r), - this.emit("network", r, null)), - (i.label = 7); - case 7: - return [2, this._network]; - } - }); - }); - }), - Object.defineProperty(e.prototype, "ready", { - get: function () { - var r = this; - return (0, D7.poll)(function () { - return r._ready().then( - function (n) { - return n; - }, - function (n) { - if ( - !( - n.code === ei.Logger.errors.NETWORK_ERROR && - n.event === "noNetwork" - ) - ) - throw n; - } - ); - }); - }, - enumerable: !1, - configurable: !0, - }), - (e.getFormatter = function () { - return fMe == null && (fMe = new xyt.Formatter()), fMe; - }), - (e.getNetwork = function (r) { - return (0, lTr.getNetwork)(r ?? "homestead"); - }), - (e.prototype.ccipReadFetch = function (r, n, i) { - return nn(this, void 0, void 0, function () { - var o, a, s, c, u, h, w, M, k; - return on(this, function (O) { - switch (O.label) { - case 0: - if (this.disableCcipRead || i.length === 0) - return [2, null]; - (o = r.to.toLowerCase()), - (a = n.toLowerCase()), - (s = []), - (c = 0), - (O.label = 1); - case 1: - return c < i.length - ? ((u = i[c]), - (h = u.replace("{sender}", o).replace("{data}", a)), - (w = - u.indexOf("{data}") >= 0 - ? null - : JSON.stringify({ data: a, sender: o })), - [ - 4, - (0, D7.fetchJson)( - { url: h, errorPassThrough: !0 }, - w, - function (D, F) { - return (D.status = F.statusCode), D; - } - ), - ]) - : [3, 4]; - case 2: - if (((M = O.sent()), M.data)) return [2, M.data]; - if ( - ((k = M.message || "unknown error"), - M.status >= 400 && M.status < 500) - ) - return [ - 2, - qn.throwError( - "response not found during CCIP fetch: " + k, - ei.Logger.errors.SERVER_ERROR, - { url: u, errorMessage: k } - ), - ]; - s.push(k), (O.label = 3); - case 3: - return c++, [3, 1]; - case 4: - return [ - 2, - qn.throwError( - "error encountered during CCIP fetch: " + - s - .map(function (D) { - return JSON.stringify(D); - }) - .join(", "), - ei.Logger.errors.SERVER_ERROR, - { urls: i, errorMessages: s } - ), - ]; - } - }); - }); - }), - (e.prototype._getInternalBlockNumber = function (r) { - return nn(this, void 0, void 0, function () { - var n, - i, - o, - a, - s, - c = this; - return on(this, function (u) { - switch (u.label) { - case 0: - return [4, this._ready()]; - case 1: - if ((u.sent(), !(r > 0))) return [3, 7]; - u.label = 2; - case 2: - if (!this._internalBlockNumber) return [3, 7]; - (n = this._internalBlockNumber), (u.label = 3); - case 3: - return u.trys.push([3, 5, , 6]), [4, n]; - case 4: - return ( - (i = u.sent()), - ZK() - i.respTime <= r ? [2, i.blockNumber] : [3, 7] - ); - case 5: - return ( - (o = u.sent()), - this._internalBlockNumber === n ? [3, 7] : [3, 6] - ); - case 6: - return [3, 2]; - case 7: - return ( - (a = ZK()), - (s = (0, cs.resolveProperties)({ - blockNumber: this.perform("getBlockNumber", {}), - networkError: this.getNetwork().then( - function (h) { - return null; - }, - function (h) { - return h; - } - ), - }).then(function (h) { - var w = h.blockNumber, - M = h.networkError; - if (M) - throw ( - (c._internalBlockNumber === s && - (c._internalBlockNumber = null), - M) - ); - var k = ZK(); - return ( - (w = cl.BigNumber.from(w).toNumber()), - w < c._maxInternalBlockNumber && - (w = c._maxInternalBlockNumber), - (c._maxInternalBlockNumber = w), - c._setFastBlockNumber(w), - { blockNumber: w, reqTime: a, respTime: k } - ); - })), - (this._internalBlockNumber = s), - s.catch(function (h) { - c._internalBlockNumber === s && - (c._internalBlockNumber = null); - }), - [4, s] - ); - case 8: - return [2, u.sent().blockNumber]; - } - }); - }); - }), - (e.prototype.poll = function () { - return nn(this, void 0, void 0, function () { - var r, - n, - i, - o, - a, - s = this; - return on(this, function (c) { - switch (c.label) { - case 0: - (r = gTr++), (n = []), (i = null), (c.label = 1); - case 1: - return ( - c.trys.push([1, 3, , 4]), - [ - 4, - this._getInternalBlockNumber( - 100 + this.pollingInterval / 2 - ), - ] - ); - case 2: - return (i = c.sent()), [3, 4]; - case 3: - return (o = c.sent()), this.emit("error", o), [2]; - case 4: - if ( - (this._setFastBlockNumber(i), - this.emit("poll", r, i), - i === this._lastBlockNumber) - ) - return this.emit("didPoll", r), [2]; - if ( - (this._emitted.block === -2 && - (this._emitted.block = i - 1), - Math.abs(this._emitted.block - i) > 1e3) - ) - qn.warn( - "network block skew detected; skipping block events (emitted=" + - this._emitted.block + - " blockNumber" + - i + - ")" - ), - this.emit( - "error", - qn.makeError( - "network block skew detected", - ei.Logger.errors.NETWORK_ERROR, - { - blockNumber: i, - event: "blockSkew", - previousBlockNumber: this._emitted.block, - } - ) - ), - this.emit("block", i); - else - for (a = this._emitted.block + 1; a <= i; a++) - this.emit("block", a); - return ( - this._emitted.block !== i && - ((this._emitted.block = i), - Object.keys(this._emitted).forEach(function (u) { - if (u !== "block") { - var h = s._emitted[u]; - h !== "pending" && - i - h > 12 && - delete s._emitted[u]; - } - })), - this._lastBlockNumber === -2 && - (this._lastBlockNumber = i - 1), - this._events.forEach(function (u) { - switch (u.type) { - case "tx": { - var h = u.hash, - w = s - .getTransactionReceipt(h) - .then(function (O) { - return ( - !O || - O.blockNumber == null || - ((s._emitted["t:" + h] = O.blockNumber), - s.emit(h, O)), - null - ); - }) - .catch(function (O) { - s.emit("error", O); - }); - n.push(w); - break; - } - case "filter": { - if (!u._inflight) { - (u._inflight = !0), - u._lastBlockNumber === -2 && - (u._lastBlockNumber = i - 1); - var M = u.filter; - (M.fromBlock = u._lastBlockNumber + 1), - (M.toBlock = i); - var k = M.toBlock - s._maxFilterBlockRange; - k > M.fromBlock && (M.fromBlock = k), - M.fromBlock < 0 && (M.fromBlock = 0); - var w = s - .getLogs(M) - .then(function (D) { - (u._inflight = !1), - D.length !== 0 && - D.forEach(function (F) { - F.blockNumber > u._lastBlockNumber && - (u._lastBlockNumber = F.blockNumber), - (s._emitted["b:" + F.blockHash] = - F.blockNumber), - (s._emitted[ - "t:" + F.transactionHash - ] = F.blockNumber), - s.emit(M, F); - }); - }) - .catch(function (D) { - s.emit("error", D), (u._inflight = !1); - }); - n.push(w); - } - break; - } - } - }), - (this._lastBlockNumber = i), - Promise.all(n) - .then(function () { - s.emit("didPoll", r); - }) - .catch(function (u) { - s.emit("error", u); - }), - [2] - ); - } - }); - }); - }), - (e.prototype.resetEventsBlock = function (r) { - (this._lastBlockNumber = r - 1), this.polling && this.poll(); - }), - Object.defineProperty(e.prototype, "network", { - get: function () { - return this._network; - }, - enumerable: !1, - configurable: !0, - }), - (e.prototype.detectNetwork = function () { - return nn(this, void 0, void 0, function () { - return on(this, function (r) { - return [ - 2, - qn.throwError( - "provider does not support network detection", - ei.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "provider.detectNetwork" } - ), - ]; - }); - }); - }), - (e.prototype.getNetwork = function () { - return nn(this, void 0, void 0, function () { - var r, n, i; - return on(this, function (o) { - switch (o.label) { - case 0: - return [4, this._ready()]; - case 1: - return (r = o.sent()), [4, this.detectNetwork()]; - case 2: - return ( - (n = o.sent()), - r.chainId === n.chainId - ? [3, 5] - : this.anyNetwork - ? ((this._network = n), - (this._lastBlockNumber = -2), - (this._fastBlockNumber = null), - (this._fastBlockNumberPromise = null), - (this._fastQueryDate = 0), - (this._emitted.block = -2), - (this._maxInternalBlockNumber = -1024), - (this._internalBlockNumber = null), - this.emit("network", n, r), - [4, Eyt(0)]) - : [3, 4] - ); - case 3: - return o.sent(), [2, this._network]; - case 4: - throw ( - ((i = qn.makeError( - "underlying network changed", - ei.Logger.errors.NETWORK_ERROR, - { event: "changed", network: r, detectedNetwork: n } - )), - this.emit("error", i), - i) - ); - case 5: - return [2, r]; - } - }); - }); - }), - Object.defineProperty(e.prototype, "blockNumber", { - get: function () { - var r = this; - return ( - this._getInternalBlockNumber( - 100 + this.pollingInterval / 2 - ).then( - function (n) { - r._setFastBlockNumber(n); - }, - function (n) {} - ), - this._fastBlockNumber != null ? this._fastBlockNumber : -1 - ); - }, - enumerable: !1, - configurable: !0, - }), - Object.defineProperty(e.prototype, "polling", { - get: function () { - return this._poller != null; - }, - set: function (r) { - var n = this; - r && !this._poller - ? ((this._poller = setInterval(function () { - n.poll(); - }, this.pollingInterval)), - this._bootstrapPoll || - (this._bootstrapPoll = setTimeout(function () { - n.poll(), - (n._bootstrapPoll = setTimeout(function () { - n._poller || n.poll(), (n._bootstrapPoll = null); - }, n.pollingInterval)); - }, 0))) - : !r && - this._poller && - (clearInterval(this._poller), (this._poller = null)); - }, - enumerable: !1, - configurable: !0, - }), - Object.defineProperty(e.prototype, "pollingInterval", { - get: function () { - return this._pollingInterval; - }, - set: function (r) { - var n = this; - if (typeof r != "number" || r <= 0 || parseInt(String(r)) != r) - throw new Error("invalid polling interval"); - (this._pollingInterval = r), - this._poller && - (clearInterval(this._poller), - (this._poller = setInterval(function () { - n.poll(); - }, this._pollingInterval))); - }, - enumerable: !1, - configurable: !0, - }), - (e.prototype._getFastBlockNumber = function () { - var r = this, - n = ZK(); - return ( - n - this._fastQueryDate > 2 * this._pollingInterval && - ((this._fastQueryDate = n), - (this._fastBlockNumberPromise = this.getBlockNumber().then( - function (i) { - return ( - (r._fastBlockNumber == null || i > r._fastBlockNumber) && - (r._fastBlockNumber = i), - r._fastBlockNumber - ); - } - ))), - this._fastBlockNumberPromise - ); - }), - (e.prototype._setFastBlockNumber = function (r) { - (this._fastBlockNumber != null && r < this._fastBlockNumber) || - ((this._fastQueryDate = ZK()), - (this._fastBlockNumber == null || r > this._fastBlockNumber) && - ((this._fastBlockNumber = r), - (this._fastBlockNumberPromise = Promise.resolve(r)))); - }), - (e.prototype.waitForTransaction = function (r, n, i) { - return nn(this, void 0, void 0, function () { - return on(this, function (o) { - return [2, this._waitForTransaction(r, n ?? 1, i || 0, null)]; - }); - }); - }), - (e.prototype._waitForTransaction = function (r, n, i, o) { - return nn(this, void 0, void 0, function () { - var a, - s = this; - return on(this, function (c) { - switch (c.label) { - case 0: - return [4, this.getTransactionReceipt(r)]; - case 1: - return ( - (a = c.sent()), - (a ? a.confirmations : 0) >= n - ? [2, a] - : [ - 2, - new Promise(function (u, h) { - var w = [], - M = !1, - k = function () { - return M - ? !0 - : ((M = !0), - w.forEach(function (z) { - z(); - }), - !1); - }, - O = function (z) { - z.confirmations < n || k() || u(z); - }; - if ( - (s.on(r, O), - w.push(function () { - s.removeListener(r, O); - }), - o) - ) { - var D = o.startBlock, - F = null, - N = function (z) { - return nn(s, void 0, void 0, function () { - var H = this; - return on(this, function (Z) { - switch (Z.label) { - case 0: - return M ? [2] : [4, Eyt(1e3)]; - case 1: - return ( - Z.sent(), - this.getTransactionCount( - o.from - ).then( - function ($) { - return nn( - H, - void 0, - void 0, - function () { - var ue, te, ne, A, l, p; - return on( - this, - function (y) { - switch (y.label) { - case 0: - return M - ? [2] - : $ <= o.nonce - ? ((D = z), - [3, 9]) - : [3, 1]; - case 1: - return [ - 4, - this.getTransaction( - r - ), - ]; - case 2: - if ( - ((ue = - y.sent()), - ue && - ue.blockNumber != - null) - ) - return [2]; - F == null && - ((F = D - 3), - F < - o.startBlock && - (F = - o.startBlock)), - (y.label = 3); - case 3: - return F <= z - ? M - ? [2] - : [ - 4, - this.getBlockWithTransactions( - F - ), - ] - : [3, 9]; - case 4: - (te = y.sent()), - (ne = 0), - (y.label = 5); - case 5: - return ne < - te.transactions - .length - ? ((A = - te - .transactions[ - ne - ]), - A.hash === r - ? [2] - : A.from === - o.from && - A.nonce === - o.nonce - ? M - ? [2] - : [ - 4, - this.waitForTransaction( - A.hash, - n - ), - ] - : [3, 7]) - : [3, 8]; - case 6: - return ( - (l = y.sent()), - k() - ? [2] - : ((p = - "replaced"), - A.data === - o.data && - A.to === - o.to && - A.value.eq( - o.value - ) - ? (p = - "repriced") - : A.data === - "0x" && - A.from === - A.to && - A.value.isZero() && - (p = - "cancelled"), - h( - qn.makeError( - "transaction was replaced", - ei - .Logger - .errors - .TRANSACTION_REPLACED, - { - cancelled: - p === - "replaced" || - p === - "cancelled", - reason: - p, - replacement: - this._wrapTransaction( - A - ), - hash: r, - receipt: - l, - } - ) - ), - [2]) - ); - case 7: - return ( - ne++, [3, 5] - ); - case 8: - return ( - F++, [3, 3] - ); - case 9: - return M - ? [2] - : (this.once( - "block", - N - ), - [2]); - } - } - ); - } - ); - }, - function ($) { - M || H.once("block", N); - } - ), - [2] - ); - } - }); - }); - }; - if (M) return; - s.once("block", N), - w.push(function () { - s.removeListener("block", N); - }); - } - if (typeof i == "number" && i > 0) { - var q = setTimeout(function () { - k() || - h( - qn.makeError( - "timeout exceeded", - ei.Logger.errors.TIMEOUT, - { timeout: i } - ) - ); - }, i); - q.unref && q.unref(), - w.push(function () { - clearTimeout(q); - }); - } - }), - ] - ); - } - }); - }); - }), - (e.prototype.getBlockNumber = function () { - return nn(this, void 0, void 0, function () { - return on(this, function (r) { - return [2, this._getInternalBlockNumber(0)]; - }); - }); - }), - (e.prototype.getGasPrice = function () { - return nn(this, void 0, void 0, function () { - var r; - return on(this, function (n) { - switch (n.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return n.sent(), [4, this.perform("getGasPrice", {})]; - case 2: - r = n.sent(); - try { - return [2, cl.BigNumber.from(r)]; - } catch (i) { - return [ - 2, - qn.throwError( - "bad result from backend", - ei.Logger.errors.SERVER_ERROR, - { method: "getGasPrice", result: r, error: i } - ), - ]; - } - return [2]; - } - }); - }); - }), - (e.prototype.getBalance = function (r, n) { - return nn(this, void 0, void 0, function () { - var i, o; - return on(this, function (a) { - switch (a.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return ( - a.sent(), - [ - 4, - (0, cs.resolveProperties)({ - address: this._getAddress(r), - blockTag: this._getBlockTag(n), - }), - ] - ); - case 2: - return (i = a.sent()), [4, this.perform("getBalance", i)]; - case 3: - o = a.sent(); - try { - return [2, cl.BigNumber.from(o)]; - } catch (s) { - return [ - 2, - qn.throwError( - "bad result from backend", - ei.Logger.errors.SERVER_ERROR, - { - method: "getBalance", - params: i, - result: o, - error: s, - } - ), - ]; - } - return [2]; - } - }); - }); - }), - (e.prototype.getTransactionCount = function (r, n) { - return nn(this, void 0, void 0, function () { - var i, o; - return on(this, function (a) { - switch (a.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return ( - a.sent(), - [ - 4, - (0, cs.resolveProperties)({ - address: this._getAddress(r), - blockTag: this._getBlockTag(n), - }), - ] - ); - case 2: - return ( - (i = a.sent()), - [4, this.perform("getTransactionCount", i)] - ); - case 3: - o = a.sent(); - try { - return [2, cl.BigNumber.from(o).toNumber()]; - } catch (s) { - return [ - 2, - qn.throwError( - "bad result from backend", - ei.Logger.errors.SERVER_ERROR, - { - method: "getTransactionCount", - params: i, - result: o, - error: s, - } - ), - ]; - } - return [2]; - } - }); - }); - }), - (e.prototype.getCode = function (r, n) { - return nn(this, void 0, void 0, function () { - var i, o; - return on(this, function (a) { - switch (a.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return ( - a.sent(), - [ - 4, - (0, cs.resolveProperties)({ - address: this._getAddress(r), - blockTag: this._getBlockTag(n), - }), - ] - ); - case 2: - return (i = a.sent()), [4, this.perform("getCode", i)]; - case 3: - o = a.sent(); - try { - return [2, (0, Gr.hexlify)(o)]; - } catch (s) { - return [ - 2, - qn.throwError( - "bad result from backend", - ei.Logger.errors.SERVER_ERROR, - { method: "getCode", params: i, result: o, error: s } - ), - ]; - } - return [2]; - } - }); - }); - }), - (e.prototype.getStorageAt = function (r, n, i) { - return nn(this, void 0, void 0, function () { - var o, a; - return on(this, function (s) { - switch (s.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return ( - s.sent(), - [ - 4, - (0, cs.resolveProperties)({ - address: this._getAddress(r), - blockTag: this._getBlockTag(i), - position: Promise.resolve(n).then(function (c) { - return (0, Gr.hexValue)(c); - }), - }), - ] - ); - case 2: - return (o = s.sent()), [4, this.perform("getStorageAt", o)]; - case 3: - a = s.sent(); - try { - return [2, (0, Gr.hexlify)(a)]; - } catch (c) { - return [ - 2, - qn.throwError( - "bad result from backend", - ei.Logger.errors.SERVER_ERROR, - { - method: "getStorageAt", - params: o, - result: a, - error: c, - } - ), - ]; - } - return [2]; - } - }); - }); - }), - (e.prototype._wrapTransaction = function (r, n, i) { - var o = this; - if (n != null && (0, Gr.hexDataLength)(n) !== 32) - throw new Error("invalid response - sendTransaction"); - var a = r; - return ( - n != null && - r.hash !== n && - qn.throwError( - "Transaction hash mismatch from Provider.sendTransaction.", - ei.Logger.errors.UNKNOWN_ERROR, - { expectedHash: r.hash, returnedHash: n } - ), - (a.wait = function (s, c) { - return nn(o, void 0, void 0, function () { - var u, h; - return on(this, function (w) { - switch (w.label) { - case 0: - return ( - s == null && (s = 1), - c == null && (c = 0), - (u = void 0), - s !== 0 && - i != null && - (u = { - data: r.data, - from: r.from, - nonce: r.nonce, - to: r.to, - value: r.value, - startBlock: i, - }), - [4, this._waitForTransaction(r.hash, s, c, u)] - ); - case 1: - return ( - (h = w.sent()), - h == null && s === 0 - ? [2, null] - : ((this._emitted["t:" + r.hash] = h.blockNumber), - h.status === 0 && - qn.throwError( - "transaction failed", - ei.Logger.errors.CALL_EXCEPTION, - { - transactionHash: r.hash, - transaction: r, - receipt: h, - } - ), - [2, h]) - ); - } - }); - }); - }), - a - ); - }), - (e.prototype.sendTransaction = function (r) { - return nn(this, void 0, void 0, function () { - var n, i, o, a, s; - return on(this, function (c) { - switch (c.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return ( - c.sent(), - [ - 4, - Promise.resolve(r).then(function (u) { - return (0, Gr.hexlify)(u); - }), - ] - ); - case 2: - return ( - (n = c.sent()), - (i = this.formatter.transaction(r)), - i.confirmations == null && (i.confirmations = 0), - [ - 4, - this._getInternalBlockNumber( - 100 + 2 * this.pollingInterval - ), - ] - ); - case 3: - (o = c.sent()), (c.label = 4); - case 4: - return ( - c.trys.push([4, 6, , 7]), - [ - 4, - this.perform("sendTransaction", { - signedTransaction: n, - }), - ] - ); - case 5: - return (a = c.sent()), [2, this._wrapTransaction(i, a, o)]; - case 6: - throw ( - ((s = c.sent()), - (s.transaction = i), - (s.transactionHash = i.hash), - s) - ); - case 7: - return [2]; - } - }); - }); - }), - (e.prototype._getTransactionRequest = function (r) { - return nn(this, void 0, void 0, function () { - var n, - i, - o, - a, - s = this; - return on(this, function (c) { - switch (c.label) { - case 0: - return [4, r]; - case 1: - return ( - (n = c.sent()), - (i = {}), - ["from", "to"].forEach(function (u) { - n[u] != null && - (i[u] = Promise.resolve(n[u]).then(function (h) { - return h ? s._getAddress(h) : null; - })); - }), - [ - "gasLimit", - "gasPrice", - "maxFeePerGas", - "maxPriorityFeePerGas", - "value", - ].forEach(function (u) { - n[u] != null && - (i[u] = Promise.resolve(n[u]).then(function (h) { - return h ? cl.BigNumber.from(h) : null; - })); - }), - ["type"].forEach(function (u) { - n[u] != null && - (i[u] = Promise.resolve(n[u]).then(function (h) { - return h ?? null; - })); - }), - n.accessList && - (i.accessList = this.formatter.accessList( - n.accessList - )), - ["data"].forEach(function (u) { - n[u] != null && - (i[u] = Promise.resolve(n[u]).then(function (h) { - return h ? (0, Gr.hexlify)(h) : null; - })); - }), - (a = (o = this.formatter).transactionRequest), - [4, (0, cs.resolveProperties)(i)] - ); - case 2: - return [2, a.apply(o, [c.sent()])]; - } - }); - }); - }), - (e.prototype._getFilter = function (r) { - return nn(this, void 0, void 0, function () { - var n, - i, - o, - a = this; - return on(this, function (s) { - switch (s.label) { - case 0: - return [4, r]; - case 1: - return ( - (r = s.sent()), - (n = {}), - r.address != null && - (n.address = this._getAddress(r.address)), - ["blockHash", "topics"].forEach(function (c) { - r[c] != null && (n[c] = r[c]); - }), - ["fromBlock", "toBlock"].forEach(function (c) { - r[c] != null && (n[c] = a._getBlockTag(r[c])); - }), - (o = (i = this.formatter).filter), - [4, (0, cs.resolveProperties)(n)] - ); - case 2: - return [2, o.apply(i, [s.sent()])]; - } - }); - }); - }), - (e.prototype._call = function (r, n, i) { - return nn(this, void 0, void 0, function () { - var o, a, s, c, u, h, w, M, k, O, D, F, N, q, z, H; - return on(this, function (Z) { - switch (Z.label) { - case 0: - return ( - i >= dTr && - qn.throwError( - "CCIP read exceeded maximum redirections", - ei.Logger.errors.SERVER_ERROR, - { redirects: i, transaction: r } - ), - (o = r.to), - [4, this.perform("call", { transaction: r, blockTag: n })] - ); - case 1: - if ( - ((a = Z.sent()), - !( - i >= 0 && - n === "latest" && - o != null && - a.substring(0, 10) === "0x556f1830" && - (0, Gr.hexDataLength)(a) % 32 === 4 - )) - ) - return [3, 5]; - Z.label = 2; - case 2: - for ( - Z.trys.push([2, 4, , 5]), - s = (0, Gr.hexDataSlice)(a, 4), - c = (0, Gr.hexDataSlice)(s, 0, 32), - cl.BigNumber.from(c).eq(o) || - qn.throwError( - "CCIP Read sender did not match", - ei.Logger.errors.CALL_EXCEPTION, - { - name: "OffchainLookup", - signature: - "OffchainLookup(address,string[],bytes,bytes4,bytes)", - transaction: r, - data: a, - } - ), - u = [], - h = cl.BigNumber.from( - (0, Gr.hexDataSlice)(s, 32, 64) - ).toNumber(), - w = cl.BigNumber.from( - (0, Gr.hexDataSlice)(s, h, h + 32) - ).toNumber(), - M = (0, Gr.hexDataSlice)(s, h + 32), - k = 0; - k < w; - k++ - ) - (O = Mie(M, k * 32)), - O == null && - qn.throwError( - "CCIP Read contained corrupt URL string", - ei.Logger.errors.CALL_EXCEPTION, - { - name: "OffchainLookup", - signature: - "OffchainLookup(address,string[],bytes,bytes4,bytes)", - transaction: r, - data: a, - } - ), - u.push(O); - return ( - (D = YK(s, 64)), - cl.BigNumber.from( - (0, Gr.hexDataSlice)(s, 100, 128) - ).isZero() || - qn.throwError( - "CCIP Read callback selector included junk", - ei.Logger.errors.CALL_EXCEPTION, - { - name: "OffchainLookup", - signature: - "OffchainLookup(address,string[],bytes,bytes4,bytes)", - transaction: r, - data: a, - } - ), - (F = (0, Gr.hexDataSlice)(s, 96, 100)), - (N = YK(s, 128)), - [4, this.ccipReadFetch(r, D, u)] - ); - case 3: - return ( - (q = Z.sent()), - q == null && - qn.throwError( - "CCIP Read disabled or provided no URLs", - ei.Logger.errors.CALL_EXCEPTION, - { - name: "OffchainLookup", - signature: - "OffchainLookup(address,string[],bytes,bytes4,bytes)", - transaction: r, - data: a, - } - ), - (z = { - to: o, - data: (0, Gr.hexConcat)([F, Iyt([q, N])]), - }), - [2, this._call(z, n, i + 1)] - ); - case 4: - if ( - ((H = Z.sent()), H.code === ei.Logger.errors.SERVER_ERROR) - ) - throw H; - return [3, 5]; - case 5: - try { - return [2, (0, Gr.hexlify)(a)]; - } catch ($) { - return [ - 2, - qn.throwError( - "bad result from backend", - ei.Logger.errors.SERVER_ERROR, - { - method: "call", - params: { transaction: r, blockTag: n }, - result: a, - error: $, - } - ), - ]; - } - return [2]; - } - }); - }); - }), - (e.prototype.call = function (r, n) { - return nn(this, void 0, void 0, function () { - var i; - return on(this, function (o) { - switch (o.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return ( - o.sent(), - [ - 4, - (0, cs.resolveProperties)({ - transaction: this._getTransactionRequest(r), - blockTag: this._getBlockTag(n), - ccipReadEnabled: Promise.resolve(r.ccipReadEnabled), - }), - ] - ); - case 2: - return ( - (i = o.sent()), - [ - 2, - this._call( - i.transaction, - i.blockTag, - i.ccipReadEnabled ? 0 : -1 - ), - ] - ); - } - }); - }); - }), - (e.prototype.estimateGas = function (r) { - return nn(this, void 0, void 0, function () { - var n, i; - return on(this, function (o) { - switch (o.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return ( - o.sent(), - [ - 4, - (0, cs.resolveProperties)({ - transaction: this._getTransactionRequest(r), - }), - ] - ); - case 2: - return (n = o.sent()), [4, this.perform("estimateGas", n)]; - case 3: - i = o.sent(); - try { - return [2, cl.BigNumber.from(i)]; - } catch (a) { - return [ - 2, - qn.throwError( - "bad result from backend", - ei.Logger.errors.SERVER_ERROR, - { - method: "estimateGas", - params: n, - result: i, - error: a, - } - ), - ]; - } - return [2]; - } - }); - }); - }), - (e.prototype._getAddress = function (r) { - return nn(this, void 0, void 0, function () { - var n; - return on(this, function (i) { - switch (i.label) { - case 0: - return [4, r]; - case 1: - return ( - (r = i.sent()), - typeof r != "string" && - qn.throwArgumentError( - "invalid address or ENS name", - "name", - r - ), - [4, this.resolveName(r)] - ); - case 2: - return ( - (n = i.sent()), - n == null && - qn.throwError( - "ENS name not configured", - ei.Logger.errors.UNSUPPORTED_OPERATION, - { - operation: "resolveName(" + JSON.stringify(r) + ")", - } - ), - [2, n] - ); - } - }); - }); - }), - (e.prototype._getBlock = function (r, n) { - return nn(this, void 0, void 0, function () { - var i, - o, - a, - s, - c = this; - return on(this, function (u) { - switch (u.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return u.sent(), [4, r]; - case 2: - return ( - (r = u.sent()), - (i = -128), - (o = { includeTransactions: !!n }), - (0, Gr.isHexString)(r, 32) - ? ((o.blockHash = r), [3, 6]) - : [3, 3] - ); - case 3: - return ( - u.trys.push([3, 5, , 6]), - (a = o), - [4, this._getBlockTag(r)] - ); - case 4: - return ( - (a.blockTag = u.sent()), - (0, Gr.isHexString)(o.blockTag) && - (i = parseInt(o.blockTag.substring(2), 16)), - [3, 6] - ); - case 5: - return ( - (s = u.sent()), - qn.throwArgumentError( - "invalid block hash or block tag", - "blockHashOrBlockTag", - r - ), - [3, 6] - ); - case 6: - return [ - 2, - (0, D7.poll)( - function () { - return nn(c, void 0, void 0, function () { - var h, - w, - M, - k, - O, - D, - F = this; - return on(this, function (N) { - switch (N.label) { - case 0: - return [4, this.perform("getBlock", o)]; - case 1: - if (((h = N.sent()), h == null)) - return o.blockHash != null && - this._emitted["b:" + o.blockHash] == null - ? [2, null] - : o.blockTag != null && - i > this._emitted.block - ? [2, null] - : [2, void 0]; - if (!n) return [3, 8]; - (w = null), (M = 0), (N.label = 2); - case 2: - return M < h.transactions.length - ? ((k = h.transactions[M]), - k.blockNumber != null - ? [3, 3] - : ((k.confirmations = 0), [3, 6])) - : [3, 7]; - case 3: - return k.confirmations != null - ? [3, 6] - : w != null - ? [3, 5] - : [ - 4, - this._getInternalBlockNumber( - 100 + 2 * this.pollingInterval - ), - ]; - case 4: - (w = N.sent()), (N.label = 5); - case 5: - (O = w - k.blockNumber + 1), - O <= 0 && (O = 1), - (k.confirmations = O), - (N.label = 6); - case 6: - return M++, [3, 2]; - case 7: - return ( - (D = - this.formatter.blockWithTransactions(h)), - (D.transactions = D.transactions.map( - function (q) { - return F._wrapTransaction(q); - } - )), - [2, D] - ); - case 8: - return [2, this.formatter.block(h)]; - } - }); - }); - }, - { oncePoll: this } - ), - ]; - } - }); - }); - }), - (e.prototype.getBlock = function (r) { - return this._getBlock(r, !1); - }), - (e.prototype.getBlockWithTransactions = function (r) { - return this._getBlock(r, !0); - }), - (e.prototype.getTransaction = function (r) { - return nn(this, void 0, void 0, function () { - var n, - i = this; - return on(this, function (o) { - switch (o.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return o.sent(), [4, r]; - case 2: - return ( - (r = o.sent()), - (n = { transactionHash: this.formatter.hash(r, !0) }), - [ - 2, - (0, D7.poll)( - function () { - return nn(i, void 0, void 0, function () { - var a, s, c, u; - return on(this, function (h) { - switch (h.label) { - case 0: - return [ - 4, - this.perform("getTransaction", n), - ]; - case 1: - return ( - (a = h.sent()), - a == null - ? this._emitted["t:" + r] == null - ? [2, null] - : [2, void 0] - : ((s = - this.formatter.transactionResponse( - a - )), - s.blockNumber != null - ? [3, 2] - : ((s.confirmations = 0), [3, 4])) - ); - case 2: - return s.confirmations != null - ? [3, 4] - : [ - 4, - this._getInternalBlockNumber( - 100 + 2 * this.pollingInterval - ), - ]; - case 3: - (c = h.sent()), - (u = c - s.blockNumber + 1), - u <= 0 && (u = 1), - (s.confirmations = u), - (h.label = 4); - case 4: - return [2, this._wrapTransaction(s)]; - } - }); - }); - }, - { oncePoll: this } - ), - ] - ); - } - }); - }); - }), - (e.prototype.getTransactionReceipt = function (r) { - return nn(this, void 0, void 0, function () { - var n, - i = this; - return on(this, function (o) { - switch (o.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return o.sent(), [4, r]; - case 2: - return ( - (r = o.sent()), - (n = { transactionHash: this.formatter.hash(r, !0) }), - [ - 2, - (0, D7.poll)( - function () { - return nn(i, void 0, void 0, function () { - var a, s, c, u; - return on(this, function (h) { - switch (h.label) { - case 0: - return [ - 4, - this.perform("getTransactionReceipt", n), - ]; - case 1: - return ( - (a = h.sent()), - a == null - ? this._emitted["t:" + r] == null - ? [2, null] - : [2, void 0] - : a.blockHash == null - ? [2, void 0] - : ((s = this.formatter.receipt(a)), - s.blockNumber != null - ? [3, 2] - : ((s.confirmations = 0), [3, 4])) - ); - case 2: - return s.confirmations != null - ? [3, 4] - : [ - 4, - this._getInternalBlockNumber( - 100 + 2 * this.pollingInterval - ), - ]; - case 3: - (c = h.sent()), - (u = c - s.blockNumber + 1), - u <= 0 && (u = 1), - (s.confirmations = u), - (h.label = 4); - case 4: - return [2, s]; - } - }); - }); - }, - { oncePoll: this } - ), - ] - ); - } - }); - }); - }), - (e.prototype.getLogs = function (r) { - return nn(this, void 0, void 0, function () { - var n, i; - return on(this, function (o) { - switch (o.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return ( - o.sent(), - [ - 4, - (0, cs.resolveProperties)({ - filter: this._getFilter(r), - }), - ] - ); - case 2: - return (n = o.sent()), [4, this.perform("getLogs", n)]; - case 3: - return ( - (i = o.sent()), - i.forEach(function (a) { - a.removed == null && (a.removed = !1); - }), - [ - 2, - xyt.Formatter.arrayOf( - this.formatter.filterLog.bind(this.formatter) - )(i), - ] - ); - } - }); - }); - }), - (e.prototype.getEtherPrice = function () { - return nn(this, void 0, void 0, function () { - return on(this, function (r) { - switch (r.label) { - case 0: - return [4, this.getNetwork()]; - case 1: - return r.sent(), [2, this.perform("getEtherPrice", {})]; - } - }); - }); - }), - (e.prototype._getBlockTag = function (r) { - return nn(this, void 0, void 0, function () { - var n; - return on(this, function (i) { - switch (i.label) { - case 0: - return [4, r]; - case 1: - return ( - (r = i.sent()), - typeof r == "number" && r < 0 - ? (r % 1 && - qn.throwArgumentError( - "invalid BlockTag", - "blockTag", - r - ), - [ - 4, - this._getInternalBlockNumber( - 100 + 2 * this.pollingInterval - ), - ]) - : [3, 3] - ); - case 2: - return ( - (n = i.sent()), - (n += r), - n < 0 && (n = 0), - [2, this.formatter.blockTag(n)] - ); - case 3: - return [2, this.formatter.blockTag(r)]; - } - }); - }); - }), - (e.prototype.getResolver = function (r) { - return nn(this, void 0, void 0, function () { - var n, i, o, a; - return on(this, function (s) { - switch (s.label) { - case 0: - (n = r), (s.label = 1); - case 1: - return n === "" || n === "." - ? [2, null] - : r !== "eth" && n === "eth" - ? [2, null] - : [4, this._getResolver(n, "getResolver")]; - case 2: - return ( - (i = s.sent()), - i == null - ? [3, 5] - : ((o = new pMe(this, i, r)), - (a = n !== r), - a ? [4, o.supportsWildcard()] : [3, 4]) - ); - case 3: - (a = !s.sent()), (s.label = 4); - case 4: - return a ? [2, null] : [2, o]; - case 5: - return (n = n.split(".").slice(1).join(".")), [3, 1]; - case 6: - return [2]; - } - }); - }); - }), - (e.prototype._getResolver = function (r, n) { - return nn(this, void 0, void 0, function () { - var i, o, a; - return on(this, function (s) { - switch (s.label) { - case 0: - return n == null && (n = "ENS"), [4, this.getNetwork()]; - case 1: - (i = s.sent()), - i.ensAddress || - qn.throwError( - "network does not support ENS", - ei.Logger.errors.UNSUPPORTED_OPERATION, - { operation: n, network: i.name } - ), - (s.label = 2); - case 2: - return ( - s.trys.push([2, 4, , 5]), - [ - 4, - this.call({ - to: i.ensAddress, - data: "0x0178b8bf" + (0, XK.namehash)(r).substring(2), - }), - ] - ); - case 3: - return (o = s.sent()), [2, this.formatter.callAddress(o)]; - case 4: - return (a = s.sent()), [3, 5]; - case 5: - return [2, null]; - } - }); - }); - }), - (e.prototype.resolveName = function (r) { - return nn(this, void 0, void 0, function () { - var n; - return on(this, function (i) { - switch (i.label) { - case 0: - return [4, r]; - case 1: - r = i.sent(); - try { - return [2, Promise.resolve(this.formatter.address(r))]; - } catch (o) { - if ((0, Gr.isHexString)(r)) throw o; - } - return ( - typeof r != "string" && - qn.throwArgumentError("invalid ENS name", "name", r), - [4, this.getResolver(r)] - ); - case 2: - return (n = i.sent()), n ? [4, n.getAddress()] : [2, null]; - case 3: - return [2, i.sent()]; - } - }); - }); - }), - (e.prototype.lookupAddress = function (r) { - return nn(this, void 0, void 0, function () { - var n, i, o, a, s; - return on(this, function (c) { - switch (c.label) { - case 0: - return [4, r]; - case 1: - return ( - (r = c.sent()), - (r = this.formatter.address(r)), - (n = r.substring(2).toLowerCase() + ".addr.reverse"), - [4, this._getResolver(n, "lookupAddress")] - ); - case 2: - return ( - (i = c.sent()), - i == null - ? [2, null] - : ((a = Mie), - [ - 4, - this.call({ - to: i, - data: - "0x691f3431" + (0, XK.namehash)(n).substring(2), - }), - ]) - ); - case 3: - return ( - (o = a.apply(void 0, [c.sent(), 0])), - [4, this.resolveName(o)] - ); - case 4: - return (s = c.sent()), s != r ? [2, null] : [2, o]; - } - }); - }); - }), - (e.prototype.getAvatar = function (r) { - return nn(this, void 0, void 0, function () { - var n, i, o, a, s, c, u, h, w, M; - return on(this, function (k) { - switch (k.label) { - case 0: - return ( - (n = null), - (0, Gr.isHexString)(r) - ? ((i = this.formatter.address(r)), - (o = i.substring(2).toLowerCase() + ".addr.reverse"), - [4, this._getResolver(o, "getAvatar")]) - : [3, 10] - ); - case 1: - if (((a = k.sent()), !a)) return [2, null]; - (n = new pMe(this, a, o)), (k.label = 2); - case 2: - return k.trys.push([2, 4, , 5]), [4, n.getAvatar()]; - case 3: - return (s = k.sent()), s ? [2, s.url] : [3, 5]; - case 4: - if ( - ((c = k.sent()), - c.code !== ei.Logger.errors.CALL_EXCEPTION) - ) - throw c; - return [3, 5]; - case 5: - return ( - k.trys.push([5, 8, , 9]), - (h = Mie), - [ - 4, - this.call({ - to: a, - data: "0x691f3431" + (0, XK.namehash)(o).substring(2), - }), - ] - ); - case 6: - return ( - (u = h.apply(void 0, [k.sent(), 0])), - [4, this.getResolver(u)] - ); - case 7: - return (n = k.sent()), [3, 9]; - case 8: - if ( - ((w = k.sent()), - w.code !== ei.Logger.errors.CALL_EXCEPTION) - ) - throw w; - return [2, null]; - case 9: - return [3, 12]; - case 10: - return [4, this.getResolver(r)]; - case 11: - if (((n = k.sent()), !n)) return [2, null]; - k.label = 12; - case 12: - return [4, n.getAvatar()]; - case 13: - return (M = k.sent()), M == null ? [2, null] : [2, M.url]; - } - }); - }); - }), - (e.prototype.perform = function (r, n) { - return qn.throwError( - r + " not implemented", - ei.Logger.errors.NOT_IMPLEMENTED, - { operation: r } - ); - }), - (e.prototype._startEvent = function (r) { - this.polling = - this._events.filter(function (n) { - return n.pollable(); - }).length > 0; - }), - (e.prototype._stopEvent = function (r) { - this.polling = - this._events.filter(function (n) { - return n.pollable(); - }).length > 0; - }), - (e.prototype._addEventListener = function (r, n, i) { - var o = new Oyt(N7(r), n, i); - return this._events.push(o), this._startEvent(o), this; - }), - (e.prototype.on = function (r, n) { - return this._addEventListener(r, n, !1); - }), - (e.prototype.once = function (r, n) { - return this._addEventListener(r, n, !0); - }), - (e.prototype.emit = function (r) { - for (var n = this, i = [], o = 1; o < arguments.length; o++) - i[o - 1] = arguments[o]; - var a = !1, - s = [], - c = N7(r); - return ( - (this._events = this._events.filter(function (u) { - return u.tag !== c - ? !0 - : (setTimeout(function () { - u.listener.apply(n, i); - }, 0), - (a = !0), - u.once ? (s.push(u), !1) : !0); - })), - s.forEach(function (u) { - n._stopEvent(u); - }), - a - ); - }), - (e.prototype.listenerCount = function (r) { - if (!r) return this._events.length; - var n = N7(r); - return this._events.filter(function (i) { - return i.tag === n; - }).length; - }), - (e.prototype.listeners = function (r) { - if (r == null) - return this._events.map(function (i) { - return i.listener; - }); - var n = N7(r); - return this._events - .filter(function (i) { - return i.tag === n; - }) - .map(function (i) { - return i.listener; - }); - }), - (e.prototype.off = function (r, n) { - var i = this; - if (n == null) return this.removeAllListeners(r); - var o = [], - a = !1, - s = N7(r); - return ( - (this._events = this._events.filter(function (c) { - return c.tag !== s || c.listener != n || a - ? !0 - : ((a = !0), o.push(c), !1); - })), - o.forEach(function (c) { - i._stopEvent(c); - }), - this - ); - }), - (e.prototype.removeAllListeners = function (r) { - var n = this, - i = []; - if (r == null) (i = this._events), (this._events = []); - else { - var o = N7(r); - this._events = this._events.filter(function (a) { - return a.tag !== o ? !0 : (i.push(a), !1); - }); - } - return ( - i.forEach(function (a) { - n._stopEvent(a); - }), - this - ); - }), - e - ); - })(Pyt.Provider); - ll.BaseProvider = vTr; - }); - var L7 = I((Zy) => { - "use strict"; - m(); - g(); - var gMe = - (Zy && Zy.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(), - kx = - (Zy && Zy.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - Px = - (Zy && Zy.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(Zy, "__esModule", { value: !0 }); - Zy.JsonRpcProvider = Zy.JsonRpcSigner = void 0; - var bTr = r6(), - yMe = Ro(), - F7 = Ar(), - Cyt = db(), - ls = $r(), - Ryt = Eo(), - wTr = e0(), - Dyt = R7(), - ru = rr(), - _Tr = gc(), - Ts = new ru.Logger(_Tr.version), - xTr = QK(), - STr = ["call", "estimateGas"]; - function tH(t, e) { - if (t == null) return null; - if (typeof t.message == "string" && t.message.match("reverted")) { - var r = (0, F7.isHexString)(t.data) ? t.data : null; - if (!e || r) return { message: t.message, data: r }; - } - if (typeof t == "object") { - for (var n in t) { - var i = tH(t[n], e); - if (i) return i; - } - return null; - } - if (typeof t == "string") - try { - return tH(JSON.parse(t), e); - } catch {} - return null; - } - function Fyt(t, e, r) { - var n = r.transaction || r.signedTransaction; - if (t === "call") { - var i = tH(e, !0); - if (i) return i.data; - Ts.throwError( - "missing revert data in call exception; Transaction reverted without a reason string", - ru.Logger.errors.CALL_EXCEPTION, - { data: "0x", transaction: n, error: e } - ); - } - if (t === "estimateGas") { - var i = tH(e.body, !1); - i == null && (i = tH(e, !1)), - i && - Ts.throwError( - "cannot estimate gas; transaction may fail or may require manual gas limit", - ru.Logger.errors.UNPREDICTABLE_GAS_LIMIT, - { reason: i.message, method: t, transaction: n, error: e } - ); - } - var o = e.message; - throw ( - (e.code === ru.Logger.errors.SERVER_ERROR && - e.error && - typeof e.error.message == "string" - ? (o = e.error.message) - : typeof e.body == "string" - ? (o = e.body) - : typeof e.responseText == "string" && (o = e.responseText), - (o = (o || "").toLowerCase()), - o.match( - /insufficient funds|base fee exceeds gas limit|InsufficientFunds/i - ) && - Ts.throwError( - "insufficient funds for intrinsic transaction cost", - ru.Logger.errors.INSUFFICIENT_FUNDS, - { error: e, method: t, transaction: n } - ), - o.match(/nonce (is )?too low/i) && - Ts.throwError( - "nonce has already been used", - ru.Logger.errors.NONCE_EXPIRED, - { error: e, method: t, transaction: n } - ), - o.match( - /replacement transaction underpriced|transaction gas price.*too low/i - ) && - Ts.throwError( - "replacement fee too low", - ru.Logger.errors.REPLACEMENT_UNDERPRICED, - { error: e, method: t, transaction: n } - ), - o.match(/only replay-protected/i) && - Ts.throwError( - "legacy pre-eip-155 transactions not supported", - ru.Logger.errors.UNSUPPORTED_OPERATION, - { error: e, method: t, transaction: n } - ), - STr.indexOf(t) >= 0 && - o.match( - /gas required exceeds allowance|always failing transaction|execution reverted|revert/ - ) && - Ts.throwError( - "cannot estimate gas; transaction may fail or may require manual gas limit", - ru.Logger.errors.UNPREDICTABLE_GAS_LIMIT, - { error: e, method: t, transaction: n } - ), - e) - ); - } - function Nyt(t) { - return new Promise(function (e) { - setTimeout(e, t); - }); - } - function ATr(t) { - if (t.error) { - var e = new Error(t.error.message); - throw ((e.code = t.error.code), (e.data = t.error.data), e); - } - return t.result; - } - function eH(t) { - return t && t.toLowerCase(); - } - var mMe = {}, - vMe = (function (t) { - gMe(e, t); - function e(r, n, i) { - var o = t.call(this) || this; - if (r !== mMe) - throw new Error( - "do not call the JsonRpcSigner constructor directly; use provider.getSigner" - ); - return ( - (0, ls.defineReadOnly)(o, "provider", n), - i == null && (i = 0), - typeof i == "string" - ? ((0, ls.defineReadOnly)( - o, - "_address", - o.provider.formatter.address(i) - ), - (0, ls.defineReadOnly)(o, "_index", null)) - : typeof i == "number" - ? ((0, ls.defineReadOnly)(o, "_index", i), - (0, ls.defineReadOnly)(o, "_address", null)) - : Ts.throwArgumentError( - "invalid address or index", - "addressOrIndex", - i - ), - o - ); - } - return ( - (e.prototype.connect = function (r) { - return Ts.throwError( - "cannot alter JSON-RPC Signer connection", - ru.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "connect" } - ); - }), - (e.prototype.connectUnchecked = function () { - return new ETr(mMe, this.provider, this._address || this._index); - }), - (e.prototype.getAddress = function () { - var r = this; - return this._address - ? Promise.resolve(this._address) - : this.provider.send("eth_accounts", []).then(function (n) { - return ( - n.length <= r._index && - Ts.throwError( - "unknown account #" + r._index, - ru.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "getAddress" } - ), - r.provider.formatter.address(n[r._index]) - ); - }); - }), - (e.prototype.sendUncheckedTransaction = function (r) { - var n = this; - r = (0, ls.shallowCopy)(r); - var i = this.getAddress().then(function (a) { - return a && (a = a.toLowerCase()), a; - }); - if (r.gasLimit == null) { - var o = (0, ls.shallowCopy)(r); - (o.from = i), (r.gasLimit = this.provider.estimateGas(o)); - } - return ( - r.to != null && - (r.to = Promise.resolve(r.to).then(function (a) { - return kx(n, void 0, void 0, function () { - var s; - return Px(this, function (c) { - switch (c.label) { - case 0: - return a == null - ? [2, null] - : [4, this.provider.resolveName(a)]; - case 1: - return ( - (s = c.sent()), - s == null && - Ts.throwArgumentError( - "provided ENS name resolves to null", - "tx.to", - a - ), - [2, s] - ); - } - }); - }); - })), - (0, ls.resolveProperties)({ - tx: (0, ls.resolveProperties)(r), - sender: i, - }).then(function (a) { - var s = a.tx, - c = a.sender; - s.from != null - ? s.from.toLowerCase() !== c && - Ts.throwArgumentError( - "from address mismatch", - "transaction", - r - ) - : (s.from = c); - var u = n.provider.constructor.hexlifyTransaction(s, { - from: !0, - }); - return n.provider.send("eth_sendTransaction", [u]).then( - function (h) { - return h; - }, - function (h) { - return ( - typeof h.message == "string" && - h.message.match(/user denied/i) && - Ts.throwError( - "user rejected transaction", - ru.Logger.errors.ACTION_REJECTED, - { action: "sendTransaction", transaction: s } - ), - Fyt("sendTransaction", h, u) - ); - } - ); - }) - ); - }), - (e.prototype.signTransaction = function (r) { - return Ts.throwError( - "signing transactions is unsupported", - ru.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "signTransaction" } - ); - }), - (e.prototype.sendTransaction = function (r) { - return kx(this, void 0, void 0, function () { - var n, - i, - o, - a = this; - return Px(this, function (s) { - switch (s.label) { - case 0: - return [ - 4, - this.provider._getInternalBlockNumber( - 100 + 2 * this.provider.pollingInterval - ), - ]; - case 1: - return ( - (n = s.sent()), [4, this.sendUncheckedTransaction(r)] - ); - case 2: - (i = s.sent()), (s.label = 3); - case 3: - return ( - s.trys.push([3, 5, , 6]), - [ - 4, - (0, Dyt.poll)( - function () { - return kx(a, void 0, void 0, function () { - var c; - return Px(this, function (u) { - switch (u.label) { - case 0: - return [4, this.provider.getTransaction(i)]; - case 1: - return ( - (c = u.sent()), - c === null - ? [2, void 0] - : [ - 2, - this.provider._wrapTransaction( - c, - i, - n - ), - ] - ); - } - }); - }); - }, - { oncePoll: this.provider } - ), - ] - ); - case 4: - return [2, s.sent()]; - case 5: - throw ((o = s.sent()), (o.transactionHash = i), o); - case 6: - return [2]; - } - }); - }); - }), - (e.prototype.signMessage = function (r) { - return kx(this, void 0, void 0, function () { - var n, i, o; - return Px(this, function (a) { - switch (a.label) { - case 0: - return ( - (n = typeof r == "string" ? (0, Ryt.toUtf8Bytes)(r) : r), - [4, this.getAddress()] - ); - case 1: - (i = a.sent()), (a.label = 2); - case 2: - return ( - a.trys.push([2, 4, , 5]), - [ - 4, - this.provider.send("personal_sign", [ - (0, F7.hexlify)(n), - i.toLowerCase(), - ]), - ] - ); - case 3: - return [2, a.sent()]; - case 4: - throw ( - ((o = a.sent()), - typeof o.message == "string" && - o.message.match(/user denied/i) && - Ts.throwError( - "user rejected signing", - ru.Logger.errors.ACTION_REJECTED, - { action: "signMessage", from: i, messageData: r } - ), - o) - ); - case 5: - return [2]; - } - }); - }); - }), - (e.prototype._legacySignMessage = function (r) { - return kx(this, void 0, void 0, function () { - var n, i, o; - return Px(this, function (a) { - switch (a.label) { - case 0: - return ( - (n = typeof r == "string" ? (0, Ryt.toUtf8Bytes)(r) : r), - [4, this.getAddress()] - ); - case 1: - (i = a.sent()), (a.label = 2); - case 2: - return ( - a.trys.push([2, 4, , 5]), - [ - 4, - this.provider.send("eth_sign", [ - i.toLowerCase(), - (0, F7.hexlify)(n), - ]), - ] - ); - case 3: - return [2, a.sent()]; - case 4: - throw ( - ((o = a.sent()), - typeof o.message == "string" && - o.message.match(/user denied/i) && - Ts.throwError( - "user rejected signing", - ru.Logger.errors.ACTION_REJECTED, - { - action: "_legacySignMessage", - from: i, - messageData: r, - } - ), - o) - ); - case 5: - return [2]; - } - }); - }); - }), - (e.prototype._signTypedData = function (r, n, i) { - return kx(this, void 0, void 0, function () { - var o, - a, - s, - c = this; - return Px(this, function (u) { - switch (u.label) { - case 0: - return [ - 4, - Cyt._TypedDataEncoder.resolveNames(r, n, i, function (h) { - return c.provider.resolveName(h); - }), - ]; - case 1: - return (o = u.sent()), [4, this.getAddress()]; - case 2: - (a = u.sent()), (u.label = 3); - case 3: - return ( - u.trys.push([3, 5, , 6]), - [ - 4, - this.provider.send("eth_signTypedData_v4", [ - a.toLowerCase(), - JSON.stringify( - Cyt._TypedDataEncoder.getPayload( - o.domain, - n, - o.value - ) - ), - ]), - ] - ); - case 4: - return [2, u.sent()]; - case 5: - throw ( - ((s = u.sent()), - typeof s.message == "string" && - s.message.match(/user denied/i) && - Ts.throwError( - "user rejected signing", - ru.Logger.errors.ACTION_REJECTED, - { - action: "_signTypedData", - from: a, - messageData: { - domain: o.domain, - types: n, - value: o.value, - }, - } - ), - s) - ); - case 6: - return [2]; - } - }); - }); - }), - (e.prototype.unlock = function (r) { - return kx(this, void 0, void 0, function () { - var n, i; - return Px(this, function (o) { - switch (o.label) { - case 0: - return (n = this.provider), [4, this.getAddress()]; - case 1: - return ( - (i = o.sent()), - [ - 2, - n.send("personal_unlockAccount", [ - i.toLowerCase(), - r, - null, - ]), - ] - ); - } - }); - }); - }), - e - ); - })(bTr.Signer); - Zy.JsonRpcSigner = vMe; - var ETr = (function (t) { - gMe(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.prototype.sendTransaction = function (r) { - var n = this; - return this.sendUncheckedTransaction(r).then(function (i) { - return { - hash: i, - nonce: null, - gasLimit: null, - gasPrice: null, - data: null, - value: null, - chainId: null, - confirmations: 0, - from: null, - wait: function (o) { - return n.provider.waitForTransaction(i, o); - }, - }; - }); - }), - e - ); - })(vMe), - MTr = { - chainId: !0, - data: !0, - gasLimit: !0, - gasPrice: !0, - nonce: !0, - to: !0, - value: !0, - type: !0, - accessList: !0, - maxFeePerGas: !0, - maxPriorityFeePerGas: !0, - }, - TTr = (function (t) { - gMe(e, t); - function e(r, n) { - var i = this, - o = n; - return ( - o == null && - (o = new Promise(function (a, s) { - setTimeout(function () { - i.detectNetwork().then( - function (c) { - a(c); - }, - function (c) { - s(c); - } - ); - }, 0); - })), - (i = t.call(this, o) || this), - r || (r = (0, ls.getStatic)(i.constructor, "defaultUrl")()), - typeof r == "string" - ? (0, ls.defineReadOnly)( - i, - "connection", - Object.freeze({ url: r }) - ) - : (0, ls.defineReadOnly)( - i, - "connection", - Object.freeze((0, ls.shallowCopy)(r)) - ), - (i._nextId = 42), - i - ); - } - return ( - Object.defineProperty(e.prototype, "_cache", { - get: function () { - return ( - this._eventLoopCache == null && (this._eventLoopCache = {}), - this._eventLoopCache - ); - }, - enumerable: !1, - configurable: !0, - }), - (e.defaultUrl = function () { - return "http://localhost:8545"; - }), - (e.prototype.detectNetwork = function () { - var r = this; - return ( - this._cache.detectNetwork || - ((this._cache.detectNetwork = this._uncachedDetectNetwork()), - setTimeout(function () { - r._cache.detectNetwork = null; - }, 0)), - this._cache.detectNetwork - ); - }), - (e.prototype._uncachedDetectNetwork = function () { - return kx(this, void 0, void 0, function () { - var r, n, i, o; - return Px(this, function (a) { - switch (a.label) { - case 0: - return [4, Nyt(0)]; - case 1: - a.sent(), (r = null), (a.label = 2); - case 2: - return ( - a.trys.push([2, 4, , 9]), - [4, this.send("eth_chainId", [])] - ); - case 3: - return (r = a.sent()), [3, 9]; - case 4: - (n = a.sent()), (a.label = 5); - case 5: - return ( - a.trys.push([5, 7, , 8]), - [4, this.send("net_version", [])] - ); - case 6: - return (r = a.sent()), [3, 8]; - case 7: - return (i = a.sent()), [3, 8]; - case 8: - return [3, 9]; - case 9: - if (r != null) { - o = (0, ls.getStatic)(this.constructor, "getNetwork"); - try { - return [2, o(yMe.BigNumber.from(r).toNumber())]; - } catch (s) { - return [ - 2, - Ts.throwError( - "could not detect network", - ru.Logger.errors.NETWORK_ERROR, - { - chainId: r, - event: "invalidNetwork", - serverError: s, - } - ), - ]; - } - } - return [ - 2, - Ts.throwError( - "could not detect network", - ru.Logger.errors.NETWORK_ERROR, - { event: "noNetwork" } - ), - ]; - } - }); - }); - }), - (e.prototype.getSigner = function (r) { - return new vMe(mMe, this, r); - }), - (e.prototype.getUncheckedSigner = function (r) { - return this.getSigner(r).connectUnchecked(); - }), - (e.prototype.listAccounts = function () { - var r = this; - return this.send("eth_accounts", []).then(function (n) { - return n.map(function (i) { - return r.formatter.address(i); - }); - }); - }), - (e.prototype.send = function (r, n) { - var i = this, - o = { method: r, params: n, id: this._nextId++, jsonrpc: "2.0" }; - this.emit("debug", { - action: "request", - request: (0, ls.deepCopy)(o), - provider: this, - }); - var a = ["eth_chainId", "eth_blockNumber"].indexOf(r) >= 0; - if (a && this._cache[r]) return this._cache[r]; - var s = (0, Dyt.fetchJson)( - this.connection, - JSON.stringify(o), - ATr - ).then( - function (c) { - return ( - i.emit("debug", { - action: "response", - request: o, - response: c, - provider: i, - }), - c - ); - }, - function (c) { - throw ( - (i.emit("debug", { - action: "response", - error: c, - request: o, - provider: i, - }), - c) - ); - } - ); - return ( - a && - ((this._cache[r] = s), - setTimeout(function () { - i._cache[r] = null; - }, 0)), - s - ); - }), - (e.prototype.prepareRequest = function (r, n) { - switch (r) { - case "getBlockNumber": - return ["eth_blockNumber", []]; - case "getGasPrice": - return ["eth_gasPrice", []]; - case "getBalance": - return ["eth_getBalance", [eH(n.address), n.blockTag]]; - case "getTransactionCount": - return ["eth_getTransactionCount", [eH(n.address), n.blockTag]]; - case "getCode": - return ["eth_getCode", [eH(n.address), n.blockTag]]; - case "getStorageAt": - return [ - "eth_getStorageAt", - [ - eH(n.address), - (0, F7.hexZeroPad)(n.position, 32), - n.blockTag, - ], - ]; - case "sendTransaction": - return ["eth_sendRawTransaction", [n.signedTransaction]]; - case "getBlock": - return n.blockTag - ? [ - "eth_getBlockByNumber", - [n.blockTag, !!n.includeTransactions], - ] - : n.blockHash - ? [ - "eth_getBlockByHash", - [n.blockHash, !!n.includeTransactions], - ] - : null; - case "getTransaction": - return ["eth_getTransactionByHash", [n.transactionHash]]; - case "getTransactionReceipt": - return ["eth_getTransactionReceipt", [n.transactionHash]]; - case "call": { - var i = (0, ls.getStatic)( - this.constructor, - "hexlifyTransaction" - ); - return [ - "eth_call", - [i(n.transaction, { from: !0 }), n.blockTag], - ]; - } - case "estimateGas": { - var i = (0, ls.getStatic)( - this.constructor, - "hexlifyTransaction" - ); - return ["eth_estimateGas", [i(n.transaction, { from: !0 })]]; - } - case "getLogs": - return ( - n.filter && - n.filter.address != null && - (n.filter.address = eH(n.filter.address)), - ["eth_getLogs", [n.filter]] - ); - default: - break; - } - return null; - }), - (e.prototype.perform = function (r, n) { - return kx(this, void 0, void 0, function () { - var i, o, a, s; - return Px(this, function (c) { - switch (c.label) { - case 0: - return r === "call" || r === "estimateGas" - ? ((i = n.transaction), - i && - i.type != null && - yMe.BigNumber.from(i.type).isZero() - ? i.maxFeePerGas == null && - i.maxPriorityFeePerGas == null - ? [4, this.getFeeData()] - : [3, 2] - : [3, 2]) - : [3, 2]; - case 1: - (o = c.sent()), - o.maxFeePerGas == null && - o.maxPriorityFeePerGas == null && - ((n = (0, ls.shallowCopy)(n)), - (n.transaction = (0, ls.shallowCopy)(i)), - delete n.transaction.type), - (c.label = 2); - case 2: - (a = this.prepareRequest(r, n)), - a == null && - Ts.throwError( - r + " not implemented", - ru.Logger.errors.NOT_IMPLEMENTED, - { operation: r } - ), - (c.label = 3); - case 3: - return c.trys.push([3, 5, , 6]), [4, this.send(a[0], a[1])]; - case 4: - return [2, c.sent()]; - case 5: - return (s = c.sent()), [2, Fyt(r, s, n)]; - case 6: - return [2]; - } - }); - }); - }), - (e.prototype._startEvent = function (r) { - r.tag === "pending" && this._startPending(), - t.prototype._startEvent.call(this, r); - }), - (e.prototype._startPending = function () { - if (this._pendingFilter == null) { - var r = this, - n = this.send("eth_newPendingTransactionFilter", []); - (this._pendingFilter = n), - n - .then(function (i) { - function o() { - r.send("eth_getFilterChanges", [i]) - .then(function (a) { - if (r._pendingFilter != n) return null; - var s = Promise.resolve(); - return ( - a.forEach(function (c) { - (r._emitted["t:" + c.toLowerCase()] = "pending"), - (s = s.then(function () { - return r.getTransaction(c).then(function (u) { - return r.emit("pending", u), null; - }); - })); - }), - s.then(function () { - return Nyt(1e3); - }) - ); - }) - .then(function () { - if (r._pendingFilter != n) { - r.send("eth_uninstallFilter", [i]); - return; - } - return ( - setTimeout(function () { - o(); - }, 0), - null - ); - }) - .catch(function (a) {}); - } - return o(), i; - }) - .catch(function (i) {}); - } - }), - (e.prototype._stopEvent = function (r) { - r.tag === "pending" && - this.listenerCount("pending") === 0 && - (this._pendingFilter = null), - t.prototype._stopEvent.call(this, r); - }), - (e.hexlifyTransaction = function (r, n) { - var i = (0, ls.shallowCopy)(MTr); - if (n) for (var o in n) n[o] && (i[o] = !0); - (0, ls.checkProperties)(r, i); - var a = {}; - return ( - [ - "chainId", - "gasLimit", - "gasPrice", - "type", - "maxFeePerGas", - "maxPriorityFeePerGas", - "nonce", - "value", - ].forEach(function (s) { - if (r[s] != null) { - var c = (0, F7.hexValue)(yMe.BigNumber.from(r[s])); - s === "gasLimit" && (s = "gas"), (a[s] = c); - } - }), - ["from", "to", "data"].forEach(function (s) { - r[s] != null && (a[s] = (0, F7.hexlify)(r[s])); - }), - r.accessList && - (a.accessList = (0, wTr.accessListify)(r.accessList)), - a - ); - }), - e - ); - })(xTr.BaseProvider); - Zy.JsonRpcProvider = TTr; - }); - var zyt = I((q7) => { - "use strict"; - m(); - g(); - Object.defineProperty(q7, "__esModule", { value: !0 }); - q7.WebSocket = void 0; - var Lyt = rr(), - kTr = gc(), - Tie = null; - q7.WebSocket = Tie; - try { - if (((q7.WebSocket = Tie = WebSocket), Tie == null)) - throw new Error("inject please"); - } catch { - (qyt = new Lyt.Logger(kTr.version)), - (q7.WebSocket = Tie = - function () { - qyt.throwError( - "WebSockets not supported in this environment", - Lyt.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "new WebSocket()" } - ); - }); - } - var qyt; - }); - var Pie = I((Ib) => { - "use strict"; - m(); - g(); - var PTr = - (Ib && Ib.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(), - bMe = - (Ib && Ib.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - wMe = - (Ib && Ib.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(Ib, "__esModule", { value: !0 }); - Ib.WebSocketProvider = void 0; - var OTr = Ro(), - fE = $r(), - BTr = L7(), - jyt = zyt(), - rH = rr(), - ITr = gc(), - kie = new rH.Logger(ITr.version), - CTr = 1, - RTr = (function (t) { - PTr(e, t); - function e(r, n) { - var i = this; - n === "any" && - kie.throwError( - "WebSocketProvider does not support 'any' network yet", - rH.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "network:any" } - ), - typeof r == "string" - ? (i = t.call(this, r, n) || this) - : (i = t.call(this, "_websocket", n) || this), - (i._pollingInterval = -1), - (i._wsReady = !1), - typeof r == "string" - ? (0, fE.defineReadOnly)( - i, - "_websocket", - new jyt.WebSocket(i.connection.url) - ) - : (0, fE.defineReadOnly)(i, "_websocket", r), - (0, fE.defineReadOnly)(i, "_requests", {}), - (0, fE.defineReadOnly)(i, "_subs", {}), - (0, fE.defineReadOnly)(i, "_subIds", {}), - (0, fE.defineReadOnly)( - i, - "_detectNetwork", - t.prototype.detectNetwork.call(i) - ), - (i.websocket.onopen = function () { - (i._wsReady = !0), - Object.keys(i._requests).forEach(function (a) { - i.websocket.send(i._requests[a].payload); - }); - }), - (i.websocket.onmessage = function (a) { - var s = a.data, - c = JSON.parse(s); - if (c.id != null) { - var u = String(c.id), - h = i._requests[u]; - if ((delete i._requests[u], c.result !== void 0)) - h.callback(null, c.result), - i.emit("debug", { - action: "response", - request: JSON.parse(h.payload), - response: c.result, - provider: i, - }); - else { - var w = null; - c.error - ? ((w = new Error(c.error.message || "unknown error")), - (0, fE.defineReadOnly)(w, "code", c.error.code || null), - (0, fE.defineReadOnly)(w, "response", s)) - : (w = new Error("unknown error")), - h.callback(w, void 0), - i.emit("debug", { - action: "response", - error: w, - request: JSON.parse(h.payload), - provider: i, - }); - } - } else if (c.method === "eth_subscription") { - var M = i._subs[c.params.subscription]; - M && M.processFunc(c.params.result); - } else console.warn("this should not happen"); - }); - var o = setInterval(function () { - i.emit("poll"); - }, 1e3); - return o.unref && o.unref(), i; - } - return ( - Object.defineProperty(e.prototype, "websocket", { - get: function () { - return this._websocket; - }, - enumerable: !1, - configurable: !0, - }), - (e.prototype.detectNetwork = function () { - return this._detectNetwork; - }), - Object.defineProperty(e.prototype, "pollingInterval", { - get: function () { - return 0; - }, - set: function (r) { - kie.throwError( - "cannot set polling interval on WebSocketProvider", - rH.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "setPollingInterval" } - ); - }, - enumerable: !1, - configurable: !0, - }), - (e.prototype.resetEventsBlock = function (r) { - kie.throwError( - "cannot reset events block on WebSocketProvider", - rH.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "resetEventBlock" } - ); - }), - (e.prototype.poll = function () { - return bMe(this, void 0, void 0, function () { - return wMe(this, function (r) { - return [2, null]; - }); - }); - }), - Object.defineProperty(e.prototype, "polling", { - set: function (r) { - !r || - kie.throwError( - "cannot set polling on WebSocketProvider", - rH.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "setPolling" } - ); - }, - enumerable: !1, - configurable: !0, - }), - (e.prototype.send = function (r, n) { - var i = this, - o = CTr++; - return new Promise(function (a, s) { - function c(h, w) { - return h ? s(h) : a(w); - } - var u = JSON.stringify({ - method: r, - params: n, - id: o, - jsonrpc: "2.0", - }); - i.emit("debug", { - action: "request", - request: JSON.parse(u), - provider: i, - }), - (i._requests[String(o)] = { callback: c, payload: u }), - i._wsReady && i.websocket.send(u); - }); - }), - (e.defaultUrl = function () { - return "ws://localhost:8546"; - }), - (e.prototype._subscribe = function (r, n, i) { - return bMe(this, void 0, void 0, function () { - var o, - a, - s = this; - return wMe(this, function (c) { - switch (c.label) { - case 0: - return ( - (o = this._subIds[r]), - o == null && - ((o = Promise.all(n).then(function (u) { - return s.send("eth_subscribe", u); - })), - (this._subIds[r] = o)), - [4, o] - ); - case 1: - return ( - (a = c.sent()), - (this._subs[a] = { tag: r, processFunc: i }), - [2] - ); - } - }); - }); - }), - (e.prototype._startEvent = function (r) { - var n = this; - switch (r.type) { - case "block": - this._subscribe("block", ["newHeads"], function (o) { - var a = OTr.BigNumber.from(o.number).toNumber(); - (n._emitted.block = a), n.emit("block", a); - }); - break; - case "pending": - this._subscribe( - "pending", - ["newPendingTransactions"], - function (o) { - n.emit("pending", o); - } - ); - break; - case "filter": - this._subscribe( - r.tag, - ["logs", this._getFilter(r.filter)], - function (o) { - o.removed == null && (o.removed = !1), - n.emit(r.filter, n.formatter.filterLog(o)); - } - ); - break; - case "tx": { - var i = function (o) { - var a = o.hash; - n.getTransactionReceipt(a).then(function (s) { - !s || n.emit(a, s); - }); - }; - i(r), - this._subscribe("tx", ["newHeads"], function (o) { - n._events - .filter(function (a) { - return a.type === "tx"; - }) - .forEach(i); - }); - break; - } - case "debug": - case "poll": - case "willPoll": - case "didPoll": - case "error": - break; - default: - console.log("unhandled:", r); - break; - } - }), - (e.prototype._stopEvent = function (r) { - var n = this, - i = r.tag; - if (r.type === "tx") { - if ( - this._events.filter(function (a) { - return a.type === "tx"; - }).length - ) - return; - i = "tx"; - } else if (this.listenerCount(r.event)) return; - var o = this._subIds[i]; - !o || - (delete this._subIds[i], - o.then(function (a) { - !n._subs[a] || - (delete n._subs[a], n.send("eth_unsubscribe", [a])); - })); - }), - (e.prototype.destroy = function () { - return bMe(this, void 0, void 0, function () { - var r = this; - return wMe(this, function (n) { - switch (n.label) { - case 0: - return this.websocket.readyState !== - jyt.WebSocket.CONNECTING - ? [3, 2] - : [ - 4, - new Promise(function (i) { - (r.websocket.onopen = function () { - i(!0); - }), - (r.websocket.onerror = function () { - i(!1); - }); - }), - ]; - case 1: - n.sent(), (n.label = 2); - case 2: - return this.websocket.close(1e3), [2]; - } - }); - }); - }), - e - ); - })(BTr.JsonRpcProvider); - Ib.WebSocketProvider = RTr; - }); - var dE = I((Xy) => { - "use strict"; - m(); - g(); - var Uyt = - (Xy && Xy.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(), - NTr = - (Xy && Xy.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - DTr = - (Xy && Xy.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(Xy, "__esModule", { value: !0 }); - Xy.UrlJsonRpcProvider = Xy.StaticJsonRpcProvider = void 0; - var z7 = $r(), - Oie = rr(), - FTr = gc(), - nH = new Oie.Logger(FTr.version), - LTr = L7(), - Kyt = (function (t) { - Uyt(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.prototype.detectNetwork = function () { - return NTr(this, void 0, void 0, function () { - var r; - return DTr(this, function (n) { - switch (n.label) { - case 0: - return ( - (r = this.network), - r != null - ? [3, 2] - : [4, t.prototype.detectNetwork.call(this)] - ); - case 1: - (r = n.sent()), - r || - nH.throwError( - "no network detected", - Oie.Logger.errors.UNKNOWN_ERROR, - {} - ), - this._network == null && - ((0, z7.defineReadOnly)(this, "_network", r), - this.emit("network", r, null)), - (n.label = 2); - case 2: - return [2, r]; - } - }); - }); - }), - e - ); - })(LTr.JsonRpcProvider); - Xy.StaticJsonRpcProvider = Kyt; - var qTr = (function (t) { - Uyt(e, t); - function e(r, n) { - var i = this.constructor, - o = this; - nH.checkAbstract(i, e), - (r = (0, z7.getStatic)(i, "getNetwork")(r)), - (n = (0, z7.getStatic)(i, "getApiKey")(n)); - var a = (0, z7.getStatic)(i, "getUrl")(r, n); - return ( - (o = t.call(this, a, r) || this), - typeof n == "string" - ? (0, z7.defineReadOnly)(o, "apiKey", n) - : n != null && - Object.keys(n).forEach(function (s) { - (0, z7.defineReadOnly)(o, s, n[s]); - }), - o - ); - } - return ( - (e.prototype._startPending = function () { - nH.warn("WARNING: API provider does not support pending filters"); - }), - (e.prototype.isCommunityResource = function () { - return !1; - }), - (e.prototype.getSigner = function (r) { - return nH.throwError( - "API provider does not support signing", - Oie.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "getSigner" } - ); - }), - (e.prototype.listAccounts = function () { - return Promise.resolve([]); - }), - (e.getApiKey = function (r) { - return r; - }), - (e.getUrl = function (r, n) { - return nH.throwError( - "not implemented; sub-classes must override getUrl", - Oie.Logger.errors.NOT_IMPLEMENTED, - { operation: "getUrl" } - ); - }), - e - ); - })(Kyt); - Xy.UrlJsonRpcProvider = qTr; - }); - var Jyt = I((hE) => { - "use strict"; - m(); - g(); - var Vyt = - (hE && hE.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(hE, "__esModule", { value: !0 }); - hE.AlchemyProvider = hE.AlchemyWebSocketProvider = void 0; - var zTr = $r(), - jTr = lE(), - UTr = Pie(), - KTr = rr(), - HTr = gc(), - Hyt = new KTr.Logger(HTr.version), - VTr = dE(), - Bie = "_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC", - Wyt = (function (t) { - Vyt(e, t); - function e(r, n) { - var i = this, - o = new Gyt(r, n), - a = o.connection.url - .replace(/^http/i, "ws") - .replace(".alchemyapi.", ".ws.alchemyapi."); - return ( - (i = t.call(this, a, o.network) || this), - (0, zTr.defineReadOnly)(i, "apiKey", o.apiKey), - i - ); - } - return ( - (e.prototype.isCommunityResource = function () { - return this.apiKey === Bie; - }), - e - ); - })(UTr.WebSocketProvider); - hE.AlchemyWebSocketProvider = Wyt; - var Gyt = (function (t) { - Vyt(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.getWebSocketProvider = function (r, n) { - return new Wyt(r, n); - }), - (e.getApiKey = function (r) { - return r == null - ? Bie - : (r && - typeof r != "string" && - Hyt.throwArgumentError("invalid apiKey", "apiKey", r), - r); - }), - (e.getUrl = function (r, n) { - var i = null; - switch (r.name) { - case "homestead": - i = "eth-mainnet.alchemyapi.io/v2/"; - break; - case "goerli": - i = "eth-goerli.g.alchemy.com/v2/"; - break; - case "matic": - i = "polygon-mainnet.g.alchemy.com/v2/"; - break; - case "maticmum": - i = "polygon-mumbai.g.alchemy.com/v2/"; - break; - case "arbitrum": - i = "arb-mainnet.g.alchemy.com/v2/"; - break; - case "arbitrum-goerli": - i = "arb-goerli.g.alchemy.com/v2/"; - break; - case "optimism": - i = "opt-mainnet.g.alchemy.com/v2/"; - break; - case "optimism-goerli": - i = "opt-goerli.g.alchemy.com/v2/"; - break; - default: - Hyt.throwArgumentError( - "unsupported network", - "network", - arguments[0] - ); - } - return { - allowGzip: !0, - url: "https://" + i + n, - throttleCallback: function (o, a) { - return ( - n === Bie && (0, jTr.showThrottleMessage)(), Promise.resolve(!0) - ); - }, - }; - }), - (e.prototype.isCommunityResource = function () { - return this.apiKey === Bie; - }), - e - ); - })(VTr.UrlJsonRpcProvider); - hE.AlchemyProvider = Gyt; - }); - var $yt = I((j7) => { - "use strict"; - m(); - g(); - var WTr = - (j7 && j7.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(j7, "__esModule", { value: !0 }); - j7.AnkrProvider = void 0; - var GTr = lE(), - JTr = dE(), - $Tr = rr(), - ZTr = gc(), - XTr = new $Tr.Logger(ZTr.version), - Iie = "9f7d929b018cdffb338517efa06f58359e86ff1ffd350bc889738523659e7972"; - function YTr(t) { - switch (t) { - case "homestead": - return "rpc.ankr.com/eth/"; - case "ropsten": - return "rpc.ankr.com/eth_ropsten/"; - case "rinkeby": - return "rpc.ankr.com/eth_rinkeby/"; - case "goerli": - return "rpc.ankr.com/eth_goerli/"; - case "matic": - return "rpc.ankr.com/polygon/"; - case "arbitrum": - return "rpc.ankr.com/arbitrum/"; - } - return XTr.throwArgumentError("unsupported network", "name", t); - } - var QTr = (function (t) { - WTr(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.prototype.isCommunityResource = function () { - return this.apiKey === Iie; - }), - (e.getApiKey = function (r) { - return r ?? Iie; - }), - (e.getUrl = function (r, n) { - n == null && (n = Iie); - var i = { - allowGzip: !0, - url: "https://" + YTr(r.name) + n, - throttleCallback: function (o, a) { - return ( - n.apiKey === Iie && (0, GTr.showThrottleMessage)(), - Promise.resolve(!0) - ); - }, - }; - return ( - n.projectSecret != null && - ((i.user = ""), (i.password = n.projectSecret)), - i - ); - }), - e - ); - })(JTr.UrlJsonRpcProvider); - j7.AnkrProvider = QTr; - }); - var Xyt = I((Cb) => { - "use strict"; - m(); - g(); - var e6r = - (Cb && Cb.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(), - t6r = - (Cb && Cb.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - r6r = - (Cb && Cb.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(Cb, "__esModule", { value: !0 }); - Cb.CloudflareProvider = void 0; - var n6r = dE(), - i6r = rr(), - o6r = gc(), - Zyt = new i6r.Logger(o6r.version), - a6r = (function (t) { - e6r(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.getApiKey = function (r) { - return ( - r != null && - Zyt.throwArgumentError( - "apiKey not supported for cloudflare", - "apiKey", - r - ), - null - ); - }), - (e.getUrl = function (r, n) { - var i = null; - switch (r.name) { - case "homestead": - i = "https://cloudflare-eth.com/"; - break; - default: - Zyt.throwArgumentError( - "unsupported network", - "network", - arguments[0] - ); - } - return i; - }), - (e.prototype.perform = function (r, n) { - return t6r(this, void 0, void 0, function () { - var i; - return r6r(this, function (o) { - switch (o.label) { - case 0: - return r !== "getBlockNumber" - ? [3, 2] - : [ - 4, - t.prototype.perform.call(this, "getBlock", { - blockTag: "latest", - }), - ]; - case 1: - return (i = o.sent()), [2, i.number]; - case 2: - return [2, t.prototype.perform.call(this, r, n)]; - } - }); - }); - }), - e - ); - })(n6r.UrlJsonRpcProvider); - Cb.CloudflareProvider = a6r; - }); - var tmt = I((Nb) => { - "use strict"; - m(); - g(); - var s6r = - (Nb && Nb.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(), - Cie = - (Nb && Nb.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - Rie = - (Nb && Nb.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(Nb, "__esModule", { value: !0 }); - Nb.EtherscanProvider = void 0; - var Nie = Ar(), - _Me = $r(), - u6r = e0(), - c6r = R7(), - l6r = lE(), - Rb = rr(), - f6r = gc(), - pE = new Rb.Logger(f6r.version), - d6r = QK(); - function Yyt(t) { - var e = {}; - for (var r in t) - if (t[r] != null) { - var n = t[r]; - (r === "type" && n === 0) || - ({ - type: !0, - gasLimit: !0, - gasPrice: !0, - maxFeePerGs: !0, - maxPriorityFeePerGas: !0, - nonce: !0, - value: !0, - }[r] - ? (n = (0, Nie.hexValue)((0, Nie.hexlify)(n))) - : r === "accessList" - ? (n = - "[" + - (0, u6r.accessListify)(n) - .map(function (i) { - return ( - '{address:"' + - i.address + - '",storageKeys:["' + - i.storageKeys.join('","') + - '"]}' - ); - }) - .join(",") + - "]") - : (n = (0, Nie.hexlify)(n)), - (e[r] = n)); - } - return e; - } - function h6r(t) { - if ( - t.status == 0 && - (t.message === "No records found" || - t.message === "No transactions found") - ) - return t.result; - if ( - t.status != 1 || - typeof t.message != "string" || - !t.message.match(/^OK/) - ) { - var e = new Error("invalid response"); - throw ( - ((e.result = JSON.stringify(t)), - (t.result || "").toLowerCase().indexOf("rate limit") >= 0 && - (e.throttleRetry = !0), - e) - ); - } - return t.result; - } - function Qyt(t) { - if ( - t && - t.status == 0 && - t.message == "NOTOK" && - (t.result || "").toLowerCase().indexOf("rate limit") >= 0 - ) { - var e = new Error("throttled response"); - throw ((e.result = JSON.stringify(t)), (e.throttleRetry = !0), e); - } - if (t.jsonrpc != "2.0") { - var e = new Error("invalid response"); - throw ((e.result = JSON.stringify(t)), e); - } - if (t.error) { - var e = new Error(t.error.message || "unknown error"); - throw ( - (t.error.code && (e.code = t.error.code), - t.error.data && (e.data = t.error.data), - e) - ); - } - return t.result; - } - function emt(t) { - if (t === "pending") throw new Error("pending not supported"); - return t === "latest" ? t : parseInt(t.substring(2), 16); - } - function xMe(t, e, r) { - if (t === "call" && e.code === Rb.Logger.errors.SERVER_ERROR) { - var n = e.error; - if ( - n && - (n.message.match(/reverted/i) || - n.message.match(/VM execution error/i)) - ) { - var i = n.data; - if ( - (i && (i = "0x" + i.replace(/^.*0x/i, "")), (0, Nie.isHexString)(i)) - ) - return i; - pE.throwError( - "missing revert data in call exception", - Rb.Logger.errors.CALL_EXCEPTION, - { error: e, data: "0x" } - ); - } - } - var o = e.message; - throw ( - (e.code === Rb.Logger.errors.SERVER_ERROR && - (e.error && typeof e.error.message == "string" - ? (o = e.error.message) - : typeof e.body == "string" - ? (o = e.body) - : typeof e.responseText == "string" && (o = e.responseText)), - (o = (o || "").toLowerCase()), - o.match(/insufficient funds/) && - pE.throwError( - "insufficient funds for intrinsic transaction cost", - Rb.Logger.errors.INSUFFICIENT_FUNDS, - { error: e, method: t, transaction: r } - ), - o.match( - /same hash was already imported|transaction nonce is too low|nonce too low/ - ) && - pE.throwError( - "nonce has already been used", - Rb.Logger.errors.NONCE_EXPIRED, - { error: e, method: t, transaction: r } - ), - o.match(/another transaction with same nonce/) && - pE.throwError( - "replacement fee too low", - Rb.Logger.errors.REPLACEMENT_UNDERPRICED, - { error: e, method: t, transaction: r } - ), - o.match(/execution failed due to an exception|execution reverted/) && - pE.throwError( - "cannot estimate gas; transaction may fail or may require manual gas limit", - Rb.Logger.errors.UNPREDICTABLE_GAS_LIMIT, - { error: e, method: t, transaction: r } - ), - e) - ); - } - var p6r = (function (t) { - s6r(e, t); - function e(r, n) { - var i = t.call(this, r) || this; - return ( - (0, _Me.defineReadOnly)(i, "baseUrl", i.getBaseUrl()), - (0, _Me.defineReadOnly)(i, "apiKey", n || null), - i - ); - } - return ( - (e.prototype.getBaseUrl = function () { - switch (this.network ? this.network.name : "invalid") { - case "homestead": - return "https://api.etherscan.io"; - case "goerli": - return "https://api-goerli.etherscan.io"; - case "sepolia": - return "https://api-sepolia.etherscan.io"; - case "matic": - return "https://api.polygonscan.com"; - case "maticmum": - return "https://api-testnet.polygonscan.com"; - case "arbitrum": - return "https://api.arbiscan.io"; - case "arbitrum-goerli": - return "https://api-goerli.arbiscan.io"; - case "optimism": - return "https://api-optimistic.etherscan.io"; - case "optimism-goerli": - return "https://api-goerli-optimistic.etherscan.io"; - default: - } - return pE.throwArgumentError( - "unsupported network", - "network", - this.network.name - ); - }), - (e.prototype.getUrl = function (r, n) { - var i = Object.keys(n).reduce(function (a, s) { - var c = n[s]; - return c != null && (a += "&" + s + "=" + c), a; - }, ""), - o = this.apiKey ? "&apikey=" + this.apiKey : ""; - return this.baseUrl + "/api?module=" + r + i + o; - }), - (e.prototype.getPostUrl = function () { - return this.baseUrl + "/api"; - }), - (e.prototype.getPostData = function (r, n) { - return (n.module = r), (n.apikey = this.apiKey), n; - }), - (e.prototype.fetch = function (r, n, i) { - return Cie(this, void 0, void 0, function () { - var o, - a, - s, - c, - u, - h, - w = this; - return Rie(this, function (M) { - switch (M.label) { - case 0: - return ( - (o = i ? this.getPostUrl() : this.getUrl(r, n)), - (a = i ? this.getPostData(r, n) : null), - (s = r === "proxy" ? Qyt : h6r), - this.emit("debug", { - action: "request", - request: o, - provider: this, - }), - (c = { - url: o, - throttleSlotInterval: 1e3, - throttleCallback: function (k, O) { - return ( - w.isCommunityResource() && - (0, l6r.showThrottleMessage)(), - Promise.resolve(!0) - ); - }, - }), - (u = null), - a && - ((c.headers = { - "content-type": - "application/x-www-form-urlencoded; charset=UTF-8", - }), - (u = Object.keys(a) - .map(function (k) { - return k + "=" + a[k]; - }) - .join("&"))), - [4, (0, c6r.fetchJson)(c, u, s || Qyt)] - ); - case 1: - return ( - (h = M.sent()), - this.emit("debug", { - action: "response", - request: o, - response: (0, _Me.deepCopy)(h), - provider: this, - }), - [2, h] - ); - } - }); - }); - }), - (e.prototype.detectNetwork = function () { - return Cie(this, void 0, void 0, function () { - return Rie(this, function (r) { - return [2, this.network]; - }); - }); - }), - (e.prototype.perform = function (r, n) { - return Cie(this, void 0, void 0, function () { - var i, a, o, a, s, c, u, h, w, M, k, O, D; - return Rie(this, function (F) { - switch (F.label) { - case 0: - switch (((i = r), i)) { - case "getBlockNumber": - return [3, 1]; - case "getGasPrice": - return [3, 2]; - case "getBalance": - return [3, 3]; - case "getTransactionCount": - return [3, 4]; - case "getCode": - return [3, 5]; - case "getStorageAt": - return [3, 6]; - case "sendTransaction": - return [3, 7]; - case "getBlock": - return [3, 8]; - case "getTransaction": - return [3, 9]; - case "getTransactionReceipt": - return [3, 10]; - case "call": - return [3, 11]; - case "estimateGas": - return [3, 15]; - case "getLogs": - return [3, 19]; - case "getEtherPrice": - return [3, 26]; - } - return [3, 28]; - case 1: - return [ - 2, - this.fetch("proxy", { action: "eth_blockNumber" }), - ]; - case 2: - return [2, this.fetch("proxy", { action: "eth_gasPrice" })]; - case 3: - return [ - 2, - this.fetch("account", { - action: "balance", - address: n.address, - tag: n.blockTag, - }), - ]; - case 4: - return [ - 2, - this.fetch("proxy", { - action: "eth_getTransactionCount", - address: n.address, - tag: n.blockTag, - }), - ]; - case 5: - return [ - 2, - this.fetch("proxy", { - action: "eth_getCode", - address: n.address, - tag: n.blockTag, - }), - ]; - case 6: - return [ - 2, - this.fetch("proxy", { - action: "eth_getStorageAt", - address: n.address, - position: n.position, - tag: n.blockTag, - }), - ]; - case 7: - return [ - 2, - this.fetch( - "proxy", - { - action: "eth_sendRawTransaction", - hex: n.signedTransaction, - }, - !0 - ).catch(function (N) { - return xMe("sendTransaction", N, n.signedTransaction); - }), - ]; - case 8: - if (n.blockTag) - return [ - 2, - this.fetch("proxy", { - action: "eth_getBlockByNumber", - tag: n.blockTag, - boolean: n.includeTransactions ? "true" : "false", - }), - ]; - throw new Error("getBlock by blockHash not implemented"); - case 9: - return [ - 2, - this.fetch("proxy", { - action: "eth_getTransactionByHash", - txhash: n.transactionHash, - }), - ]; - case 10: - return [ - 2, - this.fetch("proxy", { - action: "eth_getTransactionReceipt", - txhash: n.transactionHash, - }), - ]; - case 11: - if (n.blockTag !== "latest") - throw new Error( - "EtherscanProvider does not support blockTag for call" - ); - (a = Yyt(n.transaction)), - (a.module = "proxy"), - (a.action = "eth_call"), - (F.label = 12); - case 12: - return ( - F.trys.push([12, 14, , 15]), [4, this.fetch("proxy", a, !0)] - ); - case 13: - return [2, F.sent()]; - case 14: - return (o = F.sent()), [2, xMe("call", o, n.transaction)]; - case 15: - (a = Yyt(n.transaction)), - (a.module = "proxy"), - (a.action = "eth_estimateGas"), - (F.label = 16); - case 16: - return ( - F.trys.push([16, 18, , 19]), [4, this.fetch("proxy", a, !0)] - ); - case 17: - return [2, F.sent()]; - case 18: - return ( - (s = F.sent()), [2, xMe("estimateGas", s, n.transaction)] - ); - case 19: - return ( - (c = { action: "getLogs" }), - n.filter.fromBlock && - (c.fromBlock = emt(n.filter.fromBlock)), - n.filter.toBlock && (c.toBlock = emt(n.filter.toBlock)), - n.filter.address && (c.address = n.filter.address), - n.filter.topics && - n.filter.topics.length > 0 && - (n.filter.topics.length > 1 && - pE.throwError( - "unsupported topic count", - Rb.Logger.errors.UNSUPPORTED_OPERATION, - { topics: n.filter.topics } - ), - n.filter.topics.length === 1 && - ((u = n.filter.topics[0]), - (typeof u != "string" || u.length !== 66) && - pE.throwError( - "unsupported topic format", - Rb.Logger.errors.UNSUPPORTED_OPERATION, - { topic0: u } - ), - (c.topic0 = u))), - [4, this.fetch("logs", c)] - ); - case 20: - (h = F.sent()), (w = {}), (M = 0), (F.label = 21); - case 21: - return M < h.length - ? ((k = h[M]), - k.blockHash != null - ? [3, 24] - : w[k.blockNumber] != null - ? [3, 23] - : [4, this.getBlock(k.blockNumber)]) - : [3, 25]; - case 22: - (O = F.sent()), - O && (w[k.blockNumber] = O.hash), - (F.label = 23); - case 23: - (k.blockHash = w[k.blockNumber]), (F.label = 24); - case 24: - return M++, [3, 21]; - case 25: - return [2, h]; - case 26: - return this.network.name !== "homestead" - ? [2, 0] - : ((D = parseFloat), - [4, this.fetch("stats", { action: "ethprice" })]); - case 27: - return [2, D.apply(void 0, [F.sent().ethusd])]; - case 28: - return [3, 29]; - case 29: - return [2, t.prototype.perform.call(this, r, n)]; - } - }); - }); - }), - (e.prototype.getHistory = function (r, n, i) { - return Cie(this, void 0, void 0, function () { - var o, - a, - s, - c = this; - return Rie(this, function (u) { - switch (u.label) { - case 0: - return (s = { action: "txlist" }), [4, this.resolveName(r)]; - case 1: - return ( - (o = - ((s.address = u.sent()), - (s.startblock = n ?? 0), - (s.endblock = i ?? 99999999), - (s.sort = "asc"), - s)), - [4, this.fetch("account", o)] - ); - case 2: - return ( - (a = u.sent()), - [ - 2, - a.map(function (h) { - ["contractAddress", "to"].forEach(function (M) { - h[M] == "" && delete h[M]; - }), - h.creates == null && - h.contractAddress != null && - (h.creates = h.contractAddress); - var w = c.formatter.transactionResponse(h); - return ( - h.timeStamp && (w.timestamp = parseInt(h.timeStamp)), - w - ); - }), - ] - ); - } - }); - }); - }), - (e.prototype.isCommunityResource = function () { - return this.apiKey == null; - }), - e - ); - })(d6r.BaseProvider); - Nb.EtherscanProvider = p6r; - }); - var amt = I((Fb) => { - "use strict"; - m(); - g(); - var y6r = - (Fb && Fb.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(), - Lie = - (Fb && Fb.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - oH = - (Fb && Fb.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(Fb, "__esModule", { value: !0 }); - Fb.FallbackProvider = void 0; - var m6r = vx(), - g6r = Ro(), - U7 = Ar(), - Db = $r(), - v6r = s6(), - b6r = R7(), - w6r = QK(), - rmt = lE(), - yE = rr(), - _6r = gc(), - w6 = new yE.Logger(_6r.version); - function Die() { - return new Date().getTime(); - } - function nmt(t) { - for (var e = null, r = 0; r < t.length; r++) { - var n = t[r]; - if (n == null) return null; - e - ? (e.name === n.name && - e.chainId === n.chainId && - (e.ensAddress === n.ensAddress || - (e.ensAddress == null && n.ensAddress == null))) || - w6.throwArgumentError("provider mismatch", "networks", t) - : (e = n); - } - return e; - } - function imt(t, e) { - t = t.slice().sort(); - var r = Math.floor(t.length / 2); - if (t.length % 2) return t[r]; - var n = t[r - 1], - i = t[r]; - return e != null && Math.abs(n - i) > e ? null : (n + i) / 2; - } - function K7(t) { - if (t === null) return "null"; - if (typeof t == "number" || typeof t == "boolean") - return JSON.stringify(t); - if (typeof t == "string") return t; - if (g6r.BigNumber.isBigNumber(t)) return t.toString(); - if (Array.isArray(t)) - return JSON.stringify( - t.map(function (r) { - return K7(r); - }) - ); - if (typeof t == "object") { - var e = Object.keys(t); - return ( - e.sort(), - "{" + - e - .map(function (r) { - var n = t[r]; - return ( - typeof n == "function" ? (n = "[function]") : (n = K7(n)), - JSON.stringify(r) + ":" + n - ); - }) - .join(",") + - "}" - ); - } - throw new Error("unknown value type: " + typeof t); - } - var x6r = 1; - function omt(t) { - var e = null, - r = null, - n = new Promise(function (a) { - (e = function () { - r && (clearTimeout(r), (r = null)), a(); - }), - (r = setTimeout(e, t)); - }), - i = function (a) { - return (n = n.then(a)), n; - }; - function o() { - return n; - } - return { cancel: e, getPromise: o, wait: i }; - } - var S6r = [ - yE.Logger.errors.CALL_EXCEPTION, - yE.Logger.errors.INSUFFICIENT_FUNDS, - yE.Logger.errors.NONCE_EXPIRED, - yE.Logger.errors.REPLACEMENT_UNDERPRICED, - yE.Logger.errors.UNPREDICTABLE_GAS_LIMIT, - ], - A6r = [ - "address", - "args", - "errorArgs", - "errorSignature", - "method", - "transaction", - ]; - function Fie(t, e) { - var r = { weight: t.weight }; - return ( - Object.defineProperty(r, "provider", { - get: function () { - return t.provider; - }, - }), - t.start && (r.start = t.start), - e && (r.duration = e - t.start), - t.done && - (t.error ? (r.error = t.error) : (r.result = t.result || null)), - r - ); - } - function E6r(t, e) { - return function (r) { - var n = {}; - r.forEach(function (s) { - var c = t(s.result); - n[c] || (n[c] = { count: 0, result: s.result }), n[c].count++; - }); - for (var i = Object.keys(n), o = 0; o < i.length; o++) { - var a = n[i[o]]; - if (a.count >= e) return a.result; - } - }; - } - function M6r(t, e, r) { - var n = K7; - switch (e) { - case "getBlockNumber": - return function (i) { - var o = i.map(function (s) { - return s.result; - }), - a = imt( - i.map(function (s) { - return s.result; - }), - 2 - ); - if (a != null) - return ( - (a = Math.ceil(a)), - o.indexOf(a + 1) >= 0 && a++, - a >= t._highestBlockNumber && (t._highestBlockNumber = a), - t._highestBlockNumber - ); - }; - case "getGasPrice": - return function (i) { - var o = i.map(function (a) { - return a.result; - }); - return o.sort(), o[Math.floor(o.length / 2)]; - }; - case "getEtherPrice": - return function (i) { - return imt( - i.map(function (o) { - return o.result; - }) - ); - }; - case "getBalance": - case "getTransactionCount": - case "getCode": - case "getStorageAt": - case "call": - case "estimateGas": - case "getLogs": - break; - case "getTransaction": - case "getTransactionReceipt": - n = function (i) { - return i == null - ? null - : ((i = (0, Db.shallowCopy)(i)), (i.confirmations = -1), K7(i)); - }; - break; - case "getBlock": - r.includeTransactions - ? (n = function (i) { - return i == null - ? null - : ((i = (0, Db.shallowCopy)(i)), - (i.transactions = i.transactions.map(function (o) { - return ( - (o = (0, Db.shallowCopy)(o)), (o.confirmations = -1), o - ); - })), - K7(i)); - }) - : (n = function (i) { - return i == null ? null : K7(i); - }); - break; - default: - throw new Error("unknown method: " + e); - } - return E6r(n, t.quorum); - } - function iH(t, e) { - return Lie(this, void 0, void 0, function () { - var r; - return oH(this, function (n) { - return ( - (r = t.provider), - (r.blockNumber != null && r.blockNumber >= e) || e === -1 - ? [2, r] - : [ - 2, - (0, b6r.poll)( - function () { - return new Promise(function (i, o) { - setTimeout(function () { - return r.blockNumber >= e - ? i(r) - : t.cancelled - ? i(null) - : i(void 0); - }, 0); - }); - }, - { oncePoll: r } - ), - ] - ); - }); - }); - } - function T6r(t, e, r, n) { - return Lie(this, void 0, void 0, function () { - var i, o, a; - return oH(this, function (s) { - switch (s.label) { - case 0: - switch (((i = t.provider), (o = r), o)) { - case "getBlockNumber": - return [3, 1]; - case "getGasPrice": - return [3, 1]; - case "getEtherPrice": - return [3, 2]; - case "getBalance": - return [3, 3]; - case "getTransactionCount": - return [3, 3]; - case "getCode": - return [3, 3]; - case "getStorageAt": - return [3, 6]; - case "getBlock": - return [3, 9]; - case "call": - return [3, 12]; - case "estimateGas": - return [3, 12]; - case "getTransaction": - return [3, 15]; - case "getTransactionReceipt": - return [3, 15]; - case "getLogs": - return [3, 16]; - } - return [3, 19]; - case 1: - return [2, i[r]()]; - case 2: - return i.getEtherPrice ? [2, i.getEtherPrice()] : [3, 19]; - case 3: - return n.blockTag && (0, U7.isHexString)(n.blockTag) - ? [4, iH(t, e)] - : [3, 5]; - case 4: - (i = s.sent()), (s.label = 5); - case 5: - return [2, i[r](n.address, n.blockTag || "latest")]; - case 6: - return n.blockTag && (0, U7.isHexString)(n.blockTag) - ? [4, iH(t, e)] - : [3, 8]; - case 7: - (i = s.sent()), (s.label = 8); - case 8: - return [ - 2, - i.getStorageAt(n.address, n.position, n.blockTag || "latest"), - ]; - case 9: - return n.blockTag && (0, U7.isHexString)(n.blockTag) - ? [4, iH(t, e)] - : [3, 11]; - case 10: - (i = s.sent()), (s.label = 11); - case 11: - return [ - 2, - i[ - n.includeTransactions - ? "getBlockWithTransactions" - : "getBlock" - ](n.blockTag || n.blockHash), - ]; - case 12: - return n.blockTag && (0, U7.isHexString)(n.blockTag) - ? [4, iH(t, e)] - : [3, 14]; - case 13: - (i = s.sent()), (s.label = 14); - case 14: - return r === "call" && n.blockTag - ? [2, i[r](n.transaction, n.blockTag)] - : [2, i[r](n.transaction)]; - case 15: - return [2, i[r](n.transactionHash)]; - case 16: - return ( - (a = n.filter), - (a.fromBlock && (0, U7.isHexString)(a.fromBlock)) || - (a.toBlock && (0, U7.isHexString)(a.toBlock)) - ? [4, iH(t, e)] - : [3, 18] - ); - case 17: - (i = s.sent()), (s.label = 18); - case 18: - return [2, i.getLogs(a)]; - case 19: - return [ - 2, - w6.throwError( - "unknown method error", - yE.Logger.errors.UNKNOWN_ERROR, - { method: r, params: n } - ), - ]; - } - }); - }); - } - var k6r = (function (t) { - y6r(e, t); - function e(r, n) { - var i = this; - r.length === 0 && - w6.throwArgumentError("missing providers", "providers", r); - var o = r.map(function (c, u) { - if (m6r.Provider.isProvider(c)) { - var h = (0, rmt.isCommunityResource)(c) ? 2e3 : 750, - w = 1; - return Object.freeze({ - provider: c, - weight: 1, - stallTimeout: h, - priority: w, - }); - } - var M = (0, Db.shallowCopy)(c); - M.priority == null && (M.priority = 1), - M.stallTimeout == null && - (M.stallTimeout = (0, rmt.isCommunityResource)(c) ? 2e3 : 750), - M.weight == null && (M.weight = 1); - var k = M.weight; - return ( - (k % 1 || k > 512 || k < 1) && - w6.throwArgumentError( - "invalid weight; must be integer in [1, 512]", - "providers[" + u + "].weight", - k - ), - Object.freeze(M) - ); - }), - a = o.reduce(function (c, u) { - return c + u.weight; - }, 0); - n == null - ? (n = a / 2) - : n > a && - w6.throwArgumentError( - "quorum will always fail; larger than total weight", - "quorum", - n - ); - var s = nmt( - o.map(function (c) { - return c.provider.network; - }) - ); - return ( - s == null && - (s = new Promise(function (c, u) { - setTimeout(function () { - i.detectNetwork().then(c, u); - }, 0); - })), - (i = t.call(this, s) || this), - (0, Db.defineReadOnly)(i, "providerConfigs", Object.freeze(o)), - (0, Db.defineReadOnly)(i, "quorum", n), - (i._highestBlockNumber = -1), - i - ); - } - return ( - (e.prototype.detectNetwork = function () { - return Lie(this, void 0, void 0, function () { - var r; - return oH(this, function (n) { - switch (n.label) { - case 0: - return [ - 4, - Promise.all( - this.providerConfigs.map(function (i) { - return i.provider.getNetwork(); - }) - ), - ]; - case 1: - return (r = n.sent()), [2, nmt(r)]; - } - }); - }); - }), - (e.prototype.perform = function (r, n) { - return Lie(this, void 0, void 0, function () { - var i, - o, - a, - s, - c, - u, - h, - w, - M, - k, - O, - D = this; - return oH(this, function (F) { - switch (F.label) { - case 0: - return r !== "sendTransaction" - ? [3, 2] - : [ - 4, - Promise.all( - this.providerConfigs.map(function (N) { - return N.provider - .sendTransaction(n.signedTransaction) - .then( - function (q) { - return q.hash; - }, - function (q) { - return q; - } - ); - }) - ), - ]; - case 1: - for (i = F.sent(), o = 0; o < i.length; o++) - if (((a = i[o]), typeof a == "string")) return [2, a]; - throw i[0]; - case 2: - return this._highestBlockNumber === -1 && - r !== "getBlockNumber" - ? [4, this.getBlockNumber()] - : [3, 4]; - case 3: - F.sent(), (F.label = 4); - case 4: - (s = M6r(this, r, n)), - (c = (0, v6r.shuffled)( - this.providerConfigs.map(Db.shallowCopy) - )), - c.sort(function (N, q) { - return N.priority - q.priority; - }), - (u = this._highestBlockNumber), - (h = 0), - (w = !0), - (M = function () { - var N, q, z, H, Z, $, ue; - return oH(this, function (te) { - switch (te.label) { - case 0: - for ( - N = Die(), - q = c - .filter(function (ne) { - return ( - ne.runner && - N - ne.start < ne.stallTimeout - ); - }) - .reduce(function (ne, A) { - return ne + A.weight; - }, 0), - z = function () { - var ne = c[h++], - A = x6r++; - (ne.start = Die()), - (ne.staller = omt(ne.stallTimeout)), - ne.staller.wait(function () { - ne.staller = null; - }), - (ne.runner = T6r(ne, u, r, n).then( - function (l) { - (ne.done = !0), - (ne.result = l), - D.listenerCount("debug") && - D.emit("debug", { - action: "request", - rid: A, - backend: Fie(ne, Die()), - request: { - method: r, - params: (0, Db.deepCopy)(n), - }, - provider: D, - }); - }, - function (l) { - (ne.done = !0), - (ne.error = l), - D.listenerCount("debug") && - D.emit("debug", { - action: "request", - rid: A, - backend: Fie(ne, Die()), - request: { - method: r, - params: (0, Db.deepCopy)(n), - }, - provider: D, - }); - } - )), - k.listenerCount("debug") && - k.emit("debug", { - action: "request", - rid: A, - backend: Fie(ne, null), - request: { - method: r, - params: (0, Db.deepCopy)(n), - }, - provider: k, - }), - (q += ne.weight); - }; - q < k.quorum && h < c.length; - - ) - z(); - return ( - (H = []), - c.forEach(function (ne) { - ne.done || - !ne.runner || - (H.push(ne.runner), - ne.staller && - H.push(ne.staller.getPromise())); - }), - H.length ? [4, Promise.race(H)] : [3, 2] - ); - case 1: - te.sent(), (te.label = 2); - case 2: - return ( - (Z = c.filter(function (ne) { - return ne.done && ne.error == null; - })), - Z.length >= k.quorum - ? (($ = s(Z)), - $ !== void 0 - ? (c.forEach(function (ne) { - ne.staller && ne.staller.cancel(), - (ne.cancelled = !0); - }), - [2, { value: $ }]) - : w - ? [3, 4] - : [4, omt(100).getPromise()]) - : [3, 5] - ); - case 3: - te.sent(), (te.label = 4); - case 4: - (w = !1), (te.label = 5); - case 5: - return ( - (ue = c.reduce(function (ne, A) { - if (!A.done || A.error == null) return ne; - var l = A.error.code; - return ( - S6r.indexOf(l) >= 0 && - (ne[l] || - (ne[l] = { error: A.error, weight: 0 }), - (ne[l].weight += A.weight)), - ne - ); - }, {})), - Object.keys(ue).forEach(function (ne) { - var A = ue[ne]; - if (!(A.weight < D.quorum)) { - c.forEach(function (y) { - y.staller && y.staller.cancel(), - (y.cancelled = !0); - }); - var l = A.error, - p = {}; - A6r.forEach(function (y) { - l[y] != null && (p[y] = l[y]); - }), - w6.throwError(l.reason || l.message, ne, p); - } - }), - c.filter(function (ne) { - return !ne.done; - }).length === 0 - ? [2, "break"] - : [2] - ); - } - }); - }), - (k = this), - (F.label = 5); - case 5: - return [5, M()]; - case 6: - return ( - (O = F.sent()), - typeof O == "object" - ? [2, O.value] - : O === "break" - ? [3, 7] - : [3, 5] - ); - case 7: - return ( - c.forEach(function (N) { - N.staller && N.staller.cancel(), (N.cancelled = !0); - }), - [ - 2, - w6.throwError( - "failed to meet quorum", - yE.Logger.errors.SERVER_ERROR, - { - method: r, - params: n, - results: c.map(function (N) { - return Fie(N); - }), - provider: this, - } - ), - ] - ); - } - }); - }); - }), - e - ); - })(w6r.BaseProvider); - Fb.FallbackProvider = k6r; - }); - var smt = I((qie) => { - "use strict"; - m(); - g(); - Object.defineProperty(qie, "__esModule", { value: !0 }); - qie.IpcProvider = void 0; - var P6r = null; - qie.IpcProvider = P6r; - }); - var fmt = I((mE) => { - "use strict"; - m(); - g(); - var umt = - (mE && mE.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(mE, "__esModule", { value: !0 }); - mE.InfuraProvider = mE.InfuraWebSocketProvider = void 0; - var SMe = $r(), - O6r = Pie(), - B6r = lE(), - AMe = rr(), - I6r = gc(), - zie = new AMe.Logger(I6r.version), - C6r = dE(), - aH = "84842078b09946638c03157f83405213", - cmt = (function (t) { - umt(e, t); - function e(r, n) { - var i = this, - o = new lmt(r, n), - a = o.connection; - a.password && - zie.throwError( - "INFURA WebSocket project secrets unsupported", - AMe.Logger.errors.UNSUPPORTED_OPERATION, - { operation: "InfuraProvider.getWebSocketProvider()" } - ); - var s = a.url.replace(/^http/i, "ws").replace("/v3/", "/ws/v3/"); - return ( - (i = t.call(this, s, r) || this), - (0, SMe.defineReadOnly)(i, "apiKey", o.projectId), - (0, SMe.defineReadOnly)(i, "projectId", o.projectId), - (0, SMe.defineReadOnly)(i, "projectSecret", o.projectSecret), - i - ); - } - return ( - (e.prototype.isCommunityResource = function () { - return this.projectId === aH; - }), - e - ); - })(O6r.WebSocketProvider); - mE.InfuraWebSocketProvider = cmt; - var lmt = (function (t) { - umt(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.getWebSocketProvider = function (r, n) { - return new cmt(r, n); - }), - (e.getApiKey = function (r) { - var n = { apiKey: aH, projectId: aH, projectSecret: null }; - return ( - r == null || - (typeof r == "string" - ? (n.projectId = r) - : r.projectSecret != null - ? (zie.assertArgument( - typeof r.projectId == "string", - "projectSecret requires a projectId", - "projectId", - r.projectId - ), - zie.assertArgument( - typeof r.projectSecret == "string", - "invalid projectSecret", - "projectSecret", - "[REDACTED]" - ), - (n.projectId = r.projectId), - (n.projectSecret = r.projectSecret)) - : r.projectId && (n.projectId = r.projectId), - (n.apiKey = n.projectId)), - n - ); - }), - (e.getUrl = function (r, n) { - var i = null; - switch (r ? r.name : "unknown") { - case "homestead": - i = "mainnet.infura.io"; - break; - case "goerli": - i = "goerli.infura.io"; - break; - case "sepolia": - i = "sepolia.infura.io"; - break; - case "matic": - i = "polygon-mainnet.infura.io"; - break; - case "maticmum": - i = "polygon-mumbai.infura.io"; - break; - case "optimism": - i = "optimism-mainnet.infura.io"; - break; - case "optimism-goerli": - i = "optimism-goerli.infura.io"; - break; - case "arbitrum": - i = "arbitrum-mainnet.infura.io"; - break; - case "arbitrum-goerli": - i = "arbitrum-goerli.infura.io"; - break; - default: - zie.throwError( - "unsupported network", - AMe.Logger.errors.INVALID_ARGUMENT, - { argument: "network", value: r } - ); - } - var o = { - allowGzip: !0, - url: "https://" + i + "/v3/" + n.projectId, - throttleCallback: function (a, s) { - return ( - n.projectId === aH && (0, B6r.showThrottleMessage)(), - Promise.resolve(!0) - ); - }, - }; - return ( - n.projectSecret != null && - ((o.user = ""), (o.password = n.projectSecret)), - o - ); - }), - (e.prototype.isCommunityResource = function () { - return this.projectId === aH; - }), - e - ); - })(C6r.UrlJsonRpcProvider); - mE.InfuraProvider = lmt; - }); - var dmt = I((H7) => { - "use strict"; - m(); - g(); - var R6r = - (H7 && H7.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(H7, "__esModule", { value: !0 }); - H7.JsonRpcBatchProvider = void 0; - var N6r = $r(), - D6r = R7(), - F6r = L7(), - L6r = (function (t) { - R6r(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.prototype.send = function (r, n) { - var i = this, - o = { method: r, params: n, id: this._nextId++, jsonrpc: "2.0" }; - this._pendingBatch == null && (this._pendingBatch = []); - var a = { request: o, resolve: null, reject: null }, - s = new Promise(function (c, u) { - (a.resolve = c), (a.reject = u); - }); - return ( - this._pendingBatch.push(a), - this._pendingBatchAggregator || - (this._pendingBatchAggregator = setTimeout(function () { - var c = i._pendingBatch; - (i._pendingBatch = null), (i._pendingBatchAggregator = null); - var u = c.map(function (h) { - return h.request; - }); - return ( - i.emit("debug", { - action: "requestBatch", - request: (0, N6r.deepCopy)(u), - provider: i, - }), - (0, D6r.fetchJson)(i.connection, JSON.stringify(u)).then( - function (h) { - i.emit("debug", { - action: "response", - request: u, - response: h, - provider: i, - }), - c.forEach(function (w, M) { - var k = h[M]; - if (k.error) { - var O = new Error(k.error.message); - (O.code = k.error.code), - (O.data = k.error.data), - w.reject(O); - } else w.resolve(k.result); - }); - }, - function (h) { - i.emit("debug", { - action: "response", - error: h, - request: u, - provider: i, - }), - c.forEach(function (w) { - w.reject(h); - }); - } - ) - ); - }, 10)), - s - ); - }), - e - ); - })(F6r.JsonRpcProvider); - H7.JsonRpcBatchProvider = L6r; - }); - var hmt = I((V7) => { - "use strict"; - m(); - g(); - var q6r = - (V7 && V7.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(V7, "__esModule", { value: !0 }); - V7.NodesmithProvider = void 0; - var z6r = dE(), - j6r = rr(), - U6r = gc(), - EMe = new j6r.Logger(U6r.version), - K6r = "ETHERS_JS_SHARED", - H6r = (function (t) { - q6r(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.getApiKey = function (r) { - return ( - r && - typeof r != "string" && - EMe.throwArgumentError("invalid apiKey", "apiKey", r), - r || K6r - ); - }), - (e.getUrl = function (r, n) { - EMe.warn( - "NodeSmith will be discontinued on 2019-12-20; please migrate to another platform." - ); - var i = null; - switch (r.name) { - case "homestead": - i = "https://ethereum.api.nodesmith.io/v1/mainnet/jsonrpc"; - break; - case "ropsten": - i = "https://ethereum.api.nodesmith.io/v1/ropsten/jsonrpc"; - break; - case "rinkeby": - i = "https://ethereum.api.nodesmith.io/v1/rinkeby/jsonrpc"; - break; - case "goerli": - i = "https://ethereum.api.nodesmith.io/v1/goerli/jsonrpc"; - break; - case "kovan": - i = "https://ethereum.api.nodesmith.io/v1/kovan/jsonrpc"; - break; - default: - EMe.throwArgumentError( - "unsupported network", - "network", - arguments[0] - ); - } - return i + "?apiKey=" + n; - }), - e - ); - })(z6r.UrlJsonRpcProvider); - V7.NodesmithProvider = H6r; - }); - var gmt = I((W7) => { - "use strict"; - m(); - g(); - var V6r = - (W7 && W7.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(W7, "__esModule", { value: !0 }); - W7.PocketProvider = void 0; - var mmt = rr(), - W6r = gc(), - pmt = new mmt.Logger(W6r.version), - G6r = dE(), - ymt = "62e1ad51b37b8e00394bda3b", - J6r = (function (t) { - V6r(e, t); - function e() { - return (t !== null && t.apply(this, arguments)) || this; - } - return ( - (e.getApiKey = function (r) { - var n = { - applicationId: null, - loadBalancer: !0, - applicationSecretKey: null, - }; - return ( - r == null - ? (n.applicationId = ymt) - : typeof r == "string" - ? (n.applicationId = r) - : r.applicationSecretKey != null - ? ((n.applicationId = r.applicationId), - (n.applicationSecretKey = r.applicationSecretKey)) - : r.applicationId - ? (n.applicationId = r.applicationId) - : pmt.throwArgumentError( - "unsupported PocketProvider apiKey", - "apiKey", - r - ), - n - ); - }), - (e.getUrl = function (r, n) { - var i = null; - switch (r ? r.name : "unknown") { - case "goerli": - i = "eth-goerli.gateway.pokt.network"; - break; - case "homestead": - i = "eth-mainnet.gateway.pokt.network"; - break; - case "kovan": - i = "poa-kovan.gateway.pokt.network"; - break; - case "matic": - i = "poly-mainnet.gateway.pokt.network"; - break; - case "maticmum": - i = "polygon-mumbai-rpc.gateway.pokt.network"; - break; - case "rinkeby": - i = "eth-rinkeby.gateway.pokt.network"; - break; - case "ropsten": - i = "eth-ropsten.gateway.pokt.network"; - break; - default: - pmt.throwError( - "unsupported network", - mmt.Logger.errors.INVALID_ARGUMENT, - { argument: "network", value: r } - ); - } - var o = "https://" + i + "/v1/lb/" + n.applicationId, - a = { headers: {}, url: o }; - return ( - n.applicationSecretKey != null && - ((a.user = ""), (a.password = n.applicationSecretKey)), - a - ); - }), - (e.prototype.isCommunityResource = function () { - return this.applicationId === ymt; - }), - e - ); - })(G6r.UrlJsonRpcProvider); - W7.PocketProvider = J6r; - }); - var wmt = I((G7) => { - "use strict"; - m(); - g(); - var $6r = - (G7 && G7.__extends) || - (function () { - var t = function (e, r) { - return ( - (t = - Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && - function (n, i) { - n.__proto__ = i; - }) || - function (n, i) { - for (var o in i) - Object.prototype.hasOwnProperty.call(i, o) && (n[o] = i[o]); - }), - t(e, r) - ); - }; - return function (e, r) { - if (typeof r != "function" && r !== null) - throw new TypeError( - "Class extends value " + - String(r) + - " is not a constructor or null" - ); - t(e, r); - function n() { - this.constructor = e; - } - e.prototype = - r === null - ? Object.create(r) - : ((n.prototype = r.prototype), new n()); - }; - })(); - Object.defineProperty(G7, "__esModule", { value: !0 }); - G7.Web3Provider = void 0; - var jie = $r(), - Z6r = rr(), - X6r = gc(), - vmt = new Z6r.Logger(X6r.version), - Y6r = L7(), - Q6r = 1; - function bmt(t, e) { - var r = "Web3LegacyFetcher"; - return function (n, i) { - var o = this, - a = { method: n, params: i, id: Q6r++, jsonrpc: "2.0" }; - return new Promise(function (s, c) { - o.emit("debug", { - action: "request", - fetcher: r, - request: (0, jie.deepCopy)(a), - provider: o, - }), - e(a, function (u, h) { - if (u) - return ( - o.emit("debug", { - action: "response", - fetcher: r, - error: u, - request: a, - provider: o, - }), - c(u) - ); - if ( - (o.emit("debug", { - action: "response", - fetcher: r, - request: a, - response: h, - provider: o, - }), - h.error) - ) { - var w = new Error(h.error.message); - return (w.code = h.error.code), (w.data = h.error.data), c(w); - } - s(h.result); - }); - }); - }; - } - function e8r(t) { - return function (e, r) { - var n = this; - r == null && (r = []); - var i = { method: e, params: r }; - return ( - this.emit("debug", { - action: "request", - fetcher: "Eip1193Fetcher", - request: (0, jie.deepCopy)(i), - provider: this, - }), - t.request(i).then( - function (o) { - return ( - n.emit("debug", { - action: "response", - fetcher: "Eip1193Fetcher", - request: i, - response: o, - provider: n, - }), - o - ); - }, - function (o) { - throw ( - (n.emit("debug", { - action: "response", - fetcher: "Eip1193Fetcher", - request: i, - error: o, - provider: n, - }), - o) - ); - } - ) - ); - }; - } - var t8r = (function (t) { - $6r(e, t); - function e(r, n) { - var i = this; - r == null && vmt.throwArgumentError("missing provider", "provider", r); - var o = null, - a = null, - s = null; - return ( - typeof r == "function" - ? ((o = "unknown:"), (a = r)) - : ((o = r.host || r.path || ""), - !o && r.isMetaMask && (o = "metamask"), - (s = r), - r.request - ? (o === "" && (o = "eip-1193:"), (a = e8r(r))) - : r.sendAsync - ? (a = bmt(r, r.sendAsync.bind(r))) - : r.send - ? (a = bmt(r, r.send.bind(r))) - : vmt.throwArgumentError("unsupported provider", "provider", r), - o || (o = "unknown:")), - (i = t.call(this, o, n) || this), - (0, jie.defineReadOnly)(i, "jsonRpcFetchFunc", a), - (0, jie.defineReadOnly)(i, "provider", s), - i - ); - } - return ( - (e.prototype.send = function (r, n) { - return this.jsonRpcFetchFunc(r, n); - }), - e - ); - })(Y6r.JsonRpcProvider); - G7.Web3Provider = t8r; - }); - var kMe = I((vr) => { - "use strict"; - m(); - g(); - Object.defineProperty(vr, "__esModule", { value: !0 }); - vr.Formatter = - vr.showThrottleMessage = - vr.isCommunityResourcable = - vr.isCommunityResource = - vr.getNetwork = - vr.getDefaultProvider = - vr.JsonRpcSigner = - vr.IpcProvider = - vr.WebSocketProvider = - vr.Web3Provider = - vr.StaticJsonRpcProvider = - vr.PocketProvider = - vr.NodesmithProvider = - vr.JsonRpcBatchProvider = - vr.JsonRpcProvider = - vr.InfuraWebSocketProvider = - vr.InfuraProvider = - vr.EtherscanProvider = - vr.CloudflareProvider = - vr.AnkrProvider = - vr.AlchemyWebSocketProvider = - vr.AlchemyProvider = - vr.FallbackProvider = - vr.UrlJsonRpcProvider = - vr.Resolver = - vr.BaseProvider = - vr.Provider = - void 0; - var r8r = vx(); - Object.defineProperty(vr, "Provider", { - enumerable: !0, - get: function () { - return r8r.Provider; - }, - }); - var xmt = sMe(); - Object.defineProperty(vr, "getNetwork", { - enumerable: !0, - get: function () { - return xmt.getNetwork; - }, - }); - var Smt = QK(); - Object.defineProperty(vr, "BaseProvider", { - enumerable: !0, - get: function () { - return Smt.BaseProvider; - }, - }); - Object.defineProperty(vr, "Resolver", { - enumerable: !0, - get: function () { - return Smt.Resolver; - }, - }); - var MMe = Jyt(); - Object.defineProperty(vr, "AlchemyProvider", { - enumerable: !0, - get: function () { - return MMe.AlchemyProvider; - }, - }); - Object.defineProperty(vr, "AlchemyWebSocketProvider", { - enumerable: !0, - get: function () { - return MMe.AlchemyWebSocketProvider; - }, - }); - var Amt = $yt(); - Object.defineProperty(vr, "AnkrProvider", { - enumerable: !0, - get: function () { - return Amt.AnkrProvider; - }, - }); - var Emt = Xyt(); - Object.defineProperty(vr, "CloudflareProvider", { - enumerable: !0, - get: function () { - return Emt.CloudflareProvider; - }, - }); - var Mmt = tmt(); - Object.defineProperty(vr, "EtherscanProvider", { - enumerable: !0, - get: function () { - return Mmt.EtherscanProvider; - }, - }); - var Tmt = amt(); - Object.defineProperty(vr, "FallbackProvider", { - enumerable: !0, - get: function () { - return Tmt.FallbackProvider; - }, - }); - var kmt = smt(); - Object.defineProperty(vr, "IpcProvider", { - enumerable: !0, - get: function () { - return kmt.IpcProvider; - }, - }); - var TMe = fmt(); - Object.defineProperty(vr, "InfuraProvider", { - enumerable: !0, - get: function () { - return TMe.InfuraProvider; - }, - }); - Object.defineProperty(vr, "InfuraWebSocketProvider", { - enumerable: !0, - get: function () { - return TMe.InfuraWebSocketProvider; - }, - }); - var Uie = L7(); - Object.defineProperty(vr, "JsonRpcProvider", { - enumerable: !0, - get: function () { - return Uie.JsonRpcProvider; - }, - }); - Object.defineProperty(vr, "JsonRpcSigner", { - enumerable: !0, - get: function () { - return Uie.JsonRpcSigner; - }, - }); - var n8r = dmt(); - Object.defineProperty(vr, "JsonRpcBatchProvider", { - enumerable: !0, - get: function () { - return n8r.JsonRpcBatchProvider; - }, - }); - var Pmt = hmt(); - Object.defineProperty(vr, "NodesmithProvider", { - enumerable: !0, - get: function () { - return Pmt.NodesmithProvider; - }, - }); - var Omt = gmt(); - Object.defineProperty(vr, "PocketProvider", { - enumerable: !0, - get: function () { - return Omt.PocketProvider; - }, - }); - var Bmt = dE(); - Object.defineProperty(vr, "StaticJsonRpcProvider", { - enumerable: !0, - get: function () { - return Bmt.StaticJsonRpcProvider; - }, - }); - Object.defineProperty(vr, "UrlJsonRpcProvider", { - enumerable: !0, - get: function () { - return Bmt.UrlJsonRpcProvider; - }, - }); - var Imt = wmt(); - Object.defineProperty(vr, "Web3Provider", { - enumerable: !0, - get: function () { - return Imt.Web3Provider; - }, - }); - var Cmt = Pie(); - Object.defineProperty(vr, "WebSocketProvider", { - enumerable: !0, - get: function () { - return Cmt.WebSocketProvider; - }, - }); - var Kie = lE(); - Object.defineProperty(vr, "Formatter", { - enumerable: !0, - get: function () { - return Kie.Formatter; - }, - }); - Object.defineProperty(vr, "isCommunityResourcable", { - enumerable: !0, - get: function () { - return Kie.isCommunityResourcable; - }, - }); - Object.defineProperty(vr, "isCommunityResource", { - enumerable: !0, - get: function () { - return Kie.isCommunityResource; - }, - }); - Object.defineProperty(vr, "showThrottleMessage", { - enumerable: !0, - get: function () { - return Kie.showThrottleMessage; - }, - }); - var Rmt = rr(), - i8r = gc(), - _mt = new Rmt.Logger(i8r.version); - function o8r(t, e) { - if ((t == null && (t = "homestead"), typeof t == "string")) { - var r = t.match(/^(ws|http)s?:/i); - if (r) - switch (r[1].toLowerCase()) { - case "http": - case "https": - return new Uie.JsonRpcProvider(t); - case "ws": - case "wss": - return new Cmt.WebSocketProvider(t); - default: - _mt.throwArgumentError("unsupported URL scheme", "network", t); - } - } - var n = (0, xmt.getNetwork)(t); - return ( - (!n || !n._defaultProvider) && - _mt.throwError( - "unsupported getDefaultProvider network", - Rmt.Logger.errors.NETWORK_ERROR, - { operation: "getDefaultProvider", network: t } - ), - n._defaultProvider( - { - FallbackProvider: Tmt.FallbackProvider, - AlchemyProvider: MMe.AlchemyProvider, - AnkrProvider: Amt.AnkrProvider, - CloudflareProvider: Emt.CloudflareProvider, - EtherscanProvider: Mmt.EtherscanProvider, - InfuraProvider: TMe.InfuraProvider, - JsonRpcProvider: Uie.JsonRpcProvider, - NodesmithProvider: Pmt.NodesmithProvider, - PocketProvider: Omt.PocketProvider, - Web3Provider: Imt.Web3Provider, - IpcProvider: kmt.IpcProvider, - }, - e - ) - ); - } - vr.getDefaultProvider = o8r; - }); - var Nmt = I((Hie) => { - "use strict"; - m(); - g(); - Object.defineProperty(Hie, "__esModule", { value: !0 }); - Hie.version = void 0; - Hie.version = "web/5.7.1"; - }); - var Dmt = I((gE) => { - "use strict"; - m(); - g(); - var a8r = - (gE && gE.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - s8r = - (gE && gE.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(gE, "__esModule", { value: !0 }); - gE.getUrl = void 0; - var u8r = Ar(); - function c8r(t, e) { - return a8r(this, void 0, void 0, function () { - var r, n, i, o, a; - return s8r(this, function (s) { - switch (s.label) { - case 0: - return ( - e == null && (e = {}), - (r = { - method: e.method || "GET", - headers: e.headers || {}, - body: e.body || void 0, - }), - e.skipFetchSetup !== !0 && - ((r.mode = "cors"), - (r.cache = "no-cache"), - (r.credentials = "same-origin"), - (r.redirect = "follow"), - (r.referrer = "client")), - e.fetchOptions != null && - ((n = e.fetchOptions), - n.mode && (r.mode = n.mode), - n.cache && (r.cache = n.cache), - n.credentials && (r.credentials = n.credentials), - n.redirect && (r.redirect = n.redirect), - n.referrer && (r.referrer = n.referrer)), - [4, fetch(t, r)] - ); - case 1: - return (i = s.sent()), [4, i.arrayBuffer()]; - case 2: - return ( - (o = s.sent()), - (a = {}), - i.headers.forEach - ? i.headers.forEach(function (c, u) { - a[u.toLowerCase()] = c; - }) - : i.headers.keys().forEach(function (c) { - a[c.toLowerCase()] = i.headers.get(c); - }), - [ - 2, - { - headers: a, - statusCode: i.status, - statusMessage: i.statusText, - body: (0, u8r.arrayify)(new Uint8Array(o)), - }, - ] - ); - } - }); - }); - } - gE.getUrl = c8r; - }); - var jmt = I((Yy) => { - "use strict"; - m(); - g(); - var l8r = - (Yy && Yy.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }, - f8r = - (Yy && Yy.__generator) || - function (t, e) { - var r = { - label: 0, - sent: function () { - if (o[0] & 1) throw o[1]; - return o[1]; - }, - trys: [], - ops: [], - }, - n, - i, - o, - a; - return ( - (a = { next: s(0), throw: s(1), return: s(2) }), - typeof Symbol == "function" && - (a[Symbol.iterator] = function () { - return this; - }), - a - ); - function s(u) { - return function (h) { - return c([u, h]); - }; - } - function c(u) { - if (n) throw new TypeError("Generator is already executing."); - for (; r; ) - try { - if ( - ((n = 1), - i && - (o = - u[0] & 2 - ? i.return - : u[0] - ? i.throw || ((o = i.return) && o.call(i), 0) - : i.next) && - !(o = o.call(i, u[1])).done) - ) - return o; - switch (((i = 0), o && (u = [u[0] & 2, o.value]), u[0])) { - case 0: - case 1: - o = u; - break; - case 4: - return r.label++, { value: u[1], done: !1 }; - case 5: - r.label++, (i = u[1]), (u = [0]); - continue; - case 7: - (u = r.ops.pop()), r.trys.pop(); - continue; - default: - if ( - ((o = r.trys), - !(o = o.length > 0 && o[o.length - 1]) && - (u[0] === 6 || u[0] === 2)) - ) { - r = 0; - continue; - } - if (u[0] === 3 && (!o || (u[1] > o[0] && u[1] < o[3]))) { - r.label = u[1]; - break; - } - if (u[0] === 6 && r.label < o[1]) { - (r.label = o[1]), (o = u); - break; - } - if (o && r.label < o[2]) { - (r.label = o[2]), r.ops.push(u); - break; - } - o[2] && r.ops.pop(), r.trys.pop(); - continue; - } - u = e.call(t, r); - } catch (h) { - (u = [6, h]), (i = 0); - } finally { - n = o = 0; - } - if (u[0] & 5) throw u[1]; - return { value: u[0] ? u[1] : void 0, done: !0 }; - } - }; - Object.defineProperty(Yy, "__esModule", { value: !0 }); - Yy.poll = Yy.fetchJson = Yy._fetchData = void 0; - var Fmt = lb(), - Lmt = Ar(), - Vie = $r(), - sH = Eo(), - Ox = rr(), - d8r = Nmt(), - xg = new Ox.Logger(d8r.version), - h8r = Dmt(); - function qmt(t) { - return new Promise(function (e) { - setTimeout(e, t); - }); - } - function vE(t, e) { - if (t == null) return null; - if (typeof t == "string") return t; - if ((0, Lmt.isBytesLike)(t)) { - if ( - e && - (e.split("/")[0] === "text" || - e.split(";")[0].trim() === "application/json") - ) - try { - return (0, sH.toUtf8String)(t); - } catch {} - return (0, Lmt.hexlify)(t); - } - return t; - } - function p8r(t) { - return (0, sH.toUtf8Bytes)( - t.replace(/%([0-9a-f][0-9a-f])/gi, function (e, r) { - return String.fromCharCode(parseInt(r, 16)); - }) - ); - } - function zmt(t, e, r) { - var n = - typeof t == "object" && t.throttleLimit != null ? t.throttleLimit : 12; - xg.assertArgument( - n > 0 && n % 1 === 0, - "invalid connection throttle limit", - "connection.throttleLimit", - n - ); - var i = typeof t == "object" ? t.throttleCallback : null, - o = - typeof t == "object" && typeof t.throttleSlotInterval == "number" - ? t.throttleSlotInterval - : 100; - xg.assertArgument( - o > 0 && o % 1 === 0, - "invalid connection throttle slot interval", - "connection.throttleSlotInterval", - o - ); - var a = typeof t == "object" ? !!t.errorPassThrough : !1, - s = {}, - c = null, - u = { method: "GET" }, - h = !1, - w = 2 * 60 * 1e3; - if (typeof t == "string") c = t; - else if (typeof t == "object") { - if ( - ((t == null || t.url == null) && - xg.throwArgumentError("missing URL", "connection.url", t), - (c = t.url), - typeof t.timeout == "number" && t.timeout > 0 && (w = t.timeout), - t.headers) - ) - for (var M in t.headers) - (s[M.toLowerCase()] = { key: M, value: String(t.headers[M]) }), - ["if-none-match", "if-modified-since"].indexOf(M.toLowerCase()) >= - 0 && (h = !0); - if ( - ((u.allowGzip = !!t.allowGzip), t.user != null && t.password != null) - ) { - c.substring(0, 6) !== "https:" && - t.allowInsecureAuthentication !== !0 && - xg.throwError( - "basic authentication requires a secure https url", - Ox.Logger.errors.INVALID_ARGUMENT, - { argument: "url", url: c, user: t.user, password: "[REDACTED]" } - ); - var k = t.user + ":" + t.password; - s.authorization = { - key: "Authorization", - value: "Basic " + (0, Fmt.encode)((0, sH.toUtf8Bytes)(k)), - }; - } - t.skipFetchSetup != null && (u.skipFetchSetup = !!t.skipFetchSetup), - t.fetchOptions != null && - (u.fetchOptions = (0, Vie.shallowCopy)(t.fetchOptions)); - } - var O = new RegExp("^data:([^;:]*)?(;base64)?,(.*)$", "i"), - D = c ? c.match(O) : null; - if (D) - try { - var F = { - statusCode: 200, - statusMessage: "OK", - headers: { "content-type": D[1] || "text/plain" }, - body: D[2] ? (0, Fmt.decode)(D[3]) : p8r(D[3]), - }, - N = F.body; - return r && (N = r(F.body, F)), Promise.resolve(N); - } catch (Z) { - xg.throwError( - "processing response error", - Ox.Logger.errors.SERVER_ERROR, - { - body: vE(D[1], D[2]), - error: Z, - requestBody: null, - requestMethod: "GET", - url: c, - } - ); - } - e && - ((u.method = "POST"), - (u.body = e), - s["content-type"] == null && - (s["content-type"] = { - key: "Content-Type", - value: "application/octet-stream", - }), - s["content-length"] == null && - (s["content-length"] = { - key: "Content-Length", - value: String(e.length), - })); - var q = {}; - Object.keys(s).forEach(function (Z) { - var $ = s[Z]; - q[$.key] = $.value; - }), - (u.headers = q); - var z = (function () { - var Z = null, - $ = new Promise(function (te, ne) { - w && - (Z = setTimeout(function () { - Z != null && - ((Z = null), - ne( - xg.makeError("timeout", Ox.Logger.errors.TIMEOUT, { - requestBody: vE(u.body, q["content-type"]), - requestMethod: u.method, - timeout: w, - url: c, - }) - )); - }, w)); - }), - ue = function () { - Z != null && (clearTimeout(Z), (Z = null)); - }; - return { promise: $, cancel: ue }; - })(), - H = (function () { - return l8r(this, void 0, void 0, function () { - var Z, $, ue, d, te, ne, A, l, p, y, d, v; - return f8r(this, function (_) { - switch (_.label) { - case 0: - (Z = 0), (_.label = 1); - case 1: - if (!(Z < n)) return [3, 20]; - ($ = null), (_.label = 2); - case 2: - return _.trys.push([2, 9, , 10]), [4, (0, h8r.getUrl)(c, u)]; - case 3: - return ( - ($ = _.sent()), - Z < n - ? $.statusCode === 301 || $.statusCode === 302 - ? ((ue = $.headers.location || ""), - u.method === "GET" && ue.match(/^https:/) - ? ((c = $.headers.location), [3, 19]) - : [3, 8]) - : [3, 4] - : [3, 8] - ); - case 4: - return $.statusCode !== 429 - ? [3, 8] - : ((d = !0), i ? [4, i(Z, c)] : [3, 6]); - case 5: - (d = _.sent()), (_.label = 6); - case 6: - return d - ? ((te = 0), - (ne = $.headers["retry-after"]), - typeof ne == "string" && ne.match(/^[1-9][0-9]*$/) - ? (te = parseInt(ne) * 1e3) - : (te = - o * - parseInt(String(Math.random() * Math.pow(2, Z)))), - [4, qmt(te)]) - : [3, 8]; - case 7: - return _.sent(), [3, 19]; - case 8: - return [3, 10]; - case 9: - return ( - (A = _.sent()), - ($ = A.response), - $ == null && - (z.cancel(), - xg.throwError( - "missing response", - Ox.Logger.errors.SERVER_ERROR, - { - requestBody: vE(u.body, q["content-type"]), - requestMethod: u.method, - serverError: A, - url: c, - } - )), - [3, 10] - ); - case 10: - if ( - ((l = $.body), - h && $.statusCode === 304 - ? (l = null) - : !a && - ($.statusCode < 200 || $.statusCode >= 300) && - (z.cancel(), - xg.throwError( - "bad response", - Ox.Logger.errors.SERVER_ERROR, - { - status: $.statusCode, - headers: $.headers, - body: vE( - l, - $.headers ? $.headers["content-type"] : null - ), - requestBody: vE(u.body, q["content-type"]), - requestMethod: u.method, - url: c, - } - )), - !r) - ) - return [3, 18]; - _.label = 11; - case 11: - return _.trys.push([11, 13, , 18]), [4, r(l, $)]; - case 12: - return (p = _.sent()), z.cancel(), [2, p]; - case 13: - return ( - (y = _.sent()), - y.throttleRetry && Z < n - ? ((d = !0), i ? [4, i(Z, c)] : [3, 15]) - : [3, 17] - ); - case 14: - (d = _.sent()), (_.label = 15); - case 15: - return d - ? ((v = - o * parseInt(String(Math.random() * Math.pow(2, Z)))), - [4, qmt(v)]) - : [3, 17]; - case 16: - return _.sent(), [3, 19]; - case 17: - return ( - z.cancel(), - xg.throwError( - "processing response error", - Ox.Logger.errors.SERVER_ERROR, - { - body: vE( - l, - $.headers ? $.headers["content-type"] : null - ), - error: y, - requestBody: vE(u.body, q["content-type"]), - requestMethod: u.method, - url: c, - } - ), - [3, 18] - ); - case 18: - return z.cancel(), [2, l]; - case 19: - return Z++, [3, 1]; - case 20: - return [ - 2, - xg.throwError( - "failed response", - Ox.Logger.errors.SERVER_ERROR, - { - requestBody: vE(u.body, q["content-type"]), - requestMethod: u.method, - url: c, - } - ), - ]; - } - }); - }); - })(); - return Promise.race([z.promise, H]); - } - Yy._fetchData = zmt; - function y8r(t, e, r) { - var n = function (s, c) { - var u = null; - if (s != null) - try { - u = JSON.parse((0, sH.toUtf8String)(s)); - } catch (h) { - xg.throwError("invalid JSON", Ox.Logger.errors.SERVER_ERROR, { - body: s, - error: h, - }); - } - return r && (u = r(u, c)), u; - }, - i = null; - if (e != null) { - i = (0, sH.toUtf8Bytes)(e); - var o = typeof t == "string" ? { url: t } : (0, Vie.shallowCopy)(t); - if (o.headers) { - var a = - Object.keys(o.headers).filter(function (s) { - return s.toLowerCase() === "content-type"; - }).length !== 0; - a || - ((o.headers = (0, Vie.shallowCopy)(o.headers)), - (o.headers["content-type"] = "application/json")); - } else o.headers = { "content-type": "application/json" }; - t = o; - } - return zmt(t, i, n); - } - Yy.fetchJson = y8r; - function m8r(t, e) { - return ( - e || (e = {}), - (e = (0, Vie.shallowCopy)(e)), - e.floor == null && (e.floor = 0), - e.ceiling == null && (e.ceiling = 1e4), - e.interval == null && (e.interval = 250), - new Promise(function (r, n) { - var i = null, - o = !1, - a = function () { - return o ? !1 : ((o = !0), i && clearTimeout(i), !0); - }; - e.timeout && - (i = setTimeout(function () { - a() && n(new Error("timeout")); - }, e.timeout)); - var s = e.retryLimit, - c = 0; - function u() { - return t().then( - function (h) { - if (h !== void 0) a() && r(h); - else if (e.oncePoll) e.oncePoll.once("poll", u); - else if (e.onceBlock) e.onceBlock.once("block", u); - else if (!o) { - if ((c++, c > s)) { - a() && n(new Error("retry limit reached")); - return; - } - var w = - e.interval * - parseInt(String(Math.random() * Math.pow(2, c))); - w < e.floor && (w = e.floor), - w > e.ceiling && (w = e.ceiling), - setTimeout(u, w); - } - return null; - }, - function (h) { - a() && n(h); - } - ); - } - u(); - }) - ); - } - Yy.poll = m8r; - }); - var Wmt = I((Je) => { - "use strict"; - m(); - g(); - var g8r = - (Je && Je.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - v8r = - (Je && Je.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Umt = - (Je && Je.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - g8r(e, t, r); - return v8r(e, t), e; - }; - Object.defineProperty(Je, "__esModule", { value: !0 }); - Je.formatBytes32String = - Je.Utf8ErrorFuncs = - Je.toUtf8String = - Je.toUtf8CodePoints = - Je.toUtf8Bytes = - Je._toEscapedUtf8String = - Je.nameprep = - Je.hexDataSlice = - Je.hexDataLength = - Je.hexZeroPad = - Je.hexValue = - Je.hexStripZeros = - Je.hexConcat = - Je.isHexString = - Je.hexlify = - Je.base64 = - Je.base58 = - Je.TransactionDescription = - Je.LogDescription = - Je.Interface = - Je.SigningKey = - Je.HDNode = - Je.defaultPath = - Je.isBytesLike = - Je.isBytes = - Je.zeroPad = - Je.stripZeros = - Je.concat = - Je.arrayify = - Je.shallowCopy = - Je.resolveProperties = - Je.getStatic = - Je.defineReadOnly = - Je.deepCopy = - Je.checkProperties = - Je.poll = - Je.fetchJson = - Je._fetchData = - Je.RLP = - Je.Logger = - Je.checkResultErrors = - Je.FormatTypes = - Je.ParamType = - Je.FunctionFragment = - Je.EventFragment = - Je.ErrorFragment = - Je.ConstructorFragment = - Je.Fragment = - Je.defaultAbiCoder = - Je.AbiCoder = - void 0; - Je.Indexed = - Je.Utf8ErrorReason = - Je.UnicodeNormalizationForm = - Je.SupportedAlgorithm = - Je.mnemonicToSeed = - Je.isValidMnemonic = - Je.entropyToMnemonic = - Je.mnemonicToEntropy = - Je.getAccountPath = - Je.verifyTypedData = - Je.verifyMessage = - Je.recoverPublicKey = - Je.computePublicKey = - Je.recoverAddress = - Je.computeAddress = - Je.getJsonWalletAddress = - Je.TransactionTypes = - Je.serializeTransaction = - Je.parseTransaction = - Je.accessListify = - Je.joinSignature = - Je.splitSignature = - Je.soliditySha256 = - Je.solidityKeccak256 = - Je.solidityPack = - Je.shuffled = - Je.randomBytes = - Je.sha512 = - Je.sha256 = - Je.ripemd160 = - Je.keccak256 = - Je.computeHmac = - Je.commify = - Je.parseUnits = - Je.formatUnits = - Je.parseEther = - Je.formatEther = - Je.isAddress = - Je.getCreate2Address = - Je.getContractAddress = - Je.getIcapAddress = - Je.getAddress = - Je._TypedDataEncoder = - Je.id = - Je.isValidName = - Je.namehash = - Je.hashMessage = - Je.dnsEncode = - Je.parseBytes32String = - void 0; - var Zh = Ire(); - Object.defineProperty(Je, "AbiCoder", { - enumerable: !0, - get: function () { - return Zh.AbiCoder; - }, - }); - Object.defineProperty(Je, "checkResultErrors", { - enumerable: !0, - get: function () { - return Zh.checkResultErrors; - }, - }); - Object.defineProperty(Je, "ConstructorFragment", { - enumerable: !0, - get: function () { - return Zh.ConstructorFragment; - }, - }); - Object.defineProperty(Je, "defaultAbiCoder", { - enumerable: !0, - get: function () { - return Zh.defaultAbiCoder; - }, - }); - Object.defineProperty(Je, "ErrorFragment", { - enumerable: !0, - get: function () { - return Zh.ErrorFragment; - }, - }); - Object.defineProperty(Je, "EventFragment", { - enumerable: !0, - get: function () { - return Zh.EventFragment; - }, - }); - Object.defineProperty(Je, "FormatTypes", { - enumerable: !0, - get: function () { - return Zh.FormatTypes; - }, - }); - Object.defineProperty(Je, "Fragment", { - enumerable: !0, - get: function () { - return Zh.Fragment; - }, - }); - Object.defineProperty(Je, "FunctionFragment", { - enumerable: !0, - get: function () { - return Zh.FunctionFragment; - }, - }); - Object.defineProperty(Je, "Indexed", { - enumerable: !0, - get: function () { - return Zh.Indexed; - }, - }); - Object.defineProperty(Je, "Interface", { - enumerable: !0, - get: function () { - return Zh.Interface; - }, - }); - Object.defineProperty(Je, "LogDescription", { - enumerable: !0, - get: function () { - return Zh.LogDescription; - }, - }); - Object.defineProperty(Je, "ParamType", { - enumerable: !0, - get: function () { - return Zh.ParamType; - }, - }); - Object.defineProperty(Je, "TransactionDescription", { - enumerable: !0, - get: function () { - return Zh.TransactionDescription; - }, - }); - var uH = Vh(); - Object.defineProperty(Je, "getAddress", { - enumerable: !0, - get: function () { - return uH.getAddress; - }, - }); - Object.defineProperty(Je, "getCreate2Address", { - enumerable: !0, - get: function () { - return uH.getCreate2Address; - }, - }); - Object.defineProperty(Je, "getContractAddress", { - enumerable: !0, - get: function () { - return uH.getContractAddress; - }, - }); - Object.defineProperty(Je, "getIcapAddress", { - enumerable: !0, - get: function () { - return uH.getIcapAddress; - }, - }); - Object.defineProperty(Je, "isAddress", { - enumerable: !0, - get: function () { - return uH.isAddress; - }, - }); - var b8r = Umt(lb()); - Je.base64 = b8r; - var w8r = jR(); - Object.defineProperty(Je, "base58", { - enumerable: !0, - get: function () { - return w8r.Base58; - }, - }); - var fl = Ar(); - Object.defineProperty(Je, "arrayify", { - enumerable: !0, - get: function () { - return fl.arrayify; - }, - }); - Object.defineProperty(Je, "concat", { - enumerable: !0, - get: function () { - return fl.concat; - }, - }); - Object.defineProperty(Je, "hexConcat", { - enumerable: !0, - get: function () { - return fl.hexConcat; - }, - }); - Object.defineProperty(Je, "hexDataSlice", { - enumerable: !0, - get: function () { - return fl.hexDataSlice; - }, - }); - Object.defineProperty(Je, "hexDataLength", { - enumerable: !0, - get: function () { - return fl.hexDataLength; - }, - }); - Object.defineProperty(Je, "hexlify", { - enumerable: !0, - get: function () { - return fl.hexlify; - }, - }); - Object.defineProperty(Je, "hexStripZeros", { - enumerable: !0, - get: function () { - return fl.hexStripZeros; - }, - }); - Object.defineProperty(Je, "hexValue", { - enumerable: !0, - get: function () { - return fl.hexValue; - }, - }); - Object.defineProperty(Je, "hexZeroPad", { - enumerable: !0, - get: function () { - return fl.hexZeroPad; - }, - }); - Object.defineProperty(Je, "isBytes", { - enumerable: !0, - get: function () { - return fl.isBytes; - }, - }); - Object.defineProperty(Je, "isBytesLike", { - enumerable: !0, - get: function () { - return fl.isBytesLike; - }, - }); - Object.defineProperty(Je, "isHexString", { - enumerable: !0, - get: function () { - return fl.isHexString; - }, - }); - Object.defineProperty(Je, "joinSignature", { - enumerable: !0, - get: function () { - return fl.joinSignature; - }, - }); - Object.defineProperty(Je, "zeroPad", { - enumerable: !0, - get: function () { - return fl.zeroPad; - }, - }); - Object.defineProperty(Je, "splitSignature", { - enumerable: !0, - get: function () { - return fl.splitSignature; - }, - }); - Object.defineProperty(Je, "stripZeros", { - enumerable: !0, - get: function () { - return fl.stripZeros; - }, - }); - var J7 = db(); - Object.defineProperty(Je, "_TypedDataEncoder", { - enumerable: !0, - get: function () { - return J7._TypedDataEncoder; - }, - }); - Object.defineProperty(Je, "dnsEncode", { - enumerable: !0, - get: function () { - return J7.dnsEncode; - }, - }); - Object.defineProperty(Je, "hashMessage", { - enumerable: !0, - get: function () { - return J7.hashMessage; - }, - }); - Object.defineProperty(Je, "id", { - enumerable: !0, - get: function () { - return J7.id; - }, - }); - Object.defineProperty(Je, "isValidName", { - enumerable: !0, - get: function () { - return J7.isValidName; - }, - }); - Object.defineProperty(Je, "namehash", { - enumerable: !0, - get: function () { - return J7.namehash; - }, - }); - var _6 = aK(); - Object.defineProperty(Je, "defaultPath", { - enumerable: !0, - get: function () { - return _6.defaultPath; - }, - }); - Object.defineProperty(Je, "entropyToMnemonic", { - enumerable: !0, - get: function () { - return _6.entropyToMnemonic; - }, - }); - Object.defineProperty(Je, "getAccountPath", { - enumerable: !0, - get: function () { - return _6.getAccountPath; - }, - }); - Object.defineProperty(Je, "HDNode", { - enumerable: !0, - get: function () { - return _6.HDNode; - }, - }); - Object.defineProperty(Je, "isValidMnemonic", { - enumerable: !0, - get: function () { - return _6.isValidMnemonic; - }, - }); - Object.defineProperty(Je, "mnemonicToEntropy", { - enumerable: !0, - get: function () { - return _6.mnemonicToEntropy; - }, - }); - Object.defineProperty(Je, "mnemonicToSeed", { - enumerable: !0, - get: function () { - return _6.mnemonicToSeed; - }, - }); - var _8r = mne(); - Object.defineProperty(Je, "getJsonWalletAddress", { - enumerable: !0, - get: function () { - return _8r.getJsonWalletAddress; - }, - }); - var x8r = Hh(); - Object.defineProperty(Je, "keccak256", { - enumerable: !0, - get: function () { - return x8r.keccak256; - }, - }); - var S8r = rr(); - Object.defineProperty(Je, "Logger", { - enumerable: !0, - get: function () { - return S8r.Logger; - }, - }); - var Wie = pb(); - Object.defineProperty(Je, "computeHmac", { - enumerable: !0, - get: function () { - return Wie.computeHmac; - }, - }); - Object.defineProperty(Je, "ripemd160", { - enumerable: !0, - get: function () { - return Wie.ripemd160; - }, - }); - Object.defineProperty(Je, "sha256", { - enumerable: !0, - get: function () { - return Wie.sha256; - }, - }); - Object.defineProperty(Je, "sha512", { - enumerable: !0, - get: function () { - return Wie.sha512; - }, - }); - var PMe = LEe(); - Object.defineProperty(Je, "solidityKeccak256", { - enumerable: !0, - get: function () { - return PMe.keccak256; - }, - }); - Object.defineProperty(Je, "solidityPack", { - enumerable: !0, - get: function () { - return PMe.pack; - }, - }); - Object.defineProperty(Je, "soliditySha256", { - enumerable: !0, - get: function () { - return PMe.sha256; - }, - }); - var Kmt = s6(); - Object.defineProperty(Je, "randomBytes", { - enumerable: !0, - get: function () { - return Kmt.randomBytes; - }, - }); - Object.defineProperty(Je, "shuffled", { - enumerable: !0, - get: function () { - return Kmt.shuffled; - }, - }); - var $7 = $r(); - Object.defineProperty(Je, "checkProperties", { - enumerable: !0, - get: function () { - return $7.checkProperties; - }, - }); - Object.defineProperty(Je, "deepCopy", { - enumerable: !0, - get: function () { - return $7.deepCopy; - }, - }); - Object.defineProperty(Je, "defineReadOnly", { - enumerable: !0, - get: function () { - return $7.defineReadOnly; - }, - }); - Object.defineProperty(Je, "getStatic", { - enumerable: !0, - get: function () { - return $7.getStatic; - }, - }); - Object.defineProperty(Je, "resolveProperties", { - enumerable: !0, - get: function () { - return $7.resolveProperties; - }, - }); - Object.defineProperty(Je, "shallowCopy", { - enumerable: !0, - get: function () { - return $7.shallowCopy; - }, - }); - var A8r = Umt(zU()); - Je.RLP = A8r; - var OMe = qR(); - Object.defineProperty(Je, "computePublicKey", { - enumerable: !0, - get: function () { - return OMe.computePublicKey; - }, - }); - Object.defineProperty(Je, "recoverPublicKey", { - enumerable: !0, - get: function () { - return OMe.recoverPublicKey; - }, - }); - Object.defineProperty(Je, "SigningKey", { - enumerable: !0, - get: function () { - return OMe.SigningKey; - }, - }); - var bE = Eo(); - Object.defineProperty(Je, "formatBytes32String", { - enumerable: !0, - get: function () { - return bE.formatBytes32String; - }, - }); - Object.defineProperty(Je, "nameprep", { - enumerable: !0, - get: function () { - return bE.nameprep; - }, - }); - Object.defineProperty(Je, "parseBytes32String", { - enumerable: !0, - get: function () { - return bE.parseBytes32String; - }, - }); - Object.defineProperty(Je, "_toEscapedUtf8String", { - enumerable: !0, - get: function () { - return bE._toEscapedUtf8String; - }, - }); - Object.defineProperty(Je, "toUtf8Bytes", { - enumerable: !0, - get: function () { - return bE.toUtf8Bytes; - }, - }); - Object.defineProperty(Je, "toUtf8CodePoints", { - enumerable: !0, - get: function () { - return bE.toUtf8CodePoints; - }, - }); - Object.defineProperty(Je, "toUtf8String", { - enumerable: !0, - get: function () { - return bE.toUtf8String; - }, - }); - Object.defineProperty(Je, "Utf8ErrorFuncs", { - enumerable: !0, - get: function () { - return bE.Utf8ErrorFuncs; - }, - }); - var Z7 = e0(); - Object.defineProperty(Je, "accessListify", { - enumerable: !0, - get: function () { - return Z7.accessListify; - }, - }); - Object.defineProperty(Je, "computeAddress", { - enumerable: !0, - get: function () { - return Z7.computeAddress; - }, - }); - Object.defineProperty(Je, "parseTransaction", { - enumerable: !0, - get: function () { - return Z7.parse; - }, - }); - Object.defineProperty(Je, "recoverAddress", { - enumerable: !0, - get: function () { - return Z7.recoverAddress; - }, - }); - Object.defineProperty(Je, "serializeTransaction", { - enumerable: !0, - get: function () { - return Z7.serialize; - }, - }); - Object.defineProperty(Je, "TransactionTypes", { - enumerable: !0, - get: function () { - return Z7.TransactionTypes; - }, - }); - var cH = qEe(); - Object.defineProperty(Je, "commify", { - enumerable: !0, - get: function () { - return cH.commify; - }, - }); - Object.defineProperty(Je, "formatEther", { - enumerable: !0, - get: function () { - return cH.formatEther; - }, - }); - Object.defineProperty(Je, "parseEther", { - enumerable: !0, - get: function () { - return cH.parseEther; - }, - }); - Object.defineProperty(Je, "formatUnits", { - enumerable: !0, - get: function () { - return cH.formatUnits; - }, - }); - Object.defineProperty(Je, "parseUnits", { - enumerable: !0, - get: function () { - return cH.parseUnits; - }, - }); - var Hmt = lK(); - Object.defineProperty(Je, "verifyMessage", { - enumerable: !0, - get: function () { - return Hmt.verifyMessage; - }, - }); - Object.defineProperty(Je, "verifyTypedData", { - enumerable: !0, - get: function () { - return Hmt.verifyTypedData; - }, - }); - var BMe = jmt(); - Object.defineProperty(Je, "_fetchData", { - enumerable: !0, - get: function () { - return BMe._fetchData; - }, - }); - Object.defineProperty(Je, "fetchJson", { - enumerable: !0, - get: function () { - return BMe.fetchJson; - }, - }); - Object.defineProperty(Je, "poll", { - enumerable: !0, - get: function () { - return BMe.poll; - }, - }); - var E8r = pb(); - Object.defineProperty(Je, "SupportedAlgorithm", { - enumerable: !0, - get: function () { - return E8r.SupportedAlgorithm; - }, - }); - var Vmt = Eo(); - Object.defineProperty(Je, "UnicodeNormalizationForm", { - enumerable: !0, - get: function () { - return Vmt.UnicodeNormalizationForm; - }, - }); - Object.defineProperty(Je, "Utf8ErrorReason", { - enumerable: !0, - get: function () { - return Vmt.Utf8ErrorReason; - }, - }); - }); - var Gmt = I((Gie) => { - "use strict"; - m(); - g(); - Object.defineProperty(Gie, "__esModule", { value: !0 }); - Gie.version = void 0; - Gie.version = "ethers/5.7.2"; - }); - var RMe = I((yn) => { - "use strict"; - m(); - g(); - var M8r = - (yn && yn.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - T8r = - (yn && yn.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - IMe = - (yn && yn.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - M8r(e, t, r); - return T8r(e, t), e; - }; - Object.defineProperty(yn, "__esModule", { value: !0 }); - yn.Wordlist = - yn.version = - yn.wordlists = - yn.utils = - yn.logger = - yn.errors = - yn.constants = - yn.FixedNumber = - yn.BigNumber = - yn.ContractFactory = - yn.Contract = - yn.BaseContract = - yn.providers = - yn.getDefaultProvider = - yn.VoidSigner = - yn.Wallet = - yn.Signer = - void 0; - var CMe = UAe(); - Object.defineProperty(yn, "BaseContract", { - enumerable: !0, - get: function () { - return CMe.BaseContract; - }, - }); - Object.defineProperty(yn, "Contract", { - enumerable: !0, - get: function () { - return CMe.Contract; - }, - }); - Object.defineProperty(yn, "ContractFactory", { - enumerable: !0, - get: function () { - return CMe.ContractFactory; - }, - }); - var Jmt = Ro(); - Object.defineProperty(yn, "BigNumber", { - enumerable: !0, - get: function () { - return Jmt.BigNumber; - }, - }); - Object.defineProperty(yn, "FixedNumber", { - enumerable: !0, - get: function () { - return Jmt.FixedNumber; - }, - }); - var $mt = r6(); - Object.defineProperty(yn, "Signer", { - enumerable: !0, - get: function () { - return $mt.Signer; - }, - }); - Object.defineProperty(yn, "VoidSigner", { - enumerable: !0, - get: function () { - return $mt.VoidSigner; - }, - }); - var k8r = lK(); - Object.defineProperty(yn, "Wallet", { - enumerable: !0, - get: function () { - return k8r.Wallet; - }, - }); - var P8r = IMe(ub()); - yn.constants = P8r; - var O8r = IMe(kMe()); - yn.providers = O8r; - var B8r = kMe(); - Object.defineProperty(yn, "getDefaultProvider", { - enumerable: !0, - get: function () { - return B8r.getDefaultProvider; - }, - }); - var Zmt = one(); - Object.defineProperty(yn, "Wordlist", { - enumerable: !0, - get: function () { - return Zmt.Wordlist; - }, - }); - Object.defineProperty(yn, "wordlists", { - enumerable: !0, - get: function () { - return Zmt.wordlists; - }, - }); - var I8r = IMe(Wmt()); - yn.utils = I8r; - var Xmt = rr(); - Object.defineProperty(yn, "errors", { - enumerable: !0, - get: function () { - return Xmt.ErrorCode; - }, - }); - var Ymt = Gmt(); - Object.defineProperty(yn, "version", { - enumerable: !0, - get: function () { - return Ymt.version; - }, - }); - var C8r = new Xmt.Logger(Ymt.version); - yn.logger = C8r; - }); - var DMe = I((an) => { - "use strict"; - m(); - g(); - var R8r = - (an && an.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - N8r = - (an && an.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - D8r = - (an && an.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - R8r(e, t, r); - return N8r(e, t), e; - }; - Object.defineProperty(an, "__esModule", { value: !0 }); - an.Wordlist = - an.version = - an.wordlists = - an.utils = - an.logger = - an.errors = - an.constants = - an.FixedNumber = - an.BigNumber = - an.ContractFactory = - an.Contract = - an.BaseContract = - an.providers = - an.getDefaultProvider = - an.VoidSigner = - an.Wallet = - an.Signer = - an.ethers = - void 0; - var Qmt = D8r(RMe()); - an.ethers = Qmt; - try { - (NMe = window), NMe._ethers == null && (NMe._ethers = Qmt); - } catch {} - var NMe, - vc = RMe(); - Object.defineProperty(an, "Signer", { - enumerable: !0, - get: function () { - return vc.Signer; - }, - }); - Object.defineProperty(an, "Wallet", { - enumerable: !0, - get: function () { - return vc.Wallet; - }, - }); - Object.defineProperty(an, "VoidSigner", { - enumerable: !0, - get: function () { - return vc.VoidSigner; - }, - }); - Object.defineProperty(an, "getDefaultProvider", { - enumerable: !0, - get: function () { - return vc.getDefaultProvider; - }, - }); - Object.defineProperty(an, "providers", { - enumerable: !0, - get: function () { - return vc.providers; - }, - }); - Object.defineProperty(an, "BaseContract", { - enumerable: !0, - get: function () { - return vc.BaseContract; - }, - }); - Object.defineProperty(an, "Contract", { - enumerable: !0, - get: function () { - return vc.Contract; - }, - }); - Object.defineProperty(an, "ContractFactory", { - enumerable: !0, - get: function () { - return vc.ContractFactory; - }, - }); - Object.defineProperty(an, "BigNumber", { - enumerable: !0, - get: function () { - return vc.BigNumber; - }, - }); - Object.defineProperty(an, "FixedNumber", { - enumerable: !0, - get: function () { - return vc.FixedNumber; - }, - }); - Object.defineProperty(an, "constants", { - enumerable: !0, - get: function () { - return vc.constants; - }, - }); - Object.defineProperty(an, "errors", { - enumerable: !0, - get: function () { - return vc.errors; - }, - }); - Object.defineProperty(an, "logger", { - enumerable: !0, - get: function () { - return vc.logger; - }, - }); - Object.defineProperty(an, "utils", { - enumerable: !0, - get: function () { - return vc.utils; - }, - }); - Object.defineProperty(an, "wordlists", { - enumerable: !0, - get: function () { - return vc.wordlists; - }, - }); - Object.defineProperty(an, "version", { - enumerable: !0, - get: function () { - return vc.version; - }, - }); - Object.defineProperty(an, "Wordlist", { - enumerable: !0, - get: function () { - return vc.Wordlist; - }, - }); - }); - var lH = I((x6) => { - "use strict"; - m(); - g(); - var Jie = - (x6 && x6.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(x6, "__esModule", { value: !0 }); - x6.getRedstonePrice = void 0; - var F8r = Jie(wT()), - L8r = Jie(ng()), - q8r = Jie(zee()), - z8r = Jie(m6()), - FMe = class { - constructor(e) { - (this.minConfirm = 5), - (this.isSlow = !1), - (this.needsFee = !0), - Object.assign(this, e); - } - get address() { - return this._address; - } - async ready() { - this._address = this.wallet - ? this.ownerToAddress(await this.getPublicKey()) - : void 0; - } - async getId(e) { - return L8r.default.encode( - Buffer.from(await F8r.default.crypto.hash(await e.rawSignature())) - ); - } - async price() { - return egt(this.ticker); - } - }; - x6.default = FMe; - async function egt(t) { - let e = await q8r.default.get( - `https://api.redstone.finance/prices?symbol=${t}&provider=redstone&limit=1` - ); - return ( - await z8r.default.checkAndThrow(e, "Getting price data"), - e.data[0].value - ); - } - x6.getRedstonePrice = egt; - }); - var jMe = I((fH) => { - "use strict"; - m(); - g(); - var zMe = - (fH && fH.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(fH, "__esModule", { value: !0 }); - var j8r = zMe(J2e()), - LMe = DMe(), - S6 = zMe(Sy()), - tgt = S7(), - U8r = zMe(lH()), - K8r = LMe.ethers.BigNumber, - H8r = tgt.InjectedEthereumSigner, - qMe = class extends U8r.default { - constructor(e) { - super(e), (this.base = ["wei", 1e18]); - } - async getTx(e) { - let n = await this.providerInstance.getTransaction(e); - if (!n) throw new Error("Tx doesn't exist"); - return { - from: n.from, - to: n.to, - blockHeight: n.blockNumber ? new S6.default(n.blockNumber) : null, - amount: new S6.default(n.value.toHexString(), 16), - pending: !n.blockNumber, - confirmed: n.confirmations >= this.minConfirm, - }; - } - ownerToAddress(e) { - return ( - "0x" + - (0, j8r.default)(Buffer.from(e.slice(1))) - .slice(-20) - .toString("hex") - ); - } - async sign(e) { - return (await this.getSigner()).sign(e); - } - getSigner() { - return ( - this.signer || - (this.signer = new tgt.InjectedEthereumSigner(this.wallet)), - this.signer - ); - } - async verify(e, r, n) { - return H8r.verify(e, r, n); - } - async getCurrentHeight() { - let r = await this.providerInstance.send("eth_blockNumber", []); - return new S6.default(r, 16); - } - async getFee(e, r) { - let n = this.providerInstance, - i = { - to: r, - from: this.address, - value: "0x" + new S6.default(e).toString(16), - }, - o = await n.estimateGas(i), - a = await n.getGasPrice(); - return new S6.default(o.mul(a).toString()); - } - async sendTx(e) { - let n = await this.w3signer.sendTransaction(e); - return n ? n.hash : void 0; - } - async createTx(e, r, n) { - let i = K8r.from(new S6.default(e).toFixed()), - o = this.w3signer, - a = await o.estimateGas({ - to: r, - from: this.address, - value: i.toHexString(), - }), - s = await o.getGasPrice(); - this.name === "matic" && - (s = LMe.ethers.BigNumber.from( - new S6.default(s.toString()) - .multipliedBy(10) - .decimalPlaces(0) - .toString() - )); - let c = await o.populateTransaction({ - to: r, - from: this.address, - value: i.toHexString(), - gasPrice: s, - gasLimit: a, - }); - return { txId: void 0, tx: c }; - } - async getPublicKey() { - let e = await this.getSigner(); - return await e.setPublicKey(), e.publicKey; - } - pruneBalanceTransactions(e) { - throw new Error("Method not implemented."); - } - async ready() { - var e; - (this.w3signer = await this.wallet.getSigner()), - (this._address = this.ownerToAddress(await this.getPublicKey())), - (this.providerInstance = new LMe.ethers.providers.JsonRpcProvider( - this.providerUrl - )), - await ((e = this.providerInstance) === null || e === void 0 - ? void 0 - : e._ready()); - } - }; - fH.default = qMe; - }); - var dH = I(($ie) => { - "use strict"; - m(); - g(); - Object.defineProperty($ie, "__esModule", { value: !0 }); - $ie.KeyStore = void 0; - var UMe = class {}; - $ie.KeyStore = UMe; - }); - var rgt = I((E1n, Zie) => { - m(); - g(); - (function (t) { - "use strict"; - var e = function (oe) { - var ie, - re = new Float64Array(16); - if (oe) for (ie = 0; ie < oe.length; ie++) re[ie] = oe[ie]; - return re; - }, - r = function () { - throw new Error("no PRNG"); - }, - n = new Uint8Array(16), - i = new Uint8Array(32); - i[0] = 9; - var o = e(), - a = e([1]), - s = e([56129, 1]), - c = e([ - 30883, 4953, 19914, 30187, 55467, 16705, 2637, 112, 59544, 30585, - 16505, 36039, 65139, 11119, 27886, 20995, - ]), - u = e([ - 61785, 9906, 39828, 60374, 45398, 33411, 5274, 224, 53552, 61171, - 33010, 6542, 64743, 22239, 55772, 9222, - ]), - h = e([ - 54554, 36645, 11616, 51542, 42930, 38181, 51040, 26924, 56412, 64982, - 57905, 49316, 21502, 52590, 14035, 8553, - ]), - w = e([ - 26200, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, 26214, - 26214, 26214, 26214, 26214, 26214, 26214, - ]), - M = e([ - 41136, 18958, 6951, 50414, 58488, 44335, 6150, 12099, 55207, 15867, - 153, 11085, 57099, 20417, 9344, 11139, - ]); - function k(oe, ie, re, U) { - (oe[ie] = (re >> 24) & 255), - (oe[ie + 1] = (re >> 16) & 255), - (oe[ie + 2] = (re >> 8) & 255), - (oe[ie + 3] = re & 255), - (oe[ie + 4] = (U >> 24) & 255), - (oe[ie + 5] = (U >> 16) & 255), - (oe[ie + 6] = (U >> 8) & 255), - (oe[ie + 7] = U & 255); - } - function O(oe, ie, re, U, se) { - var be, - Qe = 0; - for (be = 0; be < se; be++) Qe |= oe[ie + be] ^ re[U + be]; - return (1 & ((Qe - 1) >>> 8)) - 1; - } - function D(oe, ie, re, U) { - return O(oe, ie, re, U, 16); - } - function F(oe, ie, re, U) { - return O(oe, ie, re, U, 32); - } - function N(oe, ie, re, U) { - for ( - var se = - (U[0] & 255) | - ((U[1] & 255) << 8) | - ((U[2] & 255) << 16) | - ((U[3] & 255) << 24), - be = - (re[0] & 255) | - ((re[1] & 255) << 8) | - ((re[2] & 255) << 16) | - ((re[3] & 255) << 24), - Qe = - (re[4] & 255) | - ((re[5] & 255) << 8) | - ((re[6] & 255) << 16) | - ((re[7] & 255) << 24), - Ae = - (re[8] & 255) | - ((re[9] & 255) << 8) | - ((re[10] & 255) << 16) | - ((re[11] & 255) << 24), - ke = - (re[12] & 255) | - ((re[13] & 255) << 8) | - ((re[14] & 255) << 16) | - ((re[15] & 255) << 24), - Ct = - (U[4] & 255) | - ((U[5] & 255) << 8) | - ((U[6] & 255) << 16) | - ((U[7] & 255) << 24), - ut = - (ie[0] & 255) | - ((ie[1] & 255) << 8) | - ((ie[2] & 255) << 16) | - ((ie[3] & 255) << 24), - St = - (ie[4] & 255) | - ((ie[5] & 255) << 8) | - ((ie[6] & 255) << 16) | - ((ie[7] & 255) << 24), - wt = - (ie[8] & 255) | - ((ie[9] & 255) << 8) | - ((ie[10] & 255) << 16) | - ((ie[11] & 255) << 24), - zt = - (ie[12] & 255) | - ((ie[13] & 255) << 8) | - ((ie[14] & 255) << 16) | - ((ie[15] & 255) << 24), - jt = - (U[8] & 255) | - ((U[9] & 255) << 8) | - ((U[10] & 255) << 16) | - ((U[11] & 255) << 24), - Ht = - (re[16] & 255) | - ((re[17] & 255) << 8) | - ((re[18] & 255) << 16) | - ((re[19] & 255) << 24), - Ut = - (re[20] & 255) | - ((re[21] & 255) << 8) | - ((re[22] & 255) << 16) | - ((re[23] & 255) << 24), - Kt = - (re[24] & 255) | - ((re[25] & 255) << 8) | - ((re[26] & 255) << 16) | - ((re[27] & 255) << 24), - Ot = - (re[28] & 255) | - ((re[29] & 255) << 8) | - ((re[30] & 255) << 16) | - ((re[31] & 255) << 24), - Bt = - (U[12] & 255) | - ((U[13] & 255) << 8) | - ((U[14] & 255) << 16) | - ((U[15] & 255) << 24), - Et = se, - Mt = be, - gt = Qe, - Pt = Ae, - It = ke, - yt = Ct, - nt = ut, - it = St, - _t = wt, - ht = zt, - mt = jt, - Nt = Ht, - hr = Ut, - Yr = Kt, - Kr = Ot, - or = Bt, - Ce, - mn = 0; - mn < 20; - mn += 2 - ) - (Ce = (Et + hr) | 0), - (It ^= (Ce << 7) | (Ce >>> (32 - 7))), - (Ce = (It + Et) | 0), - (_t ^= (Ce << 9) | (Ce >>> (32 - 9))), - (Ce = (_t + It) | 0), - (hr ^= (Ce << 13) | (Ce >>> (32 - 13))), - (Ce = (hr + _t) | 0), - (Et ^= (Ce << 18) | (Ce >>> (32 - 18))), - (Ce = (yt + Mt) | 0), - (ht ^= (Ce << 7) | (Ce >>> (32 - 7))), - (Ce = (ht + yt) | 0), - (Yr ^= (Ce << 9) | (Ce >>> (32 - 9))), - (Ce = (Yr + ht) | 0), - (Mt ^= (Ce << 13) | (Ce >>> (32 - 13))), - (Ce = (Mt + Yr) | 0), - (yt ^= (Ce << 18) | (Ce >>> (32 - 18))), - (Ce = (mt + nt) | 0), - (Kr ^= (Ce << 7) | (Ce >>> (32 - 7))), - (Ce = (Kr + mt) | 0), - (gt ^= (Ce << 9) | (Ce >>> (32 - 9))), - (Ce = (gt + Kr) | 0), - (nt ^= (Ce << 13) | (Ce >>> (32 - 13))), - (Ce = (nt + gt) | 0), - (mt ^= (Ce << 18) | (Ce >>> (32 - 18))), - (Ce = (or + Nt) | 0), - (Pt ^= (Ce << 7) | (Ce >>> (32 - 7))), - (Ce = (Pt + or) | 0), - (it ^= (Ce << 9) | (Ce >>> (32 - 9))), - (Ce = (it + Pt) | 0), - (Nt ^= (Ce << 13) | (Ce >>> (32 - 13))), - (Ce = (Nt + it) | 0), - (or ^= (Ce << 18) | (Ce >>> (32 - 18))), - (Ce = (Et + Pt) | 0), - (Mt ^= (Ce << 7) | (Ce >>> (32 - 7))), - (Ce = (Mt + Et) | 0), - (gt ^= (Ce << 9) | (Ce >>> (32 - 9))), - (Ce = (gt + Mt) | 0), - (Pt ^= (Ce << 13) | (Ce >>> (32 - 13))), - (Ce = (Pt + gt) | 0), - (Et ^= (Ce << 18) | (Ce >>> (32 - 18))), - (Ce = (yt + It) | 0), - (nt ^= (Ce << 7) | (Ce >>> (32 - 7))), - (Ce = (nt + yt) | 0), - (it ^= (Ce << 9) | (Ce >>> (32 - 9))), - (Ce = (it + nt) | 0), - (It ^= (Ce << 13) | (Ce >>> (32 - 13))), - (Ce = (It + it) | 0), - (yt ^= (Ce << 18) | (Ce >>> (32 - 18))), - (Ce = (mt + ht) | 0), - (Nt ^= (Ce << 7) | (Ce >>> (32 - 7))), - (Ce = (Nt + mt) | 0), - (_t ^= (Ce << 9) | (Ce >>> (32 - 9))), - (Ce = (_t + Nt) | 0), - (ht ^= (Ce << 13) | (Ce >>> (32 - 13))), - (Ce = (ht + _t) | 0), - (mt ^= (Ce << 18) | (Ce >>> (32 - 18))), - (Ce = (or + Kr) | 0), - (hr ^= (Ce << 7) | (Ce >>> (32 - 7))), - (Ce = (hr + or) | 0), - (Yr ^= (Ce << 9) | (Ce >>> (32 - 9))), - (Ce = (Yr + hr) | 0), - (Kr ^= (Ce << 13) | (Ce >>> (32 - 13))), - (Ce = (Kr + Yr) | 0), - (or ^= (Ce << 18) | (Ce >>> (32 - 18))); - (Et = (Et + se) | 0), - (Mt = (Mt + be) | 0), - (gt = (gt + Qe) | 0), - (Pt = (Pt + Ae) | 0), - (It = (It + ke) | 0), - (yt = (yt + Ct) | 0), - (nt = (nt + ut) | 0), - (it = (it + St) | 0), - (_t = (_t + wt) | 0), - (ht = (ht + zt) | 0), - (mt = (mt + jt) | 0), - (Nt = (Nt + Ht) | 0), - (hr = (hr + Ut) | 0), - (Yr = (Yr + Kt) | 0), - (Kr = (Kr + Ot) | 0), - (or = (or + Bt) | 0), - (oe[0] = (Et >>> 0) & 255), - (oe[1] = (Et >>> 8) & 255), - (oe[2] = (Et >>> 16) & 255), - (oe[3] = (Et >>> 24) & 255), - (oe[4] = (Mt >>> 0) & 255), - (oe[5] = (Mt >>> 8) & 255), - (oe[6] = (Mt >>> 16) & 255), - (oe[7] = (Mt >>> 24) & 255), - (oe[8] = (gt >>> 0) & 255), - (oe[9] = (gt >>> 8) & 255), - (oe[10] = (gt >>> 16) & 255), - (oe[11] = (gt >>> 24) & 255), - (oe[12] = (Pt >>> 0) & 255), - (oe[13] = (Pt >>> 8) & 255), - (oe[14] = (Pt >>> 16) & 255), - (oe[15] = (Pt >>> 24) & 255), - (oe[16] = (It >>> 0) & 255), - (oe[17] = (It >>> 8) & 255), - (oe[18] = (It >>> 16) & 255), - (oe[19] = (It >>> 24) & 255), - (oe[20] = (yt >>> 0) & 255), - (oe[21] = (yt >>> 8) & 255), - (oe[22] = (yt >>> 16) & 255), - (oe[23] = (yt >>> 24) & 255), - (oe[24] = (nt >>> 0) & 255), - (oe[25] = (nt >>> 8) & 255), - (oe[26] = (nt >>> 16) & 255), - (oe[27] = (nt >>> 24) & 255), - (oe[28] = (it >>> 0) & 255), - (oe[29] = (it >>> 8) & 255), - (oe[30] = (it >>> 16) & 255), - (oe[31] = (it >>> 24) & 255), - (oe[32] = (_t >>> 0) & 255), - (oe[33] = (_t >>> 8) & 255), - (oe[34] = (_t >>> 16) & 255), - (oe[35] = (_t >>> 24) & 255), - (oe[36] = (ht >>> 0) & 255), - (oe[37] = (ht >>> 8) & 255), - (oe[38] = (ht >>> 16) & 255), - (oe[39] = (ht >>> 24) & 255), - (oe[40] = (mt >>> 0) & 255), - (oe[41] = (mt >>> 8) & 255), - (oe[42] = (mt >>> 16) & 255), - (oe[43] = (mt >>> 24) & 255), - (oe[44] = (Nt >>> 0) & 255), - (oe[45] = (Nt >>> 8) & 255), - (oe[46] = (Nt >>> 16) & 255), - (oe[47] = (Nt >>> 24) & 255), - (oe[48] = (hr >>> 0) & 255), - (oe[49] = (hr >>> 8) & 255), - (oe[50] = (hr >>> 16) & 255), - (oe[51] = (hr >>> 24) & 255), - (oe[52] = (Yr >>> 0) & 255), - (oe[53] = (Yr >>> 8) & 255), - (oe[54] = (Yr >>> 16) & 255), - (oe[55] = (Yr >>> 24) & 255), - (oe[56] = (Kr >>> 0) & 255), - (oe[57] = (Kr >>> 8) & 255), - (oe[58] = (Kr >>> 16) & 255), - (oe[59] = (Kr >>> 24) & 255), - (oe[60] = (or >>> 0) & 255), - (oe[61] = (or >>> 8) & 255), - (oe[62] = (or >>> 16) & 255), - (oe[63] = (or >>> 24) & 255); - } - function q(oe, ie, re, U) { - for ( - var se = - (U[0] & 255) | - ((U[1] & 255) << 8) | - ((U[2] & 255) << 16) | - ((U[3] & 255) << 24), - be = - (re[0] & 255) | - ((re[1] & 255) << 8) | - ((re[2] & 255) << 16) | - ((re[3] & 255) << 24), - Qe = - (re[4] & 255) | - ((re[5] & 255) << 8) | - ((re[6] & 255) << 16) | - ((re[7] & 255) << 24), - Ae = - (re[8] & 255) | - ((re[9] & 255) << 8) | - ((re[10] & 255) << 16) | - ((re[11] & 255) << 24), - ke = - (re[12] & 255) | - ((re[13] & 255) << 8) | - ((re[14] & 255) << 16) | - ((re[15] & 255) << 24), - Ct = - (U[4] & 255) | - ((U[5] & 255) << 8) | - ((U[6] & 255) << 16) | - ((U[7] & 255) << 24), - ut = - (ie[0] & 255) | - ((ie[1] & 255) << 8) | - ((ie[2] & 255) << 16) | - ((ie[3] & 255) << 24), - St = - (ie[4] & 255) | - ((ie[5] & 255) << 8) | - ((ie[6] & 255) << 16) | - ((ie[7] & 255) << 24), - wt = - (ie[8] & 255) | - ((ie[9] & 255) << 8) | - ((ie[10] & 255) << 16) | - ((ie[11] & 255) << 24), - zt = - (ie[12] & 255) | - ((ie[13] & 255) << 8) | - ((ie[14] & 255) << 16) | - ((ie[15] & 255) << 24), - jt = - (U[8] & 255) | - ((U[9] & 255) << 8) | - ((U[10] & 255) << 16) | - ((U[11] & 255) << 24), - Ht = - (re[16] & 255) | - ((re[17] & 255) << 8) | - ((re[18] & 255) << 16) | - ((re[19] & 255) << 24), - Ut = - (re[20] & 255) | - ((re[21] & 255) << 8) | - ((re[22] & 255) << 16) | - ((re[23] & 255) << 24), - Kt = - (re[24] & 255) | - ((re[25] & 255) << 8) | - ((re[26] & 255) << 16) | - ((re[27] & 255) << 24), - Ot = - (re[28] & 255) | - ((re[29] & 255) << 8) | - ((re[30] & 255) << 16) | - ((re[31] & 255) << 24), - Bt = - (U[12] & 255) | - ((U[13] & 255) << 8) | - ((U[14] & 255) << 16) | - ((U[15] & 255) << 24), - Et = se, - Mt = be, - gt = Qe, - Pt = Ae, - It = ke, - yt = Ct, - nt = ut, - it = St, - _t = wt, - ht = zt, - mt = jt, - Nt = Ht, - hr = Ut, - Yr = Kt, - Kr = Ot, - or = Bt, - Ce, - mn = 0; - mn < 20; - mn += 2 - ) - (Ce = (Et + hr) | 0), - (It ^= (Ce << 7) | (Ce >>> (32 - 7))), - (Ce = (It + Et) | 0), - (_t ^= (Ce << 9) | (Ce >>> (32 - 9))), - (Ce = (_t + It) | 0), - (hr ^= (Ce << 13) | (Ce >>> (32 - 13))), - (Ce = (hr + _t) | 0), - (Et ^= (Ce << 18) | (Ce >>> (32 - 18))), - (Ce = (yt + Mt) | 0), - (ht ^= (Ce << 7) | (Ce >>> (32 - 7))), - (Ce = (ht + yt) | 0), - (Yr ^= (Ce << 9) | (Ce >>> (32 - 9))), - (Ce = (Yr + ht) | 0), - (Mt ^= (Ce << 13) | (Ce >>> (32 - 13))), - (Ce = (Mt + Yr) | 0), - (yt ^= (Ce << 18) | (Ce >>> (32 - 18))), - (Ce = (mt + nt) | 0), - (Kr ^= (Ce << 7) | (Ce >>> (32 - 7))), - (Ce = (Kr + mt) | 0), - (gt ^= (Ce << 9) | (Ce >>> (32 - 9))), - (Ce = (gt + Kr) | 0), - (nt ^= (Ce << 13) | (Ce >>> (32 - 13))), - (Ce = (nt + gt) | 0), - (mt ^= (Ce << 18) | (Ce >>> (32 - 18))), - (Ce = (or + Nt) | 0), - (Pt ^= (Ce << 7) | (Ce >>> (32 - 7))), - (Ce = (Pt + or) | 0), - (it ^= (Ce << 9) | (Ce >>> (32 - 9))), - (Ce = (it + Pt) | 0), - (Nt ^= (Ce << 13) | (Ce >>> (32 - 13))), - (Ce = (Nt + it) | 0), - (or ^= (Ce << 18) | (Ce >>> (32 - 18))), - (Ce = (Et + Pt) | 0), - (Mt ^= (Ce << 7) | (Ce >>> (32 - 7))), - (Ce = (Mt + Et) | 0), - (gt ^= (Ce << 9) | (Ce >>> (32 - 9))), - (Ce = (gt + Mt) | 0), - (Pt ^= (Ce << 13) | (Ce >>> (32 - 13))), - (Ce = (Pt + gt) | 0), - (Et ^= (Ce << 18) | (Ce >>> (32 - 18))), - (Ce = (yt + It) | 0), - (nt ^= (Ce << 7) | (Ce >>> (32 - 7))), - (Ce = (nt + yt) | 0), - (it ^= (Ce << 9) | (Ce >>> (32 - 9))), - (Ce = (it + nt) | 0), - (It ^= (Ce << 13) | (Ce >>> (32 - 13))), - (Ce = (It + it) | 0), - (yt ^= (Ce << 18) | (Ce >>> (32 - 18))), - (Ce = (mt + ht) | 0), - (Nt ^= (Ce << 7) | (Ce >>> (32 - 7))), - (Ce = (Nt + mt) | 0), - (_t ^= (Ce << 9) | (Ce >>> (32 - 9))), - (Ce = (_t + Nt) | 0), - (ht ^= (Ce << 13) | (Ce >>> (32 - 13))), - (Ce = (ht + _t) | 0), - (mt ^= (Ce << 18) | (Ce >>> (32 - 18))), - (Ce = (or + Kr) | 0), - (hr ^= (Ce << 7) | (Ce >>> (32 - 7))), - (Ce = (hr + or) | 0), - (Yr ^= (Ce << 9) | (Ce >>> (32 - 9))), - (Ce = (Yr + hr) | 0), - (Kr ^= (Ce << 13) | (Ce >>> (32 - 13))), - (Ce = (Kr + Yr) | 0), - (or ^= (Ce << 18) | (Ce >>> (32 - 18))); - (oe[0] = (Et >>> 0) & 255), - (oe[1] = (Et >>> 8) & 255), - (oe[2] = (Et >>> 16) & 255), - (oe[3] = (Et >>> 24) & 255), - (oe[4] = (yt >>> 0) & 255), - (oe[5] = (yt >>> 8) & 255), - (oe[6] = (yt >>> 16) & 255), - (oe[7] = (yt >>> 24) & 255), - (oe[8] = (mt >>> 0) & 255), - (oe[9] = (mt >>> 8) & 255), - (oe[10] = (mt >>> 16) & 255), - (oe[11] = (mt >>> 24) & 255), - (oe[12] = (or >>> 0) & 255), - (oe[13] = (or >>> 8) & 255), - (oe[14] = (or >>> 16) & 255), - (oe[15] = (or >>> 24) & 255), - (oe[16] = (nt >>> 0) & 255), - (oe[17] = (nt >>> 8) & 255), - (oe[18] = (nt >>> 16) & 255), - (oe[19] = (nt >>> 24) & 255), - (oe[20] = (it >>> 0) & 255), - (oe[21] = (it >>> 8) & 255), - (oe[22] = (it >>> 16) & 255), - (oe[23] = (it >>> 24) & 255), - (oe[24] = (_t >>> 0) & 255), - (oe[25] = (_t >>> 8) & 255), - (oe[26] = (_t >>> 16) & 255), - (oe[27] = (_t >>> 24) & 255), - (oe[28] = (ht >>> 0) & 255), - (oe[29] = (ht >>> 8) & 255), - (oe[30] = (ht >>> 16) & 255), - (oe[31] = (ht >>> 24) & 255); - } - function z(oe, ie, re, U) { - N(oe, ie, re, U); - } - function H(oe, ie, re, U) { - q(oe, ie, re, U); - } - var Z = new Uint8Array([ - 101, 120, 112, 97, 110, 100, 32, 51, 50, 45, 98, 121, 116, 101, 32, 107, - ]); - function $(oe, ie, re, U, se, be, Qe) { - var Ae = new Uint8Array(16), - ke = new Uint8Array(64), - Ct, - ut; - for (ut = 0; ut < 16; ut++) Ae[ut] = 0; - for (ut = 0; ut < 8; ut++) Ae[ut] = be[ut]; - for (; se >= 64; ) { - for (z(ke, Ae, Qe, Z), ut = 0; ut < 64; ut++) - oe[ie + ut] = re[U + ut] ^ ke[ut]; - for (Ct = 1, ut = 8; ut < 16; ut++) - (Ct = (Ct + (Ae[ut] & 255)) | 0), (Ae[ut] = Ct & 255), (Ct >>>= 8); - (se -= 64), (ie += 64), (U += 64); - } - if (se > 0) - for (z(ke, Ae, Qe, Z), ut = 0; ut < se; ut++) - oe[ie + ut] = re[U + ut] ^ ke[ut]; - return 0; - } - function ue(oe, ie, re, U, se) { - var be = new Uint8Array(16), - Qe = new Uint8Array(64), - Ae, - ke; - for (ke = 0; ke < 16; ke++) be[ke] = 0; - for (ke = 0; ke < 8; ke++) be[ke] = U[ke]; - for (; re >= 64; ) { - for (z(Qe, be, se, Z), ke = 0; ke < 64; ke++) oe[ie + ke] = Qe[ke]; - for (Ae = 1, ke = 8; ke < 16; ke++) - (Ae = (Ae + (be[ke] & 255)) | 0), (be[ke] = Ae & 255), (Ae >>>= 8); - (re -= 64), (ie += 64); - } - if (re > 0) - for (z(Qe, be, se, Z), ke = 0; ke < re; ke++) oe[ie + ke] = Qe[ke]; - return 0; - } - function te(oe, ie, re, U, se) { - var be = new Uint8Array(32); - H(be, U, se, Z); - for (var Qe = new Uint8Array(8), Ae = 0; Ae < 8; Ae++) - Qe[Ae] = U[Ae + 16]; - return ue(oe, ie, re, Qe, be); - } - function ne(oe, ie, re, U, se, be, Qe) { - var Ae = new Uint8Array(32); - H(Ae, be, Qe, Z); - for (var ke = new Uint8Array(8), Ct = 0; Ct < 8; Ct++) - ke[Ct] = be[Ct + 16]; - return $(oe, ie, re, U, se, ke, Ae); - } - var A = function (oe) { - (this.buffer = new Uint8Array(16)), - (this.r = new Uint16Array(10)), - (this.h = new Uint16Array(10)), - (this.pad = new Uint16Array(8)), - (this.leftover = 0), - (this.fin = 0); - var ie, re, U, se, be, Qe, Ae, ke; - (ie = (oe[0] & 255) | ((oe[1] & 255) << 8)), - (this.r[0] = ie & 8191), - (re = (oe[2] & 255) | ((oe[3] & 255) << 8)), - (this.r[1] = ((ie >>> 13) | (re << 3)) & 8191), - (U = (oe[4] & 255) | ((oe[5] & 255) << 8)), - (this.r[2] = ((re >>> 10) | (U << 6)) & 7939), - (se = (oe[6] & 255) | ((oe[7] & 255) << 8)), - (this.r[3] = ((U >>> 7) | (se << 9)) & 8191), - (be = (oe[8] & 255) | ((oe[9] & 255) << 8)), - (this.r[4] = ((se >>> 4) | (be << 12)) & 255), - (this.r[5] = (be >>> 1) & 8190), - (Qe = (oe[10] & 255) | ((oe[11] & 255) << 8)), - (this.r[6] = ((be >>> 14) | (Qe << 2)) & 8191), - (Ae = (oe[12] & 255) | ((oe[13] & 255) << 8)), - (this.r[7] = ((Qe >>> 11) | (Ae << 5)) & 8065), - (ke = (oe[14] & 255) | ((oe[15] & 255) << 8)), - (this.r[8] = ((Ae >>> 8) | (ke << 8)) & 8191), - (this.r[9] = (ke >>> 5) & 127), - (this.pad[0] = (oe[16] & 255) | ((oe[17] & 255) << 8)), - (this.pad[1] = (oe[18] & 255) | ((oe[19] & 255) << 8)), - (this.pad[2] = (oe[20] & 255) | ((oe[21] & 255) << 8)), - (this.pad[3] = (oe[22] & 255) | ((oe[23] & 255) << 8)), - (this.pad[4] = (oe[24] & 255) | ((oe[25] & 255) << 8)), - (this.pad[5] = (oe[26] & 255) | ((oe[27] & 255) << 8)), - (this.pad[6] = (oe[28] & 255) | ((oe[29] & 255) << 8)), - (this.pad[7] = (oe[30] & 255) | ((oe[31] & 255) << 8)); - }; - (A.prototype.blocks = function (oe, ie, re) { - for ( - var U = this.fin ? 0 : 2048, - se, - be, - Qe, - Ae, - ke, - Ct, - ut, - St, - wt, - zt, - jt, - Ht, - Ut, - Kt, - Ot, - Bt, - Et, - Mt, - gt, - Pt = this.h[0], - It = this.h[1], - yt = this.h[2], - nt = this.h[3], - it = this.h[4], - _t = this.h[5], - ht = this.h[6], - mt = this.h[7], - Nt = this.h[8], - hr = this.h[9], - Yr = this.r[0], - Kr = this.r[1], - or = this.r[2], - Ce = this.r[3], - mn = this.r[4], - ii = this.r[5], - Tn = this.r[6], - cn = this.r[7], - kn = this.r[8], - gn = this.r[9]; - re >= 16; - - ) - (se = (oe[ie + 0] & 255) | ((oe[ie + 1] & 255) << 8)), - (Pt += se & 8191), - (be = (oe[ie + 2] & 255) | ((oe[ie + 3] & 255) << 8)), - (It += ((se >>> 13) | (be << 3)) & 8191), - (Qe = (oe[ie + 4] & 255) | ((oe[ie + 5] & 255) << 8)), - (yt += ((be >>> 10) | (Qe << 6)) & 8191), - (Ae = (oe[ie + 6] & 255) | ((oe[ie + 7] & 255) << 8)), - (nt += ((Qe >>> 7) | (Ae << 9)) & 8191), - (ke = (oe[ie + 8] & 255) | ((oe[ie + 9] & 255) << 8)), - (it += ((Ae >>> 4) | (ke << 12)) & 8191), - (_t += (ke >>> 1) & 8191), - (Ct = (oe[ie + 10] & 255) | ((oe[ie + 11] & 255) << 8)), - (ht += ((ke >>> 14) | (Ct << 2)) & 8191), - (ut = (oe[ie + 12] & 255) | ((oe[ie + 13] & 255) << 8)), - (mt += ((Ct >>> 11) | (ut << 5)) & 8191), - (St = (oe[ie + 14] & 255) | ((oe[ie + 15] & 255) << 8)), - (Nt += ((ut >>> 8) | (St << 8)) & 8191), - (hr += (St >>> 5) | U), - (wt = 0), - (zt = wt), - (zt += Pt * Yr), - (zt += It * (5 * gn)), - (zt += yt * (5 * kn)), - (zt += nt * (5 * cn)), - (zt += it * (5 * Tn)), - (wt = zt >>> 13), - (zt &= 8191), - (zt += _t * (5 * ii)), - (zt += ht * (5 * mn)), - (zt += mt * (5 * Ce)), - (zt += Nt * (5 * or)), - (zt += hr * (5 * Kr)), - (wt += zt >>> 13), - (zt &= 8191), - (jt = wt), - (jt += Pt * Kr), - (jt += It * Yr), - (jt += yt * (5 * gn)), - (jt += nt * (5 * kn)), - (jt += it * (5 * cn)), - (wt = jt >>> 13), - (jt &= 8191), - (jt += _t * (5 * Tn)), - (jt += ht * (5 * ii)), - (jt += mt * (5 * mn)), - (jt += Nt * (5 * Ce)), - (jt += hr * (5 * or)), - (wt += jt >>> 13), - (jt &= 8191), - (Ht = wt), - (Ht += Pt * or), - (Ht += It * Kr), - (Ht += yt * Yr), - (Ht += nt * (5 * gn)), - (Ht += it * (5 * kn)), - (wt = Ht >>> 13), - (Ht &= 8191), - (Ht += _t * (5 * cn)), - (Ht += ht * (5 * Tn)), - (Ht += mt * (5 * ii)), - (Ht += Nt * (5 * mn)), - (Ht += hr * (5 * Ce)), - (wt += Ht >>> 13), - (Ht &= 8191), - (Ut = wt), - (Ut += Pt * Ce), - (Ut += It * or), - (Ut += yt * Kr), - (Ut += nt * Yr), - (Ut += it * (5 * gn)), - (wt = Ut >>> 13), - (Ut &= 8191), - (Ut += _t * (5 * kn)), - (Ut += ht * (5 * cn)), - (Ut += mt * (5 * Tn)), - (Ut += Nt * (5 * ii)), - (Ut += hr * (5 * mn)), - (wt += Ut >>> 13), - (Ut &= 8191), - (Kt = wt), - (Kt += Pt * mn), - (Kt += It * Ce), - (Kt += yt * or), - (Kt += nt * Kr), - (Kt += it * Yr), - (wt = Kt >>> 13), - (Kt &= 8191), - (Kt += _t * (5 * gn)), - (Kt += ht * (5 * kn)), - (Kt += mt * (5 * cn)), - (Kt += Nt * (5 * Tn)), - (Kt += hr * (5 * ii)), - (wt += Kt >>> 13), - (Kt &= 8191), - (Ot = wt), - (Ot += Pt * ii), - (Ot += It * mn), - (Ot += yt * Ce), - (Ot += nt * or), - (Ot += it * Kr), - (wt = Ot >>> 13), - (Ot &= 8191), - (Ot += _t * Yr), - (Ot += ht * (5 * gn)), - (Ot += mt * (5 * kn)), - (Ot += Nt * (5 * cn)), - (Ot += hr * (5 * Tn)), - (wt += Ot >>> 13), - (Ot &= 8191), - (Bt = wt), - (Bt += Pt * Tn), - (Bt += It * ii), - (Bt += yt * mn), - (Bt += nt * Ce), - (Bt += it * or), - (wt = Bt >>> 13), - (Bt &= 8191), - (Bt += _t * Kr), - (Bt += ht * Yr), - (Bt += mt * (5 * gn)), - (Bt += Nt * (5 * kn)), - (Bt += hr * (5 * cn)), - (wt += Bt >>> 13), - (Bt &= 8191), - (Et = wt), - (Et += Pt * cn), - (Et += It * Tn), - (Et += yt * ii), - (Et += nt * mn), - (Et += it * Ce), - (wt = Et >>> 13), - (Et &= 8191), - (Et += _t * or), - (Et += ht * Kr), - (Et += mt * Yr), - (Et += Nt * (5 * gn)), - (Et += hr * (5 * kn)), - (wt += Et >>> 13), - (Et &= 8191), - (Mt = wt), - (Mt += Pt * kn), - (Mt += It * cn), - (Mt += yt * Tn), - (Mt += nt * ii), - (Mt += it * mn), - (wt = Mt >>> 13), - (Mt &= 8191), - (Mt += _t * Ce), - (Mt += ht * or), - (Mt += mt * Kr), - (Mt += Nt * Yr), - (Mt += hr * (5 * gn)), - (wt += Mt >>> 13), - (Mt &= 8191), - (gt = wt), - (gt += Pt * gn), - (gt += It * kn), - (gt += yt * cn), - (gt += nt * Tn), - (gt += it * ii), - (wt = gt >>> 13), - (gt &= 8191), - (gt += _t * mn), - (gt += ht * Ce), - (gt += mt * or), - (gt += Nt * Kr), - (gt += hr * Yr), - (wt += gt >>> 13), - (gt &= 8191), - (wt = ((wt << 2) + wt) | 0), - (wt = (wt + zt) | 0), - (zt = wt & 8191), - (wt = wt >>> 13), - (jt += wt), - (Pt = zt), - (It = jt), - (yt = Ht), - (nt = Ut), - (it = Kt), - (_t = Ot), - (ht = Bt), - (mt = Et), - (Nt = Mt), - (hr = gt), - (ie += 16), - (re -= 16); - (this.h[0] = Pt), - (this.h[1] = It), - (this.h[2] = yt), - (this.h[3] = nt), - (this.h[4] = it), - (this.h[5] = _t), - (this.h[6] = ht), - (this.h[7] = mt), - (this.h[8] = Nt), - (this.h[9] = hr); - }), - (A.prototype.finish = function (oe, ie) { - var re = new Uint16Array(10), - U, - se, - be, - Qe; - if (this.leftover) { - for (Qe = this.leftover, this.buffer[Qe++] = 1; Qe < 16; Qe++) - this.buffer[Qe] = 0; - (this.fin = 1), this.blocks(this.buffer, 0, 16); - } - for (U = this.h[1] >>> 13, this.h[1] &= 8191, Qe = 2; Qe < 10; Qe++) - (this.h[Qe] += U), (U = this.h[Qe] >>> 13), (this.h[Qe] &= 8191); - for ( - this.h[0] += U * 5, - U = this.h[0] >>> 13, - this.h[0] &= 8191, - this.h[1] += U, - U = this.h[1] >>> 13, - this.h[1] &= 8191, - this.h[2] += U, - re[0] = this.h[0] + 5, - U = re[0] >>> 13, - re[0] &= 8191, - Qe = 1; - Qe < 10; - Qe++ - ) - (re[Qe] = this.h[Qe] + U), (U = re[Qe] >>> 13), (re[Qe] &= 8191); - for (re[9] -= 1 << 13, se = (U ^ 1) - 1, Qe = 0; Qe < 10; Qe++) - re[Qe] &= se; - for (se = ~se, Qe = 0; Qe < 10; Qe++) - this.h[Qe] = (this.h[Qe] & se) | re[Qe]; - for ( - this.h[0] = (this.h[0] | (this.h[1] << 13)) & 65535, - this.h[1] = ((this.h[1] >>> 3) | (this.h[2] << 10)) & 65535, - this.h[2] = ((this.h[2] >>> 6) | (this.h[3] << 7)) & 65535, - this.h[3] = ((this.h[3] >>> 9) | (this.h[4] << 4)) & 65535, - this.h[4] = - ((this.h[4] >>> 12) | (this.h[5] << 1) | (this.h[6] << 14)) & - 65535, - this.h[5] = ((this.h[6] >>> 2) | (this.h[7] << 11)) & 65535, - this.h[6] = ((this.h[7] >>> 5) | (this.h[8] << 8)) & 65535, - this.h[7] = ((this.h[8] >>> 8) | (this.h[9] << 5)) & 65535, - be = this.h[0] + this.pad[0], - this.h[0] = be & 65535, - Qe = 1; - Qe < 8; - Qe++ - ) - (be = (((this.h[Qe] + this.pad[Qe]) | 0) + (be >>> 16)) | 0), - (this.h[Qe] = be & 65535); - (oe[ie + 0] = (this.h[0] >>> 0) & 255), - (oe[ie + 1] = (this.h[0] >>> 8) & 255), - (oe[ie + 2] = (this.h[1] >>> 0) & 255), - (oe[ie + 3] = (this.h[1] >>> 8) & 255), - (oe[ie + 4] = (this.h[2] >>> 0) & 255), - (oe[ie + 5] = (this.h[2] >>> 8) & 255), - (oe[ie + 6] = (this.h[3] >>> 0) & 255), - (oe[ie + 7] = (this.h[3] >>> 8) & 255), - (oe[ie + 8] = (this.h[4] >>> 0) & 255), - (oe[ie + 9] = (this.h[4] >>> 8) & 255), - (oe[ie + 10] = (this.h[5] >>> 0) & 255), - (oe[ie + 11] = (this.h[5] >>> 8) & 255), - (oe[ie + 12] = (this.h[6] >>> 0) & 255), - (oe[ie + 13] = (this.h[6] >>> 8) & 255), - (oe[ie + 14] = (this.h[7] >>> 0) & 255), - (oe[ie + 15] = (this.h[7] >>> 8) & 255); - }), - (A.prototype.update = function (oe, ie, re) { - var U, se; - if (this.leftover) { - for ( - se = 16 - this.leftover, se > re && (se = re), U = 0; - U < se; - U++ - ) - this.buffer[this.leftover + U] = oe[ie + U]; - if ( - ((re -= se), - (ie += se), - (this.leftover += se), - this.leftover < 16) - ) - return; - this.blocks(this.buffer, 0, 16), (this.leftover = 0); - } - if ( - (re >= 16 && - ((se = re - (re % 16)), - this.blocks(oe, ie, se), - (ie += se), - (re -= se)), - re) - ) { - for (U = 0; U < re; U++) - this.buffer[this.leftover + U] = oe[ie + U]; - this.leftover += re; - } - }); - function l(oe, ie, re, U, se, be) { - var Qe = new A(be); - return Qe.update(re, U, se), Qe.finish(oe, ie), 0; - } - function p(oe, ie, re, U, se, be) { - var Qe = new Uint8Array(16); - return l(Qe, 0, re, U, se, be), D(oe, ie, Qe, 0); - } - function y(oe, ie, re, U, se) { - var be; - if (re < 32) return -1; - for ( - ne(oe, 0, ie, 0, re, U, se), l(oe, 16, oe, 32, re - 32, oe), be = 0; - be < 16; - be++ - ) - oe[be] = 0; - return 0; - } - function d(oe, ie, re, U, se) { - var be, - Qe = new Uint8Array(32); - if ( - re < 32 || - (te(Qe, 0, 32, U, se), p(ie, 16, ie, 32, re - 32, Qe) !== 0) - ) - return -1; - for (ne(oe, 0, ie, 0, re, U, se), be = 0; be < 32; be++) oe[be] = 0; - return 0; - } - function v(oe, ie) { - var re; - for (re = 0; re < 16; re++) oe[re] = ie[re] | 0; - } - function _(oe) { - var ie, - re, - U = 1; - for (ie = 0; ie < 16; ie++) - (re = oe[ie] + U + 65535), - (U = Math.floor(re / 65536)), - (oe[ie] = re - U * 65536); - oe[0] += U - 1 + 37 * (U - 1); - } - function S(oe, ie, re) { - for (var U, se = ~(re - 1), be = 0; be < 16; be++) - (U = se & (oe[be] ^ ie[be])), (oe[be] ^= U), (ie[be] ^= U); - } - function b(oe, ie) { - var re, - U, - se, - be = e(), - Qe = e(); - for (re = 0; re < 16; re++) Qe[re] = ie[re]; - for (_(Qe), _(Qe), _(Qe), U = 0; U < 2; U++) { - for (be[0] = Qe[0] - 65517, re = 1; re < 15; re++) - (be[re] = Qe[re] - 65535 - ((be[re - 1] >> 16) & 1)), - (be[re - 1] &= 65535); - (be[15] = Qe[15] - 32767 - ((be[14] >> 16) & 1)), - (se = (be[15] >> 16) & 1), - (be[14] &= 65535), - S(Qe, be, 1 - se); - } - for (re = 0; re < 16; re++) - (oe[2 * re] = Qe[re] & 255), (oe[2 * re + 1] = Qe[re] >> 8); - } - function f(oe, ie) { - var re = new Uint8Array(32), - U = new Uint8Array(32); - return b(re, oe), b(U, ie), F(re, 0, U, 0); - } - function x(oe) { - var ie = new Uint8Array(32); - return b(ie, oe), ie[0] & 1; - } - function C(oe, ie) { - var re; - for (re = 0; re < 16; re++) oe[re] = ie[2 * re] + (ie[2 * re + 1] << 8); - oe[15] &= 32767; - } - function E(oe, ie, re) { - for (var U = 0; U < 16; U++) oe[U] = ie[U] + re[U]; - } - function B(oe, ie, re) { - for (var U = 0; U < 16; U++) oe[U] = ie[U] - re[U]; - } - function G(oe, ie, re) { - var U, - se, - be = 0, - Qe = 0, - Ae = 0, - ke = 0, - Ct = 0, - ut = 0, - St = 0, - wt = 0, - zt = 0, - jt = 0, - Ht = 0, - Ut = 0, - Kt = 0, - Ot = 0, - Bt = 0, - Et = 0, - Mt = 0, - gt = 0, - Pt = 0, - It = 0, - yt = 0, - nt = 0, - it = 0, - _t = 0, - ht = 0, - mt = 0, - Nt = 0, - hr = 0, - Yr = 0, - Kr = 0, - or = 0, - Ce = re[0], - mn = re[1], - ii = re[2], - Tn = re[3], - cn = re[4], - kn = re[5], - gn = re[6], - zo = re[7], - yi = re[8], - qi = re[9], - Xo = re[10], - Yo = re[11], - Xa = re[12], - yu = re[13], - ys = re[14], - ms = re[15]; - (U = ie[0]), - (be += U * Ce), - (Qe += U * mn), - (Ae += U * ii), - (ke += U * Tn), - (Ct += U * cn), - (ut += U * kn), - (St += U * gn), - (wt += U * zo), - (zt += U * yi), - (jt += U * qi), - (Ht += U * Xo), - (Ut += U * Yo), - (Kt += U * Xa), - (Ot += U * yu), - (Bt += U * ys), - (Et += U * ms), - (U = ie[1]), - (Qe += U * Ce), - (Ae += U * mn), - (ke += U * ii), - (Ct += U * Tn), - (ut += U * cn), - (St += U * kn), - (wt += U * gn), - (zt += U * zo), - (jt += U * yi), - (Ht += U * qi), - (Ut += U * Xo), - (Kt += U * Yo), - (Ot += U * Xa), - (Bt += U * yu), - (Et += U * ys), - (Mt += U * ms), - (U = ie[2]), - (Ae += U * Ce), - (ke += U * mn), - (Ct += U * ii), - (ut += U * Tn), - (St += U * cn), - (wt += U * kn), - (zt += U * gn), - (jt += U * zo), - (Ht += U * yi), - (Ut += U * qi), - (Kt += U * Xo), - (Ot += U * Yo), - (Bt += U * Xa), - (Et += U * yu), - (Mt += U * ys), - (gt += U * ms), - (U = ie[3]), - (ke += U * Ce), - (Ct += U * mn), - (ut += U * ii), - (St += U * Tn), - (wt += U * cn), - (zt += U * kn), - (jt += U * gn), - (Ht += U * zo), - (Ut += U * yi), - (Kt += U * qi), - (Ot += U * Xo), - (Bt += U * Yo), - (Et += U * Xa), - (Mt += U * yu), - (gt += U * ys), - (Pt += U * ms), - (U = ie[4]), - (Ct += U * Ce), - (ut += U * mn), - (St += U * ii), - (wt += U * Tn), - (zt += U * cn), - (jt += U * kn), - (Ht += U * gn), - (Ut += U * zo), - (Kt += U * yi), - (Ot += U * qi), - (Bt += U * Xo), - (Et += U * Yo), - (Mt += U * Xa), - (gt += U * yu), - (Pt += U * ys), - (It += U * ms), - (U = ie[5]), - (ut += U * Ce), - (St += U * mn), - (wt += U * ii), - (zt += U * Tn), - (jt += U * cn), - (Ht += U * kn), - (Ut += U * gn), - (Kt += U * zo), - (Ot += U * yi), - (Bt += U * qi), - (Et += U * Xo), - (Mt += U * Yo), - (gt += U * Xa), - (Pt += U * yu), - (It += U * ys), - (yt += U * ms), - (U = ie[6]), - (St += U * Ce), - (wt += U * mn), - (zt += U * ii), - (jt += U * Tn), - (Ht += U * cn), - (Ut += U * kn), - (Kt += U * gn), - (Ot += U * zo), - (Bt += U * yi), - (Et += U * qi), - (Mt += U * Xo), - (gt += U * Yo), - (Pt += U * Xa), - (It += U * yu), - (yt += U * ys), - (nt += U * ms), - (U = ie[7]), - (wt += U * Ce), - (zt += U * mn), - (jt += U * ii), - (Ht += U * Tn), - (Ut += U * cn), - (Kt += U * kn), - (Ot += U * gn), - (Bt += U * zo), - (Et += U * yi), - (Mt += U * qi), - (gt += U * Xo), - (Pt += U * Yo), - (It += U * Xa), - (yt += U * yu), - (nt += U * ys), - (it += U * ms), - (U = ie[8]), - (zt += U * Ce), - (jt += U * mn), - (Ht += U * ii), - (Ut += U * Tn), - (Kt += U * cn), - (Ot += U * kn), - (Bt += U * gn), - (Et += U * zo), - (Mt += U * yi), - (gt += U * qi), - (Pt += U * Xo), - (It += U * Yo), - (yt += U * Xa), - (nt += U * yu), - (it += U * ys), - (_t += U * ms), - (U = ie[9]), - (jt += U * Ce), - (Ht += U * mn), - (Ut += U * ii), - (Kt += U * Tn), - (Ot += U * cn), - (Bt += U * kn), - (Et += U * gn), - (Mt += U * zo), - (gt += U * yi), - (Pt += U * qi), - (It += U * Xo), - (yt += U * Yo), - (nt += U * Xa), - (it += U * yu), - (_t += U * ys), - (ht += U * ms), - (U = ie[10]), - (Ht += U * Ce), - (Ut += U * mn), - (Kt += U * ii), - (Ot += U * Tn), - (Bt += U * cn), - (Et += U * kn), - (Mt += U * gn), - (gt += U * zo), - (Pt += U * yi), - (It += U * qi), - (yt += U * Xo), - (nt += U * Yo), - (it += U * Xa), - (_t += U * yu), - (ht += U * ys), - (mt += U * ms), - (U = ie[11]), - (Ut += U * Ce), - (Kt += U * mn), - (Ot += U * ii), - (Bt += U * Tn), - (Et += U * cn), - (Mt += U * kn), - (gt += U * gn), - (Pt += U * zo), - (It += U * yi), - (yt += U * qi), - (nt += U * Xo), - (it += U * Yo), - (_t += U * Xa), - (ht += U * yu), - (mt += U * ys), - (Nt += U * ms), - (U = ie[12]), - (Kt += U * Ce), - (Ot += U * mn), - (Bt += U * ii), - (Et += U * Tn), - (Mt += U * cn), - (gt += U * kn), - (Pt += U * gn), - (It += U * zo), - (yt += U * yi), - (nt += U * qi), - (it += U * Xo), - (_t += U * Yo), - (ht += U * Xa), - (mt += U * yu), - (Nt += U * ys), - (hr += U * ms), - (U = ie[13]), - (Ot += U * Ce), - (Bt += U * mn), - (Et += U * ii), - (Mt += U * Tn), - (gt += U * cn), - (Pt += U * kn), - (It += U * gn), - (yt += U * zo), - (nt += U * yi), - (it += U * qi), - (_t += U * Xo), - (ht += U * Yo), - (mt += U * Xa), - (Nt += U * yu), - (hr += U * ys), - (Yr += U * ms), - (U = ie[14]), - (Bt += U * Ce), - (Et += U * mn), - (Mt += U * ii), - (gt += U * Tn), - (Pt += U * cn), - (It += U * kn), - (yt += U * gn), - (nt += U * zo), - (it += U * yi), - (_t += U * qi), - (ht += U * Xo), - (mt += U * Yo), - (Nt += U * Xa), - (hr += U * yu), - (Yr += U * ys), - (Kr += U * ms), - (U = ie[15]), - (Et += U * Ce), - (Mt += U * mn), - (gt += U * ii), - (Pt += U * Tn), - (It += U * cn), - (yt += U * kn), - (nt += U * gn), - (it += U * zo), - (_t += U * yi), - (ht += U * qi), - (mt += U * Xo), - (Nt += U * Yo), - (hr += U * Xa), - (Yr += U * yu), - (Kr += U * ys), - (or += U * ms), - (be += 38 * Mt), - (Qe += 38 * gt), - (Ae += 38 * Pt), - (ke += 38 * It), - (Ct += 38 * yt), - (ut += 38 * nt), - (St += 38 * it), - (wt += 38 * _t), - (zt += 38 * ht), - (jt += 38 * mt), - (Ht += 38 * Nt), - (Ut += 38 * hr), - (Kt += 38 * Yr), - (Ot += 38 * Kr), - (Bt += 38 * or), - (se = 1), - (U = be + se + 65535), - (se = Math.floor(U / 65536)), - (be = U - se * 65536), - (U = Qe + se + 65535), - (se = Math.floor(U / 65536)), - (Qe = U - se * 65536), - (U = Ae + se + 65535), - (se = Math.floor(U / 65536)), - (Ae = U - se * 65536), - (U = ke + se + 65535), - (se = Math.floor(U / 65536)), - (ke = U - se * 65536), - (U = Ct + se + 65535), - (se = Math.floor(U / 65536)), - (Ct = U - se * 65536), - (U = ut + se + 65535), - (se = Math.floor(U / 65536)), - (ut = U - se * 65536), - (U = St + se + 65535), - (se = Math.floor(U / 65536)), - (St = U - se * 65536), - (U = wt + se + 65535), - (se = Math.floor(U / 65536)), - (wt = U - se * 65536), - (U = zt + se + 65535), - (se = Math.floor(U / 65536)), - (zt = U - se * 65536), - (U = jt + se + 65535), - (se = Math.floor(U / 65536)), - (jt = U - se * 65536), - (U = Ht + se + 65535), - (se = Math.floor(U / 65536)), - (Ht = U - se * 65536), - (U = Ut + se + 65535), - (se = Math.floor(U / 65536)), - (Ut = U - se * 65536), - (U = Kt + se + 65535), - (se = Math.floor(U / 65536)), - (Kt = U - se * 65536), - (U = Ot + se + 65535), - (se = Math.floor(U / 65536)), - (Ot = U - se * 65536), - (U = Bt + se + 65535), - (se = Math.floor(U / 65536)), - (Bt = U - se * 65536), - (U = Et + se + 65535), - (se = Math.floor(U / 65536)), - (Et = U - se * 65536), - (be += se - 1 + 37 * (se - 1)), - (se = 1), - (U = be + se + 65535), - (se = Math.floor(U / 65536)), - (be = U - se * 65536), - (U = Qe + se + 65535), - (se = Math.floor(U / 65536)), - (Qe = U - se * 65536), - (U = Ae + se + 65535), - (se = Math.floor(U / 65536)), - (Ae = U - se * 65536), - (U = ke + se + 65535), - (se = Math.floor(U / 65536)), - (ke = U - se * 65536), - (U = Ct + se + 65535), - (se = Math.floor(U / 65536)), - (Ct = U - se * 65536), - (U = ut + se + 65535), - (se = Math.floor(U / 65536)), - (ut = U - se * 65536), - (U = St + se + 65535), - (se = Math.floor(U / 65536)), - (St = U - se * 65536), - (U = wt + se + 65535), - (se = Math.floor(U / 65536)), - (wt = U - se * 65536), - (U = zt + se + 65535), - (se = Math.floor(U / 65536)), - (zt = U - se * 65536), - (U = jt + se + 65535), - (se = Math.floor(U / 65536)), - (jt = U - se * 65536), - (U = Ht + se + 65535), - (se = Math.floor(U / 65536)), - (Ht = U - se * 65536), - (U = Ut + se + 65535), - (se = Math.floor(U / 65536)), - (Ut = U - se * 65536), - (U = Kt + se + 65535), - (se = Math.floor(U / 65536)), - (Kt = U - se * 65536), - (U = Ot + se + 65535), - (se = Math.floor(U / 65536)), - (Ot = U - se * 65536), - (U = Bt + se + 65535), - (se = Math.floor(U / 65536)), - (Bt = U - se * 65536), - (U = Et + se + 65535), - (se = Math.floor(U / 65536)), - (Et = U - se * 65536), - (be += se - 1 + 37 * (se - 1)), - (oe[0] = be), - (oe[1] = Qe), - (oe[2] = Ae), - (oe[3] = ke), - (oe[4] = Ct), - (oe[5] = ut), - (oe[6] = St), - (oe[7] = wt), - (oe[8] = zt), - (oe[9] = jt), - (oe[10] = Ht), - (oe[11] = Ut), - (oe[12] = Kt), - (oe[13] = Ot), - (oe[14] = Bt), - (oe[15] = Et); - } - function L(oe, ie) { - G(oe, ie, ie); - } - function ee(oe, ie) { - var re = e(), - U; - for (U = 0; U < 16; U++) re[U] = ie[U]; - for (U = 253; U >= 0; U--) - L(re, re), U !== 2 && U !== 4 && G(re, re, ie); - for (U = 0; U < 16; U++) oe[U] = re[U]; - } - function ge(oe, ie) { - var re = e(), - U; - for (U = 0; U < 16; U++) re[U] = ie[U]; - for (U = 250; U >= 0; U--) L(re, re), U !== 1 && G(re, re, ie); - for (U = 0; U < 16; U++) oe[U] = re[U]; - } - function fe(oe, ie, re) { - var U = new Uint8Array(32), - se = new Float64Array(80), - be, - Qe, - Ae = e(), - ke = e(), - Ct = e(), - ut = e(), - St = e(), - wt = e(); - for (Qe = 0; Qe < 31; Qe++) U[Qe] = ie[Qe]; - for ( - U[31] = (ie[31] & 127) | 64, U[0] &= 248, C(se, re), Qe = 0; - Qe < 16; - Qe++ - ) - (ke[Qe] = se[Qe]), (ut[Qe] = Ae[Qe] = Ct[Qe] = 0); - for (Ae[0] = ut[0] = 1, Qe = 254; Qe >= 0; --Qe) - (be = (U[Qe >>> 3] >>> (Qe & 7)) & 1), - S(Ae, ke, be), - S(Ct, ut, be), - E(St, Ae, Ct), - B(Ae, Ae, Ct), - E(Ct, ke, ut), - B(ke, ke, ut), - L(ut, St), - L(wt, Ae), - G(Ae, Ct, Ae), - G(Ct, ke, St), - E(St, Ae, Ct), - B(Ae, Ae, Ct), - L(ke, Ae), - B(Ct, ut, wt), - G(Ae, Ct, s), - E(Ae, Ae, ut), - G(Ct, Ct, Ae), - G(Ae, ut, wt), - G(ut, ke, se), - L(ke, St), - S(Ae, ke, be), - S(Ct, ut, be); - for (Qe = 0; Qe < 16; Qe++) - (se[Qe + 16] = Ae[Qe]), - (se[Qe + 32] = Ct[Qe]), - (se[Qe + 48] = ke[Qe]), - (se[Qe + 64] = ut[Qe]); - var zt = se.subarray(32), - jt = se.subarray(16); - return ee(zt, zt), G(jt, jt, zt), b(oe, jt), 0; - } - function V(oe, ie) { - return fe(oe, ie, i); - } - function ye(oe, ie) { - return r(ie, 32), V(oe, ie); - } - function ae(oe, ie, re) { - var U = new Uint8Array(32); - return fe(U, re, ie), H(oe, n, U, Z); - } - var le = y, - Me = d; - function de(oe, ie, re, U, se, be) { - var Qe = new Uint8Array(32); - return ae(Qe, se, be), le(oe, ie, re, U, Qe); - } - function ve(oe, ie, re, U, se, be) { - var Qe = new Uint8Array(32); - return ae(Qe, se, be), Me(oe, ie, re, U, Qe); - } - var De = [ - 1116352408, 3609767458, 1899447441, 602891725, 3049323471, 3964484399, - 3921009573, 2173295548, 961987163, 4081628472, 1508970993, 3053834265, - 2453635748, 2937671579, 2870763221, 3664609560, 3624381080, 2734883394, - 310598401, 1164996542, 607225278, 1323610764, 1426881987, 3590304994, - 1925078388, 4068182383, 2162078206, 991336113, 2614888103, 633803317, - 3248222580, 3479774868, 3835390401, 2666613458, 4022224774, 944711139, - 264347078, 2341262773, 604807628, 2007800933, 770255983, 1495990901, - 1249150122, 1856431235, 1555081692, 3175218132, 1996064986, 2198950837, - 2554220882, 3999719339, 2821834349, 766784016, 2952996808, 2566594879, - 3210313671, 3203337956, 3336571891, 1034457026, 3584528711, 2466948901, - 113926993, 3758326383, 338241895, 168717936, 666307205, 1188179964, - 773529912, 1546045734, 1294757372, 1522805485, 1396182291, 2643833823, - 1695183700, 2343527390, 1986661051, 1014477480, 2177026350, 1206759142, - 2456956037, 344077627, 2730485921, 1290863460, 2820302411, 3158454273, - 3259730800, 3505952657, 3345764771, 106217008, 3516065817, 3606008344, - 3600352804, 1432725776, 4094571909, 1467031594, 275423344, 851169720, - 430227734, 3100823752, 506948616, 1363258195, 659060556, 3750685593, - 883997877, 3785050280, 958139571, 3318307427, 1322822218, 3812723403, - 1537002063, 2003034995, 1747873779, 3602036899, 1955562222, 1575990012, - 2024104815, 1125592928, 2227730452, 2716904306, 2361852424, 442776044, - 2428436474, 593698344, 2756734187, 3733110249, 3204031479, 2999351573, - 3329325298, 3815920427, 3391569614, 3928383900, 3515267271, 566280711, - 3940187606, 3454069534, 4118630271, 4000239992, 116418474, 1914138554, - 174292421, 2731055270, 289380356, 3203993006, 460393269, 320620315, - 685471733, 587496836, 852142971, 1086792851, 1017036298, 365543100, - 1126000580, 2618297676, 1288033470, 3409855158, 1501505948, 4234509866, - 1607167915, 987167468, 1816402316, 1246189591, - ]; - function me(oe, ie, re, U) { - for ( - var se = new Int32Array(16), - be = new Int32Array(16), - Qe, - Ae, - ke, - Ct, - ut, - St, - wt, - zt, - jt, - Ht, - Ut, - Kt, - Ot, - Bt, - Et, - Mt, - gt, - Pt, - It, - yt, - nt, - it, - _t, - ht, - mt, - Nt, - hr = oe[0], - Yr = oe[1], - Kr = oe[2], - or = oe[3], - Ce = oe[4], - mn = oe[5], - ii = oe[6], - Tn = oe[7], - cn = ie[0], - kn = ie[1], - gn = ie[2], - zo = ie[3], - yi = ie[4], - qi = ie[5], - Xo = ie[6], - Yo = ie[7], - Xa = 0; - U >= 128; - - ) { - for (It = 0; It < 16; It++) - (yt = 8 * It + Xa), - (se[It] = - (re[yt + 0] << 24) | - (re[yt + 1] << 16) | - (re[yt + 2] << 8) | - re[yt + 3]), - (be[It] = - (re[yt + 4] << 24) | - (re[yt + 5] << 16) | - (re[yt + 6] << 8) | - re[yt + 7]); - for (It = 0; It < 80; It++) - if ( - ((Qe = hr), - (Ae = Yr), - (ke = Kr), - (Ct = or), - (ut = Ce), - (St = mn), - (wt = ii), - (zt = Tn), - (jt = cn), - (Ht = kn), - (Ut = gn), - (Kt = zo), - (Ot = yi), - (Bt = qi), - (Et = Xo), - (Mt = Yo), - (nt = Tn), - (it = Yo), - (_t = it & 65535), - (ht = it >>> 16), - (mt = nt & 65535), - (Nt = nt >>> 16), - (nt = - ((Ce >>> 14) | (yi << (32 - 14))) ^ - ((Ce >>> 18) | (yi << (32 - 18))) ^ - ((yi >>> (41 - 32)) | (Ce << (32 - (41 - 32))))), - (it = - ((yi >>> 14) | (Ce << (32 - 14))) ^ - ((yi >>> 18) | (Ce << (32 - 18))) ^ - ((Ce >>> (41 - 32)) | (yi << (32 - (41 - 32))))), - (_t += it & 65535), - (ht += it >>> 16), - (mt += nt & 65535), - (Nt += nt >>> 16), - (nt = (Ce & mn) ^ (~Ce & ii)), - (it = (yi & qi) ^ (~yi & Xo)), - (_t += it & 65535), - (ht += it >>> 16), - (mt += nt & 65535), - (Nt += nt >>> 16), - (nt = De[It * 2]), - (it = De[It * 2 + 1]), - (_t += it & 65535), - (ht += it >>> 16), - (mt += nt & 65535), - (Nt += nt >>> 16), - (nt = se[It % 16]), - (it = be[It % 16]), - (_t += it & 65535), - (ht += it >>> 16), - (mt += nt & 65535), - (Nt += nt >>> 16), - (ht += _t >>> 16), - (mt += ht >>> 16), - (Nt += mt >>> 16), - (gt = (mt & 65535) | (Nt << 16)), - (Pt = (_t & 65535) | (ht << 16)), - (nt = gt), - (it = Pt), - (_t = it & 65535), - (ht = it >>> 16), - (mt = nt & 65535), - (Nt = nt >>> 16), - (nt = - ((hr >>> 28) | (cn << (32 - 28))) ^ - ((cn >>> (34 - 32)) | (hr << (32 - (34 - 32)))) ^ - ((cn >>> (39 - 32)) | (hr << (32 - (39 - 32))))), - (it = - ((cn >>> 28) | (hr << (32 - 28))) ^ - ((hr >>> (34 - 32)) | (cn << (32 - (34 - 32)))) ^ - ((hr >>> (39 - 32)) | (cn << (32 - (39 - 32))))), - (_t += it & 65535), - (ht += it >>> 16), - (mt += nt & 65535), - (Nt += nt >>> 16), - (nt = (hr & Yr) ^ (hr & Kr) ^ (Yr & Kr)), - (it = (cn & kn) ^ (cn & gn) ^ (kn & gn)), - (_t += it & 65535), - (ht += it >>> 16), - (mt += nt & 65535), - (Nt += nt >>> 16), - (ht += _t >>> 16), - (mt += ht >>> 16), - (Nt += mt >>> 16), - (zt = (mt & 65535) | (Nt << 16)), - (Mt = (_t & 65535) | (ht << 16)), - (nt = Ct), - (it = Kt), - (_t = it & 65535), - (ht = it >>> 16), - (mt = nt & 65535), - (Nt = nt >>> 16), - (nt = gt), - (it = Pt), - (_t += it & 65535), - (ht += it >>> 16), - (mt += nt & 65535), - (Nt += nt >>> 16), - (ht += _t >>> 16), - (mt += ht >>> 16), - (Nt += mt >>> 16), - (Ct = (mt & 65535) | (Nt << 16)), - (Kt = (_t & 65535) | (ht << 16)), - (Yr = Qe), - (Kr = Ae), - (or = ke), - (Ce = Ct), - (mn = ut), - (ii = St), - (Tn = wt), - (hr = zt), - (kn = jt), - (gn = Ht), - (zo = Ut), - (yi = Kt), - (qi = Ot), - (Xo = Bt), - (Yo = Et), - (cn = Mt), - It % 16 === 15) - ) - for (yt = 0; yt < 16; yt++) - (nt = se[yt]), - (it = be[yt]), - (_t = it & 65535), - (ht = it >>> 16), - (mt = nt & 65535), - (Nt = nt >>> 16), - (nt = se[(yt + 9) % 16]), - (it = be[(yt + 9) % 16]), - (_t += it & 65535), - (ht += it >>> 16), - (mt += nt & 65535), - (Nt += nt >>> 16), - (gt = se[(yt + 1) % 16]), - (Pt = be[(yt + 1) % 16]), - (nt = - ((gt >>> 1) | (Pt << (32 - 1))) ^ - ((gt >>> 8) | (Pt << (32 - 8))) ^ - (gt >>> 7)), - (it = - ((Pt >>> 1) | (gt << (32 - 1))) ^ - ((Pt >>> 8) | (gt << (32 - 8))) ^ - ((Pt >>> 7) | (gt << (32 - 7)))), - (_t += it & 65535), - (ht += it >>> 16), - (mt += nt & 65535), - (Nt += nt >>> 16), - (gt = se[(yt + 14) % 16]), - (Pt = be[(yt + 14) % 16]), - (nt = - ((gt >>> 19) | (Pt << (32 - 19))) ^ - ((Pt >>> (61 - 32)) | (gt << (32 - (61 - 32)))) ^ - (gt >>> 6)), - (it = - ((Pt >>> 19) | (gt << (32 - 19))) ^ - ((gt >>> (61 - 32)) | (Pt << (32 - (61 - 32)))) ^ - ((Pt >>> 6) | (gt << (32 - 6)))), - (_t += it & 65535), - (ht += it >>> 16), - (mt += nt & 65535), - (Nt += nt >>> 16), - (ht += _t >>> 16), - (mt += ht >>> 16), - (Nt += mt >>> 16), - (se[yt] = (mt & 65535) | (Nt << 16)), - (be[yt] = (_t & 65535) | (ht << 16)); - (nt = hr), - (it = cn), - (_t = it & 65535), - (ht = it >>> 16), - (mt = nt & 65535), - (Nt = nt >>> 16), - (nt = oe[0]), - (it = ie[0]), - (_t += it & 65535), - (ht += it >>> 16), - (mt += nt & 65535), - (Nt += nt >>> 16), - (ht += _t >>> 16), - (mt += ht >>> 16), - (Nt += mt >>> 16), - (oe[0] = hr = (mt & 65535) | (Nt << 16)), - (ie[0] = cn = (_t & 65535) | (ht << 16)), - (nt = Yr), - (it = kn), - (_t = it & 65535), - (ht = it >>> 16), - (mt = nt & 65535), - (Nt = nt >>> 16), - (nt = oe[1]), - (it = ie[1]), - (_t += it & 65535), - (ht += it >>> 16), - (mt += nt & 65535), - (Nt += nt >>> 16), - (ht += _t >>> 16), - (mt += ht >>> 16), - (Nt += mt >>> 16), - (oe[1] = Yr = (mt & 65535) | (Nt << 16)), - (ie[1] = kn = (_t & 65535) | (ht << 16)), - (nt = Kr), - (it = gn), - (_t = it & 65535), - (ht = it >>> 16), - (mt = nt & 65535), - (Nt = nt >>> 16), - (nt = oe[2]), - (it = ie[2]), - (_t += it & 65535), - (ht += it >>> 16), - (mt += nt & 65535), - (Nt += nt >>> 16), - (ht += _t >>> 16), - (mt += ht >>> 16), - (Nt += mt >>> 16), - (oe[2] = Kr = (mt & 65535) | (Nt << 16)), - (ie[2] = gn = (_t & 65535) | (ht << 16)), - (nt = or), - (it = zo), - (_t = it & 65535), - (ht = it >>> 16), - (mt = nt & 65535), - (Nt = nt >>> 16), - (nt = oe[3]), - (it = ie[3]), - (_t += it & 65535), - (ht += it >>> 16), - (mt += nt & 65535), - (Nt += nt >>> 16), - (ht += _t >>> 16), - (mt += ht >>> 16), - (Nt += mt >>> 16), - (oe[3] = or = (mt & 65535) | (Nt << 16)), - (ie[3] = zo = (_t & 65535) | (ht << 16)), - (nt = Ce), - (it = yi), - (_t = it & 65535), - (ht = it >>> 16), - (mt = nt & 65535), - (Nt = nt >>> 16), - (nt = oe[4]), - (it = ie[4]), - (_t += it & 65535), - (ht += it >>> 16), - (mt += nt & 65535), - (Nt += nt >>> 16), - (ht += _t >>> 16), - (mt += ht >>> 16), - (Nt += mt >>> 16), - (oe[4] = Ce = (mt & 65535) | (Nt << 16)), - (ie[4] = yi = (_t & 65535) | (ht << 16)), - (nt = mn), - (it = qi), - (_t = it & 65535), - (ht = it >>> 16), - (mt = nt & 65535), - (Nt = nt >>> 16), - (nt = oe[5]), - (it = ie[5]), - (_t += it & 65535), - (ht += it >>> 16), - (mt += nt & 65535), - (Nt += nt >>> 16), - (ht += _t >>> 16), - (mt += ht >>> 16), - (Nt += mt >>> 16), - (oe[5] = mn = (mt & 65535) | (Nt << 16)), - (ie[5] = qi = (_t & 65535) | (ht << 16)), - (nt = ii), - (it = Xo), - (_t = it & 65535), - (ht = it >>> 16), - (mt = nt & 65535), - (Nt = nt >>> 16), - (nt = oe[6]), - (it = ie[6]), - (_t += it & 65535), - (ht += it >>> 16), - (mt += nt & 65535), - (Nt += nt >>> 16), - (ht += _t >>> 16), - (mt += ht >>> 16), - (Nt += mt >>> 16), - (oe[6] = ii = (mt & 65535) | (Nt << 16)), - (ie[6] = Xo = (_t & 65535) | (ht << 16)), - (nt = Tn), - (it = Yo), - (_t = it & 65535), - (ht = it >>> 16), - (mt = nt & 65535), - (Nt = nt >>> 16), - (nt = oe[7]), - (it = ie[7]), - (_t += it & 65535), - (ht += it >>> 16), - (mt += nt & 65535), - (Nt += nt >>> 16), - (ht += _t >>> 16), - (mt += ht >>> 16), - (Nt += mt >>> 16), - (oe[7] = Tn = (mt & 65535) | (Nt << 16)), - (ie[7] = Yo = (_t & 65535) | (ht << 16)), - (Xa += 128), - (U -= 128); - } - return U; - } - function _e(oe, ie, re) { - var U = new Int32Array(8), - se = new Int32Array(8), - be = new Uint8Array(256), - Qe, - Ae = re; - for ( - U[0] = 1779033703, - U[1] = 3144134277, - U[2] = 1013904242, - U[3] = 2773480762, - U[4] = 1359893119, - U[5] = 2600822924, - U[6] = 528734635, - U[7] = 1541459225, - se[0] = 4089235720, - se[1] = 2227873595, - se[2] = 4271175723, - se[3] = 1595750129, - se[4] = 2917565137, - se[5] = 725511199, - se[6] = 4215389547, - se[7] = 327033209, - me(U, se, ie, re), - re %= 128, - Qe = 0; - Qe < re; - Qe++ - ) - be[Qe] = ie[Ae - re + Qe]; - for ( - be[re] = 128, - re = 256 - 128 * (re < 112 ? 1 : 0), - be[re - 9] = 0, - k(be, re - 8, (Ae / 536870912) | 0, Ae << 3), - me(U, se, be, re), - Qe = 0; - Qe < 8; - Qe++ - ) - k(oe, 8 * Qe, U[Qe], se[Qe]); - return 0; - } - function Ye(oe, ie) { - var re = e(), - U = e(), - se = e(), - be = e(), - Qe = e(), - Ae = e(), - ke = e(), - Ct = e(), - ut = e(); - B(re, oe[1], oe[0]), - B(ut, ie[1], ie[0]), - G(re, re, ut), - E(U, oe[0], oe[1]), - E(ut, ie[0], ie[1]), - G(U, U, ut), - G(se, oe[3], ie[3]), - G(se, se, u), - G(be, oe[2], ie[2]), - E(be, be, be), - B(Qe, U, re), - B(Ae, be, se), - E(ke, be, se), - E(Ct, U, re), - G(oe[0], Qe, Ae), - G(oe[1], Ct, ke), - G(oe[2], ke, Ae), - G(oe[3], Qe, Ct); - } - function Ee(oe, ie, re) { - var U; - for (U = 0; U < 4; U++) S(oe[U], ie[U], re); - } - function Be(oe, ie) { - var re = e(), - U = e(), - se = e(); - ee(se, ie[2]), - G(re, ie[0], se), - G(U, ie[1], se), - b(oe, U), - (oe[31] ^= x(re) << 7); - } - function kt(oe, ie, re) { - var U, se; - for ( - v(oe[0], o), v(oe[1], a), v(oe[2], a), v(oe[3], o), se = 255; - se >= 0; - --se - ) - (U = (re[(se / 8) | 0] >> (se & 7)) & 1), - Ee(oe, ie, U), - Ye(ie, oe), - Ye(oe, oe), - Ee(oe, ie, U); - } - function Ve(oe, ie) { - var re = [e(), e(), e(), e()]; - v(re[0], h), v(re[1], w), v(re[2], a), G(re[3], h, w), kt(oe, re, ie); - } - function We(oe, ie, re) { - var U = new Uint8Array(64), - se = [e(), e(), e(), e()], - be; - for ( - re || r(ie, 32), - _e(U, ie, 32), - U[0] &= 248, - U[31] &= 127, - U[31] |= 64, - Ve(se, U), - Be(oe, se), - be = 0; - be < 32; - be++ - ) - ie[be + 32] = oe[be]; - return 0; - } - var er = new Float64Array([ - 237, 211, 245, 92, 26, 99, 18, 88, 214, 156, 247, 162, 222, 249, 222, - 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, - ]); - function Ue(oe, ie) { - var re, U, se, be; - for (U = 63; U >= 32; --U) { - for (re = 0, se = U - 32, be = U - 12; se < be; ++se) - (ie[se] += re - 16 * ie[U] * er[se - (U - 32)]), - (re = Math.floor((ie[se] + 128) / 256)), - (ie[se] -= re * 256); - (ie[se] += re), (ie[U] = 0); - } - for (re = 0, se = 0; se < 32; se++) - (ie[se] += re - (ie[31] >> 4) * er[se]), - (re = ie[se] >> 8), - (ie[se] &= 255); - for (se = 0; se < 32; se++) ie[se] -= re * er[se]; - for (U = 0; U < 32; U++) - (ie[U + 1] += ie[U] >> 8), (oe[U] = ie[U] & 255); - } - function Y(oe) { - var ie = new Float64Array(64), - re; - for (re = 0; re < 64; re++) ie[re] = oe[re]; - for (re = 0; re < 64; re++) oe[re] = 0; - Ue(oe, ie); - } - function W(oe, ie, re, U) { - var se = new Uint8Array(64), - be = new Uint8Array(64), - Qe = new Uint8Array(64), - Ae, - ke, - Ct = new Float64Array(64), - ut = [e(), e(), e(), e()]; - _e(se, U, 32), (se[0] &= 248), (se[31] &= 127), (se[31] |= 64); - var St = re + 64; - for (Ae = 0; Ae < re; Ae++) oe[64 + Ae] = ie[Ae]; - for (Ae = 0; Ae < 32; Ae++) oe[32 + Ae] = se[32 + Ae]; - for ( - _e(Qe, oe.subarray(32), re + 32), - Y(Qe), - Ve(ut, Qe), - Be(oe, ut), - Ae = 32; - Ae < 64; - Ae++ - ) - oe[Ae] = U[Ae]; - for (_e(be, oe, re + 64), Y(be), Ae = 0; Ae < 64; Ae++) Ct[Ae] = 0; - for (Ae = 0; Ae < 32; Ae++) Ct[Ae] = Qe[Ae]; - for (Ae = 0; Ae < 32; Ae++) - for (ke = 0; ke < 32; ke++) Ct[Ae + ke] += be[Ae] * se[ke]; - return Ue(oe.subarray(32), Ct), St; - } - function j(oe, ie) { - var re = e(), - U = e(), - se = e(), - be = e(), - Qe = e(), - Ae = e(), - ke = e(); - return ( - v(oe[2], a), - C(oe[1], ie), - L(se, oe[1]), - G(be, se, c), - B(se, se, oe[2]), - E(be, oe[2], be), - L(Qe, be), - L(Ae, Qe), - G(ke, Ae, Qe), - G(re, ke, se), - G(re, re, be), - ge(re, re), - G(re, re, se), - G(re, re, be), - G(re, re, be), - G(oe[0], re, be), - L(U, oe[0]), - G(U, U, be), - f(U, se) && G(oe[0], oe[0], M), - L(U, oe[0]), - G(U, U, be), - f(U, se) - ? -1 - : (x(oe[0]) === ie[31] >> 7 && B(oe[0], o, oe[0]), - G(oe[3], oe[0], oe[1]), - 0) - ); - } - function ce(oe, ie, re, U) { - var se, - be = new Uint8Array(32), - Qe = new Uint8Array(64), - Ae = [e(), e(), e(), e()], - ke = [e(), e(), e(), e()]; - if (re < 64 || j(ke, U)) return -1; - for (se = 0; se < re; se++) oe[se] = ie[se]; - for (se = 0; se < 32; se++) oe[se + 32] = U[se]; - if ( - (_e(Qe, oe, re), - Y(Qe), - kt(Ae, ke, Qe), - Ve(ke, ie.subarray(32)), - Ye(Ae, ke), - Be(be, Ae), - (re -= 64), - F(ie, 0, be, 0)) - ) { - for (se = 0; se < re; se++) oe[se] = 0; - return -1; - } - for (se = 0; se < re; se++) oe[se] = ie[se + 64]; - return re; - } - var ze = 32, - we = 24, - xe = 32, - Ft = 16, - Ke = 32, - pe = 32, - Re = 32, - Se = 32, - Pe = 32, - At = we, - Ie = xe, - je = Ft, - qt = 64, - Fe = 32, - He = 64, - lr = 32, - Xe = 64; - t.lowlevel = { - crypto_core_hsalsa20: H, - crypto_stream_xor: ne, - crypto_stream: te, - crypto_stream_salsa20_xor: $, - crypto_stream_salsa20: ue, - crypto_onetimeauth: l, - crypto_onetimeauth_verify: p, - crypto_verify_16: D, - crypto_verify_32: F, - crypto_secretbox: y, - crypto_secretbox_open: d, - crypto_scalarmult: fe, - crypto_scalarmult_base: V, - crypto_box_beforenm: ae, - crypto_box_afternm: le, - crypto_box: de, - crypto_box_open: ve, - crypto_box_keypair: ye, - crypto_hash: _e, - crypto_sign: W, - crypto_sign_keypair: We, - crypto_sign_open: ce, - crypto_secretbox_KEYBYTES: ze, - crypto_secretbox_NONCEBYTES: we, - crypto_secretbox_ZEROBYTES: xe, - crypto_secretbox_BOXZEROBYTES: Ft, - crypto_scalarmult_BYTES: Ke, - crypto_scalarmult_SCALARBYTES: pe, - crypto_box_PUBLICKEYBYTES: Re, - crypto_box_SECRETKEYBYTES: Se, - crypto_box_BEFORENMBYTES: Pe, - crypto_box_NONCEBYTES: At, - crypto_box_ZEROBYTES: Ie, - crypto_box_BOXZEROBYTES: je, - crypto_sign_BYTES: qt, - crypto_sign_PUBLICKEYBYTES: Fe, - crypto_sign_SECRETKEYBYTES: He, - crypto_sign_SEEDBYTES: lr, - crypto_hash_BYTES: Xe, - gf: e, - D: c, - L: er, - pack25519: b, - unpack25519: C, - M: G, - A: E, - S: L, - Z: B, - pow2523: ge, - add: Ye, - set25519: v, - modL: Ue, - scalarmult: kt, - scalarbase: Ve, - }; - function Ze(oe, ie) { - if (oe.length !== ze) throw new Error("bad key size"); - if (ie.length !== we) throw new Error("bad nonce size"); - } - function Ir(oe, ie) { - if (oe.length !== Re) throw new Error("bad public key size"); - if (ie.length !== Se) throw new Error("bad secret key size"); - } - function $e() { - for (var oe = 0; oe < arguments.length; oe++) - if (!(arguments[oe] instanceof Uint8Array)) - throw new TypeError("unexpected type, use Uint8Array"); - } - function tt(oe) { - for (var ie = 0; ie < oe.length; ie++) oe[ie] = 0; - } - (t.randomBytes = function (oe) { - var ie = new Uint8Array(oe); - return r(ie, oe), ie; - }), - (t.secretbox = function (oe, ie, re) { - $e(oe, ie, re), Ze(re, ie); - for ( - var U = new Uint8Array(xe + oe.length), - se = new Uint8Array(U.length), - be = 0; - be < oe.length; - be++ - ) - U[be + xe] = oe[be]; - return y(se, U, U.length, ie, re), se.subarray(Ft); - }), - (t.secretbox.open = function (oe, ie, re) { - $e(oe, ie, re), Ze(re, ie); - for ( - var U = new Uint8Array(Ft + oe.length), - se = new Uint8Array(U.length), - be = 0; - be < oe.length; - be++ - ) - U[be + Ft] = oe[be]; - return U.length < 32 || d(se, U, U.length, ie, re) !== 0 - ? null - : se.subarray(xe); - }), - (t.secretbox.keyLength = ze), - (t.secretbox.nonceLength = we), - (t.secretbox.overheadLength = Ft), - (t.scalarMult = function (oe, ie) { - if (($e(oe, ie), oe.length !== pe)) throw new Error("bad n size"); - if (ie.length !== Ke) throw new Error("bad p size"); - var re = new Uint8Array(Ke); - return fe(re, oe, ie), re; - }), - (t.scalarMult.base = function (oe) { - if (($e(oe), oe.length !== pe)) throw new Error("bad n size"); - var ie = new Uint8Array(Ke); - return V(ie, oe), ie; - }), - (t.scalarMult.scalarLength = pe), - (t.scalarMult.groupElementLength = Ke), - (t.box = function (oe, ie, re, U) { - var se = t.box.before(re, U); - return t.secretbox(oe, ie, se); - }), - (t.box.before = function (oe, ie) { - $e(oe, ie), Ir(oe, ie); - var re = new Uint8Array(Pe); - return ae(re, oe, ie), re; - }), - (t.box.after = t.secretbox), - (t.box.open = function (oe, ie, re, U) { - var se = t.box.before(re, U); - return t.secretbox.open(oe, ie, se); - }), - (t.box.open.after = t.secretbox.open), - (t.box.keyPair = function () { - var oe = new Uint8Array(Re), - ie = new Uint8Array(Se); - return ye(oe, ie), { publicKey: oe, secretKey: ie }; - }), - (t.box.keyPair.fromSecretKey = function (oe) { - if (($e(oe), oe.length !== Se)) - throw new Error("bad secret key size"); - var ie = new Uint8Array(Re); - return V(ie, oe), { publicKey: ie, secretKey: new Uint8Array(oe) }; - }), - (t.box.publicKeyLength = Re), - (t.box.secretKeyLength = Se), - (t.box.sharedKeyLength = Pe), - (t.box.nonceLength = At), - (t.box.overheadLength = t.secretbox.overheadLength), - (t.sign = function (oe, ie) { - if (($e(oe, ie), ie.length !== He)) - throw new Error("bad secret key size"); - var re = new Uint8Array(qt + oe.length); - return W(re, oe, oe.length, ie), re; - }), - (t.sign.open = function (oe, ie) { - if (($e(oe, ie), ie.length !== Fe)) - throw new Error("bad public key size"); - var re = new Uint8Array(oe.length), - U = ce(re, oe, oe.length, ie); - if (U < 0) return null; - for (var se = new Uint8Array(U), be = 0; be < se.length; be++) - se[be] = re[be]; - return se; - }), - (t.sign.detached = function (oe, ie) { - for ( - var re = t.sign(oe, ie), U = new Uint8Array(qt), se = 0; - se < U.length; - se++ - ) - U[se] = re[se]; - return U; - }), - (t.sign.detached.verify = function (oe, ie, re) { - if (($e(oe, ie, re), ie.length !== qt)) - throw new Error("bad signature size"); - if (re.length !== Fe) throw new Error("bad public key size"); - var U = new Uint8Array(qt + oe.length), - se = new Uint8Array(qt + oe.length), - be; - for (be = 0; be < qt; be++) U[be] = ie[be]; - for (be = 0; be < oe.length; be++) U[be + qt] = oe[be]; - return ce(se, U, U.length, re) >= 0; - }), - (t.sign.keyPair = function () { - var oe = new Uint8Array(Fe), - ie = new Uint8Array(He); - return We(oe, ie), { publicKey: oe, secretKey: ie }; - }), - (t.sign.keyPair.fromSecretKey = function (oe) { - if (($e(oe), oe.length !== He)) - throw new Error("bad secret key size"); - for (var ie = new Uint8Array(Fe), re = 0; re < ie.length; re++) - ie[re] = oe[32 + re]; - return { publicKey: ie, secretKey: new Uint8Array(oe) }; - }), - (t.sign.keyPair.fromSeed = function (oe) { - if (($e(oe), oe.length !== lr)) throw new Error("bad seed size"); - for ( - var ie = new Uint8Array(Fe), re = new Uint8Array(He), U = 0; - U < 32; - U++ - ) - re[U] = oe[U]; - return We(ie, re, !0), { publicKey: ie, secretKey: re }; - }), - (t.sign.publicKeyLength = Fe), - (t.sign.secretKeyLength = He), - (t.sign.seedLength = lr), - (t.sign.signatureLength = qt), - (t.hash = function (oe) { - $e(oe); - var ie = new Uint8Array(Xe); - return _e(ie, oe, oe.length), ie; - }), - (t.hash.hashLength = Xe), - (t.verify = function (oe, ie) { - return ( - $e(oe, ie), - oe.length === 0 || ie.length === 0 || oe.length !== ie.length - ? !1 - : O(oe, 0, ie, 0, oe.length) === 0 - ); - }), - (t.setPRNG = function (oe) { - r = oe; - }), - (function () { - var oe = typeof self < "u" ? self.crypto || self.msCrypto : null; - if (oe && oe.getRandomValues) { - var ie = 65536; - t.setPRNG(function (re, U) { - var se, - be = new Uint8Array(U); - for (se = 0; se < U; se += ie) - oe.getRandomValues(be.subarray(se, se + Math.min(U - se, ie))); - for (se = 0; se < U; se++) re[se] = be[se]; - tt(be); - }); - } else - typeof p7e < "u" && - ((oe = Rp()), - oe && - oe.randomBytes && - t.setPRNG(function (re, U) { - var se, - be = oe.randomBytes(U); - for (se = 0; se < U; se++) re[se] = be[se]; - tt(be); - })); - })(); - })( - typeof Zie < "u" && Zie.exports - ? Zie.exports - : (self.nacl = self.nacl || {}) - ); - }); - var _E = I((yo) => { - "use strict"; - m(); - g(); - var V8r = - (yo && yo.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - W8r = - (yo && yo.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Lb = - (yo && yo.__decorate) || - function (t, e, r, n) { - var i = arguments.length, - o = - i < 3 - ? e - : n === null - ? (n = Object.getOwnPropertyDescriptor(e, r)) - : n, - a; - if ( - typeof Reflect == "object" && - typeof Reflect.decorate == "function" - ) - o = Reflect.decorate(t, e, r, n); - else - for (var s = t.length - 1; s >= 0; s--) - (a = t[s]) && - (o = (i < 3 ? a(o) : i > 3 ? a(e, r, o) : a(e, r)) || o); - return i > 3 && o && Object.defineProperty(e, r, o), o; - }, - G8r = - (yo && yo.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.hasOwnProperty.call(t, r) && - V8r(e, t, r); - return W8r(e, t), e; - }, - ngt = - (yo && yo.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(yo, "__esModule", { value: !0 }); - yo.deserializeUnchecked = - yo.deserialize = - yo.serialize = - yo.BinaryReader = - yo.BinaryWriter = - yo.BorshError = - yo.baseDecode = - yo.baseEncode = - void 0; - var wE = ngt(Ho()), - igt = ngt(xv()), - J8r = G8r(p1e()), - $8r = - typeof window.TextDecoder != "function" - ? J8r.TextDecoder - : window.TextDecoder, - Z8r = new $8r("utf-8", { fatal: !0 }); - function X8r(t) { - return ( - typeof t == "string" && (t = Buffer.from(t, "utf8")), - igt.default.encode(Buffer.from(t)) - ); - } - yo.baseEncode = X8r; - function Y8r(t) { - return Buffer.from(igt.default.decode(t)); - } - yo.baseDecode = Y8r; - var KMe = 1024, - bc = class extends Error { - constructor(e) { - super(e), (this.fieldPath = []), (this.originalMessage = e); - } - addToFieldPath(e) { - this.fieldPath.splice(0, 0, e), - (this.message = - this.originalMessage + ": " + this.fieldPath.join(".")); - } - }; - yo.BorshError = bc; - var Xie = class { - constructor() { - (this.buf = Buffer.alloc(KMe)), (this.length = 0); - } - maybeResize() { - this.buf.length < 16 + this.length && - (this.buf = Buffer.concat([this.buf, Buffer.alloc(KMe)])); - } - writeU8(e) { - this.maybeResize(), - this.buf.writeUInt8(e, this.length), - (this.length += 1); - } - writeU16(e) { - this.maybeResize(), - this.buf.writeUInt16LE(e, this.length), - (this.length += 2); - } - writeU32(e) { - this.maybeResize(), - this.buf.writeUInt32LE(e, this.length), - (this.length += 4); - } - writeU64(e) { - this.maybeResize(), - this.writeBuffer(Buffer.from(new wE.default(e).toArray("le", 8))); - } - writeU128(e) { - this.maybeResize(), - this.writeBuffer(Buffer.from(new wE.default(e).toArray("le", 16))); - } - writeU256(e) { - this.maybeResize(), - this.writeBuffer(Buffer.from(new wE.default(e).toArray("le", 32))); - } - writeU512(e) { - this.maybeResize(), - this.writeBuffer(Buffer.from(new wE.default(e).toArray("le", 64))); - } - writeBuffer(e) { - (this.buf = Buffer.concat([ - Buffer.from(this.buf.subarray(0, this.length)), - e, - Buffer.alloc(KMe), - ])), - (this.length += e.length); - } - writeString(e) { - this.maybeResize(); - let r = Buffer.from(e, "utf8"); - this.writeU32(r.length), this.writeBuffer(r); - } - writeFixedArray(e) { - this.writeBuffer(Buffer.from(e)); - } - writeArray(e, r) { - this.maybeResize(), this.writeU32(e.length); - for (let n of e) this.maybeResize(), r(n); - } - toArray() { - return this.buf.subarray(0, this.length); - } - }; - yo.BinaryWriter = Xie; - function qb(t, e, r) { - let n = r.value; - r.value = function (...i) { - try { - return n.apply(this, i); - } catch (o) { - if (o instanceof RangeError) { - let a = o.code; - if ( - ["ERR_BUFFER_OUT_OF_BOUNDS", "ERR_OUT_OF_RANGE"].indexOf(a) >= 0 - ) - throw new bc("Reached the end of buffer when deserializing"); - } - throw o; - } - }; - } - var Xd = class { - constructor(e) { - (this.buf = e), (this.offset = 0); - } - readU8() { - let e = this.buf.readUInt8(this.offset); - return (this.offset += 1), e; - } - readU16() { - let e = this.buf.readUInt16LE(this.offset); - return (this.offset += 2), e; - } - readU32() { - let e = this.buf.readUInt32LE(this.offset); - return (this.offset += 4), e; - } - readU64() { - let e = this.readBuffer(8); - return new wE.default(e, "le"); - } - readU128() { - let e = this.readBuffer(16); - return new wE.default(e, "le"); - } - readU256() { - let e = this.readBuffer(32); - return new wE.default(e, "le"); - } - readU512() { - let e = this.readBuffer(64); - return new wE.default(e, "le"); - } - readBuffer(e) { - if (this.offset + e > this.buf.length) - throw new bc(`Expected buffer length ${e} isn't within bounds`); - let r = this.buf.slice(this.offset, this.offset + e); - return (this.offset += e), r; - } - readString() { - let e = this.readU32(), - r = this.readBuffer(e); - try { - return Z8r.decode(r); - } catch (n) { - throw new bc(`Error decoding UTF-8 string: ${n}`); - } - } - readFixedArray(e) { - return new Uint8Array(this.readBuffer(e)); - } - readArray(e) { - let r = this.readU32(), - n = Array(); - for (let i = 0; i < r; ++i) n.push(e()); - return n; - } - }; - Lb([qb], Xd.prototype, "readU8", null); - Lb([qb], Xd.prototype, "readU16", null); - Lb([qb], Xd.prototype, "readU32", null); - Lb([qb], Xd.prototype, "readU64", null); - Lb([qb], Xd.prototype, "readU128", null); - Lb([qb], Xd.prototype, "readU256", null); - Lb([qb], Xd.prototype, "readU512", null); - Lb([qb], Xd.prototype, "readString", null); - Lb([qb], Xd.prototype, "readFixedArray", null); - Lb([qb], Xd.prototype, "readArray", null); - yo.BinaryReader = Xd; - function ogt(t) { - return t.charAt(0).toUpperCase() + t.slice(1); - } - function hH(t, e, r, n, i) { - try { - if (typeof n == "string") i[`write${ogt(n)}`](r); - else if (n instanceof Array) - if (typeof n[0] == "number") { - if (r.length !== n[0]) - throw new bc( - `Expecting byte array of length ${n[0]}, but got ${r.length} bytes` - ); - i.writeFixedArray(r); - } else if (n.length === 2 && typeof n[1] == "number") { - if (r.length !== n[1]) - throw new bc( - `Expecting byte array of length ${n[1]}, but got ${r.length} bytes` - ); - for (let o = 0; o < n[1]; o++) hH(t, null, r[o], n[0], i); - } else - i.writeArray(r, (o) => { - hH(t, e, o, n[0], i); - }); - else if (n.kind !== void 0) - switch (n.kind) { - case "option": { - r == null ? i.writeU8(0) : (i.writeU8(1), hH(t, e, r, n.type, i)); - break; - } - default: - throw new bc(`FieldType ${n} unrecognized`); - } - else agt(t, r, i); - } catch (o) { - throw (o instanceof bc && o.addToFieldPath(e), o); - } - } - function agt(t, e, r) { - if (typeof e.borshSerialize == "function") { - e.borshSerialize(r); - return; - } - let n = t.get(e.constructor); - if (!n) throw new bc(`Class ${e.constructor.name} is missing in schema`); - if (n.kind === "struct") - n.fields.map(([i, o]) => { - hH(t, i, e[i], o, r); - }); - else if (n.kind === "enum") { - let i = e[n.field]; - for (let o = 0; o < n.values.length; ++o) { - let [a, s] = n.values[o]; - if (a === i) { - r.writeU8(o), hH(t, a, e[a], s, r); - break; - } - } - } else - throw new bc( - `Unexpected schema kind: ${n.kind} for ${e.constructor.name}` - ); - } - function Q8r(t, e, r = Xie) { - let n = new r(); - return agt(t, e, n), n.toArray(); - } - yo.serialize = Q8r; - function pH(t, e, r, n) { - try { - if (typeof r == "string") return n[`read${ogt(r)}`](); - if (r instanceof Array) { - if (typeof r[0] == "number") return n.readFixedArray(r[0]); - if (typeof r[1] == "number") { - let i = []; - for (let o = 0; o < r[1]; o++) i.push(pH(t, null, r[0], n)); - return i; - } else return n.readArray(() => pH(t, e, r[0], n)); - } - return r.kind === "option" - ? n.readU8() - ? pH(t, e, r.type, n) - : void 0 - : HMe(t, r, n); - } catch (i) { - throw (i instanceof bc && i.addToFieldPath(e), i); - } - } - function HMe(t, e, r) { - if (typeof e.borshDeserialize == "function") return e.borshDeserialize(r); - let n = t.get(e); - if (!n) throw new bc(`Class ${e.name} is missing in schema`); - if (n.kind === "struct") { - let i = {}; - for (let [o, a] of t.get(e).fields) i[o] = pH(t, o, a, r); - return new e(i); - } - if (n.kind === "enum") { - let i = r.readU8(); - if (i >= n.values.length) - throw new bc(`Enum index: ${i} is out of range`); - let [o, a] = n.values[i], - s = pH(t, o, a, r); - return new e({ [o]: s }); - } - throw new bc( - `Unexpected schema kind: ${n.kind} for ${e.constructor.name}` - ); - } - function ekr(t, e, r, n = Xd) { - let i = new n(r), - o = HMe(t, e, i); - if (i.offset < r.length) - throw new bc( - `Unexpected ${r.length - i.offset} bytes after deserialized data` - ); - return o; - } - yo.deserialize = ekr; - function tkr(t, e, r, n = Xd) { - let i = new n(r); - return HMe(t, e, i); - } - yo.deserializeUnchecked = tkr; - }); - var VMe = I((Bx) => { - "use strict"; - m(); - g(); - Object.defineProperty(Bx, "__esModule", { value: !0 }); - var A6 = _E(); - Object.defineProperty(Bx, "base_encode", { - enumerable: !0, - get: function () { - return A6.baseEncode; - }, - }); - Object.defineProperty(Bx, "base_decode", { - enumerable: !0, - get: function () { - return A6.baseDecode; - }, - }); - Object.defineProperty(Bx, "serialize", { - enumerable: !0, - get: function () { - return A6.serialize; - }, - }); - Object.defineProperty(Bx, "deserialize", { - enumerable: !0, - get: function () { - return A6.deserialize; - }, - }); - Object.defineProperty(Bx, "BorshError", { - enumerable: !0, - get: function () { - return A6.BorshError; - }, - }); - Object.defineProperty(Bx, "BinaryWriter", { - enumerable: !0, - get: function () { - return A6.BinaryWriter; - }, - }); - Object.defineProperty(Bx, "BinaryReader", { - enumerable: !0, - get: function () { - return A6.BinaryReader; - }, - }); - }); - var Yie = I((X7) => { - "use strict"; - m(); - g(); - Object.defineProperty(X7, "__esModule", { value: !0 }); - X7.Assignable = X7.Enum = void 0; - var WMe = class { - constructor(e) { - if (Object.keys(e).length !== 1) - throw new Error("Enum can only take single value"); - Object.keys(e).map((r) => { - (this[r] = e[r]), (this.enum = r); - }); - } - }; - X7.Enum = WMe; - var GMe = class { - constructor(e) { - Object.keys(e).map((r) => { - this[r] = e[r]; - }); - } - }; - X7.Assignable = GMe; - }); - var zb = I((n0) => { - "use strict"; - m(); - g(); - var rkr = - (n0 && n0.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(n0, "__esModule", { value: !0 }); - n0.KeyPairEd25519 = n0.KeyPair = n0.PublicKey = n0.KeyType = void 0; - var Qie = rkr(rgt()), - Y7 = VMe(), - nkr = Yie(), - Q7; - (function (t) { - t[(t.ED25519 = 0)] = "ED25519"; - })((Q7 = n0.KeyType || (n0.KeyType = {}))); - function ikr(t) { - switch (t) { - case Q7.ED25519: - return "ed25519"; - default: - throw new Error(`Unknown key type ${t}`); - } - } - function okr(t) { - switch (t.toLowerCase()) { - case "ed25519": - return Q7.ED25519; - default: - throw new Error(`Unknown key type ${t}`); - } - } - var xE = class extends nkr.Assignable { - static from(e) { - return typeof e == "string" ? xE.fromString(e) : e; - } - static fromString(e) { - let r = e.split(":"); - if (r.length === 1) - return new xE({ keyType: Q7.ED25519, data: Y7.base_decode(r[0]) }); - if (r.length === 2) - return new xE({ keyType: okr(r[0]), data: Y7.base_decode(r[1]) }); - throw new Error( - "Invalid encoded key format, must be :" - ); - } - toString() { - return `${ikr(this.keyType)}:${Y7.base_encode(this.data)}`; - } - verify(e, r) { - switch (this.keyType) { - case Q7.ED25519: - return Qie.default.sign.detached.verify(e, r, this.data); - default: - throw new Error(`Unknown key type ${this.keyType}`); - } - } - }; - n0.PublicKey = xE; - var eoe = class { - static fromRandom(e) { - switch (e.toUpperCase()) { - case "ED25519": - return SE.fromRandom(); - default: - throw new Error(`Unknown curve ${e}`); - } - } - static fromString(e) { - let r = e.split(":"); - if (r.length === 1) return new SE(r[0]); - if (r.length === 2) - switch (r[0].toUpperCase()) { - case "ED25519": - return new SE(r[1]); - default: - throw new Error(`Unknown curve: ${r[0]}`); - } - else - throw new Error( - "Invalid encoded key format, must be :" - ); - } - }; - n0.KeyPair = eoe; - var SE = class extends eoe { - constructor(e) { - super(); - let r = Qie.default.sign.keyPair.fromSecretKey(Y7.base_decode(e)); - (this.publicKey = new xE({ keyType: Q7.ED25519, data: r.publicKey })), - (this.secretKey = e); - } - static fromRandom() { - let e = Qie.default.sign.keyPair(); - return new SE(Y7.base_encode(e.secretKey)); - } - sign(e) { - return { - signature: Qie.default.sign.detached( - e, - Y7.base_decode(this.secretKey) - ), - publicKey: this.publicKey, - }; - } - verify(e, r) { - return this.publicKey.verify(e, r); - } - toString() { - return `ed25519:${this.secretKey}`; - } - getPublicKey() { - return this.publicKey; - } - }; - n0.KeyPairEd25519 = SE; - }); - var $Me = I((toe) => { - "use strict"; - m(); - g(); - Object.defineProperty(toe, "__esModule", { value: !0 }); - toe.InMemoryKeyStore = void 0; - var akr = dH(), - skr = zb(), - JMe = class extends akr.KeyStore { - constructor() { - super(), (this.keys = {}); - } - async setKey(e, r, n) { - this.keys[`${r}:${e}`] = n.toString(); - } - async getKey(e, r) { - let n = this.keys[`${r}:${e}`]; - return n ? skr.KeyPair.fromString(n) : null; - } - async removeKey(e, r) { - delete this.keys[`${r}:${e}`]; - } - async clear() { - this.keys = {}; - } - async getNetworks() { - let e = new Set(); - return ( - Object.keys(this.keys).forEach((r) => { - let n = r.split(":"); - e.add(n[1]); - }), - Array.from(e.values()) - ); - } - async getAccounts(e) { - let r = new Array(); - return ( - Object.keys(this.keys).forEach((n) => { - let i = n.split(":"); - i[i.length - 1] === e && - r.push(i.slice(0, i.length - 1).join(":")); - }), - r - ); - } - toString() { - return "InMemoryKeyStore"; - } - }; - toe.InMemoryKeyStore = JMe; - }); - var sgt = I((roe) => { - "use strict"; - m(); - g(); - Object.defineProperty(roe, "__esModule", { value: !0 }); - roe.BrowserLocalStorageKeyStore = void 0; - var ukr = dH(), - ckr = zb(), - lkr = "near-api-js:keystore:", - ZMe = class extends ukr.KeyStore { - constructor(e = window.localStorage, r = lkr) { - super(), (this.localStorage = e), (this.prefix = r); - } - async setKey(e, r, n) { - this.localStorage.setItem( - this.storageKeyForSecretKey(e, r), - n.toString() - ); - } - async getKey(e, r) { - let n = this.localStorage.getItem(this.storageKeyForSecretKey(e, r)); - return n ? ckr.KeyPair.fromString(n) : null; - } - async removeKey(e, r) { - this.localStorage.removeItem(this.storageKeyForSecretKey(e, r)); - } - async clear() { - for (let e of this.storageKeys()) - e.startsWith(this.prefix) && this.localStorage.removeItem(e); - } - async getNetworks() { - let e = new Set(); - for (let r of this.storageKeys()) - if (r.startsWith(this.prefix)) { - let n = r.substring(this.prefix.length).split(":"); - e.add(n[1]); - } - return Array.from(e.values()); - } - async getAccounts(e) { - let r = new Array(); - for (let n of this.storageKeys()) - if (n.startsWith(this.prefix)) { - let i = n.substring(this.prefix.length).split(":"); - i[1] === e && r.push(i[0]); - } - return r; - } - storageKeyForSecretKey(e, r) { - return `${this.prefix}${r}:${e}`; - } - *storageKeys() { - for (let e = 0; e < this.localStorage.length; e++) - yield this.localStorage.key(e); - } - }; - roe.BrowserLocalStorageKeyStore = ZMe; - }); - var ugt = I((noe) => { - "use strict"; - m(); - g(); - Object.defineProperty(noe, "__esModule", { value: !0 }); - noe.MergeKeyStore = void 0; - var fkr = dH(), - XMe = class extends fkr.KeyStore { - constructor(e, r = { writeKeyStoreIndex: 0 }) { - super(), (this.options = r), (this.keyStores = e); - } - async setKey(e, r, n) { - await this.keyStores[this.options.writeKeyStoreIndex].setKey(e, r, n); - } - async getKey(e, r) { - for (let n of this.keyStores) { - let i = await n.getKey(e, r); - if (i) return i; - } - return null; - } - async removeKey(e, r) { - for (let n of this.keyStores) await n.removeKey(e, r); - } - async clear() { - for (let e of this.keyStores) await e.clear(); - } - async getNetworks() { - let e = new Set(); - for (let r of this.keyStores) - for (let n of await r.getNetworks()) e.add(n); - return Array.from(e); - } - async getAccounts(e) { - let r = new Set(); - for (let n of this.keyStores) - for (let i of await n.getAccounts(e)) r.add(i); - return Array.from(r); - } - toString() { - return `MergeKeyStore(${this.keyStores.join(", ")})`; - } - }; - noe.MergeKeyStore = XMe; - }); - var cgt = I((jb) => { - "use strict"; - m(); - g(); - Object.defineProperty(jb, "__esModule", { value: !0 }); - jb.MergeKeyStore = - jb.BrowserLocalStorageKeyStore = - jb.InMemoryKeyStore = - jb.KeyStore = - void 0; - var dkr = dH(); - Object.defineProperty(jb, "KeyStore", { - enumerable: !0, - get: function () { - return dkr.KeyStore; - }, - }); - var hkr = $Me(); - Object.defineProperty(jb, "InMemoryKeyStore", { - enumerable: !0, - get: function () { - return hkr.InMemoryKeyStore; - }, - }); - var pkr = sgt(); - Object.defineProperty(jb, "BrowserLocalStorageKeyStore", { - enumerable: !0, - get: function () { - return pkr.BrowserLocalStorageKeyStore; - }, - }); - var ykr = ugt(); - Object.defineProperty(jb, "MergeKeyStore", { - enumerable: !0, - get: function () { - return ykr.MergeKeyStore; - }, - }); - }); - var QMe = I((Yd) => { - "use strict"; - m(); - g(); - Object.defineProperty(Yd, "__esModule", { value: !0 }); - Yd.getTransactionLastResult = - Yd.Provider = - Yd.IdType = - Yd.FinalExecutionStatusBasic = - Yd.ExecutionStatusBasic = - void 0; - var mkr; - (function (t) { - (t.Unknown = "Unknown"), (t.Pending = "Pending"), (t.Failure = "Failure"); - })((mkr = Yd.ExecutionStatusBasic || (Yd.ExecutionStatusBasic = {}))); - var gkr; - (function (t) { - (t.NotStarted = "NotStarted"), - (t.Started = "Started"), - (t.Failure = "Failure"); - })( - (gkr = - Yd.FinalExecutionStatusBasic || (Yd.FinalExecutionStatusBasic = {})) - ); - var vkr; - (function (t) { - (t.Transaction = "transaction"), (t.Receipt = "receipt"); - })((vkr = Yd.IdType || (Yd.IdType = {}))); - var YMe = class {}; - Yd.Provider = YMe; - function bkr(t) { - if ( - typeof t.status == "object" && - typeof t.status.SuccessValue == "string" - ) { - let e = Buffer.from(t.status.SuccessValue, "base64").toString(); - try { - return JSON.parse(e); - } catch { - return e; - } - } - return null; - } - Yd.getTransactionLastResult = bkr; - }); - var E6 = I((N1n, lgt) => { - "use strict"; - m(); - g(); - lgt.exports = wkr; - function wkr(t) { - if (!t) throw new TypeError("argument namespace is required"); - function e(r) {} - return ( - (e._file = void 0), - (e._ignored = !0), - (e._namespace = t), - (e._traced = !1), - (e._warned = Object.create(null)), - (e.function = _kr), - (e.property = xkr), - e - ); - } - function _kr(t, e) { - if (typeof t != "function") - throw new TypeError("argument fn must be a function"); - return t; - } - function xkr(t, e, r) { - if (!t || (typeof t != "object" && typeof t != "function")) - throw new TypeError("argument obj must be object"); - var n = Object.getOwnPropertyDescriptor(t, e); - if (!n) throw new TypeError("must call property on owner object"); - if (!n.configurable) throw new TypeError("property must be configurable"); - } - }); - var dgt = I((D1n, fgt) => { - "use strict"; - m(); - g(); - fgt.exports = Skr; - function Skr(t) { - if (!t) throw new TypeError("argument namespace is required"); - function e(r) {} - return ( - (e._file = void 0), - (e._ignored = !0), - (e._namespace = t), - (e._traced = !1), - (e._warned = Object.create(null)), - (e.function = Akr), - (e.property = Ekr), - e - ); - } - function Akr(t, e) { - if (typeof t != "function") - throw new TypeError("argument fn must be a function"); - return t; - } - function Ekr(t, e, r) { - if (!t || (typeof t != "object" && typeof t != "function")) - throw new TypeError("argument obj must be object"); - var n = Object.getOwnPropertyDescriptor(t, e); - if (!n) throw new TypeError("must call property on owner object"); - if (!n.configurable) throw new TypeError("property must be configurable"); - } - }); - var pgt = I((F1n, hgt) => { - "use strict"; - m(); - g(); - hgt.exports = - Object.setPrototypeOf || ({ __proto__: [] } instanceof Array ? Mkr : Tkr); - function Mkr(t, e) { - return (t.__proto__ = e), t; - } - function Tkr(t, e) { - for (var r in e) - Object.prototype.hasOwnProperty.call(t, r) || (t[r] = e[r]); - return t; - } - }); - var ygt = I((L1n, kkr) => { - kkr.exports = { - 100: "Continue", - 101: "Switching Protocols", - 102: "Processing", - 103: "Early Hints", - 200: "OK", - 201: "Created", - 202: "Accepted", - 203: "Non-Authoritative Information", - 204: "No Content", - 205: "Reset Content", - 206: "Partial Content", - 207: "Multi-Status", - 208: "Already Reported", - 226: "IM Used", - 300: "Multiple Choices", - 301: "Moved Permanently", - 302: "Found", - 303: "See Other", - 304: "Not Modified", - 305: "Use Proxy", - 306: "(Unused)", - 307: "Temporary Redirect", - 308: "Permanent Redirect", - 400: "Bad Request", - 401: "Unauthorized", - 402: "Payment Required", - 403: "Forbidden", - 404: "Not Found", - 405: "Method Not Allowed", - 406: "Not Acceptable", - 407: "Proxy Authentication Required", - 408: "Request Timeout", - 409: "Conflict", - 410: "Gone", - 411: "Length Required", - 412: "Precondition Failed", - 413: "Payload Too Large", - 414: "URI Too Long", - 415: "Unsupported Media Type", - 416: "Range Not Satisfiable", - 417: "Expectation Failed", - 418: "I'm a teapot", - 421: "Misdirected Request", - 422: "Unprocessable Entity", - 423: "Locked", - 424: "Failed Dependency", - 425: "Unordered Collection", - 426: "Upgrade Required", - 428: "Precondition Required", - 429: "Too Many Requests", - 431: "Request Header Fields Too Large", - 451: "Unavailable For Legal Reasons", - 500: "Internal Server Error", - 501: "Not Implemented", - 502: "Bad Gateway", - 503: "Service Unavailable", - 504: "Gateway Timeout", - 505: "HTTP Version Not Supported", - 506: "Variant Also Negotiates", - 507: "Insufficient Storage", - 508: "Loop Detected", - 509: "Bandwidth Limit Exceeded", - 510: "Not Extended", - 511: "Network Authentication Required", - }; - }); - var vgt = I((q1n, ggt) => { - "use strict"; - m(); - g(); - var mgt = ygt(); - ggt.exports = Ub; - Ub.STATUS_CODES = mgt; - Ub.codes = Pkr(Ub, mgt); - Ub.redirect = { - 300: !0, - 301: !0, - 302: !0, - 303: !0, - 305: !0, - 307: !0, - 308: !0, - }; - Ub.empty = { 204: !0, 205: !0, 304: !0 }; - Ub.retry = { 502: !0, 503: !0, 504: !0 }; - function Pkr(t, e) { - var r = []; - return ( - Object.keys(e).forEach(function (i) { - var o = e[i], - a = Number(i); - (t[a] = o), (t[o] = a), (t[o.toLowerCase()] = a), r.push(a); - }), - r - ); - } - function Ub(t) { - if (typeof t == "number") { - if (!Ub[t]) throw new Error("invalid status code: " + t); - return t; - } - if (typeof t != "string") - throw new TypeError("code must be a number or string"); - var e = parseInt(t, 10); - if (!isNaN(e)) { - if (!Ub[e]) throw new Error("invalid status code: " + e); - return e; - } - if (((e = Ub[t.toLowerCase()]), !e)) - throw new Error('invalid status message: "' + t + '"'); - return e; - } - }); - var wgt = I((z1n, bgt) => { - "use strict"; - m(); - g(); - bgt.exports = Okr; - function Okr(t) { - return t - .split(" ") - .map(function (e) { - return e.slice(0, 1).toUpperCase() + e.slice(1); - }) - .join("") - .replace(/[^ _0-9a-z]/gi, ""); - } - }); - var Egt = I((j1n, M6) => { - "use strict"; - m(); - g(); - var eTe = dgt()("http-errors"), - _gt = pgt(), - eN = vgt(), - tTe = dn(), - Bkr = wgt(); - M6.exports = ioe; - M6.exports.HttpError = Ikr(); - M6.exports.isHttpError = Rkr(M6.exports.HttpError); - Dkr(M6.exports, eN.codes, M6.exports.HttpError); - function xgt(t) { - return Number(String(t).charAt(0) + "00"); - } - function ioe() { - for (var t, e, r = 500, n = {}, i = 0; i < arguments.length; i++) { - var o = arguments[i]; - if (o instanceof Error) { - (t = o), (r = t.status || t.statusCode || r); - continue; - } - switch (typeof o) { - case "string": - e = o; - break; - case "number": - (r = o), - i !== 0 && - eTe( - "non-first-argument status code; replace with createError(" + - o + - ", ...)" - ); - break; - case "object": - n = o; - break; - } - } - typeof r == "number" && - (r < 400 || r >= 600) && - eTe("non-error status code; use only 4xx or 5xx status codes"), - (typeof r != "number" || (!eN[r] && (r < 400 || r >= 600))) && - (r = 500); - var a = ioe[r] || ioe[xgt(r)]; - t || - ((t = a ? new a(e) : new Error(e || eN[r])), - Error.captureStackTrace(t, ioe)), - (!a || !(t instanceof a) || t.status !== r) && - ((t.expose = r < 500), (t.status = t.statusCode = r)); - for (var s in n) s !== "status" && s !== "statusCode" && (t[s] = n[s]); - return t; - } - function Ikr() { - function t() { - throw new TypeError("cannot construct abstract class"); - } - return tTe(t, Error), t; - } - function Ckr(t, e, r) { - var n = Agt(e); - function i(o) { - var a = o ?? eN[r], - s = new Error(a); - return ( - Error.captureStackTrace(s, i), - _gt(s, i.prototype), - Object.defineProperty(s, "message", { - enumerable: !0, - configurable: !0, - value: a, - writable: !0, - }), - Object.defineProperty(s, "name", { - enumerable: !1, - configurable: !0, - value: n, - writable: !0, - }), - s - ); - } - return ( - tTe(i, t), - Sgt(i, n), - (i.prototype.status = r), - (i.prototype.statusCode = r), - (i.prototype.expose = !0), - i - ); - } - function Rkr(t) { - return function (r) { - return !r || typeof r != "object" - ? !1 - : r instanceof t - ? !0 - : r instanceof Error && - typeof r.expose == "boolean" && - typeof r.statusCode == "number" && - r.status === r.statusCode; - }; - } - function Nkr(t, e, r) { - var n = Agt(e); - function i(o) { - var a = o ?? eN[r], - s = new Error(a); - return ( - Error.captureStackTrace(s, i), - _gt(s, i.prototype), - Object.defineProperty(s, "message", { - enumerable: !0, - configurable: !0, - value: a, - writable: !0, - }), - Object.defineProperty(s, "name", { - enumerable: !1, - configurable: !0, - value: n, - writable: !0, - }), - s - ); - } - return ( - tTe(i, t), - Sgt(i, n), - (i.prototype.status = r), - (i.prototype.statusCode = r), - (i.prototype.expose = !1), - i - ); - } - function Sgt(t, e) { - var r = Object.getOwnPropertyDescriptor(t, "name"); - r && - r.configurable && - ((r.value = e), Object.defineProperty(t, "name", r)); - } - function Dkr(t, e, r) { - e.forEach(function (i) { - var o, - a = Bkr(eN[i]); - switch (xgt(i)) { - case 400: - o = Ckr(r, a, i); - break; - case 500: - o = Nkr(r, a, i); - break; - } - o && ((t[i] = o), (t[a] = o)); - }), - (t["I'mateapot"] = eTe.function( - t.ImATeapot, - `"I'mateapot"; use "ImATeapot" instead` - )); - } - function Agt(t) { - return t.substr(-5) !== "Error" ? t + "Error" : t; - } - }); - var ooe = I((rTe) => { - "use strict"; - m(); - g(); - Object.defineProperty(rTe, "__esModule", { value: !0 }); - async function Fkr(t, e, r, n) { - let i = t; - for (let o = 0; o < e; o++) { - let a = await n(); - if (a) return a; - await Lkr(i), (i *= r); - } - return null; - } - rTe.default = Fkr; - function Lkr(t) { - return new Promise((e) => setTimeout(e, t)); - } - }); - var T6 = I((Qy) => { - "use strict"; - m(); - g(); - Object.defineProperty(Qy, "__esModule", { value: !0 }); - Qy.logWarning = - Qy.ErrorContext = - Qy.TypedError = - Qy.ArgumentTypeError = - Qy.PositionalArgsError = - void 0; - var nTe = class extends Error { - constructor() { - super( - "Contract method calls expect named arguments wrapped in object, e.g. { argName1: argValue1, argName2: argValue2 }" - ); - } - }; - Qy.PositionalArgsError = nTe; - var iTe = class extends Error { - constructor(e, r, n) { - super( - `Expected ${r} for '${e}' argument, but got '${JSON.stringify(n)}'` - ); - } - }; - Qy.ArgumentTypeError = iTe; - var oTe = class extends Error { - constructor(e, r, n) { - super(e), (this.type = r || "UntypedError"), (this.context = n); - } - }; - Qy.TypedError = oTe; - var aTe = class { - constructor(e) { - this.transactionHash = e; - } - }; - Qy.ErrorContext = aTe; - function qkr(...t) { - process.env.NEAR_NO_LOGS || console.warn(...t); - } - Qy.logWarning = qkr; - }); - var yH = I((tN) => { - "use strict"; - m(); - g(); - var kgt = - (tN && tN.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(tN, "__esModule", { value: !0 }); - tN.fetchJson = void 0; - var zkr = kgt(Egt()), - jkr = kgt(ooe()), - Ukr = rN(), - Mgt = T6(), - Kkr = 1e3, - Hkr = 1.5, - Tgt = 10; - async function Vkr(t, e) { - let r = { url: null }; - typeof t == "string" ? (r.url = t) : (r = t); - let n = await jkr.default(Kkr, Tgt, Hkr, async () => { - try { - let i = await fetch(r.url, { - method: e ? "POST" : "GET", - body: e || void 0, - headers: { ...r.headers, "Content-Type": "application/json" }, - }); - if (!i.ok) { - if (i.status === 503) - return ( - Mgt.logWarning( - `Retrying HTTP request for ${r.url} as it's not available now` - ), - null - ); - throw zkr.default(i.status, await i.text()); - } - return i; - } catch (i) { - if ( - i.toString().includes("FetchError") || - i.toString().includes("Failed to fetch") - ) - return ( - Mgt.logWarning( - `Retrying HTTP request for ${r.url} because of error: ${i}` - ), - null - ); - throw i; - } - }); - if (!n) - throw new Ukr.TypedError( - `Exceeded ${Tgt} attempts for ${r.url}.`, - "RetriesExceeded" - ); - return await n.json(); - } - tN.fetchJson = Vkr; - }); - var Pgt = I((sTe, uTe) => { - m(); - g(); - (function (t, e) { - typeof sTe == "object" && typeof uTe < "u" - ? (uTe.exports = e()) - : typeof define == "function" && define.amd - ? define(e) - : ((t = t || self), (t.Mustache = e())); - })(sTe, function () { - "use strict"; - var t = Object.prototype.toString, - e = - Array.isArray || - function (l) { - return t.call(l) === "[object Array]"; - }; - function r(A) { - return typeof A == "function"; - } - function n(A) { - return e(A) ? "array" : typeof A; - } - function i(A) { - return A.replace(/[\-\[\]{}()*+?.,\\\^$|#\s]/g, "\\$&"); - } - function o(A, l) { - return A != null && typeof A == "object" && l in A; - } - function a(A, l) { - return ( - A != null && - typeof A != "object" && - A.hasOwnProperty && - A.hasOwnProperty(l) - ); - } - var s = RegExp.prototype.test; - function c(A, l) { - return s.call(A, l); - } - var u = /\S/; - function h(A) { - return !c(u, A); - } - var w = { - "&": "&", - "<": "<", - ">": ">", - '"': """, - "'": "'", - "/": "/", - "`": "`", - "=": "=", - }; - function M(A) { - return String(A).replace(/[&<>"'`=\/]/g, function (p) { - return w[p]; - }); - } - var k = /\s*/, - O = /\s+/, - D = /\s*=/, - F = /\s*\}/, - N = /#|\^|\/|>|\{|&|=|!/; - function q(A, l) { - if (!A) return []; - var p = !1, - y = [], - d = [], - v = [], - _ = !1, - S = !1, - b = "", - f = 0; - function x() { - if (_ && !S) for (; v.length; ) delete d[v.pop()]; - else v = []; - (_ = !1), (S = !1); - } - var C, E, B; - function G(de) { - if ( - (typeof de == "string" && (de = de.split(O, 2)), - !e(de) || de.length !== 2) - ) - throw new Error("Invalid tags: " + de); - (C = new RegExp(i(de[0]) + "\\s*")), - (E = new RegExp("\\s*" + i(de[1]))), - (B = new RegExp("\\s*" + i("}" + de[1]))); - } - G(l || te.tags); - for (var L = new Z(A), ee, ge, fe, V, ye, ae; !L.eos(); ) { - if (((ee = L.pos), (fe = L.scanUntil(C)), fe)) - for (var le = 0, Me = fe.length; le < Me; ++le) - (V = fe.charAt(le)), - h(V) - ? (v.push(d.length), (b += V)) - : ((S = !0), (p = !0), (b += " ")), - d.push(["text", V, ee, ee + 1]), - (ee += 1), - V === - ` -` && (x(), (b = ""), (f = 0), (p = !1)); - if (!L.scan(C)) break; - if ( - ((_ = !0), - (ge = L.scan(N) || "name"), - L.scan(k), - ge === "=" - ? ((fe = L.scanUntil(D)), L.scan(D), L.scanUntil(E)) - : ge === "{" - ? ((fe = L.scanUntil(B)), L.scan(F), L.scanUntil(E), (ge = "&")) - : (fe = L.scanUntil(E)), - !L.scan(E)) - ) - throw new Error("Unclosed tag at " + L.pos); - if ( - (ge == ">" - ? (ye = [ge, fe, ee, L.pos, b, f, p]) - : (ye = [ge, fe, ee, L.pos]), - f++, - d.push(ye), - ge === "#" || ge === "^") - ) - y.push(ye); - else if (ge === "/") { - if (((ae = y.pop()), !ae)) - throw new Error('Unopened section "' + fe + '" at ' + ee); - if (ae[1] !== fe) - throw new Error('Unclosed section "' + ae[1] + '" at ' + ee); - } else - ge === "name" || ge === "{" || ge === "&" - ? (S = !0) - : ge === "=" && G(fe); - } - if ((x(), (ae = y.pop()), ae)) - throw new Error('Unclosed section "' + ae[1] + '" at ' + L.pos); - return H(z(d)); - } - function z(A) { - for (var l = [], p, y, d = 0, v = A.length; d < v; ++d) - (p = A[d]), - p && - (p[0] === "text" && y && y[0] === "text" - ? ((y[1] += p[1]), (y[3] = p[3])) - : (l.push(p), (y = p))); - return l; - } - function H(A) { - for (var l = [], p = l, y = [], d, v, _ = 0, S = A.length; _ < S; ++_) - switch (((d = A[_]), d[0])) { - case "#": - case "^": - p.push(d), y.push(d), (p = d[4] = []); - break; - case "/": - (v = y.pop()), - (v[5] = d[2]), - (p = y.length > 0 ? y[y.length - 1][4] : l); - break; - default: - p.push(d); - } - return l; - } - function Z(A) { - (this.string = A), (this.tail = A), (this.pos = 0); - } - (Z.prototype.eos = function () { - return this.tail === ""; - }), - (Z.prototype.scan = function (l) { - var p = this.tail.match(l); - if (!p || p.index !== 0) return ""; - var y = p[0]; - return ( - (this.tail = this.tail.substring(y.length)), - (this.pos += y.length), - y - ); - }), - (Z.prototype.scanUntil = function (l) { - var p = this.tail.search(l), - y; - switch (p) { - case -1: - (y = this.tail), (this.tail = ""); - break; - case 0: - y = ""; - break; - default: - (y = this.tail.substring(0, p)), - (this.tail = this.tail.substring(p)); - } - return (this.pos += y.length), y; - }); - function $(A, l) { - (this.view = A), (this.cache = { ".": this.view }), (this.parent = l); - } - ($.prototype.push = function (l) { - return new $(l, this); - }), - ($.prototype.lookup = function (l) { - var p = this.cache, - y; - if (p.hasOwnProperty(l)) y = p[l]; - else { - for (var d = this, v, _, S, b = !1; d; ) { - if (l.indexOf(".") > 0) - for ( - v = d.view, _ = l.split("."), S = 0; - v != null && S < _.length; - - ) - S === _.length - 1 && (b = o(v, _[S]) || a(v, _[S])), - (v = v[_[S++]]); - else (v = d.view[l]), (b = o(d.view, l)); - if (b) { - y = v; - break; - } - d = d.parent; - } - p[l] = y; - } - return r(y) && (y = y.call(this.view)), y; - }); - function ue() { - this.templateCache = { - _cache: {}, - set: function (l, p) { - this._cache[l] = p; - }, - get: function (l) { - return this._cache[l]; - }, - clear: function () { - this._cache = {}; - }, - }; - } - (ue.prototype.clearCache = function () { - typeof this.templateCache < "u" && this.templateCache.clear(); - }), - (ue.prototype.parse = function (l, p) { - var y = this.templateCache, - d = l + ":" + (p || te.tags).join(":"), - v = typeof y < "u", - _ = v ? y.get(d) : void 0; - return _ == null && ((_ = q(l, p)), v && y.set(d, _)), _; - }), - (ue.prototype.render = function (l, p, y, d) { - var v = this.getConfigTags(d), - _ = this.parse(l, v), - S = p instanceof $ ? p : new $(p, void 0); - return this.renderTokens(_, S, y, l, d); - }), - (ue.prototype.renderTokens = function (l, p, y, d, v) { - for (var _ = "", S, b, f, x = 0, C = l.length; x < C; ++x) - (f = void 0), - (S = l[x]), - (b = S[0]), - b === "#" - ? (f = this.renderSection(S, p, y, d, v)) - : b === "^" - ? (f = this.renderInverted(S, p, y, d, v)) - : b === ">" - ? (f = this.renderPartial(S, p, y, v)) - : b === "&" - ? (f = this.unescapedValue(S, p)) - : b === "name" - ? (f = this.escapedValue(S, p, v)) - : b === "text" && (f = this.rawValue(S)), - f !== void 0 && (_ += f); - return _; - }), - (ue.prototype.renderSection = function (l, p, y, d, v) { - var _ = this, - S = "", - b = p.lookup(l[1]); - function f(E) { - return _.render(E, p, y, v); - } - if (!!b) { - if (e(b)) - for (var x = 0, C = b.length; x < C; ++x) - S += this.renderTokens(l[4], p.push(b[x]), y, d, v); - else if ( - typeof b == "object" || - typeof b == "string" || - typeof b == "number" - ) - S += this.renderTokens(l[4], p.push(b), y, d, v); - else if (r(b)) { - if (typeof d != "string") - throw new Error( - "Cannot use higher-order sections without the original template" - ); - (b = b.call(p.view, d.slice(l[3], l[5]), f)), - b != null && (S += b); - } else S += this.renderTokens(l[4], p, y, d, v); - return S; - } - }), - (ue.prototype.renderInverted = function (l, p, y, d, v) { - var _ = p.lookup(l[1]); - if (!_ || (e(_) && _.length === 0)) - return this.renderTokens(l[4], p, y, d, v); - }), - (ue.prototype.indentPartial = function (l, p, y) { - for ( - var d = p.replace(/[^ \t]/g, ""), - v = l.split(` -`), - _ = 0; - _ < v.length; - _++ - ) - v[_].length && (_ > 0 || !y) && (v[_] = d + v[_]); - return v.join(` -`); - }), - (ue.prototype.renderPartial = function (l, p, y, d) { - if (!!y) { - var v = this.getConfigTags(d), - _ = r(y) ? y(l[1]) : y[l[1]]; - if (_ != null) { - var S = l[6], - b = l[5], - f = l[4], - x = _; - b == 0 && f && (x = this.indentPartial(_, f, S)); - var C = this.parse(x, v); - return this.renderTokens(C, p, y, x, d); - } - } - }), - (ue.prototype.unescapedValue = function (l, p) { - var y = p.lookup(l[1]); - if (y != null) return y; - }), - (ue.prototype.escapedValue = function (l, p, y) { - var d = this.getConfigEscape(y) || te.escape, - v = p.lookup(l[1]); - if (v != null) - return typeof v == "number" && d === te.escape ? String(v) : d(v); - }), - (ue.prototype.rawValue = function (l) { - return l[1]; - }), - (ue.prototype.getConfigTags = function (l) { - return e(l) ? l : l && typeof l == "object" ? l.tags : void 0; - }), - (ue.prototype.getConfigEscape = function (l) { - if (l && typeof l == "object" && !e(l)) return l.escape; - }); - var te = { - name: "mustache.js", - version: "4.2.0", - tags: ["{{", "}}"], - clearCache: void 0, - escape: void 0, - parse: void 0, - render: void 0, - Scanner: void 0, - Context: void 0, - Writer: void 0, - set templateCache(A) { - ne.templateCache = A; - }, - get templateCache() { - return ne.templateCache; - }, - }, - ne = new ue(); - return ( - (te.clearCache = function () { - return ne.clearCache(); - }), - (te.parse = function (l, p) { - return ne.parse(l, p); - }), - (te.render = function (l, p, y, d) { - if (typeof l != "string") - throw new TypeError( - 'Invalid template! Template should be a "string" but "' + - n(l) + - '" was given as the first argument for mustache#render(template, view, partials)' - ); - return ne.render(l, p, y, d); - }), - (te.escape = M), - (te.Scanner = Z), - (te.Context = $), - (te.Writer = ue), - te - ); - }); - }); - var Ogt = I((V1n, Wkr) => { - Wkr.exports = { - schema: { - BadUTF16: { name: "BadUTF16", subtypes: [], props: {} }, - BadUTF8: { name: "BadUTF8", subtypes: [], props: {} }, - BalanceExceeded: { name: "BalanceExceeded", subtypes: [], props: {} }, - BreakpointTrap: { name: "BreakpointTrap", subtypes: [], props: {} }, - CacheError: { - name: "CacheError", - subtypes: [ - "ReadError", - "WriteError", - "DeserializationError", - "SerializationError", - ], - props: {}, - }, - CallIndirectOOB: { name: "CallIndirectOOB", subtypes: [], props: {} }, - CannotAppendActionToJointPromise: { - name: "CannotAppendActionToJointPromise", - subtypes: [], - props: {}, - }, - CannotReturnJointPromise: { - name: "CannotReturnJointPromise", - subtypes: [], - props: {}, - }, - CodeDoesNotExist: { - name: "CodeDoesNotExist", - subtypes: [], - props: { account_id: "" }, - }, - CompilationError: { - name: "CompilationError", - subtypes: ["CodeDoesNotExist", "PrepareError", "WasmerCompileError"], - props: {}, - }, - ContractSizeExceeded: { - name: "ContractSizeExceeded", - subtypes: [], - props: { limit: "", size: "" }, - }, - Deprecated: { - name: "Deprecated", - subtypes: [], - props: { method_name: "" }, - }, - Deserialization: { name: "Deserialization", subtypes: [], props: {} }, - DeserializationError: { - name: "DeserializationError", - subtypes: [], - props: {}, - }, - EmptyMethodName: { name: "EmptyMethodName", subtypes: [], props: {} }, - FunctionCallError: { - name: "FunctionCallError", - subtypes: [ - "CompilationError", - "LinkError", - "MethodResolveError", - "WasmTrap", - "WasmUnknownError", - "HostError", - "EvmError", - ], - props: {}, - }, - GasExceeded: { name: "GasExceeded", subtypes: [], props: {} }, - GasInstrumentation: { - name: "GasInstrumentation", - subtypes: [], - props: {}, - }, - GasLimitExceeded: { name: "GasLimitExceeded", subtypes: [], props: {} }, - GenericTrap: { name: "GenericTrap", subtypes: [], props: {} }, - GuestPanic: { - name: "GuestPanic", - subtypes: [], - props: { panic_msg: "" }, - }, - HostError: { - name: "HostError", - subtypes: [ - "BadUTF16", - "BadUTF8", - "GasExceeded", - "GasLimitExceeded", - "BalanceExceeded", - "EmptyMethodName", - "GuestPanic", - "IntegerOverflow", - "InvalidPromiseIndex", - "CannotAppendActionToJointPromise", - "CannotReturnJointPromise", - "InvalidPromiseResultIndex", - "InvalidRegisterId", - "IteratorWasInvalidated", - "MemoryAccessViolation", - "InvalidReceiptIndex", - "InvalidIteratorIndex", - "InvalidAccountId", - "InvalidMethodName", - "InvalidPublicKey", - "ProhibitedInView", - "NumberOfLogsExceeded", - "KeyLengthExceeded", - "ValueLengthExceeded", - "TotalLogLengthExceeded", - "NumberPromisesExceeded", - "NumberInputDataDependenciesExceeded", - "ReturnedValueLengthExceeded", - "ContractSizeExceeded", - "Deprecated", - ], - props: {}, - }, - IllegalArithmetic: { - name: "IllegalArithmetic", - subtypes: [], - props: {}, - }, - IncorrectCallIndirectSignature: { - name: "IncorrectCallIndirectSignature", - subtypes: [], - props: {}, - }, - Instantiate: { name: "Instantiate", subtypes: [], props: {} }, - IntegerOverflow: { name: "IntegerOverflow", subtypes: [], props: {} }, - InternalMemoryDeclared: { - name: "InternalMemoryDeclared", - subtypes: [], - props: {}, - }, - InvalidAccountId: { - name: "InvalidAccountId", - subtypes: [], - props: { account_id: "" }, - }, - InvalidIteratorIndex: { - name: "InvalidIteratorIndex", - subtypes: [], - props: { iterator_index: "" }, - }, - InvalidMethodName: { - name: "InvalidMethodName", - subtypes: [], - props: {}, - }, - InvalidPromiseIndex: { - name: "InvalidPromiseIndex", - subtypes: [], - props: { promise_idx: "" }, - }, - InvalidPromiseResultIndex: { - name: "InvalidPromiseResultIndex", - subtypes: [], - props: { result_idx: "" }, - }, - InvalidPublicKey: { name: "InvalidPublicKey", subtypes: [], props: {} }, - InvalidReceiptIndex: { - name: "InvalidReceiptIndex", - subtypes: [], - props: { receipt_index: "" }, - }, - InvalidRegisterId: { - name: "InvalidRegisterId", - subtypes: [], - props: { register_id: "" }, - }, - IteratorWasInvalidated: { - name: "IteratorWasInvalidated", - subtypes: [], - props: { iterator_index: "" }, - }, - KeyLengthExceeded: { - name: "KeyLengthExceeded", - subtypes: [], - props: { length: "", limit: "" }, - }, - LinkError: { name: "LinkError", subtypes: [], props: { msg: "" } }, - Memory: { name: "Memory", subtypes: [], props: {} }, - MemoryAccessViolation: { - name: "MemoryAccessViolation", - subtypes: [], - props: {}, - }, - MemoryOutOfBounds: { - name: "MemoryOutOfBounds", - subtypes: [], - props: {}, - }, - MethodEmptyName: { name: "MethodEmptyName", subtypes: [], props: {} }, - MethodInvalidSignature: { - name: "MethodInvalidSignature", - subtypes: [], - props: {}, - }, - MethodNotFound: { name: "MethodNotFound", subtypes: [], props: {} }, - MethodResolveError: { - name: "MethodResolveError", - subtypes: [ - "MethodEmptyName", - "MethodUTF8Error", - "MethodNotFound", - "MethodInvalidSignature", - ], - props: {}, - }, - MethodUTF8Error: { name: "MethodUTF8Error", subtypes: [], props: {} }, - MisalignedAtomicAccess: { - name: "MisalignedAtomicAccess", - subtypes: [], - props: {}, - }, - NumberInputDataDependenciesExceeded: { - name: "NumberInputDataDependenciesExceeded", - subtypes: [], - props: { limit: "", number_of_input_data_dependencies: "" }, - }, - NumberOfLogsExceeded: { - name: "NumberOfLogsExceeded", - subtypes: [], - props: { limit: "" }, - }, - NumberPromisesExceeded: { - name: "NumberPromisesExceeded", - subtypes: [], - props: { limit: "", number_of_promises: "" }, - }, - PrepareError: { - name: "PrepareError", - subtypes: [ - "Serialization", - "Deserialization", - "InternalMemoryDeclared", - "GasInstrumentation", - "StackHeightInstrumentation", - "Instantiate", - "Memory", - ], - props: {}, - }, - ProhibitedInView: { - name: "ProhibitedInView", - subtypes: [], - props: { method_name: "" }, - }, - ReadError: { name: "ReadError", subtypes: [], props: {} }, - ReturnedValueLengthExceeded: { - name: "ReturnedValueLengthExceeded", - subtypes: [], - props: { length: "", limit: "" }, - }, - Serialization: { name: "Serialization", subtypes: [], props: {} }, - SerializationError: { - name: "SerializationError", - subtypes: [], - props: { hash: "" }, - }, - StackHeightInstrumentation: { - name: "StackHeightInstrumentation", - subtypes: [], - props: {}, - }, - StackOverflow: { name: "StackOverflow", subtypes: [], props: {} }, - TotalLogLengthExceeded: { - name: "TotalLogLengthExceeded", - subtypes: [], - props: { length: "", limit: "" }, - }, - Unreachable: { name: "Unreachable", subtypes: [], props: {} }, - ValueLengthExceeded: { - name: "ValueLengthExceeded", - subtypes: [], - props: { length: "", limit: "" }, - }, - WasmTrap: { - name: "WasmTrap", - subtypes: [ - "Unreachable", - "IncorrectCallIndirectSignature", - "MemoryOutOfBounds", - "CallIndirectOOB", - "IllegalArithmetic", - "MisalignedAtomicAccess", - "BreakpointTrap", - "StackOverflow", - "GenericTrap", - ], - props: {}, - }, - WasmUnknownError: { name: "WasmUnknownError", subtypes: [], props: {} }, - WasmerCompileError: { - name: "WasmerCompileError", - subtypes: [], - props: { msg: "" }, - }, - WriteError: { name: "WriteError", subtypes: [], props: {} }, - AccessKeyNotFound: { - name: "AccessKeyNotFound", - subtypes: [], - props: { account_id: "", public_key: "" }, - }, - AccountAlreadyExists: { - name: "AccountAlreadyExists", - subtypes: [], - props: { account_id: "" }, - }, - AccountDoesNotExist: { - name: "AccountDoesNotExist", - subtypes: [], - props: { account_id: "" }, - }, - ActionError: { - name: "ActionError", - subtypes: [ - "AccountAlreadyExists", - "AccountDoesNotExist", - "CreateAccountOnlyByRegistrar", - "CreateAccountNotAllowed", - "ActorNoPermission", - "DeleteKeyDoesNotExist", - "AddKeyAlreadyExists", - "DeleteAccountStaking", - "LackBalanceForState", - "TriesToUnstake", - "TriesToStake", - "InsufficientStake", - "FunctionCallError", - "NewReceiptValidationError", - "OnlyImplicitAccountCreationAllowed", - ], - props: { index: "" }, - }, - ActionsValidationError: { - name: "ActionsValidationError", - subtypes: [ - "DeleteActionMustBeFinal", - "TotalPrepaidGasExceeded", - "TotalNumberOfActionsExceeded", - "AddKeyMethodNamesNumberOfBytesExceeded", - "AddKeyMethodNameLengthExceeded", - "IntegerOverflow", - "InvalidAccountId", - "ContractSizeExceeded", - "FunctionCallMethodNameLengthExceeded", - "FunctionCallArgumentsLengthExceeded", - "UnsuitableStakingKey", - "FunctionCallZeroAttachedGas", - ], - props: {}, - }, - ActorNoPermission: { - name: "ActorNoPermission", - subtypes: [], - props: { account_id: "", actor_id: "" }, - }, - AddKeyAlreadyExists: { - name: "AddKeyAlreadyExists", - subtypes: [], - props: { account_id: "", public_key: "" }, - }, - AddKeyMethodNameLengthExceeded: { - name: "AddKeyMethodNameLengthExceeded", - subtypes: [], - props: { length: "", limit: "" }, - }, - AddKeyMethodNamesNumberOfBytesExceeded: { - name: "AddKeyMethodNamesNumberOfBytesExceeded", - subtypes: [], - props: { limit: "", total_number_of_bytes: "" }, - }, - BalanceMismatchError: { - name: "BalanceMismatchError", - subtypes: [], - props: { - final_accounts_balance: "", - final_postponed_receipts_balance: "", - incoming_receipts_balance: "", - incoming_validator_rewards: "", - initial_accounts_balance: "", - initial_postponed_receipts_balance: "", - new_delayed_receipts_balance: "", - other_burnt_amount: "", - outgoing_receipts_balance: "", - processed_delayed_receipts_balance: "", - slashed_burnt_amount: "", - tx_burnt_amount: "", - }, - }, - CostOverflow: { name: "CostOverflow", subtypes: [], props: {} }, - CreateAccountNotAllowed: { - name: "CreateAccountNotAllowed", - subtypes: [], - props: { account_id: "", predecessor_id: "" }, - }, - CreateAccountOnlyByRegistrar: { - name: "CreateAccountOnlyByRegistrar", - subtypes: [], - props: { - account_id: "", - predecessor_id: "", - registrar_account_id: "", - }, - }, - DeleteAccountStaking: { - name: "DeleteAccountStaking", - subtypes: [], - props: { account_id: "" }, - }, - DeleteActionMustBeFinal: { - name: "DeleteActionMustBeFinal", - subtypes: [], - props: {}, - }, - DeleteKeyDoesNotExist: { - name: "DeleteKeyDoesNotExist", - subtypes: [], - props: { account_id: "", public_key: "" }, - }, - DepositWithFunctionCall: { - name: "DepositWithFunctionCall", - subtypes: [], - props: {}, - }, - Expired: { name: "Expired", subtypes: [], props: {} }, - FunctionCallArgumentsLengthExceeded: { - name: "FunctionCallArgumentsLengthExceeded", - subtypes: [], - props: { length: "", limit: "" }, - }, - FunctionCallMethodNameLengthExceeded: { - name: "FunctionCallMethodNameLengthExceeded", - subtypes: [], - props: { length: "", limit: "" }, - }, - FunctionCallZeroAttachedGas: { - name: "FunctionCallZeroAttachedGas", - subtypes: [], - props: {}, - }, - InsufficientStake: { - name: "InsufficientStake", - subtypes: [], - props: { account_id: "", minimum_stake: "", stake: "" }, - }, - InvalidAccessKeyError: { - name: "InvalidAccessKeyError", - subtypes: [ - "AccessKeyNotFound", - "ReceiverMismatch", - "MethodNameMismatch", - "RequiresFullAccess", - "NotEnoughAllowance", - "DepositWithFunctionCall", - ], - props: {}, - }, - InvalidChain: { name: "InvalidChain", subtypes: [], props: {} }, - InvalidDataReceiverId: { - name: "InvalidDataReceiverId", - subtypes: [], - props: { account_id: "" }, - }, - InvalidNonce: { - name: "InvalidNonce", - subtypes: [], - props: { ak_nonce: "", tx_nonce: "" }, - }, - InvalidPredecessorId: { - name: "InvalidPredecessorId", - subtypes: [], - props: { account_id: "" }, - }, - InvalidReceiverId: { - name: "InvalidReceiverId", - subtypes: [], - props: { account_id: "" }, - }, - InvalidSignature: { name: "InvalidSignature", subtypes: [], props: {} }, - InvalidSignerId: { - name: "InvalidSignerId", - subtypes: [], - props: { account_id: "" }, - }, - InvalidTxError: { - name: "InvalidTxError", - subtypes: [ - "InvalidAccessKeyError", - "InvalidSignerId", - "SignerDoesNotExist", - "InvalidNonce", - "InvalidReceiverId", - "InvalidSignature", - "NotEnoughBalance", - "LackBalanceForState", - "CostOverflow", - "InvalidChain", - "Expired", - "ActionsValidation", - ], - props: {}, - }, - LackBalanceForState: { - name: "LackBalanceForState", - subtypes: [], - props: { account_id: "", amount: "" }, - }, - MethodNameMismatch: { - name: "MethodNameMismatch", - subtypes: [], - props: { method_name: "" }, - }, - NotEnoughAllowance: { - name: "NotEnoughAllowance", - subtypes: [], - props: { account_id: "", allowance: "", cost: "", public_key: "" }, - }, - NotEnoughBalance: { - name: "NotEnoughBalance", - subtypes: [], - props: { balance: "", cost: "", signer_id: "" }, - }, - OnlyImplicitAccountCreationAllowed: { - name: "OnlyImplicitAccountCreationAllowed", - subtypes: [], - props: { account_id: "" }, - }, - ReceiptValidationError: { - name: "ReceiptValidationError", - subtypes: [ - "InvalidPredecessorId", - "InvalidReceiverId", - "InvalidSignerId", - "InvalidDataReceiverId", - "ReturnedValueLengthExceeded", - "NumberInputDataDependenciesExceeded", - "ActionsValidation", - ], - props: {}, - }, - ReceiverMismatch: { - name: "ReceiverMismatch", - subtypes: [], - props: { ak_receiver: "", tx_receiver: "" }, - }, - RequiresFullAccess: { - name: "RequiresFullAccess", - subtypes: [], - props: {}, - }, - SignerDoesNotExist: { - name: "SignerDoesNotExist", - subtypes: [], - props: { signer_id: "" }, - }, - TotalNumberOfActionsExceeded: { - name: "TotalNumberOfActionsExceeded", - subtypes: [], - props: { limit: "", total_number_of_actions: "" }, - }, - TotalPrepaidGasExceeded: { - name: "TotalPrepaidGasExceeded", - subtypes: [], - props: { limit: "", total_prepaid_gas: "" }, - }, - TriesToStake: { - name: "TriesToStake", - subtypes: [], - props: { account_id: "", balance: "", locked: "", stake: "" }, - }, - TriesToUnstake: { - name: "TriesToUnstake", - subtypes: [], - props: { account_id: "" }, - }, - TxExecutionError: { - name: "TxExecutionError", - subtypes: ["ActionError", "InvalidTxError"], - props: {}, - }, - UnsuitableStakingKey: { - name: "UnsuitableStakingKey", - subtypes: [], - props: { public_key: "" }, - }, - Closed: { name: "Closed", subtypes: [], props: {} }, - InternalError: { name: "InternalError", subtypes: [], props: {} }, - ServerError: { - name: "ServerError", - subtypes: ["TxExecutionError", "Timeout", "Closed", "InternalError"], - props: {}, - }, - Timeout: { name: "Timeout", subtypes: [], props: {} }, - }, - }; - }); - var Bgt = I((W1n, Gkr) => { - Gkr.exports = { - GasLimitExceeded: - "Exceeded the maximum amount of gas allowed to burn per contract", - MethodEmptyName: "Method name is empty", - WasmerCompileError: "Wasmer compilation error: {{msg}}", - GuestPanic: "Smart contract panicked: {{panic_msg}}", - Memory: "Error creating Wasm memory", - GasExceeded: "Exceeded the prepaid gas", - MethodUTF8Error: "Method name is not valid UTF8 string", - BadUTF16: "String encoding is bad UTF-16 sequence", - WasmTrap: "WebAssembly trap: {{msg}}", - GasInstrumentation: - "Gas instrumentation failed or contract has denied instructions.", - InvalidPromiseIndex: - "{{promise_idx}} does not correspond to existing promises", - InvalidPromiseResultIndex: - "Accessed invalid promise result index: {{result_idx}}", - Deserialization: "Error happened while deserializing the module", - MethodNotFound: "Contract method is not found", - InvalidRegisterId: "Accessed invalid register id: {{register_id}}", - InvalidReceiptIndex: - "VM Logic returned an invalid receipt index: {{receipt_index}}", - EmptyMethodName: "Method name is empty in contract call", - CannotReturnJointPromise: - "Returning joint promise is currently prohibited", - StackHeightInstrumentation: "Stack instrumentation failed", - CodeDoesNotExist: "Cannot find contract code for account {{account_id}}", - MethodInvalidSignature: "Invalid method signature", - IntegerOverflow: "Integer overflow happened during contract execution", - MemoryAccessViolation: "MemoryAccessViolation", - InvalidIteratorIndex: "Iterator index {{iterator_index}} does not exist", - IteratorWasInvalidated: - "Iterator {{iterator_index}} was invalidated after its creation by performing a mutable operation on trie", - InvalidAccountId: "VM Logic returned an invalid account id", - Serialization: "Error happened while serializing the module", - CannotAppendActionToJointPromise: - "Actions can only be appended to non-joint promise.", - InternalMemoryDeclared: - "Internal memory declaration has been found in the module", - Instantiate: "Error happened during instantiation", - ProhibitedInView: "{{method_name}} is not allowed in view calls", - InvalidMethodName: "VM Logic returned an invalid method name", - BadUTF8: "String encoding is bad UTF-8 sequence", - BalanceExceeded: "Exceeded the account balance", - LinkError: "Wasm contract link error: {{msg}}", - InvalidPublicKey: "VM Logic provided an invalid public key", - ActorNoPermission: - "Actor {{actor_id}} doesn't have permission to account {{account_id}} to complete the action", - LackBalanceForState: - "The account {{account_id}} wouldn't have enough balance to cover storage, required to have {{amount}} yoctoNEAR more", - ReceiverMismatch: - "Wrong AccessKey used for transaction: transaction is sent to receiver_id={{tx_receiver}}, but is signed with function call access key that restricted to only use with receiver_id={{ak_receiver}}. Either change receiver_id in your transaction or switch to use a FullAccessKey.", - CostOverflow: "Transaction gas or balance cost is too high", - InvalidSignature: "Transaction is not signed with the given public key", - AccessKeyNotFound: `Signer "{{account_id}}" doesn't have access key with the given public_key {{public_key}}`, - NotEnoughBalance: - "Sender {{signer_id}} does not have enough balance {{#formatNear}}{{balance}}{{/formatNear}} for operation costing {{#formatNear}}{{cost}}{{/formatNear}}", - NotEnoughAllowance: - "Access Key {account_id}:{public_key} does not have enough balance {{#formatNear}}{{allowance}}{{/formatNear}} for transaction costing {{#formatNear}}{{cost}}{{/formatNear}}", - Expired: "Transaction has expired", - DeleteAccountStaking: - "Account {{account_id}} is staking and can not be deleted", - SignerDoesNotExist: "Signer {{signer_id}} does not exist", - TriesToStake: - "Account {{account_id}} tried to stake {{#formatNear}}{{stake}}{{/formatNear}}, but has staked {{#formatNear}}{{locked}}{{/formatNear}} and only has {{#formatNear}}{{balance}}{{/formatNear}}", - AddKeyAlreadyExists: - "The public key {{public_key}} is already used for an existing access key", - InvalidSigner: - "Invalid signer account ID {{signer_id}} according to requirements", - CreateAccountNotAllowed: - "The new account_id {{account_id}} can't be created by {{predecessor_id}}", - RequiresFullAccess: - "The transaction contains more then one action, but it was signed with an access key which allows transaction to apply only one specific action. To apply more then one actions TX must be signed with a full access key", - TriesToUnstake: - "Account {{account_id}} is not yet staked, but tried to unstake", - InvalidNonce: - "Transaction nonce {{tx_nonce}} must be larger than nonce of the used access key {{ak_nonce}}", - AccountAlreadyExists: - "Can't create a new account {{account_id}}, because it already exists", - InvalidChain: - "Transaction parent block hash doesn't belong to the current chain", - AccountDoesNotExist: - "Can't complete the action because account {{account_id}} doesn't exist", - MethodNameMismatch: - "Transaction method name {{method_name}} isn't allowed by the access key", - DeleteAccountHasRent: - "Account {{account_id}} can't be deleted. It has {{#formatNear}}{{balance}}{{/formatNear}}, which is enough to cover the rent", - DeleteAccountHasEnoughBalance: - "Account {{account_id}} can't be deleted. It has {{#formatNear}}{{balance}}{{/formatNear}}, which is enough to cover it's storage", - InvalidReceiver: - "Invalid receiver account ID {{receiver_id}} according to requirements", - DeleteKeyDoesNotExist: - "Account {{account_id}} tries to remove an access key that doesn't exist", - Timeout: "Timeout exceeded", - Closed: "Connection closed", - }; - }); - var aoe = I((Xh) => { - "use strict"; - m(); - g(); - var fTe = - (Xh && Xh.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Xh, "__esModule", { value: !0 }); - Xh.getErrorTypeFromErrorMessage = - Xh.formatError = - Xh.parseResultError = - Xh.parseRpcError = - Xh.ServerError = - void 0; - var Jkr = fTe(Pgt()), - $kr = fTe(Ogt()), - Igt = fTe(Bgt()), - Zkr = dTe(), - Xkr = T6(), - Ykr = { - formatNear: () => (t, e) => Zkr.utils.format.formatNearAmount(e(t)), - }, - mH = class extends Xkr.TypedError {}; - Xh.ServerError = mH; - var lTe = class extends mH {}; - function Cgt(t) { - let e = {}, - r = Ngt(t, $kr.default.schema, e, ""), - n = new mH(Rgt(r, e), r); - return Object.assign(n, e), n; - } - Xh.parseRpcError = Cgt; - function Qkr(t) { - let e = Cgt(t.status.Failure), - r = new lTe(); - return ( - Object.assign(r, e), - (r.type = e.type), - (r.message = e.message), - (r.transaction_outcome = t.transaction_outcome), - r - ); - } - Xh.parseResultError = Qkr; - function Rgt(t, e) { - return typeof Igt.default[t] == "string" - ? Jkr.default.render(Igt.default[t], { ...e, ...Ykr }) - : JSON.stringify(e); - } - Xh.formatError = Rgt; - function Ngt(t, e, r, n) { - let i, o, a; - for (let s in e) { - if (tPr(t[s])) return t[s]; - if (cTe(t[s])) (i = t[s]), (o = e[s]), (a = s); - else if (cTe(t.kind) && cTe(t.kind[s])) - (i = t.kind[s]), (o = e[s]), (a = s); - else continue; - } - if (i && o) { - for (let s of Object.keys(o.props)) r[s] = i[s]; - return Ngt(i, e, r, a); - } else return (r.kind = t), n; - } - function ePr(t) { - switch (!0) { - case /^account .*? does not exist while viewing$/.test(t): - return "AccountDoesNotExist"; - case /^Account .*? doesn't exist$/.test(t): - return "AccountDoesNotExist"; - case /^access key .*? does not exist while viewing$/.test(t): - return "AccessKeyDoesNotExist"; - case /wasm execution failed with error: FunctionCallError\(CompilationError\(CodeDoesNotExist/.test( - t - ): - return "CodeDoesNotExist"; - case /Transaction nonce \d+ must be larger than nonce of the used access key \d+/.test( - t - ): - return "InvalidNonce"; - default: - return "UntypedError"; - } - } - Xh.getErrorTypeFromErrorMessage = ePr; - function cTe(t) { - return Object.prototype.toString.call(t) === "[object Object]"; - } - function tPr(t) { - return Object.prototype.toString.call(t) === "[object String]"; - } - }); - var qgt = I((Kb) => { - "use strict"; - m(); - g(); - var Lgt = - (Kb && Kb.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Kb, "__esModule", { value: !0 }); - Kb.JsonRpcProvider = Kb.ErrorContext = Kb.TypedError = void 0; - var soe = Lgt(E6()), - rPr = QMe(), - nPr = yH(), - k6 = T6(); - Object.defineProperty(Kb, "TypedError", { - enumerable: !0, - get: function () { - return k6.TypedError; - }, - }); - Object.defineProperty(Kb, "ErrorContext", { - enumerable: !0, - get: function () { - return k6.ErrorContext; - }, - }); - var Dgt = _E(), - iPr = Lgt(ooe()), - hTe = aoe(), - Fgt = 12, - oPr = 500, - aPr = 1.5, - sPr = 123, - pTe = class extends rPr.Provider { - constructor(e) { - super(), - e != null && typeof e == "object" - ? (this.connection = e) - : (soe.default("JsonRpcProvider(url?: string)")( - "use `JsonRpcProvider(connectionInfo: ConnectionInfo)` instead" - ), - (this.connection = { url: e })); - } - async status() { - return this.sendJsonRpc("status", []); - } - async sendTransaction(e) { - let r = e.encode(); - return this.sendJsonRpc("broadcast_tx_commit", [ - Buffer.from(r).toString("base64"), - ]); - } - async sendTransactionAsync(e) { - let r = e.encode(); - return this.sendJsonRpc("broadcast_tx_async", [ - Buffer.from(r).toString("base64"), - ]); - } - async txStatus(e, r) { - return typeof e == "string" - ? this.txStatusString(e, r) - : this.txStatusUint8Array(e, r); - } - async txStatusUint8Array(e, r) { - return this.sendJsonRpc("tx", [Dgt.baseEncode(e), r]); - } - async txStatusString(e, r) { - return this.sendJsonRpc("tx", [e, r]); - } - async txStatusReceipts(e, r) { - return this.sendJsonRpc("EXPERIMENTAL_tx_status", [ - Dgt.baseEncode(e), - r, - ]); - } - async query(...e) { - let r; - if (e.length === 1) r = await this.sendJsonRpc("query", e[0]); - else { - let [n, i] = e; - r = await this.sendJsonRpc("query", [n, i]); - } - if (r && r.error) - throw new k6.TypedError( - `Querying ${e} failed: ${r.error}. -${JSON.stringify(r, null, 2)}`, - hTe.getErrorTypeFromErrorMessage(r.error) - ); - return r; - } - async block(e) { - let { finality: r } = e, - { blockId: n } = e; - return ( - typeof e != "object" && - (soe.default("JsonRpcProvider.block(blockId)")( - "use `block({ blockId })` or `block({ finality })` instead" - ), - (n = e)), - this.sendJsonRpc("block", { block_id: n, finality: r }) - ); - } - async blockChanges(e) { - let { finality: r } = e, - { blockId: n } = e; - return this.sendJsonRpc("EXPERIMENTAL_changes_in_block", { - block_id: n, - finality: r, - }); - } - async chunk(e) { - return this.sendJsonRpc("chunk", [e]); - } - async validators(e) { - return this.sendJsonRpc("validators", [e]); - } - async experimental_genesisConfig() { - return ( - soe.default("JsonRpcProvider.experimental_protocolConfig()")( - "use `experimental_protocolConfig({ sync_checkpoint: 'genesis' })` to fetch the up-to-date or genesis protocol config explicitly" - ), - await this.sendJsonRpc("EXPERIMENTAL_protocol_config", { - sync_checkpoint: "genesis", - }) - ); - } - async experimental_protocolConfig(e) { - return await this.sendJsonRpc("EXPERIMENTAL_protocol_config", e); - } - async experimental_lightClientProof(e) { - return ( - soe.default( - "JsonRpcProvider.experimental_lightClientProof(request)" - )("use `lightClientProof` instead"), - await this.lightClientProof(e) - ); - } - async lightClientProof(e) { - return await this.sendJsonRpc("EXPERIMENTAL_light_client_proof", e); - } - async accessKeyChanges(e, r) { - let { finality: n } = r, - { blockId: i } = r; - return this.sendJsonRpc("EXPERIMENTAL_changes", { - changes_type: "all_access_key_changes", - account_ids: e, - block_id: i, - finality: n, - }); - } - async singleAccessKeyChanges(e, r) { - let { finality: n } = r, - { blockId: i } = r; - return this.sendJsonRpc("EXPERIMENTAL_changes", { - changes_type: "single_access_key_changes", - keys: e, - block_id: i, - finality: n, - }); - } - async accountChanges(e, r) { - let { finality: n } = r, - { blockId: i } = r; - return this.sendJsonRpc("EXPERIMENTAL_changes", { - changes_type: "account_changes", - account_ids: e, - block_id: i, - finality: n, - }); - } - async contractStateChanges(e, r, n = "") { - let { finality: i } = r, - { blockId: o } = r; - return this.sendJsonRpc("EXPERIMENTAL_changes", { - changes_type: "data_changes", - account_ids: e, - key_prefix_base64: n, - block_id: o, - finality: i, - }); - } - async contractCodeChanges(e, r) { - let { finality: n } = r, - { blockId: i } = r; - return this.sendJsonRpc("EXPERIMENTAL_changes", { - changes_type: "contract_code_changes", - account_ids: e, - block_id: i, - finality: n, - }); - } - async gasPrice(e) { - return await this.sendJsonRpc("gas_price", [e]); - } - async sendJsonRpc(e, r) { - let n = await iPr.default(oPr, Fgt, aPr, async () => { - try { - let o = { method: e, params: r, id: sPr++, jsonrpc: "2.0" }, - a = await nPr.fetchJson(this.connection, JSON.stringify(o)); - if (a.error) { - if (typeof a.error.data == "object") - throw typeof a.error.data.error_message == "string" && - typeof a.error.data.error_type == "string" - ? new k6.TypedError( - a.error.data.error_message, - a.error.data.error_type - ) - : hTe.parseRpcError(a.error.data); - { - let s = `[${a.error.code}] ${a.error.message}: ${a.error.data}`; - throw a.error.data === "Timeout" || - s.includes("Timeout error") || - s.includes("query has timed out") - ? new k6.TypedError(s, "TimeoutError") - : new k6.TypedError( - s, - hTe.getErrorTypeFromErrorMessage(a.error.data) - ); - } - } - return a; - } catch (o) { - if (o.type === "TimeoutError") - return ( - process.env.NEAR_NO_LOGS || - console.warn( - `Retrying request to ${e} as it has timed out`, - r - ), - null - ); - throw o; - } - }), - { result: i } = n; - if (typeof i > "u") - throw new k6.TypedError( - `Exceeded ${Fgt} attempts for request to ${e}.`, - "RetriesExceeded" - ); - return i; - } - }; - Kb.JsonRpcProvider = pTe; - }); - var rN = I((Yh) => { - "use strict"; - m(); - g(); - Object.defineProperty(Yh, "__esModule", { value: !0 }); - Yh.ErrorContext = - Yh.TypedError = - Yh.getTransactionLastResult = - Yh.FinalExecutionStatusBasic = - Yh.JsonRpcProvider = - Yh.Provider = - void 0; - var yTe = QMe(); - Object.defineProperty(Yh, "Provider", { - enumerable: !0, - get: function () { - return yTe.Provider; - }, - }); - Object.defineProperty(Yh, "getTransactionLastResult", { - enumerable: !0, - get: function () { - return yTe.getTransactionLastResult; - }, - }); - Object.defineProperty(Yh, "FinalExecutionStatusBasic", { - enumerable: !0, - get: function () { - return yTe.FinalExecutionStatusBasic; - }, - }); - var mTe = qgt(); - Object.defineProperty(Yh, "JsonRpcProvider", { - enumerable: !0, - get: function () { - return mTe.JsonRpcProvider; - }, - }); - Object.defineProperty(Yh, "TypedError", { - enumerable: !0, - get: function () { - return mTe.TypedError; - }, - }); - Object.defineProperty(Yh, "ErrorContext", { - enumerable: !0, - get: function () { - return mTe.ErrorContext; - }, - }); - }); - var AE = I((zgt, gTe) => { - m(); - g(); - (function (t, e) { - "use strict"; - function r(y, d) { - if (!y) throw new Error(d || "Assertion failed"); - } - function n(y, d) { - y.super_ = d; - var v = function () {}; - (v.prototype = d.prototype), - (y.prototype = new v()), - (y.prototype.constructor = y); - } - function i(y, d, v) { - if (i.isBN(y)) return y; - (this.negative = 0), - (this.words = null), - (this.length = 0), - (this.red = null), - y !== null && - ((d === "le" || d === "be") && ((v = d), (d = 10)), - this._init(y || 0, d || 10, v || "be")); - } - typeof t == "object" ? (t.exports = i) : (e.BN = i), - (i.BN = i), - (i.wordSize = 26); - var o; - try { - typeof window < "u" && typeof window.Buffer < "u" - ? (o = window.Buffer) - : (o = Qr().Buffer); - } catch {} - (i.isBN = function (d) { - return d instanceof i - ? !0 - : d !== null && - typeof d == "object" && - d.constructor.wordSize === i.wordSize && - Array.isArray(d.words); - }), - (i.max = function (d, v) { - return d.cmp(v) > 0 ? d : v; - }), - (i.min = function (d, v) { - return d.cmp(v) < 0 ? d : v; - }), - (i.prototype._init = function (d, v, _) { - if (typeof d == "number") return this._initNumber(d, v, _); - if (typeof d == "object") return this._initArray(d, v, _); - v === "hex" && (v = 16), - r(v === (v | 0) && v >= 2 && v <= 36), - (d = d.toString().replace(/\s+/g, "")); - var S = 0; - d[0] === "-" && (S++, (this.negative = 1)), - S < d.length && - (v === 16 - ? this._parseHex(d, S, _) - : (this._parseBase(d, v, S), - _ === "le" && this._initArray(this.toArray(), v, _))); - }), - (i.prototype._initNumber = function (d, v, _) { - d < 0 && ((this.negative = 1), (d = -d)), - d < 67108864 - ? ((this.words = [d & 67108863]), (this.length = 1)) - : d < 4503599627370496 - ? ((this.words = [d & 67108863, (d / 67108864) & 67108863]), - (this.length = 2)) - : (r(d < 9007199254740992), - (this.words = [d & 67108863, (d / 67108864) & 67108863, 1]), - (this.length = 3)), - _ === "le" && this._initArray(this.toArray(), v, _); - }), - (i.prototype._initArray = function (d, v, _) { - if ((r(typeof d.length == "number"), d.length <= 0)) - return (this.words = [0]), (this.length = 1), this; - (this.length = Math.ceil(d.length / 3)), - (this.words = new Array(this.length)); - for (var S = 0; S < this.length; S++) this.words[S] = 0; - var b, - f, - x = 0; - if (_ === "be") - for (S = d.length - 1, b = 0; S >= 0; S -= 3) - (f = d[S] | (d[S - 1] << 8) | (d[S - 2] << 16)), - (this.words[b] |= (f << x) & 67108863), - (this.words[b + 1] = (f >>> (26 - x)) & 67108863), - (x += 24), - x >= 26 && ((x -= 26), b++); - else if (_ === "le") - for (S = 0, b = 0; S < d.length; S += 3) - (f = d[S] | (d[S + 1] << 8) | (d[S + 2] << 16)), - (this.words[b] |= (f << x) & 67108863), - (this.words[b + 1] = (f >>> (26 - x)) & 67108863), - (x += 24), - x >= 26 && ((x -= 26), b++); - return this._strip(); - }); - function a(y, d) { - var v = y.charCodeAt(d); - if (v >= 48 && v <= 57) return v - 48; - if (v >= 65 && v <= 70) return v - 55; - if (v >= 97 && v <= 102) return v - 87; - r(!1, "Invalid character in " + y); - } - function s(y, d, v) { - var _ = a(y, v); - return v - 1 >= d && (_ |= a(y, v - 1) << 4), _; - } - i.prototype._parseHex = function (d, v, _) { - (this.length = Math.ceil((d.length - v) / 6)), - (this.words = new Array(this.length)); - for (var S = 0; S < this.length; S++) this.words[S] = 0; - var b = 0, - f = 0, - x; - if (_ === "be") - for (S = d.length - 1; S >= v; S -= 2) - (x = s(d, v, S) << b), - (this.words[f] |= x & 67108863), - b >= 18 - ? ((b -= 18), (f += 1), (this.words[f] |= x >>> 26)) - : (b += 8); - else { - var C = d.length - v; - for (S = C % 2 === 0 ? v + 1 : v; S < d.length; S += 2) - (x = s(d, v, S) << b), - (this.words[f] |= x & 67108863), - b >= 18 - ? ((b -= 18), (f += 1), (this.words[f] |= x >>> 26)) - : (b += 8); - } - this._strip(); - }; - function c(y, d, v, _) { - for (var S = 0, b = 0, f = Math.min(y.length, v), x = d; x < f; x++) { - var C = y.charCodeAt(x) - 48; - (S *= _), - C >= 49 ? (b = C - 49 + 10) : C >= 17 ? (b = C - 17 + 10) : (b = C), - r(C >= 0 && b < _, "Invalid character"), - (S += b); - } - return S; - } - (i.prototype._parseBase = function (d, v, _) { - (this.words = [0]), (this.length = 1); - for (var S = 0, b = 1; b <= 67108863; b *= v) S++; - S--, (b = (b / v) | 0); - for ( - var f = d.length - _, - x = f % S, - C = Math.min(f, f - x) + _, - E = 0, - B = _; - B < C; - B += S - ) - (E = c(d, B, B + S, v)), - this.imuln(b), - this.words[0] + E < 67108864 - ? (this.words[0] += E) - : this._iaddn(E); - if (x !== 0) { - var G = 1; - for (E = c(d, B, d.length, v), B = 0; B < x; B++) G *= v; - this.imuln(G), - this.words[0] + E < 67108864 - ? (this.words[0] += E) - : this._iaddn(E); - } - this._strip(); - }), - (i.prototype.copy = function (d) { - d.words = new Array(this.length); - for (var v = 0; v < this.length; v++) d.words[v] = this.words[v]; - (d.length = this.length), - (d.negative = this.negative), - (d.red = this.red); - }); - function u(y, d) { - (y.words = d.words), - (y.length = d.length), - (y.negative = d.negative), - (y.red = d.red); - } - if ( - ((i.prototype._move = function (d) { - u(d, this); - }), - (i.prototype.clone = function () { - var d = new i(null); - return this.copy(d), d; - }), - (i.prototype._expand = function (d) { - for (; this.length < d; ) this.words[this.length++] = 0; - return this; - }), - (i.prototype._strip = function () { - for (; this.length > 1 && this.words[this.length - 1] === 0; ) - this.length--; - return this._normSign(); - }), - (i.prototype._normSign = function () { - return ( - this.length === 1 && this.words[0] === 0 && (this.negative = 0), - this - ); - }), - typeof Symbol < "u" && typeof Symbol.for == "function") - ) - try { - i.prototype[Symbol.for("nodejs.util.inspect.custom")] = h; - } catch { - i.prototype.inspect = h; - } - else i.prototype.inspect = h; - function h() { - return (this.red ? ""; - } - var w = [ - "", - "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", - ], - M = [ - 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, - ], - k = [ - 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, - ]; - (i.prototype.toString = function (d, v) { - (d = d || 10), (v = v | 0 || 1); - var _; - if (d === 16 || d === "hex") { - _ = ""; - for (var S = 0, b = 0, f = 0; f < this.length; f++) { - var x = this.words[f], - C = (((x << S) | b) & 16777215).toString(16); - (b = (x >>> (24 - S)) & 16777215), - b !== 0 || f !== this.length - 1 - ? (_ = w[6 - C.length] + C + _) - : (_ = C + _), - (S += 2), - S >= 26 && ((S -= 26), f--); - } - for (b !== 0 && (_ = b.toString(16) + _); _.length % v !== 0; ) - _ = "0" + _; - return this.negative !== 0 && (_ = "-" + _), _; - } - if (d === (d | 0) && d >= 2 && d <= 36) { - var E = M[d], - B = k[d]; - _ = ""; - var G = this.clone(); - for (G.negative = 0; !G.isZero(); ) { - var L = G.modrn(B).toString(d); - (G = G.idivn(B)), - G.isZero() ? (_ = L + _) : (_ = w[E - L.length] + L + _); - } - for (this.isZero() && (_ = "0" + _); _.length % v !== 0; ) - _ = "0" + _; - return this.negative !== 0 && (_ = "-" + _), _; - } - r(!1, "Base should be between 2 and 36"); - }), - (i.prototype.toNumber = function () { - var d = this.words[0]; - return ( - this.length === 2 - ? (d += this.words[1] * 67108864) - : this.length === 3 && this.words[2] === 1 - ? (d += 4503599627370496 + this.words[1] * 67108864) - : this.length > 2 && - r(!1, "Number can only safely store up to 53 bits"), - this.negative !== 0 ? -d : d - ); - }), - (i.prototype.toJSON = function () { - return this.toString(16, 2); - }), - o && - (i.prototype.toBuffer = function (d, v) { - return this.toArrayLike(o, d, v); - }), - (i.prototype.toArray = function (d, v) { - return this.toArrayLike(Array, d, v); - }); - var O = function (d, v) { - return d.allocUnsafe ? d.allocUnsafe(v) : new d(v); - }; - (i.prototype.toArrayLike = function (d, v, _) { - this._strip(); - var S = this.byteLength(), - b = _ || Math.max(1, S); - r(S <= b, "byte array longer than desired length"), - r(b > 0, "Requested array length <= 0"); - var f = O(d, b), - x = v === "le" ? "LE" : "BE"; - return this["_toArrayLike" + x](f, S), f; - }), - (i.prototype._toArrayLikeLE = function (d, v) { - for (var _ = 0, S = 0, b = 0, f = 0; b < this.length; b++) { - var x = (this.words[b] << f) | S; - (d[_++] = x & 255), - _ < d.length && (d[_++] = (x >> 8) & 255), - _ < d.length && (d[_++] = (x >> 16) & 255), - f === 6 - ? (_ < d.length && (d[_++] = (x >> 24) & 255), (S = 0), (f = 0)) - : ((S = x >>> 24), (f += 2)); - } - if (_ < d.length) for (d[_++] = S; _ < d.length; ) d[_++] = 0; - }), - (i.prototype._toArrayLikeBE = function (d, v) { - for ( - var _ = d.length - 1, S = 0, b = 0, f = 0; - b < this.length; - b++ - ) { - var x = (this.words[b] << f) | S; - (d[_--] = x & 255), - _ >= 0 && (d[_--] = (x >> 8) & 255), - _ >= 0 && (d[_--] = (x >> 16) & 255), - f === 6 - ? (_ >= 0 && (d[_--] = (x >> 24) & 255), (S = 0), (f = 0)) - : ((S = x >>> 24), (f += 2)); - } - if (_ >= 0) for (d[_--] = S; _ >= 0; ) d[_--] = 0; - }), - Math.clz32 - ? (i.prototype._countBits = function (d) { - return 32 - Math.clz32(d); - }) - : (i.prototype._countBits = function (d) { - var v = d, - _ = 0; - return ( - v >= 4096 && ((_ += 13), (v >>>= 13)), - v >= 64 && ((_ += 7), (v >>>= 7)), - v >= 8 && ((_ += 4), (v >>>= 4)), - v >= 2 && ((_ += 2), (v >>>= 2)), - _ + v - ); - }), - (i.prototype._zeroBits = function (d) { - if (d === 0) return 26; - var v = d, - _ = 0; - return ( - (v & 8191) === 0 && ((_ += 13), (v >>>= 13)), - (v & 127) === 0 && ((_ += 7), (v >>>= 7)), - (v & 15) === 0 && ((_ += 4), (v >>>= 4)), - (v & 3) === 0 && ((_ += 2), (v >>>= 2)), - (v & 1) === 0 && _++, - _ - ); - }), - (i.prototype.bitLength = function () { - var d = this.words[this.length - 1], - v = this._countBits(d); - return (this.length - 1) * 26 + v; - }); - function D(y) { - for (var d = new Array(y.bitLength()), v = 0; v < d.length; v++) { - var _ = (v / 26) | 0, - S = v % 26; - d[v] = (y.words[_] >>> S) & 1; - } - return d; - } - (i.prototype.zeroBits = function () { - if (this.isZero()) return 0; - for (var d = 0, v = 0; v < this.length; v++) { - var _ = this._zeroBits(this.words[v]); - if (((d += _), _ !== 26)) break; - } - return d; - }), - (i.prototype.byteLength = function () { - return Math.ceil(this.bitLength() / 8); - }), - (i.prototype.toTwos = function (d) { - return this.negative !== 0 - ? this.abs().inotn(d).iaddn(1) - : this.clone(); - }), - (i.prototype.fromTwos = function (d) { - return this.testn(d - 1) - ? this.notn(d).iaddn(1).ineg() - : this.clone(); - }), - (i.prototype.isNeg = function () { - return this.negative !== 0; - }), - (i.prototype.neg = function () { - return this.clone().ineg(); - }), - (i.prototype.ineg = function () { - return this.isZero() || (this.negative ^= 1), this; - }), - (i.prototype.iuor = function (d) { - for (; this.length < d.length; ) this.words[this.length++] = 0; - for (var v = 0; v < d.length; v++) - this.words[v] = this.words[v] | d.words[v]; - return this._strip(); - }), - (i.prototype.ior = function (d) { - return r((this.negative | d.negative) === 0), this.iuor(d); - }), - (i.prototype.or = function (d) { - return this.length > d.length - ? this.clone().ior(d) - : d.clone().ior(this); - }), - (i.prototype.uor = function (d) { - return this.length > d.length - ? this.clone().iuor(d) - : d.clone().iuor(this); - }), - (i.prototype.iuand = function (d) { - var v; - this.length > d.length ? (v = d) : (v = this); - for (var _ = 0; _ < v.length; _++) - this.words[_] = this.words[_] & d.words[_]; - return (this.length = v.length), this._strip(); - }), - (i.prototype.iand = function (d) { - return r((this.negative | d.negative) === 0), this.iuand(d); - }), - (i.prototype.and = function (d) { - return this.length > d.length - ? this.clone().iand(d) - : d.clone().iand(this); - }), - (i.prototype.uand = function (d) { - return this.length > d.length - ? this.clone().iuand(d) - : d.clone().iuand(this); - }), - (i.prototype.iuxor = function (d) { - var v, _; - this.length > d.length - ? ((v = this), (_ = d)) - : ((v = d), (_ = this)); - for (var S = 0; S < _.length; S++) - this.words[S] = v.words[S] ^ _.words[S]; - if (this !== v) for (; S < v.length; S++) this.words[S] = v.words[S]; - return (this.length = v.length), this._strip(); - }), - (i.prototype.ixor = function (d) { - return r((this.negative | d.negative) === 0), this.iuxor(d); - }), - (i.prototype.xor = function (d) { - return this.length > d.length - ? this.clone().ixor(d) - : d.clone().ixor(this); - }), - (i.prototype.uxor = function (d) { - return this.length > d.length - ? this.clone().iuxor(d) - : d.clone().iuxor(this); - }), - (i.prototype.inotn = function (d) { - r(typeof d == "number" && d >= 0); - var v = Math.ceil(d / 26) | 0, - _ = d % 26; - this._expand(v), _ > 0 && v--; - for (var S = 0; S < v; S++) this.words[S] = ~this.words[S] & 67108863; - return ( - _ > 0 && (this.words[S] = ~this.words[S] & (67108863 >> (26 - _))), - this._strip() - ); - }), - (i.prototype.notn = function (d) { - return this.clone().inotn(d); - }), - (i.prototype.setn = function (d, v) { - r(typeof d == "number" && d >= 0); - var _ = (d / 26) | 0, - S = d % 26; - return ( - this._expand(_ + 1), - v - ? (this.words[_] = this.words[_] | (1 << S)) - : (this.words[_] = this.words[_] & ~(1 << S)), - this._strip() - ); - }), - (i.prototype.iadd = function (d) { - var v; - if (this.negative !== 0 && d.negative === 0) - return ( - (this.negative = 0), - (v = this.isub(d)), - (this.negative ^= 1), - this._normSign() - ); - if (this.negative === 0 && d.negative !== 0) - return ( - (d.negative = 0), - (v = this.isub(d)), - (d.negative = 1), - v._normSign() - ); - var _, S; - this.length > d.length - ? ((_ = this), (S = d)) - : ((_ = d), (S = this)); - for (var b = 0, f = 0; f < S.length; f++) - (v = (_.words[f] | 0) + (S.words[f] | 0) + b), - (this.words[f] = v & 67108863), - (b = v >>> 26); - for (; b !== 0 && f < _.length; f++) - (v = (_.words[f] | 0) + b), - (this.words[f] = v & 67108863), - (b = v >>> 26); - if (((this.length = _.length), b !== 0)) - (this.words[this.length] = b), this.length++; - else if (_ !== this) - for (; f < _.length; f++) this.words[f] = _.words[f]; - return this; - }), - (i.prototype.add = function (d) { - var v; - return d.negative !== 0 && this.negative === 0 - ? ((d.negative = 0), (v = this.sub(d)), (d.negative ^= 1), v) - : d.negative === 0 && this.negative !== 0 - ? ((this.negative = 0), (v = d.sub(this)), (this.negative = 1), v) - : this.length > d.length - ? this.clone().iadd(d) - : d.clone().iadd(this); - }), - (i.prototype.isub = function (d) { - if (d.negative !== 0) { - d.negative = 0; - var v = this.iadd(d); - return (d.negative = 1), v._normSign(); - } else if (this.negative !== 0) - return ( - (this.negative = 0), - this.iadd(d), - (this.negative = 1), - this._normSign() - ); - var _ = this.cmp(d); - if (_ === 0) - return ( - (this.negative = 0), (this.length = 1), (this.words[0] = 0), this - ); - var S, b; - _ > 0 ? ((S = this), (b = d)) : ((S = d), (b = this)); - for (var f = 0, x = 0; x < b.length; x++) - (v = (S.words[x] | 0) - (b.words[x] | 0) + f), - (f = v >> 26), - (this.words[x] = v & 67108863); - for (; f !== 0 && x < S.length; x++) - (v = (S.words[x] | 0) + f), - (f = v >> 26), - (this.words[x] = v & 67108863); - if (f === 0 && x < S.length && S !== this) - for (; x < S.length; x++) this.words[x] = S.words[x]; - return ( - (this.length = Math.max(this.length, x)), - S !== this && (this.negative = 1), - this._strip() - ); - }), - (i.prototype.sub = function (d) { - return this.clone().isub(d); - }); - function F(y, d, v) { - v.negative = d.negative ^ y.negative; - var _ = (y.length + d.length) | 0; - (v.length = _), (_ = (_ - 1) | 0); - var S = y.words[0] | 0, - b = d.words[0] | 0, - f = S * b, - x = f & 67108863, - C = (f / 67108864) | 0; - v.words[0] = x; - for (var E = 1; E < _; E++) { - for ( - var B = C >>> 26, - G = C & 67108863, - L = Math.min(E, d.length - 1), - ee = Math.max(0, E - y.length + 1); - ee <= L; - ee++ - ) { - var ge = (E - ee) | 0; - (S = y.words[ge] | 0), - (b = d.words[ee] | 0), - (f = S * b + G), - (B += (f / 67108864) | 0), - (G = f & 67108863); - } - (v.words[E] = G | 0), (C = B | 0); - } - return C !== 0 ? (v.words[E] = C | 0) : v.length--, v._strip(); - } - var N = function (d, v, _) { - var S = d.words, - b = v.words, - f = _.words, - x = 0, - C, - E, - B, - G = S[0] | 0, - L = G & 8191, - ee = G >>> 13, - ge = S[1] | 0, - fe = ge & 8191, - V = ge >>> 13, - ye = S[2] | 0, - ae = ye & 8191, - le = ye >>> 13, - Me = S[3] | 0, - de = Me & 8191, - ve = Me >>> 13, - De = S[4] | 0, - me = De & 8191, - _e = De >>> 13, - Ye = S[5] | 0, - Ee = Ye & 8191, - Be = Ye >>> 13, - kt = S[6] | 0, - Ve = kt & 8191, - We = kt >>> 13, - er = S[7] | 0, - Ue = er & 8191, - Y = er >>> 13, - W = S[8] | 0, - j = W & 8191, - ce = W >>> 13, - ze = S[9] | 0, - we = ze & 8191, - xe = ze >>> 13, - Ft = b[0] | 0, - Ke = Ft & 8191, - pe = Ft >>> 13, - Re = b[1] | 0, - Se = Re & 8191, - Pe = Re >>> 13, - At = b[2] | 0, - Ie = At & 8191, - je = At >>> 13, - qt = b[3] | 0, - Fe = qt & 8191, - He = qt >>> 13, - lr = b[4] | 0, - Xe = lr & 8191, - Ze = lr >>> 13, - Ir = b[5] | 0, - $e = Ir & 8191, - tt = Ir >>> 13, - oe = b[6] | 0, - ie = oe & 8191, - re = oe >>> 13, - U = b[7] | 0, - se = U & 8191, - be = U >>> 13, - Qe = b[8] | 0, - Ae = Qe & 8191, - ke = Qe >>> 13, - Ct = b[9] | 0, - ut = Ct & 8191, - St = Ct >>> 13; - (_.negative = d.negative ^ v.negative), - (_.length = 19), - (C = Math.imul(L, Ke)), - (E = Math.imul(L, pe)), - (E = (E + Math.imul(ee, Ke)) | 0), - (B = Math.imul(ee, pe)); - var wt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (wt >>> 26)) | 0), - (wt &= 67108863), - (C = Math.imul(fe, Ke)), - (E = Math.imul(fe, pe)), - (E = (E + Math.imul(V, Ke)) | 0), - (B = Math.imul(V, pe)), - (C = (C + Math.imul(L, Se)) | 0), - (E = (E + Math.imul(L, Pe)) | 0), - (E = (E + Math.imul(ee, Se)) | 0), - (B = (B + Math.imul(ee, Pe)) | 0); - var zt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (zt >>> 26)) | 0), - (zt &= 67108863), - (C = Math.imul(ae, Ke)), - (E = Math.imul(ae, pe)), - (E = (E + Math.imul(le, Ke)) | 0), - (B = Math.imul(le, pe)), - (C = (C + Math.imul(fe, Se)) | 0), - (E = (E + Math.imul(fe, Pe)) | 0), - (E = (E + Math.imul(V, Se)) | 0), - (B = (B + Math.imul(V, Pe)) | 0), - (C = (C + Math.imul(L, Ie)) | 0), - (E = (E + Math.imul(L, je)) | 0), - (E = (E + Math.imul(ee, Ie)) | 0), - (B = (B + Math.imul(ee, je)) | 0); - var jt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (jt >>> 26)) | 0), - (jt &= 67108863), - (C = Math.imul(de, Ke)), - (E = Math.imul(de, pe)), - (E = (E + Math.imul(ve, Ke)) | 0), - (B = Math.imul(ve, pe)), - (C = (C + Math.imul(ae, Se)) | 0), - (E = (E + Math.imul(ae, Pe)) | 0), - (E = (E + Math.imul(le, Se)) | 0), - (B = (B + Math.imul(le, Pe)) | 0), - (C = (C + Math.imul(fe, Ie)) | 0), - (E = (E + Math.imul(fe, je)) | 0), - (E = (E + Math.imul(V, Ie)) | 0), - (B = (B + Math.imul(V, je)) | 0), - (C = (C + Math.imul(L, Fe)) | 0), - (E = (E + Math.imul(L, He)) | 0), - (E = (E + Math.imul(ee, Fe)) | 0), - (B = (B + Math.imul(ee, He)) | 0); - var Ht = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (Ht >>> 26)) | 0), - (Ht &= 67108863), - (C = Math.imul(me, Ke)), - (E = Math.imul(me, pe)), - (E = (E + Math.imul(_e, Ke)) | 0), - (B = Math.imul(_e, pe)), - (C = (C + Math.imul(de, Se)) | 0), - (E = (E + Math.imul(de, Pe)) | 0), - (E = (E + Math.imul(ve, Se)) | 0), - (B = (B + Math.imul(ve, Pe)) | 0), - (C = (C + Math.imul(ae, Ie)) | 0), - (E = (E + Math.imul(ae, je)) | 0), - (E = (E + Math.imul(le, Ie)) | 0), - (B = (B + Math.imul(le, je)) | 0), - (C = (C + Math.imul(fe, Fe)) | 0), - (E = (E + Math.imul(fe, He)) | 0), - (E = (E + Math.imul(V, Fe)) | 0), - (B = (B + Math.imul(V, He)) | 0), - (C = (C + Math.imul(L, Xe)) | 0), - (E = (E + Math.imul(L, Ze)) | 0), - (E = (E + Math.imul(ee, Xe)) | 0), - (B = (B + Math.imul(ee, Ze)) | 0); - var Ut = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (Ut >>> 26)) | 0), - (Ut &= 67108863), - (C = Math.imul(Ee, Ke)), - (E = Math.imul(Ee, pe)), - (E = (E + Math.imul(Be, Ke)) | 0), - (B = Math.imul(Be, pe)), - (C = (C + Math.imul(me, Se)) | 0), - (E = (E + Math.imul(me, Pe)) | 0), - (E = (E + Math.imul(_e, Se)) | 0), - (B = (B + Math.imul(_e, Pe)) | 0), - (C = (C + Math.imul(de, Ie)) | 0), - (E = (E + Math.imul(de, je)) | 0), - (E = (E + Math.imul(ve, Ie)) | 0), - (B = (B + Math.imul(ve, je)) | 0), - (C = (C + Math.imul(ae, Fe)) | 0), - (E = (E + Math.imul(ae, He)) | 0), - (E = (E + Math.imul(le, Fe)) | 0), - (B = (B + Math.imul(le, He)) | 0), - (C = (C + Math.imul(fe, Xe)) | 0), - (E = (E + Math.imul(fe, Ze)) | 0), - (E = (E + Math.imul(V, Xe)) | 0), - (B = (B + Math.imul(V, Ze)) | 0), - (C = (C + Math.imul(L, $e)) | 0), - (E = (E + Math.imul(L, tt)) | 0), - (E = (E + Math.imul(ee, $e)) | 0), - (B = (B + Math.imul(ee, tt)) | 0); - var Kt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (Kt >>> 26)) | 0), - (Kt &= 67108863), - (C = Math.imul(Ve, Ke)), - (E = Math.imul(Ve, pe)), - (E = (E + Math.imul(We, Ke)) | 0), - (B = Math.imul(We, pe)), - (C = (C + Math.imul(Ee, Se)) | 0), - (E = (E + Math.imul(Ee, Pe)) | 0), - (E = (E + Math.imul(Be, Se)) | 0), - (B = (B + Math.imul(Be, Pe)) | 0), - (C = (C + Math.imul(me, Ie)) | 0), - (E = (E + Math.imul(me, je)) | 0), - (E = (E + Math.imul(_e, Ie)) | 0), - (B = (B + Math.imul(_e, je)) | 0), - (C = (C + Math.imul(de, Fe)) | 0), - (E = (E + Math.imul(de, He)) | 0), - (E = (E + Math.imul(ve, Fe)) | 0), - (B = (B + Math.imul(ve, He)) | 0), - (C = (C + Math.imul(ae, Xe)) | 0), - (E = (E + Math.imul(ae, Ze)) | 0), - (E = (E + Math.imul(le, Xe)) | 0), - (B = (B + Math.imul(le, Ze)) | 0), - (C = (C + Math.imul(fe, $e)) | 0), - (E = (E + Math.imul(fe, tt)) | 0), - (E = (E + Math.imul(V, $e)) | 0), - (B = (B + Math.imul(V, tt)) | 0), - (C = (C + Math.imul(L, ie)) | 0), - (E = (E + Math.imul(L, re)) | 0), - (E = (E + Math.imul(ee, ie)) | 0), - (B = (B + Math.imul(ee, re)) | 0); - var Ot = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (Ot >>> 26)) | 0), - (Ot &= 67108863), - (C = Math.imul(Ue, Ke)), - (E = Math.imul(Ue, pe)), - (E = (E + Math.imul(Y, Ke)) | 0), - (B = Math.imul(Y, pe)), - (C = (C + Math.imul(Ve, Se)) | 0), - (E = (E + Math.imul(Ve, Pe)) | 0), - (E = (E + Math.imul(We, Se)) | 0), - (B = (B + Math.imul(We, Pe)) | 0), - (C = (C + Math.imul(Ee, Ie)) | 0), - (E = (E + Math.imul(Ee, je)) | 0), - (E = (E + Math.imul(Be, Ie)) | 0), - (B = (B + Math.imul(Be, je)) | 0), - (C = (C + Math.imul(me, Fe)) | 0), - (E = (E + Math.imul(me, He)) | 0), - (E = (E + Math.imul(_e, Fe)) | 0), - (B = (B + Math.imul(_e, He)) | 0), - (C = (C + Math.imul(de, Xe)) | 0), - (E = (E + Math.imul(de, Ze)) | 0), - (E = (E + Math.imul(ve, Xe)) | 0), - (B = (B + Math.imul(ve, Ze)) | 0), - (C = (C + Math.imul(ae, $e)) | 0), - (E = (E + Math.imul(ae, tt)) | 0), - (E = (E + Math.imul(le, $e)) | 0), - (B = (B + Math.imul(le, tt)) | 0), - (C = (C + Math.imul(fe, ie)) | 0), - (E = (E + Math.imul(fe, re)) | 0), - (E = (E + Math.imul(V, ie)) | 0), - (B = (B + Math.imul(V, re)) | 0), - (C = (C + Math.imul(L, se)) | 0), - (E = (E + Math.imul(L, be)) | 0), - (E = (E + Math.imul(ee, se)) | 0), - (B = (B + Math.imul(ee, be)) | 0); - var Bt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (Bt >>> 26)) | 0), - (Bt &= 67108863), - (C = Math.imul(j, Ke)), - (E = Math.imul(j, pe)), - (E = (E + Math.imul(ce, Ke)) | 0), - (B = Math.imul(ce, pe)), - (C = (C + Math.imul(Ue, Se)) | 0), - (E = (E + Math.imul(Ue, Pe)) | 0), - (E = (E + Math.imul(Y, Se)) | 0), - (B = (B + Math.imul(Y, Pe)) | 0), - (C = (C + Math.imul(Ve, Ie)) | 0), - (E = (E + Math.imul(Ve, je)) | 0), - (E = (E + Math.imul(We, Ie)) | 0), - (B = (B + Math.imul(We, je)) | 0), - (C = (C + Math.imul(Ee, Fe)) | 0), - (E = (E + Math.imul(Ee, He)) | 0), - (E = (E + Math.imul(Be, Fe)) | 0), - (B = (B + Math.imul(Be, He)) | 0), - (C = (C + Math.imul(me, Xe)) | 0), - (E = (E + Math.imul(me, Ze)) | 0), - (E = (E + Math.imul(_e, Xe)) | 0), - (B = (B + Math.imul(_e, Ze)) | 0), - (C = (C + Math.imul(de, $e)) | 0), - (E = (E + Math.imul(de, tt)) | 0), - (E = (E + Math.imul(ve, $e)) | 0), - (B = (B + Math.imul(ve, tt)) | 0), - (C = (C + Math.imul(ae, ie)) | 0), - (E = (E + Math.imul(ae, re)) | 0), - (E = (E + Math.imul(le, ie)) | 0), - (B = (B + Math.imul(le, re)) | 0), - (C = (C + Math.imul(fe, se)) | 0), - (E = (E + Math.imul(fe, be)) | 0), - (E = (E + Math.imul(V, se)) | 0), - (B = (B + Math.imul(V, be)) | 0), - (C = (C + Math.imul(L, Ae)) | 0), - (E = (E + Math.imul(L, ke)) | 0), - (E = (E + Math.imul(ee, Ae)) | 0), - (B = (B + Math.imul(ee, ke)) | 0); - var Et = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (Et >>> 26)) | 0), - (Et &= 67108863), - (C = Math.imul(we, Ke)), - (E = Math.imul(we, pe)), - (E = (E + Math.imul(xe, Ke)) | 0), - (B = Math.imul(xe, pe)), - (C = (C + Math.imul(j, Se)) | 0), - (E = (E + Math.imul(j, Pe)) | 0), - (E = (E + Math.imul(ce, Se)) | 0), - (B = (B + Math.imul(ce, Pe)) | 0), - (C = (C + Math.imul(Ue, Ie)) | 0), - (E = (E + Math.imul(Ue, je)) | 0), - (E = (E + Math.imul(Y, Ie)) | 0), - (B = (B + Math.imul(Y, je)) | 0), - (C = (C + Math.imul(Ve, Fe)) | 0), - (E = (E + Math.imul(Ve, He)) | 0), - (E = (E + Math.imul(We, Fe)) | 0), - (B = (B + Math.imul(We, He)) | 0), - (C = (C + Math.imul(Ee, Xe)) | 0), - (E = (E + Math.imul(Ee, Ze)) | 0), - (E = (E + Math.imul(Be, Xe)) | 0), - (B = (B + Math.imul(Be, Ze)) | 0), - (C = (C + Math.imul(me, $e)) | 0), - (E = (E + Math.imul(me, tt)) | 0), - (E = (E + Math.imul(_e, $e)) | 0), - (B = (B + Math.imul(_e, tt)) | 0), - (C = (C + Math.imul(de, ie)) | 0), - (E = (E + Math.imul(de, re)) | 0), - (E = (E + Math.imul(ve, ie)) | 0), - (B = (B + Math.imul(ve, re)) | 0), - (C = (C + Math.imul(ae, se)) | 0), - (E = (E + Math.imul(ae, be)) | 0), - (E = (E + Math.imul(le, se)) | 0), - (B = (B + Math.imul(le, be)) | 0), - (C = (C + Math.imul(fe, Ae)) | 0), - (E = (E + Math.imul(fe, ke)) | 0), - (E = (E + Math.imul(V, Ae)) | 0), - (B = (B + Math.imul(V, ke)) | 0), - (C = (C + Math.imul(L, ut)) | 0), - (E = (E + Math.imul(L, St)) | 0), - (E = (E + Math.imul(ee, ut)) | 0), - (B = (B + Math.imul(ee, St)) | 0); - var Mt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (Mt >>> 26)) | 0), - (Mt &= 67108863), - (C = Math.imul(we, Se)), - (E = Math.imul(we, Pe)), - (E = (E + Math.imul(xe, Se)) | 0), - (B = Math.imul(xe, Pe)), - (C = (C + Math.imul(j, Ie)) | 0), - (E = (E + Math.imul(j, je)) | 0), - (E = (E + Math.imul(ce, Ie)) | 0), - (B = (B + Math.imul(ce, je)) | 0), - (C = (C + Math.imul(Ue, Fe)) | 0), - (E = (E + Math.imul(Ue, He)) | 0), - (E = (E + Math.imul(Y, Fe)) | 0), - (B = (B + Math.imul(Y, He)) | 0), - (C = (C + Math.imul(Ve, Xe)) | 0), - (E = (E + Math.imul(Ve, Ze)) | 0), - (E = (E + Math.imul(We, Xe)) | 0), - (B = (B + Math.imul(We, Ze)) | 0), - (C = (C + Math.imul(Ee, $e)) | 0), - (E = (E + Math.imul(Ee, tt)) | 0), - (E = (E + Math.imul(Be, $e)) | 0), - (B = (B + Math.imul(Be, tt)) | 0), - (C = (C + Math.imul(me, ie)) | 0), - (E = (E + Math.imul(me, re)) | 0), - (E = (E + Math.imul(_e, ie)) | 0), - (B = (B + Math.imul(_e, re)) | 0), - (C = (C + Math.imul(de, se)) | 0), - (E = (E + Math.imul(de, be)) | 0), - (E = (E + Math.imul(ve, se)) | 0), - (B = (B + Math.imul(ve, be)) | 0), - (C = (C + Math.imul(ae, Ae)) | 0), - (E = (E + Math.imul(ae, ke)) | 0), - (E = (E + Math.imul(le, Ae)) | 0), - (B = (B + Math.imul(le, ke)) | 0), - (C = (C + Math.imul(fe, ut)) | 0), - (E = (E + Math.imul(fe, St)) | 0), - (E = (E + Math.imul(V, ut)) | 0), - (B = (B + Math.imul(V, St)) | 0); - var gt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (gt >>> 26)) | 0), - (gt &= 67108863), - (C = Math.imul(we, Ie)), - (E = Math.imul(we, je)), - (E = (E + Math.imul(xe, Ie)) | 0), - (B = Math.imul(xe, je)), - (C = (C + Math.imul(j, Fe)) | 0), - (E = (E + Math.imul(j, He)) | 0), - (E = (E + Math.imul(ce, Fe)) | 0), - (B = (B + Math.imul(ce, He)) | 0), - (C = (C + Math.imul(Ue, Xe)) | 0), - (E = (E + Math.imul(Ue, Ze)) | 0), - (E = (E + Math.imul(Y, Xe)) | 0), - (B = (B + Math.imul(Y, Ze)) | 0), - (C = (C + Math.imul(Ve, $e)) | 0), - (E = (E + Math.imul(Ve, tt)) | 0), - (E = (E + Math.imul(We, $e)) | 0), - (B = (B + Math.imul(We, tt)) | 0), - (C = (C + Math.imul(Ee, ie)) | 0), - (E = (E + Math.imul(Ee, re)) | 0), - (E = (E + Math.imul(Be, ie)) | 0), - (B = (B + Math.imul(Be, re)) | 0), - (C = (C + Math.imul(me, se)) | 0), - (E = (E + Math.imul(me, be)) | 0), - (E = (E + Math.imul(_e, se)) | 0), - (B = (B + Math.imul(_e, be)) | 0), - (C = (C + Math.imul(de, Ae)) | 0), - (E = (E + Math.imul(de, ke)) | 0), - (E = (E + Math.imul(ve, Ae)) | 0), - (B = (B + Math.imul(ve, ke)) | 0), - (C = (C + Math.imul(ae, ut)) | 0), - (E = (E + Math.imul(ae, St)) | 0), - (E = (E + Math.imul(le, ut)) | 0), - (B = (B + Math.imul(le, St)) | 0); - var Pt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (Pt >>> 26)) | 0), - (Pt &= 67108863), - (C = Math.imul(we, Fe)), - (E = Math.imul(we, He)), - (E = (E + Math.imul(xe, Fe)) | 0), - (B = Math.imul(xe, He)), - (C = (C + Math.imul(j, Xe)) | 0), - (E = (E + Math.imul(j, Ze)) | 0), - (E = (E + Math.imul(ce, Xe)) | 0), - (B = (B + Math.imul(ce, Ze)) | 0), - (C = (C + Math.imul(Ue, $e)) | 0), - (E = (E + Math.imul(Ue, tt)) | 0), - (E = (E + Math.imul(Y, $e)) | 0), - (B = (B + Math.imul(Y, tt)) | 0), - (C = (C + Math.imul(Ve, ie)) | 0), - (E = (E + Math.imul(Ve, re)) | 0), - (E = (E + Math.imul(We, ie)) | 0), - (B = (B + Math.imul(We, re)) | 0), - (C = (C + Math.imul(Ee, se)) | 0), - (E = (E + Math.imul(Ee, be)) | 0), - (E = (E + Math.imul(Be, se)) | 0), - (B = (B + Math.imul(Be, be)) | 0), - (C = (C + Math.imul(me, Ae)) | 0), - (E = (E + Math.imul(me, ke)) | 0), - (E = (E + Math.imul(_e, Ae)) | 0), - (B = (B + Math.imul(_e, ke)) | 0), - (C = (C + Math.imul(de, ut)) | 0), - (E = (E + Math.imul(de, St)) | 0), - (E = (E + Math.imul(ve, ut)) | 0), - (B = (B + Math.imul(ve, St)) | 0); - var It = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (It >>> 26)) | 0), - (It &= 67108863), - (C = Math.imul(we, Xe)), - (E = Math.imul(we, Ze)), - (E = (E + Math.imul(xe, Xe)) | 0), - (B = Math.imul(xe, Ze)), - (C = (C + Math.imul(j, $e)) | 0), - (E = (E + Math.imul(j, tt)) | 0), - (E = (E + Math.imul(ce, $e)) | 0), - (B = (B + Math.imul(ce, tt)) | 0), - (C = (C + Math.imul(Ue, ie)) | 0), - (E = (E + Math.imul(Ue, re)) | 0), - (E = (E + Math.imul(Y, ie)) | 0), - (B = (B + Math.imul(Y, re)) | 0), - (C = (C + Math.imul(Ve, se)) | 0), - (E = (E + Math.imul(Ve, be)) | 0), - (E = (E + Math.imul(We, se)) | 0), - (B = (B + Math.imul(We, be)) | 0), - (C = (C + Math.imul(Ee, Ae)) | 0), - (E = (E + Math.imul(Ee, ke)) | 0), - (E = (E + Math.imul(Be, Ae)) | 0), - (B = (B + Math.imul(Be, ke)) | 0), - (C = (C + Math.imul(me, ut)) | 0), - (E = (E + Math.imul(me, St)) | 0), - (E = (E + Math.imul(_e, ut)) | 0), - (B = (B + Math.imul(_e, St)) | 0); - var yt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (yt >>> 26)) | 0), - (yt &= 67108863), - (C = Math.imul(we, $e)), - (E = Math.imul(we, tt)), - (E = (E + Math.imul(xe, $e)) | 0), - (B = Math.imul(xe, tt)), - (C = (C + Math.imul(j, ie)) | 0), - (E = (E + Math.imul(j, re)) | 0), - (E = (E + Math.imul(ce, ie)) | 0), - (B = (B + Math.imul(ce, re)) | 0), - (C = (C + Math.imul(Ue, se)) | 0), - (E = (E + Math.imul(Ue, be)) | 0), - (E = (E + Math.imul(Y, se)) | 0), - (B = (B + Math.imul(Y, be)) | 0), - (C = (C + Math.imul(Ve, Ae)) | 0), - (E = (E + Math.imul(Ve, ke)) | 0), - (E = (E + Math.imul(We, Ae)) | 0), - (B = (B + Math.imul(We, ke)) | 0), - (C = (C + Math.imul(Ee, ut)) | 0), - (E = (E + Math.imul(Ee, St)) | 0), - (E = (E + Math.imul(Be, ut)) | 0), - (B = (B + Math.imul(Be, St)) | 0); - var nt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (nt >>> 26)) | 0), - (nt &= 67108863), - (C = Math.imul(we, ie)), - (E = Math.imul(we, re)), - (E = (E + Math.imul(xe, ie)) | 0), - (B = Math.imul(xe, re)), - (C = (C + Math.imul(j, se)) | 0), - (E = (E + Math.imul(j, be)) | 0), - (E = (E + Math.imul(ce, se)) | 0), - (B = (B + Math.imul(ce, be)) | 0), - (C = (C + Math.imul(Ue, Ae)) | 0), - (E = (E + Math.imul(Ue, ke)) | 0), - (E = (E + Math.imul(Y, Ae)) | 0), - (B = (B + Math.imul(Y, ke)) | 0), - (C = (C + Math.imul(Ve, ut)) | 0), - (E = (E + Math.imul(Ve, St)) | 0), - (E = (E + Math.imul(We, ut)) | 0), - (B = (B + Math.imul(We, St)) | 0); - var it = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (it >>> 26)) | 0), - (it &= 67108863), - (C = Math.imul(we, se)), - (E = Math.imul(we, be)), - (E = (E + Math.imul(xe, se)) | 0), - (B = Math.imul(xe, be)), - (C = (C + Math.imul(j, Ae)) | 0), - (E = (E + Math.imul(j, ke)) | 0), - (E = (E + Math.imul(ce, Ae)) | 0), - (B = (B + Math.imul(ce, ke)) | 0), - (C = (C + Math.imul(Ue, ut)) | 0), - (E = (E + Math.imul(Ue, St)) | 0), - (E = (E + Math.imul(Y, ut)) | 0), - (B = (B + Math.imul(Y, St)) | 0); - var _t = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (_t >>> 26)) | 0), - (_t &= 67108863), - (C = Math.imul(we, Ae)), - (E = Math.imul(we, ke)), - (E = (E + Math.imul(xe, Ae)) | 0), - (B = Math.imul(xe, ke)), - (C = (C + Math.imul(j, ut)) | 0), - (E = (E + Math.imul(j, St)) | 0), - (E = (E + Math.imul(ce, ut)) | 0), - (B = (B + Math.imul(ce, St)) | 0); - var ht = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - (x = (((B + (E >>> 13)) | 0) + (ht >>> 26)) | 0), - (ht &= 67108863), - (C = Math.imul(we, ut)), - (E = Math.imul(we, St)), - (E = (E + Math.imul(xe, ut)) | 0), - (B = Math.imul(xe, St)); - var mt = (((x + C) | 0) + ((E & 8191) << 13)) | 0; - return ( - (x = (((B + (E >>> 13)) | 0) + (mt >>> 26)) | 0), - (mt &= 67108863), - (f[0] = wt), - (f[1] = zt), - (f[2] = jt), - (f[3] = Ht), - (f[4] = Ut), - (f[5] = Kt), - (f[6] = Ot), - (f[7] = Bt), - (f[8] = Et), - (f[9] = Mt), - (f[10] = gt), - (f[11] = Pt), - (f[12] = It), - (f[13] = yt), - (f[14] = nt), - (f[15] = it), - (f[16] = _t), - (f[17] = ht), - (f[18] = mt), - x !== 0 && ((f[19] = x), _.length++), - _ - ); - }; - Math.imul || (N = F); - function q(y, d, v) { - (v.negative = d.negative ^ y.negative), - (v.length = y.length + d.length); - for (var _ = 0, S = 0, b = 0; b < v.length - 1; b++) { - var f = S; - S = 0; - for ( - var x = _ & 67108863, - C = Math.min(b, d.length - 1), - E = Math.max(0, b - y.length + 1); - E <= C; - E++ - ) { - var B = b - E, - G = y.words[B] | 0, - L = d.words[E] | 0, - ee = G * L, - ge = ee & 67108863; - (f = (f + ((ee / 67108864) | 0)) | 0), - (ge = (ge + x) | 0), - (x = ge & 67108863), - (f = (f + (ge >>> 26)) | 0), - (S += f >>> 26), - (f &= 67108863); - } - (v.words[b] = x), (_ = f), (f = S); - } - return _ !== 0 ? (v.words[b] = _) : v.length--, v._strip(); - } - function z(y, d, v) { - return q(y, d, v); - } - i.prototype.mulTo = function (d, v) { - var _, - S = this.length + d.length; - return ( - this.length === 10 && d.length === 10 - ? (_ = N(this, d, v)) - : S < 63 - ? (_ = F(this, d, v)) - : S < 1024 - ? (_ = q(this, d, v)) - : (_ = z(this, d, v)), - _ - ); - }; - function H(y, d) { - (this.x = y), (this.y = d); - } - (H.prototype.makeRBT = function (d) { - for ( - var v = new Array(d), _ = i.prototype._countBits(d) - 1, S = 0; - S < d; - S++ - ) - v[S] = this.revBin(S, _, d); - return v; - }), - (H.prototype.revBin = function (d, v, _) { - if (d === 0 || d === _ - 1) return d; - for (var S = 0, b = 0; b < v; b++) - (S |= (d & 1) << (v - b - 1)), (d >>= 1); - return S; - }), - (H.prototype.permute = function (d, v, _, S, b, f) { - for (var x = 0; x < f; x++) (S[x] = v[d[x]]), (b[x] = _[d[x]]); - }), - (H.prototype.transform = function (d, v, _, S, b, f) { - this.permute(f, d, v, _, S, b); - for (var x = 1; x < b; x <<= 1) - for ( - var C = x << 1, - E = Math.cos((2 * Math.PI) / C), - B = Math.sin((2 * Math.PI) / C), - G = 0; - G < b; - G += C - ) - for (var L = E, ee = B, ge = 0; ge < x; ge++) { - var fe = _[G + ge], - V = S[G + ge], - ye = _[G + ge + x], - ae = S[G + ge + x], - le = L * ye - ee * ae; - (ae = L * ae + ee * ye), - (ye = le), - (_[G + ge] = fe + ye), - (S[G + ge] = V + ae), - (_[G + ge + x] = fe - ye), - (S[G + ge + x] = V - ae), - ge !== C && - ((le = E * L - B * ee), (ee = E * ee + B * L), (L = le)); - } - }), - (H.prototype.guessLen13b = function (d, v) { - var _ = Math.max(v, d) | 1, - S = _ & 1, - b = 0; - for (_ = (_ / 2) | 0; _; _ = _ >>> 1) b++; - return 1 << (b + 1 + S); - }), - (H.prototype.conjugate = function (d, v, _) { - if (!(_ <= 1)) - for (var S = 0; S < _ / 2; S++) { - var b = d[S]; - (d[S] = d[_ - S - 1]), - (d[_ - S - 1] = b), - (b = v[S]), - (v[S] = -v[_ - S - 1]), - (v[_ - S - 1] = -b); - } - }), - (H.prototype.normalize13b = function (d, v) { - for (var _ = 0, S = 0; S < v / 2; S++) { - var b = - Math.round(d[2 * S + 1] / v) * 8192 + - Math.round(d[2 * S] / v) + - _; - (d[S] = b & 67108863), - b < 67108864 ? (_ = 0) : (_ = (b / 67108864) | 0); - } - return d; - }), - (H.prototype.convert13b = function (d, v, _, S) { - for (var b = 0, f = 0; f < v; f++) - (b = b + (d[f] | 0)), - (_[2 * f] = b & 8191), - (b = b >>> 13), - (_[2 * f + 1] = b & 8191), - (b = b >>> 13); - for (f = 2 * v; f < S; ++f) _[f] = 0; - r(b === 0), r((b & -8192) === 0); - }), - (H.prototype.stub = function (d) { - for (var v = new Array(d), _ = 0; _ < d; _++) v[_] = 0; - return v; - }), - (H.prototype.mulp = function (d, v, _) { - var S = 2 * this.guessLen13b(d.length, v.length), - b = this.makeRBT(S), - f = this.stub(S), - x = new Array(S), - C = new Array(S), - E = new Array(S), - B = new Array(S), - G = new Array(S), - L = new Array(S), - ee = _.words; - (ee.length = S), - this.convert13b(d.words, d.length, x, S), - this.convert13b(v.words, v.length, B, S), - this.transform(x, f, C, E, S, b), - this.transform(B, f, G, L, S, b); - for (var ge = 0; ge < S; ge++) { - var fe = C[ge] * G[ge] - E[ge] * L[ge]; - (E[ge] = C[ge] * L[ge] + E[ge] * G[ge]), (C[ge] = fe); - } - return ( - this.conjugate(C, E, S), - this.transform(C, E, ee, f, S, b), - this.conjugate(ee, f, S), - this.normalize13b(ee, S), - (_.negative = d.negative ^ v.negative), - (_.length = d.length + v.length), - _._strip() - ); - }), - (i.prototype.mul = function (d) { - var v = new i(null); - return ( - (v.words = new Array(this.length + d.length)), this.mulTo(d, v) - ); - }), - (i.prototype.mulf = function (d) { - var v = new i(null); - return (v.words = new Array(this.length + d.length)), z(this, d, v); - }), - (i.prototype.imul = function (d) { - return this.clone().mulTo(d, this); - }), - (i.prototype.imuln = function (d) { - var v = d < 0; - v && (d = -d), r(typeof d == "number"), r(d < 67108864); - for (var _ = 0, S = 0; S < this.length; S++) { - var b = (this.words[S] | 0) * d, - f = (b & 67108863) + (_ & 67108863); - (_ >>= 26), - (_ += (b / 67108864) | 0), - (_ += f >>> 26), - (this.words[S] = f & 67108863); - } - return ( - _ !== 0 && ((this.words[S] = _), this.length++), - v ? this.ineg() : this - ); - }), - (i.prototype.muln = function (d) { - return this.clone().imuln(d); - }), - (i.prototype.sqr = function () { - return this.mul(this); - }), - (i.prototype.isqr = function () { - return this.imul(this.clone()); - }), - (i.prototype.pow = function (d) { - var v = D(d); - if (v.length === 0) return new i(1); - for ( - var _ = this, S = 0; - S < v.length && v[S] === 0; - S++, _ = _.sqr() - ); - if (++S < v.length) - for (var b = _.sqr(); S < v.length; S++, b = b.sqr()) - v[S] !== 0 && (_ = _.mul(b)); - return _; - }), - (i.prototype.iushln = function (d) { - r(typeof d == "number" && d >= 0); - var v = d % 26, - _ = (d - v) / 26, - S = (67108863 >>> (26 - v)) << (26 - v), - b; - if (v !== 0) { - var f = 0; - for (b = 0; b < this.length; b++) { - var x = this.words[b] & S, - C = ((this.words[b] | 0) - x) << v; - (this.words[b] = C | f), (f = x >>> (26 - v)); - } - f && ((this.words[b] = f), this.length++); - } - if (_ !== 0) { - for (b = this.length - 1; b >= 0; b--) - this.words[b + _] = this.words[b]; - for (b = 0; b < _; b++) this.words[b] = 0; - this.length += _; - } - return this._strip(); - }), - (i.prototype.ishln = function (d) { - return r(this.negative === 0), this.iushln(d); - }), - (i.prototype.iushrn = function (d, v, _) { - r(typeof d == "number" && d >= 0); - var S; - v ? (S = (v - (v % 26)) / 26) : (S = 0); - var b = d % 26, - f = Math.min((d - b) / 26, this.length), - x = 67108863 ^ ((67108863 >>> b) << b), - C = _; - if (((S -= f), (S = Math.max(0, S)), C)) { - for (var E = 0; E < f; E++) C.words[E] = this.words[E]; - C.length = f; - } - if (f !== 0) - if (this.length > f) - for (this.length -= f, E = 0; E < this.length; E++) - this.words[E] = this.words[E + f]; - else (this.words[0] = 0), (this.length = 1); - var B = 0; - for (E = this.length - 1; E >= 0 && (B !== 0 || E >= S); E--) { - var G = this.words[E] | 0; - (this.words[E] = (B << (26 - b)) | (G >>> b)), (B = G & x); - } - return ( - C && B !== 0 && (C.words[C.length++] = B), - this.length === 0 && ((this.words[0] = 0), (this.length = 1)), - this._strip() - ); - }), - (i.prototype.ishrn = function (d, v, _) { - return r(this.negative === 0), this.iushrn(d, v, _); - }), - (i.prototype.shln = function (d) { - return this.clone().ishln(d); - }), - (i.prototype.ushln = function (d) { - return this.clone().iushln(d); - }), - (i.prototype.shrn = function (d) { - return this.clone().ishrn(d); - }), - (i.prototype.ushrn = function (d) { - return this.clone().iushrn(d); - }), - (i.prototype.testn = function (d) { - r(typeof d == "number" && d >= 0); - var v = d % 26, - _ = (d - v) / 26, - S = 1 << v; - if (this.length <= _) return !1; - var b = this.words[_]; - return !!(b & S); - }), - (i.prototype.imaskn = function (d) { - r(typeof d == "number" && d >= 0); - var v = d % 26, - _ = (d - v) / 26; - if ( - (r(this.negative === 0, "imaskn works only with positive numbers"), - this.length <= _) - ) - return this; - if ( - (v !== 0 && _++, (this.length = Math.min(_, this.length)), v !== 0) - ) { - var S = 67108863 ^ ((67108863 >>> v) << v); - this.words[this.length - 1] &= S; - } - return this._strip(); - }), - (i.prototype.maskn = function (d) { - return this.clone().imaskn(d); - }), - (i.prototype.iaddn = function (d) { - return ( - r(typeof d == "number"), - r(d < 67108864), - d < 0 - ? this.isubn(-d) - : this.negative !== 0 - ? this.length === 1 && (this.words[0] | 0) <= d - ? ((this.words[0] = d - (this.words[0] | 0)), - (this.negative = 0), - this) - : ((this.negative = 0), - this.isubn(d), - (this.negative = 1), - this) - : this._iaddn(d) - ); - }), - (i.prototype._iaddn = function (d) { - this.words[0] += d; - for (var v = 0; v < this.length && this.words[v] >= 67108864; v++) - (this.words[v] -= 67108864), - v === this.length - 1 - ? (this.words[v + 1] = 1) - : this.words[v + 1]++; - return (this.length = Math.max(this.length, v + 1)), this; - }), - (i.prototype.isubn = function (d) { - if ((r(typeof d == "number"), r(d < 67108864), d < 0)) - return this.iaddn(-d); - if (this.negative !== 0) - return ( - (this.negative = 0), this.iaddn(d), (this.negative = 1), this - ); - if (((this.words[0] -= d), this.length === 1 && this.words[0] < 0)) - (this.words[0] = -this.words[0]), (this.negative = 1); - else - for (var v = 0; v < this.length && this.words[v] < 0; v++) - (this.words[v] += 67108864), (this.words[v + 1] -= 1); - return this._strip(); - }), - (i.prototype.addn = function (d) { - return this.clone().iaddn(d); - }), - (i.prototype.subn = function (d) { - return this.clone().isubn(d); - }), - (i.prototype.iabs = function () { - return (this.negative = 0), this; - }), - (i.prototype.abs = function () { - return this.clone().iabs(); - }), - (i.prototype._ishlnsubmul = function (d, v, _) { - var S = d.length + _, - b; - this._expand(S); - var f, - x = 0; - for (b = 0; b < d.length; b++) { - f = (this.words[b + _] | 0) + x; - var C = (d.words[b] | 0) * v; - (f -= C & 67108863), - (x = (f >> 26) - ((C / 67108864) | 0)), - (this.words[b + _] = f & 67108863); - } - for (; b < this.length - _; b++) - (f = (this.words[b + _] | 0) + x), - (x = f >> 26), - (this.words[b + _] = f & 67108863); - if (x === 0) return this._strip(); - for (r(x === -1), x = 0, b = 0; b < this.length; b++) - (f = -(this.words[b] | 0) + x), - (x = f >> 26), - (this.words[b] = f & 67108863); - return (this.negative = 1), this._strip(); - }), - (i.prototype._wordDiv = function (d, v) { - var _ = this.length - d.length, - S = this.clone(), - b = d, - f = b.words[b.length - 1] | 0, - x = this._countBits(f); - (_ = 26 - x), - _ !== 0 && - ((b = b.ushln(_)), S.iushln(_), (f = b.words[b.length - 1] | 0)); - var C = S.length - b.length, - E; - if (v !== "mod") { - (E = new i(null)), - (E.length = C + 1), - (E.words = new Array(E.length)); - for (var B = 0; B < E.length; B++) E.words[B] = 0; - } - var G = S.clone()._ishlnsubmul(b, 1, C); - G.negative === 0 && ((S = G), E && (E.words[C] = 1)); - for (var L = C - 1; L >= 0; L--) { - var ee = - (S.words[b.length + L] | 0) * 67108864 + - (S.words[b.length + L - 1] | 0); - for ( - ee = Math.min((ee / f) | 0, 67108863), S._ishlnsubmul(b, ee, L); - S.negative !== 0; - - ) - ee--, - (S.negative = 0), - S._ishlnsubmul(b, 1, L), - S.isZero() || (S.negative ^= 1); - E && (E.words[L] = ee); - } - return ( - E && E._strip(), - S._strip(), - v !== "div" && _ !== 0 && S.iushrn(_), - { div: E || null, mod: S } - ); - }), - (i.prototype.divmod = function (d, v, _) { - if ((r(!d.isZero()), this.isZero())) - return { div: new i(0), mod: new i(0) }; - var S, b, f; - return this.negative !== 0 && d.negative === 0 - ? ((f = this.neg().divmod(d, v)), - v !== "mod" && (S = f.div.neg()), - v !== "div" && - ((b = f.mod.neg()), _ && b.negative !== 0 && b.iadd(d)), - { div: S, mod: b }) - : this.negative === 0 && d.negative !== 0 - ? ((f = this.divmod(d.neg(), v)), - v !== "mod" && (S = f.div.neg()), - { div: S, mod: f.mod }) - : (this.negative & d.negative) !== 0 - ? ((f = this.neg().divmod(d.neg(), v)), - v !== "div" && - ((b = f.mod.neg()), _ && b.negative !== 0 && b.isub(d)), - { div: f.div, mod: b }) - : d.length > this.length || this.cmp(d) < 0 - ? { div: new i(0), mod: this } - : d.length === 1 - ? v === "div" - ? { div: this.divn(d.words[0]), mod: null } - : v === "mod" - ? { div: null, mod: new i(this.modrn(d.words[0])) } - : { - div: this.divn(d.words[0]), - mod: new i(this.modrn(d.words[0])), - } - : this._wordDiv(d, v); - }), - (i.prototype.div = function (d) { - return this.divmod(d, "div", !1).div; - }), - (i.prototype.mod = function (d) { - return this.divmod(d, "mod", !1).mod; - }), - (i.prototype.umod = function (d) { - return this.divmod(d, "mod", !0).mod; - }), - (i.prototype.divRound = function (d) { - var v = this.divmod(d); - if (v.mod.isZero()) return v.div; - var _ = v.div.negative !== 0 ? v.mod.isub(d) : v.mod, - S = d.ushrn(1), - b = d.andln(1), - f = _.cmp(S); - return f < 0 || (b === 1 && f === 0) - ? v.div - : v.div.negative !== 0 - ? v.div.isubn(1) - : v.div.iaddn(1); - }), - (i.prototype.modrn = function (d) { - var v = d < 0; - v && (d = -d), r(d <= 67108863); - for (var _ = (1 << 26) % d, S = 0, b = this.length - 1; b >= 0; b--) - S = (_ * S + (this.words[b] | 0)) % d; - return v ? -S : S; - }), - (i.prototype.modn = function (d) { - return this.modrn(d); - }), - (i.prototype.idivn = function (d) { - var v = d < 0; - v && (d = -d), r(d <= 67108863); - for (var _ = 0, S = this.length - 1; S >= 0; S--) { - var b = (this.words[S] | 0) + _ * 67108864; - (this.words[S] = (b / d) | 0), (_ = b % d); - } - return this._strip(), v ? this.ineg() : this; - }), - (i.prototype.divn = function (d) { - return this.clone().idivn(d); - }), - (i.prototype.egcd = function (d) { - r(d.negative === 0), r(!d.isZero()); - var v = this, - _ = d.clone(); - v.negative !== 0 ? (v = v.umod(d)) : (v = v.clone()); - for ( - var S = new i(1), b = new i(0), f = new i(0), x = new i(1), C = 0; - v.isEven() && _.isEven(); - - ) - v.iushrn(1), _.iushrn(1), ++C; - for (var E = _.clone(), B = v.clone(); !v.isZero(); ) { - for ( - var G = 0, L = 1; - (v.words[0] & L) === 0 && G < 26; - ++G, L <<= 1 - ); - if (G > 0) - for (v.iushrn(G); G-- > 0; ) - (S.isOdd() || b.isOdd()) && (S.iadd(E), b.isub(B)), - S.iushrn(1), - b.iushrn(1); - for ( - var ee = 0, ge = 1; - (_.words[0] & ge) === 0 && ee < 26; - ++ee, ge <<= 1 - ); - if (ee > 0) - for (_.iushrn(ee); ee-- > 0; ) - (f.isOdd() || x.isOdd()) && (f.iadd(E), x.isub(B)), - f.iushrn(1), - x.iushrn(1); - v.cmp(_) >= 0 - ? (v.isub(_), S.isub(f), b.isub(x)) - : (_.isub(v), f.isub(S), x.isub(b)); - } - return { a: f, b: x, gcd: _.iushln(C) }; - }), - (i.prototype._invmp = function (d) { - r(d.negative === 0), r(!d.isZero()); - var v = this, - _ = d.clone(); - v.negative !== 0 ? (v = v.umod(d)) : (v = v.clone()); - for ( - var S = new i(1), b = new i(0), f = _.clone(); - v.cmpn(1) > 0 && _.cmpn(1) > 0; - - ) { - for ( - var x = 0, C = 1; - (v.words[0] & C) === 0 && x < 26; - ++x, C <<= 1 - ); - if (x > 0) - for (v.iushrn(x); x-- > 0; ) S.isOdd() && S.iadd(f), S.iushrn(1); - for ( - var E = 0, B = 1; - (_.words[0] & B) === 0 && E < 26; - ++E, B <<= 1 - ); - if (E > 0) - for (_.iushrn(E); E-- > 0; ) b.isOdd() && b.iadd(f), b.iushrn(1); - v.cmp(_) >= 0 ? (v.isub(_), S.isub(b)) : (_.isub(v), b.isub(S)); - } - var G; - return ( - v.cmpn(1) === 0 ? (G = S) : (G = b), G.cmpn(0) < 0 && G.iadd(d), G - ); - }), - (i.prototype.gcd = function (d) { - if (this.isZero()) return d.abs(); - if (d.isZero()) return this.abs(); - var v = this.clone(), - _ = d.clone(); - (v.negative = 0), (_.negative = 0); - for (var S = 0; v.isEven() && _.isEven(); S++) - v.iushrn(1), _.iushrn(1); - do { - for (; v.isEven(); ) v.iushrn(1); - for (; _.isEven(); ) _.iushrn(1); - var b = v.cmp(_); - if (b < 0) { - var f = v; - (v = _), (_ = f); - } else if (b === 0 || _.cmpn(1) === 0) break; - v.isub(_); - } while (!0); - return _.iushln(S); - }), - (i.prototype.invm = function (d) { - return this.egcd(d).a.umod(d); - }), - (i.prototype.isEven = function () { - return (this.words[0] & 1) === 0; - }), - (i.prototype.isOdd = function () { - return (this.words[0] & 1) === 1; - }), - (i.prototype.andln = function (d) { - return this.words[0] & d; - }), - (i.prototype.bincn = function (d) { - r(typeof d == "number"); - var v = d % 26, - _ = (d - v) / 26, - S = 1 << v; - if (this.length <= _) - return this._expand(_ + 1), (this.words[_] |= S), this; - for (var b = S, f = _; b !== 0 && f < this.length; f++) { - var x = this.words[f] | 0; - (x += b), (b = x >>> 26), (x &= 67108863), (this.words[f] = x); - } - return b !== 0 && ((this.words[f] = b), this.length++), this; - }), - (i.prototype.isZero = function () { - return this.length === 1 && this.words[0] === 0; - }), - (i.prototype.cmpn = function (d) { - var v = d < 0; - if (this.negative !== 0 && !v) return -1; - if (this.negative === 0 && v) return 1; - this._strip(); - var _; - if (this.length > 1) _ = 1; - else { - v && (d = -d), r(d <= 67108863, "Number is too big"); - var S = this.words[0] | 0; - _ = S === d ? 0 : S < d ? -1 : 1; - } - return this.negative !== 0 ? -_ | 0 : _; - }), - (i.prototype.cmp = function (d) { - if (this.negative !== 0 && d.negative === 0) return -1; - if (this.negative === 0 && d.negative !== 0) return 1; - var v = this.ucmp(d); - return this.negative !== 0 ? -v | 0 : v; - }), - (i.prototype.ucmp = function (d) { - if (this.length > d.length) return 1; - if (this.length < d.length) return -1; - for (var v = 0, _ = this.length - 1; _ >= 0; _--) { - var S = this.words[_] | 0, - b = d.words[_] | 0; - if (S !== b) { - S < b ? (v = -1) : S > b && (v = 1); - break; - } - } - return v; - }), - (i.prototype.gtn = function (d) { - return this.cmpn(d) === 1; - }), - (i.prototype.gt = function (d) { - return this.cmp(d) === 1; - }), - (i.prototype.gten = function (d) { - return this.cmpn(d) >= 0; - }), - (i.prototype.gte = function (d) { - return this.cmp(d) >= 0; - }), - (i.prototype.ltn = function (d) { - return this.cmpn(d) === -1; - }), - (i.prototype.lt = function (d) { - return this.cmp(d) === -1; - }), - (i.prototype.lten = function (d) { - return this.cmpn(d) <= 0; - }), - (i.prototype.lte = function (d) { - return this.cmp(d) <= 0; - }), - (i.prototype.eqn = function (d) { - return this.cmpn(d) === 0; - }), - (i.prototype.eq = function (d) { - return this.cmp(d) === 0; - }), - (i.red = function (d) { - return new l(d); - }), - (i.prototype.toRed = function (d) { - return ( - r(!this.red, "Already a number in reduction context"), - r(this.negative === 0, "red works only with positives"), - d.convertTo(this)._forceRed(d) - ); - }), - (i.prototype.fromRed = function () { - return ( - r(this.red, "fromRed works only with numbers in reduction context"), - this.red.convertFrom(this) - ); - }), - (i.prototype._forceRed = function (d) { - return (this.red = d), this; - }), - (i.prototype.forceRed = function (d) { - return ( - r(!this.red, "Already a number in reduction context"), - this._forceRed(d) - ); - }), - (i.prototype.redAdd = function (d) { - return ( - r(this.red, "redAdd works only with red numbers"), - this.red.add(this, d) - ); - }), - (i.prototype.redIAdd = function (d) { - return ( - r(this.red, "redIAdd works only with red numbers"), - this.red.iadd(this, d) - ); - }), - (i.prototype.redSub = function (d) { - return ( - r(this.red, "redSub works only with red numbers"), - this.red.sub(this, d) - ); - }), - (i.prototype.redISub = function (d) { - return ( - r(this.red, "redISub works only with red numbers"), - this.red.isub(this, d) - ); - }), - (i.prototype.redShl = function (d) { - return ( - r(this.red, "redShl works only with red numbers"), - this.red.shl(this, d) - ); - }), - (i.prototype.redMul = function (d) { - return ( - r(this.red, "redMul works only with red numbers"), - this.red._verify2(this, d), - this.red.mul(this, d) - ); - }), - (i.prototype.redIMul = function (d) { - return ( - r(this.red, "redMul works only with red numbers"), - this.red._verify2(this, d), - this.red.imul(this, d) - ); - }), - (i.prototype.redSqr = function () { - return ( - r(this.red, "redSqr works only with red numbers"), - this.red._verify1(this), - this.red.sqr(this) - ); - }), - (i.prototype.redISqr = function () { - return ( - r(this.red, "redISqr works only with red numbers"), - this.red._verify1(this), - this.red.isqr(this) - ); - }), - (i.prototype.redSqrt = function () { - return ( - r(this.red, "redSqrt works only with red numbers"), - this.red._verify1(this), - this.red.sqrt(this) - ); - }), - (i.prototype.redInvm = function () { - return ( - r(this.red, "redInvm works only with red numbers"), - this.red._verify1(this), - this.red.invm(this) - ); - }), - (i.prototype.redNeg = function () { - return ( - r(this.red, "redNeg works only with red numbers"), - this.red._verify1(this), - this.red.neg(this) - ); - }), - (i.prototype.redPow = function (d) { - return ( - r(this.red && !d.red, "redPow(normalNum)"), - this.red._verify1(this), - this.red.pow(this, d) - ); - }); - var Z = { k256: null, p224: null, p192: null, p25519: null }; - function $(y, d) { - (this.name = y), - (this.p = new i(d, 16)), - (this.n = this.p.bitLength()), - (this.k = new i(1).iushln(this.n).isub(this.p)), - (this.tmp = this._tmp()); - } - ($.prototype._tmp = function () { - var d = new i(null); - return (d.words = new Array(Math.ceil(this.n / 13))), d; - }), - ($.prototype.ireduce = function (d) { - var v = d, - _; - do - this.split(v, this.tmp), - (v = this.imulK(v)), - (v = v.iadd(this.tmp)), - (_ = v.bitLength()); - while (_ > this.n); - var S = _ < this.n ? -1 : v.ucmp(this.p); - return ( - S === 0 - ? ((v.words[0] = 0), (v.length = 1)) - : S > 0 - ? v.isub(this.p) - : v.strip !== void 0 - ? v.strip() - : v._strip(), - v - ); - }), - ($.prototype.split = function (d, v) { - d.iushrn(this.n, 0, v); - }), - ($.prototype.imulK = function (d) { - return d.imul(this.k); - }); - function ue() { - $.call( - this, - "k256", - "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f" - ); - } - n(ue, $), - (ue.prototype.split = function (d, v) { - for (var _ = 4194303, S = Math.min(d.length, 9), b = 0; b < S; b++) - v.words[b] = d.words[b]; - if (((v.length = S), d.length <= 9)) { - (d.words[0] = 0), (d.length = 1); - return; - } - var f = d.words[9]; - for (v.words[v.length++] = f & _, b = 10; b < d.length; b++) { - var x = d.words[b] | 0; - (d.words[b - 10] = ((x & _) << 4) | (f >>> 22)), (f = x); - } - (f >>>= 22), - (d.words[b - 10] = f), - f === 0 && d.length > 10 ? (d.length -= 10) : (d.length -= 9); - }), - (ue.prototype.imulK = function (d) { - (d.words[d.length] = 0), (d.words[d.length + 1] = 0), (d.length += 2); - for (var v = 0, _ = 0; _ < d.length; _++) { - var S = d.words[_] | 0; - (v += S * 977), - (d.words[_] = v & 67108863), - (v = S * 64 + ((v / 67108864) | 0)); - } - return ( - d.words[d.length - 1] === 0 && - (d.length--, d.words[d.length - 1] === 0 && d.length--), - d - ); - }); - function te() { - $.call( - this, - "p224", - "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001" - ); - } - n(te, $); - function ne() { - $.call( - this, - "p192", - "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff" - ); - } - n(ne, $); - function A() { - $.call( - this, - "25519", - "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed" - ); - } - n(A, $), - (A.prototype.imulK = function (d) { - for (var v = 0, _ = 0; _ < d.length; _++) { - var S = (d.words[_] | 0) * 19 + v, - b = S & 67108863; - (S >>>= 26), (d.words[_] = b), (v = S); - } - return v !== 0 && (d.words[d.length++] = v), d; - }), - (i._prime = function (d) { - if (Z[d]) return Z[d]; - var v; - if (d === "k256") v = new ue(); - else if (d === "p224") v = new te(); - else if (d === "p192") v = new ne(); - else if (d === "p25519") v = new A(); - else throw new Error("Unknown prime " + d); - return (Z[d] = v), v; - }); - function l(y) { - if (typeof y == "string") { - var d = i._prime(y); - (this.m = d.p), (this.prime = d); - } else - r(y.gtn(1), "modulus must be greater than 1"), - (this.m = y), - (this.prime = null); - } - (l.prototype._verify1 = function (d) { - r(d.negative === 0, "red works only with positives"), - r(d.red, "red works only with red numbers"); - }), - (l.prototype._verify2 = function (d, v) { - r((d.negative | v.negative) === 0, "red works only with positives"), - r(d.red && d.red === v.red, "red works only with red numbers"); - }), - (l.prototype.imod = function (d) { - return this.prime - ? this.prime.ireduce(d)._forceRed(this) - : (u(d, d.umod(this.m)._forceRed(this)), d); - }), - (l.prototype.neg = function (d) { - return d.isZero() ? d.clone() : this.m.sub(d)._forceRed(this); - }), - (l.prototype.add = function (d, v) { - this._verify2(d, v); - var _ = d.add(v); - return _.cmp(this.m) >= 0 && _.isub(this.m), _._forceRed(this); - }), - (l.prototype.iadd = function (d, v) { - this._verify2(d, v); - var _ = d.iadd(v); - return _.cmp(this.m) >= 0 && _.isub(this.m), _; - }), - (l.prototype.sub = function (d, v) { - this._verify2(d, v); - var _ = d.sub(v); - return _.cmpn(0) < 0 && _.iadd(this.m), _._forceRed(this); - }), - (l.prototype.isub = function (d, v) { - this._verify2(d, v); - var _ = d.isub(v); - return _.cmpn(0) < 0 && _.iadd(this.m), _; - }), - (l.prototype.shl = function (d, v) { - return this._verify1(d), this.imod(d.ushln(v)); - }), - (l.prototype.imul = function (d, v) { - return this._verify2(d, v), this.imod(d.imul(v)); - }), - (l.prototype.mul = function (d, v) { - return this._verify2(d, v), this.imod(d.mul(v)); - }), - (l.prototype.isqr = function (d) { - return this.imul(d, d.clone()); - }), - (l.prototype.sqr = function (d) { - return this.mul(d, d); - }), - (l.prototype.sqrt = function (d) { - if (d.isZero()) return d.clone(); - var v = this.m.andln(3); - if ((r(v % 2 === 1), v === 3)) { - var _ = this.m.add(new i(1)).iushrn(2); - return this.pow(d, _); - } - for (var S = this.m.subn(1), b = 0; !S.isZero() && S.andln(1) === 0; ) - b++, S.iushrn(1); - r(!S.isZero()); - var f = new i(1).toRed(this), - x = f.redNeg(), - C = this.m.subn(1).iushrn(1), - E = this.m.bitLength(); - for (E = new i(2 * E * E).toRed(this); this.pow(E, C).cmp(x) !== 0; ) - E.redIAdd(x); - for ( - var B = this.pow(E, S), - G = this.pow(d, S.addn(1).iushrn(1)), - L = this.pow(d, S), - ee = b; - L.cmp(f) !== 0; - - ) { - for (var ge = L, fe = 0; ge.cmp(f) !== 0; fe++) ge = ge.redSqr(); - r(fe < ee); - var V = this.pow(B, new i(1).iushln(ee - fe - 1)); - (G = G.redMul(V)), (B = V.redSqr()), (L = L.redMul(B)), (ee = fe); - } - return G; - }), - (l.prototype.invm = function (d) { - var v = d._invmp(this.m); - return v.negative !== 0 - ? ((v.negative = 0), this.imod(v).redNeg()) - : this.imod(v); - }), - (l.prototype.pow = function (d, v) { - if (v.isZero()) return new i(1).toRed(this); - if (v.cmpn(1) === 0) return d.clone(); - var _ = 4, - S = new Array(1 << _); - (S[0] = new i(1).toRed(this)), (S[1] = d); - for (var b = 2; b < S.length; b++) S[b] = this.mul(S[b - 1], d); - var f = S[0], - x = 0, - C = 0, - E = v.bitLength() % 26; - for (E === 0 && (E = 26), b = v.length - 1; b >= 0; b--) { - for (var B = v.words[b], G = E - 1; G >= 0; G--) { - var L = (B >> G) & 1; - if ((f !== S[0] && (f = this.sqr(f)), L === 0 && x === 0)) { - C = 0; - continue; - } - (x <<= 1), - (x |= L), - C++, - !(C !== _ && (b !== 0 || G !== 0)) && - ((f = this.mul(f, S[x])), (C = 0), (x = 0)); - } - E = 26; - } - return f; - }), - (l.prototype.convertTo = function (d) { - var v = d.umod(this.m); - return v === d ? v.clone() : v; - }), - (l.prototype.convertFrom = function (d) { - var v = d.clone(); - return (v.red = null), v; - }), - (i.mont = function (d) { - return new p(d); - }); - function p(y) { - l.call(this, y), - (this.shift = this.m.bitLength()), - this.shift % 26 !== 0 && (this.shift += 26 - (this.shift % 26)), - (this.r = new i(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)); - } - n(p, l), - (p.prototype.convertTo = function (d) { - return this.imod(d.ushln(this.shift)); - }), - (p.prototype.convertFrom = function (d) { - var v = this.imod(d.mul(this.rinv)); - return (v.red = null), v; - }), - (p.prototype.imul = function (d, v) { - if (d.isZero() || v.isZero()) - return (d.words[0] = 0), (d.length = 1), d; - var _ = d.imul(v), - S = _.maskn(this.shift) - .mul(this.minv) - .imaskn(this.shift) - .mul(this.m), - b = _.isub(S).iushrn(this.shift), - f = b; - return ( - b.cmp(this.m) >= 0 - ? (f = b.isub(this.m)) - : b.cmpn(0) < 0 && (f = b.iadd(this.m)), - f._forceRed(this) - ); - }), - (p.prototype.mul = function (d, v) { - if (d.isZero() || v.isZero()) return new i(0)._forceRed(this); - var _ = d.mul(v), - S = _.maskn(this.shift) - .mul(this.minv) - .imaskn(this.shift) - .mul(this.m), - b = _.isub(S).iushrn(this.shift), - f = b; - return ( - b.cmp(this.m) >= 0 - ? (f = b.isub(this.m)) - : b.cmpn(0) < 0 && (f = b.iadd(this.m)), - f._forceRed(this) - ); - }), - (p.prototype.invm = function (d) { - var v = this.imod(d._invmp(this.m).mul(this.r2)); - return v._forceRed(this); - }); - })(typeof gTe > "u" || gTe, zgt); - }); - var vTe = I((Ka) => { - "use strict"; - m(); - g(); - var uPr = - (Ka && Ka.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Ka, "__esModule", { value: !0 }); - Ka.parseNearAmount = - Ka.formatNearAmount = - Ka.NEAR_NOMINATION = - Ka.NEAR_NOMINATION_EXP = - void 0; - var gH = uPr(AE()); - Ka.NEAR_NOMINATION_EXP = 24; - Ka.NEAR_NOMINATION = new gH.default("10", 10).pow( - new gH.default(Ka.NEAR_NOMINATION_EXP, 10) - ); - var jgt = [], - cPr = new gH.default(10); - for ( - let t = 0, e = new gH.default(5); - t < Ka.NEAR_NOMINATION_EXP; - t++, e = e.mul(cPr) - ) - jgt[t] = e; - function lPr(t, e = Ka.NEAR_NOMINATION_EXP) { - let r = new gH.default(t, 10); - if (e !== Ka.NEAR_NOMINATION_EXP) { - let o = Ka.NEAR_NOMINATION_EXP - e - 1; - o > 0 && r.iadd(jgt[o]); - } - t = r.toString(); - let n = t.substring(0, t.length - Ka.NEAR_NOMINATION_EXP) || "0", - i = t - .substring(t.length - Ka.NEAR_NOMINATION_EXP) - .padStart(Ka.NEAR_NOMINATION_EXP, "0") - .substring(0, e); - return hPr(`${yPr(n)}.${i}`); - } - Ka.formatNearAmount = lPr; - function fPr(t) { - if (!t) return null; - t = dPr(t); - let e = t.split("."), - r = e[0], - n = e[1] || ""; - if (e.length > 2 || n.length > Ka.NEAR_NOMINATION_EXP) - throw new Error(`Cannot parse '${t}' as NEAR amount`); - return pPr(r + n.padEnd(Ka.NEAR_NOMINATION_EXP, "0")); - } - Ka.parseNearAmount = fPr; - function dPr(t) { - return t.replace(/,/g, "").trim(); - } - function hPr(t) { - return t.replace(/\.?0*$/, ""); - } - function pPr(t) { - return (t = t.replace(/^0+/, "")), t === "" ? "0" : t; - } - function yPr(t) { - let e = /(-?\d+)(\d{3})/; - for (; e.test(t); ) t = t.replace(e, "$1,$2"); - return t; - } - }); - var wTe = I((mo) => { - "use strict"; - m(); - g(); - var mPr = - (mo && mo.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - gPr = - (mo && mo.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - nN = - (mo && mo.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.hasOwnProperty.call(t, r) && - mPr(e, t, r); - return gPr(e, t), e; - }; - Object.defineProperty(mo, "__esModule", { value: !0 }); - mo.logWarning = - mo.rpc_errors = - mo.KeyPairEd25519 = - mo.KeyPair = - mo.PublicKey = - mo.format = - mo.enums = - mo.web = - mo.serialize = - mo.key_pair = - void 0; - var vPr = nN(zb()); - mo.key_pair = vPr; - var bPr = nN(VMe()); - mo.serialize = bPr; - var wPr = nN(yH()); - mo.web = wPr; - var _Pr = nN(Yie()); - mo.enums = _Pr; - var xPr = nN(vTe()); - mo.format = xPr; - var SPr = nN(aoe()); - mo.rpc_errors = SPr; - var bTe = zb(); - Object.defineProperty(mo, "PublicKey", { - enumerable: !0, - get: function () { - return bTe.PublicKey; - }, - }); - Object.defineProperty(mo, "KeyPair", { - enumerable: !0, - get: function () { - return bTe.KeyPair; - }, - }); - Object.defineProperty(mo, "KeyPairEd25519", { - enumerable: !0, - get: function () { - return bTe.KeyPairEd25519; - }, - }); - var APr = T6(); - Object.defineProperty(mo, "logWarning", { - enumerable: !0, - get: function () { - return APr.logWarning; - }, - }); - }); - var wH = I((nr) => { - "use strict"; - m(); - g(); - var EPr = - (nr && nr.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(nr, "__esModule", { value: !0 }); - nr.signTransaction = - nr.createTransaction = - nr.SCHEMA = - nr.Action = - nr.SignedTransaction = - nr.Transaction = - nr.Signature = - nr.deleteAccount = - nr.deleteKey = - nr.addKey = - nr.stake = - nr.transfer = - nr.functionCall = - nr.stringifyJsonOrBytes = - nr.deployContract = - nr.createAccount = - nr.DeleteAccount = - nr.DeleteKey = - nr.AddKey = - nr.Stake = - nr.Transfer = - nr.FunctionCall = - nr.DeployContract = - nr.CreateAccount = - nr.IAction = - nr.functionCallAccessKey = - nr.fullAccessKey = - nr.AccessKey = - nr.AccessKeyPermission = - nr.FullAccessPermission = - nr.FunctionCallPermission = - void 0; - var MPr = EPr(qz()), - Cx = Yie(), - bH = _E(), - vH = zb(), - iN = class extends Cx.Assignable {}; - nr.FunctionCallPermission = iN; - var oN = class extends Cx.Assignable {}; - nr.FullAccessPermission = oN; - var P6 = class extends Cx.Enum {}; - nr.AccessKeyPermission = P6; - var O6 = class extends Cx.Assignable {}; - nr.AccessKey = O6; - function TPr() { - return new O6({ - nonce: 0, - permission: new P6({ fullAccess: new oN({}) }), - }); - } - nr.fullAccessKey = TPr; - function kPr(t, e, r) { - return new O6({ - nonce: 0, - permission: new P6({ - functionCall: new iN({ receiverId: t, allowance: r, methodNames: e }), - }), - }); - } - nr.functionCallAccessKey = kPr; - var Sg = class extends Cx.Assignable {}; - nr.IAction = Sg; - var aN = class extends Sg {}; - nr.CreateAccount = aN; - var sN = class extends Sg {}; - nr.DeployContract = sN; - var uN = class extends Sg {}; - nr.FunctionCall = uN; - var cN = class extends Sg {}; - nr.Transfer = cN; - var lN = class extends Sg {}; - nr.Stake = lN; - var fN = class extends Sg {}; - nr.AddKey = fN; - var dN = class extends Sg {}; - nr.DeleteKey = dN; - var hN = class extends Sg {}; - nr.DeleteAccount = hN; - function PPr() { - return new i0({ createAccount: new aN({}) }); - } - nr.createAccount = PPr; - function OPr(t) { - return new i0({ deployContract: new sN({ code: t }) }); - } - nr.deployContract = OPr; - function Kgt(t) { - return t.byteLength !== void 0 && t.byteLength === t.length - ? t - : Buffer.from(JSON.stringify(t)); - } - nr.stringifyJsonOrBytes = Kgt; - function BPr(t, e, r, n, i = Kgt) { - return new i0({ - functionCall: new uN({ methodName: t, args: i(e), gas: r, deposit: n }), - }); - } - nr.functionCall = BPr; - function IPr(t) { - return new i0({ transfer: new cN({ deposit: t }) }); - } - nr.transfer = IPr; - function CPr(t, e) { - return new i0({ stake: new lN({ stake: t, publicKey: e }) }); - } - nr.stake = CPr; - function RPr(t, e) { - return new i0({ addKey: new fN({ publicKey: t, accessKey: e }) }); - } - nr.addKey = RPr; - function NPr(t) { - return new i0({ deleteKey: new dN({ publicKey: t }) }); - } - nr.deleteKey = NPr; - function DPr(t) { - return new i0({ deleteAccount: new hN({ beneficiaryId: t }) }); - } - nr.deleteAccount = DPr; - var pN = class extends Cx.Assignable {}; - nr.Signature = pN; - var Ix = class extends Cx.Assignable { - encode() { - return bH.serialize(nr.SCHEMA, this); - } - static decode(e) { - return bH.deserialize(nr.SCHEMA, Ix, e); - } - }; - nr.Transaction = Ix; - var B6 = class extends Cx.Assignable { - encode() { - return bH.serialize(nr.SCHEMA, this); - } - static decode(e) { - return bH.deserialize(nr.SCHEMA, B6, e); - } - }; - nr.SignedTransaction = B6; - var i0 = class extends Cx.Enum {}; - nr.Action = i0; - nr.SCHEMA = new Map([ - [ - pN, - { - kind: "struct", - fields: [ - ["keyType", "u8"], - ["data", [64]], - ], - }, - ], - [ - B6, - { - kind: "struct", - fields: [ - ["transaction", Ix], - ["signature", pN], - ], - }, - ], - [ - Ix, - { - kind: "struct", - fields: [ - ["signerId", "string"], - ["publicKey", vH.PublicKey], - ["nonce", "u64"], - ["receiverId", "string"], - ["blockHash", [32]], - ["actions", [i0]], - ], - }, - ], - [ - vH.PublicKey, - { - kind: "struct", - fields: [ - ["keyType", "u8"], - ["data", [32]], - ], - }, - ], - [ - O6, - { - kind: "struct", - fields: [ - ["nonce", "u64"], - ["permission", P6], - ], - }, - ], - [ - P6, - { - kind: "enum", - field: "enum", - values: [ - ["functionCall", iN], - ["fullAccess", oN], - ], - }, - ], - [ - iN, - { - kind: "struct", - fields: [ - ["allowance", { kind: "option", type: "u128" }], - ["receiverId", "string"], - ["methodNames", ["string"]], - ], - }, - ], - [oN, { kind: "struct", fields: [] }], - [ - i0, - { - kind: "enum", - field: "enum", - values: [ - ["createAccount", aN], - ["deployContract", sN], - ["functionCall", uN], - ["transfer", cN], - ["stake", lN], - ["addKey", fN], - ["deleteKey", dN], - ["deleteAccount", hN], - ], - }, - ], - [aN, { kind: "struct", fields: [] }], - [sN, { kind: "struct", fields: [["code", ["u8"]]] }], - [ - uN, - { - kind: "struct", - fields: [ - ["methodName", "string"], - ["args", ["u8"]], - ["gas", "u64"], - ["deposit", "u128"], - ], - }, - ], - [cN, { kind: "struct", fields: [["deposit", "u128"]] }], - [ - lN, - { - kind: "struct", - fields: [ - ["stake", "u128"], - ["publicKey", vH.PublicKey], - ], - }, - ], - [ - fN, - { - kind: "struct", - fields: [ - ["publicKey", vH.PublicKey], - ["accessKey", O6], - ], - }, - ], - [dN, { kind: "struct", fields: [["publicKey", vH.PublicKey]] }], - [hN, { kind: "struct", fields: [["beneficiaryId", "string"]] }], - ]); - function Hgt(t, e, r, n, i, o) { - return new Ix({ - signerId: t, - publicKey: e, - nonce: n, - receiverId: r, - actions: i, - blockHash: o, - }); - } - nr.createTransaction = Hgt; - async function Ugt(t, e, r, n) { - let i = bH.serialize(nr.SCHEMA, t), - o = new Uint8Array(MPr.default.sha256.array(i)), - a = await e.signMessage(i, r, n), - s = new B6({ - transaction: t, - signature: new pN({ - keyType: t.publicKey.keyType, - data: a.signature, - }), - }); - return [o, s]; - } - async function FPr(...t) { - if (t[0].constructor === Ix) { - let [e, r, n, i] = t; - return Ugt(e, r, n, i); - } else { - let [e, r, n, i, o, a, s] = t, - c = await o.getPublicKey(a, s), - u = Hgt(a, c, e, r, n, i); - return Ugt(u, o, a, s); - } - } - nr.signTransaction = FPr; - }); - var Wgt = I((EE) => { - "use strict"; - m(); - g(); - var Vgt = - (EE && EE.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(EE, "__esModule", { value: !0 }); - EE.diffEpochValidators = EE.findSeatPrice = void 0; - var Ag = Vgt(AE()), - LPr = Vgt(E6()); - function qPr(t, e, r, n) { - return n && n < 49 - ? zPr(t, e) - : (r || - (LPr.default("findSeatPrice(validators, maxNumberOfSeats)")( - "`use `findSeatPrice(validators, maxNumberOfSeats, minimumStakeRatio)` instead" - ), - (r = [1, 6250])), - jPr(t, e, r)); - } - EE.findSeatPrice = qPr; - function zPr(t, e) { - let r = t - .map((s) => new Ag.default(s.stake, 10)) - .sort((s, c) => s.cmp(c)), - n = new Ag.default(e), - i = r.reduce((s, c) => s.add(c)); - if (i.lt(n)) throw new Error("Stakes are below seats"); - let o = new Ag.default(1), - a = i.add(new Ag.default(1)); - for (; !o.eq(a.sub(new Ag.default(1))); ) { - let s = o.add(a).div(new Ag.default(2)), - c = !1, - u = new Ag.default(0); - for (let h = 0; h < r.length; ++h) - if (((u = u.add(r[h].div(s))), u.gte(n))) { - (o = s), (c = !0); - break; - } - c || (a = s); - } - return o; - } - function jPr(t, e, r) { - if (r.length != 2) - throw Error("minimumStakeRatio should have 2 elements"); - let n = t - .map((o) => new Ag.default(o.stake, 10)) - .sort((o, a) => o.cmp(a)), - i = n.reduce((o, a) => o.add(a)); - return t.length < e - ? i.mul(new Ag.default(r[0])).div(new Ag.default(r[1])) - : n[0].add(new Ag.default(1)); - } - function UPr(t, e) { - let r = new Map(); - t.forEach((i) => r.set(i.account_id, i)); - let n = new Set(e.map((i) => i.account_id)); - return { - newValidators: e.filter((i) => !r.has(i.account_id)), - removedValidators: t.filter((i) => !n.has(i.account_id)), - changedValidators: e - .filter( - (i) => r.has(i.account_id) && r.get(i.account_id).stake != i.stake - ) - .map((i) => ({ current: r.get(i.account_id), next: i })), - }; - } - EE.diffEpochValidators = UPr; - }); - var Ggt = I((yN) => { - "use strict"; - m(); - g(); - var KPr = - (yN && yN.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(yN, "__esModule", { value: !0 }); - yN.DEFAULT_FUNCTION_CALL_GAS = void 0; - var HPr = KPr(AE()); - yN.DEFAULT_FUNCTION_CALL_GAS = new HPr.default("30000000000000"); - }); - var AH = I((mN) => { - "use strict"; - m(); - g(); - var xTe = - (mN && mN.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(mN, "__esModule", { value: !0 }); - mN.Account = void 0; - var _H = xTe(AE()), - uoe = xTe(E6()), - fs = wH(), - coe = rN(), - loe = _E(), - xH = zb(), - _Te = T6(), - Jgt = aoe(), - $gt = Ggt(), - VPr = xTe(ooe()), - WPr = 12, - GPr = 500, - JPr = 1.5; - function $Pr(t) { - return JSON.parse(Buffer.from(t).toString()); - } - function ZPr(t) { - return Buffer.from(JSON.stringify(t)); - } - var SH = class { - constructor(e, r) { - (this.accessKeyByPublicKeyCache = {}), - (this.connection = e), - (this.accountId = r); - } - get ready() { - return ( - uoe.default("Account.ready()")("not needed anymore, always ready"), - Promise.resolve() - ); - } - async fetchState() { - uoe.default("Account.fetchState()")("use `Account.state()` instead"); - } - async state() { - return this.connection.provider.query({ - request_type: "view_account", - account_id: this.accountId, - finality: "optimistic", - }); - } - printLogsAndFailures(e, r) { - if (!process.env.NEAR_NO_LOGS) - for (let n of r) - console.log( - `Receipt${ - n.receiptIds.length > 1 ? "s" : "" - }: ${n.receiptIds.join(", ")}` - ), - this.printLogs(e, n.logs, " "), - n.failure && console.warn(` Failure [${e}]: ${n.failure}`); - } - printLogs(e, r, n = "") { - if (!process.env.NEAR_NO_LOGS) - for (let i of r) console.log(`${n}Log [${e}]: ${i}`); - } - async signTransaction(e, r) { - let n = await this.findAccessKey(e, r); - if (!n) - throw new coe.TypedError( - `Can not sign transactions for account ${this.accountId} on network ${this.connection.networkId}, no matching key pair found in ${this.connection.signer}.`, - "KeyNotFound" - ); - let { accessKey: i } = n, - a = (await this.connection.provider.block({ finality: "final" })) - .header.hash, - s = ++i.nonce; - return await fs.signTransaction( - e, - s, - r, - loe.baseDecode(a), - this.connection.signer, - this.accountId, - this.connection.networkId - ); - } - signAndSendTransaction(...e) { - return typeof e[0] == "string" - ? this.signAndSendTransactionV1(e[0], e[1]) - : this.signAndSendTransactionV2(e[0]); - } - signAndSendTransactionV1(e, r) { - return ( - uoe.default("Account.signAndSendTransaction(receiverId, actions")( - "use `Account.signAndSendTransaction(SignAndSendTransactionOptions)` instead" - ), - this.signAndSendTransactionV2({ receiverId: e, actions: r }) - ); - } - async signAndSendTransactionV2({ - receiverId: e, - actions: r, - returnError: n, - }) { - let i, - o, - a = await VPr.default(GPr, WPr, JPr, async () => { - [i, o] = await this.signTransaction(e, r); - let c = o.transaction.publicKey; - try { - return await this.connection.provider.sendTransaction(o); - } catch (u) { - if (u.type === "InvalidNonce") - return ( - _Te.logWarning( - `Retrying transaction ${e}:${loe.baseEncode( - i - )} with new nonce.` - ), - delete this.accessKeyByPublicKeyCache[c.toString()], - null - ); - if (u.type === "Expired") - return ( - _Te.logWarning( - `Retrying transaction ${e}:${loe.baseEncode( - i - )} due to expired block hash` - ), - null - ); - throw ((u.context = new coe.ErrorContext(loe.baseEncode(i))), u); - } - }); - if (!a) - throw new coe.TypedError( - "nonce retries exceeded for transaction. This usually means there are too many parallel requests with the same access key.", - "RetriesExceeded" - ); - let s = [a.transaction_outcome, ...a.receipts_outcome].reduce( - (c, u) => - u.outcome.logs.length || - (typeof u.outcome.status == "object" && - typeof u.outcome.status.Failure == "object") - ? c.concat({ - receiptIds: u.outcome.receipt_ids, - logs: u.outcome.logs, - failure: - typeof u.outcome.status.Failure < "u" - ? Jgt.parseRpcError(u.outcome.status.Failure) - : null, - }) - : c, - [] - ); - if ( - (this.printLogsAndFailures(o.transaction.receiverId, s), - !n && - typeof a.status == "object" && - typeof a.status.Failure == "object") - ) - throw a.status.Failure.error_message && a.status.Failure.error_type - ? new coe.TypedError( - `Transaction ${a.transaction_outcome.id} failed. ${a.status.Failure.error_message}`, - a.status.Failure.error_type - ) - : Jgt.parseResultError(a); - return a; - } - async findAccessKey(e, r) { - let n = await this.connection.signer.getPublicKey( - this.accountId, - this.connection.networkId - ); - if (!n) return null; - let i = this.accessKeyByPublicKeyCache[n.toString()]; - if (i !== void 0) return { publicKey: n, accessKey: i }; - try { - let o = await this.connection.provider.query({ - request_type: "view_access_key", - account_id: this.accountId, - public_key: n.toString(), - finality: "optimistic", - }); - return this.accessKeyByPublicKeyCache[n.toString()] - ? { - publicKey: n, - accessKey: this.accessKeyByPublicKeyCache[n.toString()], - } - : ((this.accessKeyByPublicKeyCache[n.toString()] = o), - { publicKey: n, accessKey: o }); - } catch (o) { - if (o.type == "AccessKeyDoesNotExist") return null; - throw o; - } - } - async createAndDeployContract(e, r, n, i) { - let o = fs.fullAccessKey(); - return ( - await this.signAndSendTransaction({ - receiverId: e, - actions: [ - fs.createAccount(), - fs.transfer(i), - fs.addKey(xH.PublicKey.from(r), o), - fs.deployContract(n), - ], - }), - new SH(this.connection, e) - ); - } - async sendMoney(e, r) { - return this.signAndSendTransaction({ - receiverId: e, - actions: [fs.transfer(r)], - }); - } - async createAccount(e, r, n) { - let i = fs.fullAccessKey(); - return this.signAndSendTransaction({ - receiverId: e, - actions: [ - fs.createAccount(), - fs.transfer(n), - fs.addKey(xH.PublicKey.from(r), i), - ], - }); - } - async deleteAccount(e) { - return this.signAndSendTransaction({ - receiverId: this.accountId, - actions: [fs.deleteAccount(e)], - }); - } - async deployContract(e) { - return this.signAndSendTransaction({ - receiverId: this.accountId, - actions: [fs.deployContract(e)], - }); - } - async functionCall(...e) { - return typeof e[0] == "string" - ? this.functionCallV1(e[0], e[1], e[2], e[3], e[4]) - : this.functionCallV2(e[0]); - } - functionCallV1(e, r, n, i, o) { - return ( - uoe.default( - "Account.functionCall(contractId, methodName, args, gas, amount)" - )("use `Account.functionCall(FunctionCallOptions)` instead"), - (n = n || {}), - this.validateArgs(n), - this.signAndSendTransaction({ - receiverId: e, - actions: [ - fs.functionCall(r, n, i || $gt.DEFAULT_FUNCTION_CALL_GAS, o), - ], - }) - ); - } - functionCallV2({ - contractId: e, - methodName: r, - args: n = {}, - gas: i = $gt.DEFAULT_FUNCTION_CALL_GAS, - attachedDeposit: o, - walletMeta: a, - walletCallbackUrl: s, - stringify: c, - }) { - this.validateArgs(n); - let u = c === void 0 ? fs.stringifyJsonOrBytes : c; - return this.signAndSendTransaction({ - receiverId: e, - actions: [fs.functionCall(r, n, i, o, u)], - walletMeta: a, - walletCallbackUrl: s, - }); - } - async addKey(e, r, n, i) { - n || (n = []), Array.isArray(n) || (n = [n]); - let o; - return ( - r - ? (o = fs.functionCallAccessKey(r, n, i)) - : (o = fs.fullAccessKey()), - this.signAndSendTransaction({ - receiverId: this.accountId, - actions: [fs.addKey(xH.PublicKey.from(e), o)], - }) - ); - } - async deleteKey(e) { - return this.signAndSendTransaction({ - receiverId: this.accountId, - actions: [fs.deleteKey(xH.PublicKey.from(e))], - }); - } - async stake(e, r) { - return this.signAndSendTransaction({ - receiverId: this.accountId, - actions: [fs.stake(r, xH.PublicKey.from(e))], - }); - } - validateArgs(e) { - if ( - !(e.byteLength !== void 0 && e.byteLength === e.length) && - (Array.isArray(e) || typeof e != "object") - ) - throw new _Te.PositionalArgsError(); - } - async viewFunction( - e, - r, - n = {}, - { parse: i = $Pr, stringify: o = ZPr } = {} - ) { - this.validateArgs(n); - let a = o(n).toString("base64"), - s = await this.connection.provider.query({ - request_type: "call_function", - account_id: e, - method_name: r, - args_base64: a, - finality: "optimistic", - }); - return ( - s.logs && this.printLogs(e, s.logs), - s.result && s.result.length > 0 && i(Buffer.from(s.result)) - ); - } - async viewState(e, r = { finality: "optimistic" }) { - let { values: n } = await this.connection.provider.query({ - request_type: "view_state", - ...r, - account_id: this.accountId, - prefix_base64: Buffer.from(e).toString("base64"), - }); - return n.map(({ key: i, value: o }) => ({ - key: Buffer.from(i, "base64"), - value: Buffer.from(o, "base64"), - })); - } - async getAccessKeys() { - let e = await this.connection.provider.query({ - request_type: "view_access_key_list", - account_id: this.accountId, - finality: "optimistic", - }); - return Array.isArray(e) ? e : e.keys; - } - async getAccountDetails() { - return { - authorizedApps: (await this.getAccessKeys()) - .filter((n) => n.access_key.permission !== "FullAccess") - .map((n) => { - let i = n.access_key.permission; - return { - contractId: i.FunctionCall.receiver_id, - amount: i.FunctionCall.allowance, - publicKey: n.public_key, - }; - }), - }; - } - async getAccountBalance() { - let e = await this.connection.provider.experimental_protocolConfig({ - finality: "final", - }), - r = await this.state(), - n = new _H.default(e.runtime_config.storage_amount_per_byte), - i = new _H.default(r.storage_usage).mul(n), - o = new _H.default(r.locked), - a = new _H.default(r.amount).add(o), - s = a.sub(_H.default.max(o, i)); - return { - total: a.toString(), - stateStaked: i.toString(), - staked: o.toString(), - available: s.toString(), - }; - } - }; - mN.Account = SH; - }); - var Qgt = I((pi) => { - "use strict"; - m(); - g(); - var Ygt = - (pi && pi.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(pi, "__esModule", { value: !0 }); - pi.Account2FA = - pi.AccountMultisig = - pi.MULTISIG_CONFIRM_METHODS = - pi.MULTISIG_CHANGE_METHODS = - pi.MULTISIG_DEPOSIT = - pi.MULTISIG_GAS = - pi.MULTISIG_ALLOWANCE = - pi.MULTISIG_STORAGE_KEY = - void 0; - var ATe = Ygt(AE()), - XPr = Ygt(E6()), - YPr = AH(), - QPr = vTe(), - foe = zb(), - o0 = wH(), - e4r = yH(); - pi.MULTISIG_STORAGE_KEY = "__multisigRequest"; - pi.MULTISIG_ALLOWANCE = new ATe.default(QPr.parseNearAmount("1")); - pi.MULTISIG_GAS = new ATe.default("100000000000000"); - pi.MULTISIG_DEPOSIT = new ATe.default("0"); - pi.MULTISIG_CHANGE_METHODS = [ - "add_request", - "add_request_and_confirm", - "delete_request", - "confirm", - ]; - pi.MULTISIG_CONFIRM_METHODS = ["confirm"]; - var Zgt = { [pi.MULTISIG_STORAGE_KEY]: null }, - doe = class extends YPr.Account { - constructor(e, r, n) { - super(e, r), - (this.storage = n.storage), - (this.onAddRequestResult = n.onAddRequestResult); - } - async signAndSendTransactionWithAccount(e, r) { - return super.signAndSendTransaction({ receiverId: e, actions: r }); - } - signAndSendTransaction(...e) { - return typeof e[0] == "string" - ? this._signAndSendTransaction({ receiverId: e[0], actions: e[1] }) - : this._signAndSendTransaction(e[0]); - } - async _signAndSendTransaction({ receiverId: e, actions: r }) { - let { accountId: n } = this, - i = Buffer.from( - JSON.stringify({ - request: { receiver_id: e, actions: r4r(r, n, e) }, - }) - ), - o; - try { - o = await super.signAndSendTransaction({ - receiverId: n, - actions: [ - o0.functionCall( - "add_request_and_confirm", - i, - pi.MULTISIG_GAS, - pi.MULTISIG_DEPOSIT - ), - ], - }); - } catch (s) { - if ( - s - .toString() - .includes( - "Account has too many active requests. Confirm or delete some" - ) - ) - return ( - await this.deleteUnconfirmedRequests(), - await this.signAndSendTransaction(e, r) - ); - throw s; - } - if (!o.status) throw new Error("Request failed"); - let a = { ...o.status }; - if (!a.SuccessValue || typeof a.SuccessValue != "string") - throw new Error("Request failed"); - return ( - this.setRequest({ - accountId: n, - actions: r, - requestId: parseInt( - Buffer.from(a.SuccessValue, "base64").toString("ascii"), - 10 - ), - }), - this.onAddRequestResult && (await this.onAddRequestResult(o)), - this.deleteUnconfirmedRequests(), - o - ); - } - async deleteUnconfirmedRequests() { - let e = await this.getRequestIds(), - { requestId: r } = this.getRequest(); - for (let n of e) - if (n != r) - try { - await super.signAndSendTransaction({ - receiverId: this.accountId, - actions: [ - o0.functionCall( - "delete_request", - { request_id: n }, - pi.MULTISIG_GAS, - pi.MULTISIG_DEPOSIT - ), - ], - }); - } catch { - console.warn( - "Attempt to delete an earlier request before 15 minutes failed. Will try again." - ); - } - } - async getRequestIds() { - return this.viewFunction(this.accountId, "list_request_ids"); - } - getRequest() { - return this.storage - ? JSON.parse(this.storage.getItem(pi.MULTISIG_STORAGE_KEY) || "{}") - : Zgt[pi.MULTISIG_STORAGE_KEY]; - } - setRequest(e) { - if (this.storage) - return this.storage.setItem( - pi.MULTISIG_STORAGE_KEY, - JSON.stringify(e) - ); - Zgt[pi.MULTISIG_STORAGE_KEY] = e; - } - }; - pi.AccountMultisig = doe; - var STe = class extends doe { - constructor(e, r, n) { - super(e, r, n), - (this.helperUrl = "https://helper.testnet.near.org"), - (this.helperUrl = n.helperUrl || this.helperUrl), - (this.storage = n.storage), - (this.sendCode = n.sendCode || this.sendCodeDefault), - (this.getCode = n.getCode || this.getCodeDefault), - (this.verifyCode = n.verifyCode || this.verifyCodeDefault), - (this.onConfirmResult = n.onConfirmResult); - } - async signAndSendTransaction(...e) { - return typeof e[0] == "string" - ? (XPr.default("Account.signAndSendTransaction(receiverId, actions")( - "use `Account2FA.signAndSendTransaction(SignAndSendTransactionOptions)` instead" - ), - this.__signAndSendTransaction({ receiverId: e[0], actions: e[1] })) - : this.__signAndSendTransaction(e[0]); - } - async __signAndSendTransaction({ receiverId: e, actions: r }) { - await super.signAndSendTransaction({ receiverId: e, actions: r }), - await this.sendCode(); - let n = await this.promptAndVerify(); - return this.onConfirmResult && (await this.onConfirmResult(n)), n; - } - async deployMultisig(e) { - let { accountId: r } = this, - n = (await this.getRecoveryMethods()).data - .filter( - ({ kind: c, publicKey: u }) => - (c === "phrase" || c === "ledger") && u !== null - ) - .map((c) => c.publicKey), - i = (await this.getAccessKeys()) - .filter( - ({ public_key: c, access_key: { permission: u } }) => - u === "FullAccess" && !n.includes(c) - ) - .map((c) => c.public_key) - .map(Xgt), - o = Xgt( - (await this.postSignedJson("/2fa/getAccessKey", { accountId: r })) - .publicKey - ), - a = Buffer.from(JSON.stringify({ num_confirmations: 2 })), - s = [ - ...i.map((c) => o0.deleteKey(c)), - ...i.map((c) => - o0.addKey( - c, - o0.functionCallAccessKey(r, pi.MULTISIG_CHANGE_METHODS, null) - ) - ), - o0.addKey( - o, - o0.functionCallAccessKey(r, pi.MULTISIG_CONFIRM_METHODS, null) - ), - o0.deployContract(e), - ]; - return ( - (await this.state()).code_hash === - "11111111111111111111111111111111" && - s.push( - o0.functionCall("new", a, pi.MULTISIG_GAS, pi.MULTISIG_DEPOSIT) - ), - console.log("deploying multisig contract for", r), - await super.signAndSendTransactionWithAccount(r, s) - ); - } - async disable(e) { - let { accountId: r } = this, - i = (await this.getAccessKeys()) - .filter(({ access_key: s }) => s.permission !== "FullAccess") - .filter(({ access_key: s }) => { - let c = s.permission.FunctionCall; - return ( - c.receiver_id === r && - c.method_names.length === 4 && - c.method_names.includes("add_request_and_confirm") - ); - }), - o = foe.PublicKey.from( - (await this.postSignedJson("/2fa/getAccessKey", { accountId: r })) - .publicKey - ), - a = [ - o0.deleteKey(o), - ...i.map(({ public_key: s }) => - o0.deleteKey(foe.PublicKey.from(s)) - ), - ...i.map(({ public_key: s }) => - o0.addKey(foe.PublicKey.from(s), null) - ), - o0.deployContract(e), - ]; - return ( - console.log("disabling 2fa for", r), - await this.signAndSendTransaction({ receiverId: r, actions: a }) - ); - } - async sendCodeDefault() { - let { accountId: e } = this, - { requestId: r } = this.getRequest(), - n = await this.get2faMethod(); - return ( - await this.postSignedJson("/2fa/send", { - accountId: e, - method: n, - requestId: r, - }), - r - ); - } - async getCodeDefault(e) { - throw new Error( - 'There is no getCode callback provided. Please provide your own in AccountMultisig constructor options. It has a parameter method where method.kind is "email" or "phone".' - ); - } - async promptAndVerify() { - let e = await this.get2faMethod(), - r = await this.getCode(e); - try { - return await this.verifyCode(r); - } catch (n) { - if ( - (console.warn("Error validating security code:", n), - n.toString().includes("invalid 2fa code provided") || - n.toString().includes("2fa code not valid")) - ) - return await this.promptAndVerify(); - throw n; - } - } - async verifyCodeDefault(e) { - let { accountId: r } = this, - n = this.getRequest(); - if (!n) throw new Error("no request pending"); - let { requestId: i } = n; - return await this.postSignedJson("/2fa/verify", { - accountId: r, - securityCode: e, - requestId: i, - }); - } - async getRecoveryMethods() { - let { accountId: e } = this; - return { - accountId: e, - data: await this.postSignedJson("/account/recoveryMethods", { - accountId: e, - }), - }; - } - async get2faMethod() { - let { data: e } = await this.getRecoveryMethods(); - if ( - (e && e.length && (e = e.find((i) => i.kind.indexOf("2fa-") === 0)), - !e) - ) - return null; - let { kind: r, detail: n } = e; - return { kind: r, detail: n }; - } - async signatureFor() { - let { accountId: e } = this, - n = ( - await this.connection.provider.block({ finality: "final" }) - ).header.height.toString(), - i = await this.connection.signer.signMessage( - Buffer.from(n), - e, - this.connection.networkId - ), - o = Buffer.from(i.signature).toString("base64"); - return { blockNumber: n, blockNumberSignature: o }; - } - async postSignedJson(e, r) { - return await e4r.fetchJson( - this.helperUrl + e, - JSON.stringify({ ...r, ...(await this.signatureFor()) }) - ); - } - }; - pi.Account2FA = STe; - var Xgt = (t) => foe.PublicKey.from(t), - t4r = (t) => t.toString().replace("ed25519:", ""), - r4r = (t, e, r) => - t.map((n) => { - let i = n.enum, - { - gas: o, - publicKey: a, - methodName: s, - args: c, - deposit: u, - accessKey: h, - code: w, - } = n[i], - M = { - type: i[0].toUpperCase() + i.substr(1), - gas: (o && o.toString()) || void 0, - public_key: (a && t4r(a)) || void 0, - method_name: s, - args: (c && Buffer.from(c).toString("base64")) || void 0, - code: (w && Buffer.from(w).toString("base64")) || void 0, - amount: (u && u.toString()) || void 0, - deposit: (u && u.toString()) || "0", - permission: void 0, - }; - if ( - h && - (r === e && - h.permission.enum !== "fullAccess" && - (M.permission = { - receiver_id: e, - allowance: pi.MULTISIG_ALLOWANCE.toString(), - method_names: pi.MULTISIG_CHANGE_METHODS, - }), - h.permission.enum === "functionCall") - ) { - let { - receiverId: k, - methodNames: O, - allowance: D, - } = h.permission.functionCall; - M.permission = { - receiver_id: k, - allowance: (D && D.toString()) || void 0, - method_names: O, - }; - } - return M; - }); - }); - var TTe = I((ME) => { - "use strict"; - m(); - g(); - Object.defineProperty(ME, "__esModule", { value: !0 }); - ME.UrlAccountCreator = ME.LocalAccountCreator = ME.AccountCreator = void 0; - var n4r = yH(), - EH = class {}; - ME.AccountCreator = EH; - var ETe = class extends EH { - constructor(e, r) { - super(), (this.masterAccount = e), (this.initialBalance = r); - } - async createAccount(e, r) { - await this.masterAccount.createAccount(e, r, this.initialBalance); - } - }; - ME.LocalAccountCreator = ETe; - var MTe = class extends EH { - constructor(e, r) { - super(), (this.connection = e), (this.helperUrl = r); - } - async createAccount(e, r) { - await n4r.fetchJson( - `${this.helperUrl}/account`, - JSON.stringify({ newAccountId: e, newAccountPublicKey: r.toString() }) - ); - } - }; - ME.UrlAccountCreator = MTe; - }); - var kTe = I((TE) => { - "use strict"; - m(); - g(); - var i4r = - (TE && TE.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(TE, "__esModule", { value: !0 }); - TE.InMemorySigner = TE.Signer = void 0; - var o4r = i4r(qz()), - a4r = zb(), - s4r = $Me(), - hoe = class {}; - TE.Signer = hoe; - var MH = class extends hoe { - constructor(e) { - super(), (this.keyStore = e); - } - static async fromKeyPair(e, r, n) { - let i = new s4r.InMemoryKeyStore(); - return await i.setKey(e, r, n), new MH(i); - } - async createKey(e, r) { - let n = a4r.KeyPair.fromRandom("ed25519"); - return await this.keyStore.setKey(r, e, n), n.getPublicKey(); - } - async getPublicKey(e, r) { - let n = await this.keyStore.getKey(r, e); - return n === null ? null : n.getPublicKey(); - } - async signMessage(e, r, n) { - let i = new Uint8Array(o4r.default.sha256.array(e)); - if (!r) throw new Error("InMemorySigner requires provided account id"); - let o = await this.keyStore.getKey(n, r); - if (o === null) throw new Error(`Key for ${r} not found in ${n}`); - return o.sign(i); - } - toString() { - return `InMemorySigner(${this.keyStore})`; - } - }; - TE.InMemorySigner = MH; - }); - var PTe = I((poe) => { - "use strict"; - m(); - g(); - Object.defineProperty(poe, "__esModule", { value: !0 }); - poe.Connection = void 0; - var u4r = rN(), - c4r = kTe(); - function l4r(t) { - switch (t.type) { - case void 0: - return t; - case "JsonRpcProvider": - return new u4r.JsonRpcProvider({ ...t.args }); - default: - throw new Error(`Unknown provider type ${t.type}`); - } - } - function f4r(t) { - switch (t.type) { - case void 0: - return t; - case "InMemorySigner": - return new c4r.InMemorySigner(t.keyStore); - default: - throw new Error(`Unknown signer type ${t.type}`); - } - } - var TH = class { - constructor(e, r, n) { - (this.networkId = e), (this.provider = r), (this.signer = n); - } - static fromConfig(e) { - let r = l4r(e.provider), - n = f4r(e.signer); - return new TH(e.networkId, r, n); - } - }; - poe.Connection = TH; - }); - var CTe = I((gN) => { - "use strict"; - m(); - g(); - var rvt = - (gN && gN.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(gN, "__esModule", { value: !0 }); - gN.Contract = void 0; - var d4r = rvt(AE()), - h4r = rvt(E6()), - p4r = rN(), - BTe = T6(); - function evt(t, e) { - return { - [t](...r) { - return e(...r); - }, - }[t]; - } - var tvt = (t) => t && t.byteLength !== void 0 && t.byteLength === t.length, - OTe = (t) => Object.prototype.toString.call(t) === "[object Object]", - ITe = class { - constructor(e, r, n) { - (this.account = e), (this.contractId = r); - let { viewMethods: i = [], changeMethods: o = [] } = n; - i.forEach((a) => { - Object.defineProperty(this, a, { - writable: !1, - enumerable: !0, - value: evt(a, async (s = {}, c = {}, ...u) => { - if (u.length || !(OTe(s) || tvt(s)) || !OTe(c)) - throw new BTe.PositionalArgsError(); - return this.account.viewFunction(this.contractId, a, s, c); - }), - }); - }), - o.forEach((a) => { - Object.defineProperty(this, a, { - writable: !1, - enumerable: !0, - value: evt(a, async (...s) => { - if (s.length && (s.length > 3 || !(OTe(s[0]) || tvt(s[0])))) - throw new BTe.PositionalArgsError(); - return s.length > 1 || !(s[0] && s[0].args) - ? (h4r.default("contract.methodName(args, gas, amount)")( - "use `contract.methodName({ args, gas?, amount?, callbackUrl?, meta? })` instead" - ), - this._changeMethod({ - methodName: a, - args: s[0], - gas: s[1], - amount: s[2], - })) - : this._changeMethod({ methodName: a, ...s[0] }); - }), - }); - }); - } - async _changeMethod({ - args: e, - methodName: r, - gas: n, - amount: i, - meta: o, - callbackUrl: a, - }) { - y4r({ gas: n, amount: i }); - let s = await this.account.functionCall({ - contractId: this.contractId, - methodName: r, - args: e, - gas: n, - attachedDeposit: i, - walletMeta: o, - walletCallbackUrl: a, - }); - return p4r.getTransactionLastResult(s); - } - }; - gN.Contract = ITe; - function y4r(t) { - let e = "number, decimal string or BN"; - for (let r of Object.keys(t)) { - let n = t[r]; - if (n && !d4r.default.isBN(n) && isNaN(n)) - throw new BTe.ArgumentTypeError(r, e, n); - } - } - }); - var NTe = I((vN) => { - "use strict"; - m(); - g(); - var m4r = - (vN && vN.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(vN, "__esModule", { value: !0 }); - vN.Near = void 0; - var nvt = m4r(AE()), - kH = AH(), - g4r = PTe(), - v4r = CTe(), - ivt = TTe(), - RTe = class { - constructor(e) { - if ( - ((this.config = e), - (this.connection = g4r.Connection.fromConfig({ - networkId: e.networkId, - provider: { - type: "JsonRpcProvider", - args: { url: e.nodeUrl, headers: e.headers }, - }, - signer: e.signer || { - type: "InMemorySigner", - keyStore: e.keyStore || e.deps.keyStore, - }, - })), - e.masterAccount) - ) { - let r = e.initialBalance - ? new nvt.default(e.initialBalance) - : new nvt.default("500000000000000000000000000"); - this.accountCreator = new ivt.LocalAccountCreator( - new kH.Account(this.connection, e.masterAccount), - r - ); - } else - e.helperUrl - ? (this.accountCreator = new ivt.UrlAccountCreator( - this.connection, - e.helperUrl - )) - : (this.accountCreator = null); - } - async account(e) { - return new kH.Account(this.connection, e); - } - async createAccount(e, r) { - if (!this.accountCreator) - throw new Error( - "Must specify account creator, either via masterAccount or helperUrl configuration settings." - ); - return ( - await this.accountCreator.createAccount(e, r), - new kH.Account(this.connection, e) - ); - } - async loadContract(e, r) { - let n = new kH.Account(this.connection, r.sender); - return new v4r.Contract(n, e, r); - } - async sendTokens(e, r, n) { - return ( - console.warn( - "near.sendTokens is deprecated. Use `yourAccount.sendMoney` instead." - ), - (await new kH.Account(this.connection, r).sendMoney(n, e)) - .transaction_outcome.id - ); - } - }; - vN.Near = RTe; - }); - var uvt = I((Hb) => { - "use strict"; - m(); - g(); - var b4r = - (Hb && Hb.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Hb, "__esModule", { value: !0 }); - Hb.ConnectedWalletAccount = Hb.WalletAccount = Hb.WalletConnection = void 0; - var ovt = b4r(E6()), - w4r = AH(), - avt = wH(), - svt = wTe(), - _4r = _E(), - x4r = _E(), - S4r = "/login/", - A4r = "add_request_and_confirm", - E4r = "_wallet_auth_key", - DTe = "pending_key", - yoe = class { - constructor(e, r) { - this._near = e; - let n = r + E4r, - i = JSON.parse(window.localStorage.getItem(n)); - (this._networkId = e.config.networkId), - (this._walletBaseUrl = e.config.walletUrl), - (r = r || e.config.contractName || "default"), - (this._keyStore = e.connection.signer.keyStore), - (this._authData = i || { allKeys: [] }), - (this._authDataKey = n), - this.isSignedIn() || this._completeSignInWithAccessKey(); - } - isSignedIn() { - return !!this._authData.accountId; - } - getAccountId() { - return this._authData.accountId || ""; - } - async requestSignIn(e = {}, r, n, i) { - let o; - typeof e == "string" - ? (ovt.default("requestSignIn(contractId, title)")( - "`title` ignored; use `requestSignIn({ contractId, methodNames, successUrl, failureUrl })` instead" - ), - (o = { contractId: e, successUrl: n, failureUrl: i })) - : (o = e); - let a = new URL(window.location.href), - s = new URL(this._walletBaseUrl + S4r); - if ( - (s.searchParams.set("success_url", o.successUrl || a.href), - s.searchParams.set("failure_url", o.failureUrl || a.href), - o.contractId) - ) { - await (await this._near.account(o.contractId)).state(), - s.searchParams.set("contract_id", o.contractId); - let u = svt.KeyPair.fromRandom("ed25519"); - s.searchParams.set("public_key", u.getPublicKey().toString()), - await this._keyStore.setKey( - this._networkId, - DTe + u.getPublicKey(), - u - ); - } - o.methodNames && - o.methodNames.forEach((c) => { - s.searchParams.append("methodNames", c); - }), - window.location.assign(s.toString()); - } - async requestSignTransactions(...e) { - return Array.isArray(e[0]) - ? (ovt.default( - "WalletConnection.requestSignTransactions(transactions, callbackUrl, meta)" - )( - "use `WalletConnection.requestSignTransactions(RequestSignTransactionsOptions)` instead" - ), - this._requestSignTransactions({ - transactions: e[0], - callbackUrl: e[1], - meta: e[2], - })) - : this._requestSignTransactions(e[0]); - } - async _requestSignTransactions({ - transactions: e, - meta: r, - callbackUrl: n, - }) { - let i = new URL(window.location.href), - o = new URL("sign", this._walletBaseUrl); - o.searchParams.set( - "transactions", - e - .map((a) => x4r.serialize(avt.SCHEMA, a)) - .map((a) => Buffer.from(a).toString("base64")) - .join(",") - ), - o.searchParams.set("callbackUrl", n || i.href), - r && o.searchParams.set("meta", r), - window.location.assign(o.toString()); - } - async _completeSignInWithAccessKey() { - let e = new URL(window.location.href), - r = e.searchParams.get("public_key") || "", - n = (e.searchParams.get("all_keys") || "").split(","), - i = e.searchParams.get("account_id") || ""; - i && - ((this._authData = { accountId: i, allKeys: n }), - window.localStorage.setItem( - this._authDataKey, - JSON.stringify(this._authData) - ), - r && (await this._moveKeyFromTempToPermanent(i, r))), - e.searchParams.delete("public_key"), - e.searchParams.delete("all_keys"), - e.searchParams.delete("account_id"), - e.searchParams.delete("meta"), - e.searchParams.delete("transactionHashes"), - window.history.replaceState({}, document.title, e.toString()); - } - async _moveKeyFromTempToPermanent(e, r) { - let n = await this._keyStore.getKey(this._networkId, DTe + r); - await this._keyStore.setKey(this._networkId, e, n), - await this._keyStore.removeKey(this._networkId, DTe + r); - } - signOut() { - (this._authData = {}), - window.localStorage.removeItem(this._authDataKey); - } - account() { - return ( - this._connectedAccount || - (this._connectedAccount = new moe( - this, - this._near.connection, - this._authData.accountId - )), - this._connectedAccount - ); - } - }; - Hb.WalletConnection = yoe; - Hb.WalletAccount = yoe; - var moe = class extends w4r.Account { - constructor(e, r, n) { - super(r, n), (this.walletConnection = e); - } - signAndSendTransaction(...e) { - return typeof e[0] == "string" - ? this._signAndSendTransaction({ receiverId: e[0], actions: e[1] }) - : this._signAndSendTransaction(e[0]); - } - async _signAndSendTransaction({ - receiverId: e, - actions: r, - walletMeta: n, - walletCallbackUrl: i = window.location.href, - }) { - let o = await this.connection.signer.getPublicKey( - this.accountId, - this.connection.networkId - ), - a = await this.accessKeyForTransaction(e, r, o); - if (!a) - throw new Error( - `Cannot find matching key for transaction sent to ${e}` - ); - if (o && o.toString() === a.public_key) - try { - return await super.signAndSendTransaction({ - receiverId: e, - actions: r, - }); - } catch (M) { - if (M.type === "NotEnoughAllowance") - a = await this.accessKeyForTransaction(e, r); - else throw M; - } - let s = await this.connection.provider.block({ finality: "final" }), - c = _4r.baseDecode(s.header.hash), - u = svt.PublicKey.from(a.public_key), - h = a.access_key.nonce + 1, - w = avt.createTransaction(this.accountId, u, e, h, r, c); - return ( - await this.walletConnection.requestSignTransactions({ - transactions: [w], - meta: n, - callbackUrl: i, - }), - new Promise((M, k) => { - setTimeout(() => { - k(new Error("Failed to redirect to sign transaction")); - }, 1e3); - }) - ); - } - async accessKeyMatchesTransaction(e, r, n) { - let { - access_key: { permission: i }, - } = e; - if (i === "FullAccess") return !0; - if (i.FunctionCall) { - let { receiver_id: o, method_names: a } = i.FunctionCall; - if (o === this.accountId && a.includes(A4r)) return !0; - if (o === r) { - if (n.length !== 1) return !1; - let [{ functionCall: s }] = n; - return ( - s && - (!s.deposit || s.deposit.toString() === "0") && - (a.length === 0 || a.includes(s.methodName)) - ); - } - } - return !1; - } - async accessKeyForTransaction(e, r, n) { - let i = await this.getAccessKeys(); - if (n) { - let a = i.find((s) => s.public_key.toString() === n.toString()); - if (a && (await this.accessKeyMatchesTransaction(a, e, r))) return a; - } - let o = this.walletConnection._authData.allKeys; - for (let a of i) - if ( - o.indexOf(a.public_key) !== -1 && - (await this.accessKeyMatchesTransaction(a, e, r)) - ) - return a; - return null; - } - }; - Hb.ConnectedWalletAccount = moe; - }); - var dTe = I((An) => { - "use strict"; - m(); - g(); - var M4r = - (An && An.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - T4r = - (An && An.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - bN = - (An && An.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.hasOwnProperty.call(t, r) && - M4r(e, t, r); - return T4r(e, t), e; - }; - Object.defineProperty(An, "__esModule", { value: !0 }); - An.WalletConnection = - An.WalletAccount = - An.ConnectedWalletAccount = - An.Near = - An.KeyPair = - An.Signer = - An.InMemorySigner = - An.Contract = - An.Connection = - An.Account = - An.multisig = - An.validators = - An.transactions = - An.utils = - An.providers = - An.accountCreator = - void 0; - var k4r = bN(rN()); - An.providers = k4r; - var P4r = bN(wTe()); - An.utils = P4r; - var O4r = bN(wH()); - An.transactions = O4r; - var B4r = bN(Wgt()); - An.validators = B4r; - var I4r = AH(); - Object.defineProperty(An, "Account", { - enumerable: !0, - get: function () { - return I4r.Account; - }, - }); - var C4r = bN(Qgt()); - An.multisig = C4r; - var R4r = bN(TTe()); - An.accountCreator = R4r; - var N4r = PTe(); - Object.defineProperty(An, "Connection", { - enumerable: !0, - get: function () { - return N4r.Connection; - }, - }); - var cvt = kTe(); - Object.defineProperty(An, "Signer", { - enumerable: !0, - get: function () { - return cvt.Signer; - }, - }); - Object.defineProperty(An, "InMemorySigner", { - enumerable: !0, - get: function () { - return cvt.InMemorySigner; - }, - }); - var D4r = CTe(); - Object.defineProperty(An, "Contract", { - enumerable: !0, - get: function () { - return D4r.Contract; - }, - }); - var F4r = zb(); - Object.defineProperty(An, "KeyPair", { - enumerable: !0, - get: function () { - return F4r.KeyPair; - }, - }); - var L4r = NTe(); - Object.defineProperty(An, "Near", { - enumerable: !0, - get: function () { - return L4r.Near; - }, - }); - var FTe = uvt(); - Object.defineProperty(An, "ConnectedWalletAccount", { - enumerable: !0, - get: function () { - return FTe.ConnectedWalletAccount; - }, - }); - Object.defineProperty(An, "WalletAccount", { - enumerable: !0, - get: function () { - return FTe.WalletAccount; - }, - }); - Object.defineProperty(An, "WalletConnection", { - enumerable: !0, - get: function () { - return FTe.WalletConnection; - }, - }); - }); - var lvt = I((goe) => { - "use strict"; - m(); - g(); - Object.defineProperty(goe, "__esModule", { value: !0 }); - goe.connect = void 0; - var q4r = NTe(); - async function z4r(t) { - return new q4r.Near(t); - } - goe.connect = z4r; - }); - var dvt = I((fwn, fvt) => { - m(); - g(); - var LTe = function () { - (this.tests = {}), (this.cache = {}); - }; - LTe.prototype = { - constructor: LTe, - define: function (t, e) { - if (typeof t != "string" || !(e instanceof Function)) - throw new Error("Invalid capability definition."); - if (this.tests[t]) - throw new Error('Duplicated capability definition by "' + t + '".'); - this.tests[t] = e; - }, - check: function (t) { - if (!this.test(t)) - throw new Error( - 'The current environment does not support "' + - t + - '", therefore we cannot continue.' - ); - }, - test: function (t) { - if (this.cache[t] !== void 0) return this.cache[t]; - if (!this.tests[t]) - throw new Error('Unknown capability with name "' + t + '".'); - var e = this.tests[t]; - return (this.cache[t] = !!e()), this.cache[t]; - }, - }; - fvt.exports = LTe; - }); - var zTe = I((dwn, hvt) => { - m(); - g(); - var j4r = dvt(), - qTe = new j4r(), - PH = function (t) { - return qTe.test(t); - }; - PH.define = function (t, e) { - qTe.define(t, e); - }; - PH.check = function (t) { - qTe.check(t); - }; - PH.test = PH; - hvt.exports = PH; - }); - var yvt = I(() => { - m(); - g(); - var pvt = zTe(), - em = pvt.define, - I6 = pvt.test; - em("strict mode", function () { - return this === void 0; - }); - em("arguments.callee.caller", function () { - try { - return ( - (function () { - return arguments.callee.caller; - })() === arguments.callee - ); - } catch { - return !1; - } - }); - em("es5", function () { - return ( - I6("Array.prototype.forEach") && - I6("Array.prototype.map") && - I6("Function.prototype.bind") && - I6("Object.create") && - I6("Object.defineProperties") && - I6("Object.defineProperty") && - I6("Object.prototype.hasOwnProperty") - ); - }); - em("Array.prototype.forEach", function () { - return Array.prototype.forEach; - }); - em("Array.prototype.map", function () { - return Array.prototype.map; - }); - em("Function.prototype.bind", function () { - return Function.prototype.bind; - }); - em("Object.create", function () { - return Object.create; - }); - em("Object.defineProperties", function () { - return Object.defineProperties; - }); - em("Object.defineProperty", function () { - return Object.defineProperty; - }); - em("Object.prototype.hasOwnProperty", function () { - return Object.prototype.hasOwnProperty; - }); - em("Error.captureStackTrace", function () { - return Error.captureStackTrace; - }); - em("Error.prototype.stack", function () { - try { - throw new Error(); - } catch (t) { - return t.stack || t.stacktrace; - } - }); - }); - var voe = I((ywn, mvt) => { - m(); - g(); - yvt(); - mvt.exports = zTe(); - }); - var jTe = I(() => { - m(); - g(); - voe().check("es5"); - }); - var boe = I((vwn, gvt) => { - m(); - g(); - var U4r = function (t, e, r) { - var n = ""; - if ( - ((n += t.name || "Error"), - (n += ": " + (t.message || "")), - r instanceof Array) - ) - for (var i in r) { - var o = r[i]; - n += - ` - # ` + o; - } - for (var a in e) { - var s = e[a]; - n += - ` - at ` + s.toString(); - } - return n; - }; - gvt.exports = U4r; - }); - var bvt = I((bwn, vvt) => { - m(); - g(); - var K4r = boe(); - vvt.exports = function () { - return ( - (Error.getStackTrace = function (t) { - return t.stack; - }), - { prepareStackTrace: K4r } - ); - }; - }); - var _vt = I((wwn, wvt) => { - m(); - g(); - var ds = function () { - var t = Object.create({ Source: Object, config: {}, buildArgs: [] }); - function e(s) { - var c = "config"; - if (s instanceof Function) c = "Source"; - else if (s instanceof Array) c = "buildArgs"; - else if (s instanceof Object) c = "config"; - else throw new Error("Invalid configuration option."); - if (t.hasOwnProperty(c)) - throw new Error("Duplicated configuration option: " + c + "."); - t[c] = s; - } - for (var r = 0, n = arguments.length; r < n; ++r) e(arguments[r]); - var i = t.Source, - o = t.config, - a = t.buildArgs; - return (i.extend || ds.extend).call(i, o, a); - }; - ds.factory = function () { - var t = this; - return function () { - var e = this; - e.build instanceof Function && e.build.apply(e, arguments), - e.init instanceof Function && e.init.apply(e, arguments); - }; - }; - ds.extend = function (t, e) { - var r = this; - t || (t = {}); - var n; - return ( - t.prototype instanceof Object && t.prototype.constructor !== Object - ? (n = t.prototype.constructor) - : t.factory instanceof Function && (n = t.factory.call(r)), - (n = (r.clone || ds.clone).call(r, n, e)), - (n.merge || ds.merge).call(n, t), - n - ); - }; - ds.prototype.extend = function (t, e) { - var r = this, - n = (r.clone || ds.prototype.clone).apply(r, e); - return (n.merge || ds.prototype.merge).call(n, t), n; - }; - ds.clone = function (t, e) { - var r = this; - t instanceof Function || (t = (r.factory || ds.factory).call(r)), - (t.prototype = (r.prototype.clone || ds.prototype.clone).apply( - r.prototype, - e || [] - )), - (t.prototype.constructor = t); - for (var n in r) n !== "prototype" && (t[n] = r[n]); - return t; - }; - ds.prototype.clone = function () { - var t = this, - e = Object.create(t); - return e.build instanceof Function && e.build.apply(e, arguments), e; - }; - ds.merge = function (t) { - var e = this; - for (var r in t) r !== "prototype" && (e[r] = t[r]); - return ( - t.prototype instanceof Object && - (e.prototype.merge || ds.prototype.merge).call( - e.prototype, - t.prototype - ), - e - ); - }; - ds.prototype.merge = function (t) { - var e = this; - for (var r in t) r !== "constructor" && (e[r] = t[r]); - return e; - }; - ds.absorb = function (t) { - var e = this; - for (var r in t) - r !== "prototype" && - (e[r] === void 0 || e[r] === Function.prototype[r]) && - (e[r] = t[r]); - return ( - t.prototype instanceof Object && - (e.prototype.absorb || ds.prototype.absorb).call( - e.prototype, - t.prototype - ), - e - ); - }; - ds.prototype.absorb = function (t) { - var e = this; - for (var r in t) - r !== "constructor" && - (e[r] === void 0 || e[r] === Object.prototype[r]) && - (e[r] = t[r]); - return e; - }; - ds.getAncestor = function () { - var t = this; - if (t !== t.prototype.constructor) return t.prototype.constructor; - }; - ds.newInstance = function () { - var t = this, - e = Object.create(this.prototype); - return t.apply(e, arguments), e; - }; - wvt.exports = ds; - }); - var Svt = I((_wn, xvt) => { - m(); - g(); - xvt.exports = function () { - throw new Error("Not implemented."); - }; - }); - var Evt = I((xwn, Avt) => { - m(); - g(); - Avt.exports = { Class: _vt(), abstractMethod: Svt() }; - }); - var wN = I((Swn, Mvt) => { - m(); - g(); - jTe(); - Mvt.exports = Evt(); - }); - var kvt = I((Awn, Tvt) => { - m(); - g(); - var H4r = function (t) { - var e = !1, - r; - return ( - t instanceof Function || ((e = !0), (r = t), (t = null)), - function () { - return e || ((e = !0), (r = t.apply(this, arguments)), (t = null)), r; - } - ); - }; - Tvt.exports = H4r; - }); - var Ovt = I((Ewn, Pvt) => { - m(); - g(); - Pvt.exports = function t(e, r, n) { - if ((n || (n = []), n.length < e.length)) { - var i = e[n.length]; - for (var o in i) (n[n.length] = i[o]), t(e, r, n), --n.length; - } else r.apply(null, n); - }; - }); - var Ivt = I((Mwn, Bvt) => { - m(); - g(); - Bvt.exports = { cache: kvt(), eachCombination: Ovt() }; - }); - var _N = I((Twn, Cvt) => { - m(); - g(); - Cvt.exports = Ivt(); - }); - var Fvt = I((kwn, Dvt) => { - m(); - g(); - var OH = wN().Class, - Rvt = wN().abstractMethod, - V4r = _N().eachCombination, - Nvt = _N().cache, - W4r = voe(), - G4r = OH(Object, { - prototype: { - captureFrameStrings: function (t) { - var e = this.createError(); - t.unshift(this.captureFrameStrings), t.unshift(this.createError); - var r = this.getFrameStrings(e), - n = r.slice(t.length), - i = []; - if (W4r("arguments.callee.caller")) { - var o = [this.createError, this.captureFrameStrings]; - try { - for (var a = arguments.callee; (a = a.caller); ) o.push(a); - } catch {} - i = o.slice(t.length); - } - return { frameStrings: n, functionValues: i }; - }, - getFrameStrings: function (t) { - var e = t.message || "", - r = t.name || "", - n = this.getStackString(t); - if (n !== void 0) { - var i = n.split(` -`), - o = 0, - a = i.length; - return ( - this.hasHeader && - (o += - r.split(` -`).length + - e.split(` -`).length - - 1), - this.hasFooter && (a -= 1), - i.slice(o, a) - ); - } - }, - createError: Rvt, - getStackString: Rvt, - hasHeader: void 0, - hasFooter: void 0, - }, - }), - J4r = OH(Object, { - prototype: { - calibrateClass: function (t) { - return this.calibrateMethods(t) && this.calibrateEnvelope(t); - }, - calibrateMethods: function (t) { - try { - V4r( - [ - [ - function (e) { - return new Error(e); - }, - function (e) { - try { - throw new Error(e); - } catch (r) { - return r; - } - }, - ], - [ - function (e) { - return e.stack; - }, - function (e) { - return e.stacktrace; - }, - ], - ], - function (e, r) { - if (r(e())) throw { getStackString: r, createError: e }; - } - ); - } catch (e) { - return OH.merge.call(t, { prototype: e }), !0; - } - return !1; - }, - calibrateEnvelope: function (t) { - var e = t.prototype.getStackString, - r = t.prototype.createError, - n = e(r("marker")), - i = n.split(` -`); - return ( - OH.merge.call(t, { - prototype: { - hasHeader: /marker/.test(i[0]), - hasFooter: i[i.length - 1] === "", - }, - }), - !0 - ); - }, - }, - }); - Dvt.exports = { - getClass: Nvt(function () { - var t; - if (t) return t; - t = OH(G4r, {}); - var e = new J4r(); - if (!e.calibrateClass(t)) - throw new Error( - "Cannot read Error.prototype.stack in this environment." - ); - return t; - }), - getInstance: Nvt(function () { - var t = this.getClass(), - e = new t(); - return e; - }), - }; - }); - var zvt = I((Pwn, qvt) => { - m(); - g(); - var Lvt = wN().Class, - tm = wN().abstractMethod, - $4r = Lvt(Object, { - prototype: { - init: Lvt.prototype.merge, - frameString: void 0, - toString: function () { - return this.frameString; - }, - functionValue: void 0, - getThis: tm, - getTypeName: tm, - getFunction: function () { - return this.functionValue; - }, - getFunctionName: tm, - getMethodName: tm, - getFileName: tm, - getLineNumber: tm, - getColumnNumber: tm, - getEvalOrigin: tm, - isTopLevel: tm, - isEval: tm, - isNative: tm, - isConstructor: tm, - }, - }); - qvt.exports = $4r; - }); - var Hvt = I((Own, Kvt) => { - m(); - g(); - var jvt = wN().Class, - Z4r = zvt(), - Uvt = _N().cache, - X4r = jvt(Object, { - prototype: { - stackParser: null, - frameParser: null, - locationParsers: null, - constructor: function (t) { - jvt.prototype.merge.call(this, t); - }, - getFrames: function (t, e) { - for (var r = [], n = 0, i = t.length; n < i; ++n) - r[n] = this.getFrame(t[n], e[n]); - return r; - }, - getFrame: function (t, e) { - var r = { frameString: t, functionValue: e }; - return new Z4r(r); - }, - }, - }); - Kvt.exports = { - getClass: Uvt(function () { - return X4r; - }), - getInstance: Uvt(function () { - var t = this.getClass(), - e = new t(); - return e; - }), - }; - }); - var Jvt = I((Bwn, Gvt) => { - m(); - g(); - var Vvt = Fvt(), - Wvt = Hvt(), - Y4r = _N().cache, - UTe = boe(); - Gvt.exports = function () { - return ( - (Error.captureStackTrace = function t(e, r) { - var n, - i = [t]; - r && i.push(r); - var o = Vvt.getInstance().captureFrameStrings(i); - Object.defineProperties(e, { - stack: { - configurable: !0, - get: Y4r(function () { - var a = Wvt.getInstance().getFrames( - o.frameStrings, - o.functionValues - ); - return (Error.prepareStackTrace || UTe)(e, a, n); - }), - }, - cachedStack: { - configurable: !0, - writable: !0, - enumerable: !1, - value: !0, - }, - }); - }), - (Error.getStackTrace = function (t) { - if (t.cachedStack) return t.stack; - var e = Vvt.getInstance().getFrameStrings(t), - r = [], - n; - e - ? (r = Wvt.getInstance().getFrames(e, [])) - : (n = [ - "The stack is not readable by unthrown errors in this environment.", - ]); - var i = (Error.prepareStackTrace || UTe)(t, r, n); - if (e) - try { - Object.defineProperties(t, { - stack: { - configurable: !0, - writable: !0, - enumerable: !1, - value: i, - }, - cachedStack: { - configurable: !0, - writable: !0, - enumerable: !1, - value: !0, - }, - }); - } catch {} - return i; - }), - { prepareStackTrace: UTe } - ); - }; - }); - var Zvt = I((Iwn, $vt) => { - m(); - g(); - var Q4r = _N().cache, - KTe = boe(); - $vt.exports = function () { - return ( - (Error.captureStackTrace = function (t, e) { - Object.defineProperties(t, { - stack: { - configurable: !0, - get: Q4r(function () { - return (Error.prepareStackTrace || KTe)(t, []); - }), - }, - cachedStack: { - configurable: !0, - writable: !0, - enumerable: !1, - value: !0, - }, - }); - }), - (Error.getStackTrace = function (t) { - if (t.cachedStack) return t.stack; - var e = (Error.prepareStackTrace || KTe)(t, []); - try { - Object.defineProperties(t, { - stack: { - configurable: !0, - writable: !0, - enumerable: !1, - value: e, - }, - cachedStack: { - configurable: !0, - writable: !0, - enumerable: !1, - value: !0, - }, - }); - } catch {} - return e; - }), - { prepareStackTrace: KTe } - ); - }; - }); - var Qvt = I((Cwn, Yvt) => { - m(); - g(); - jTe(); - var Xvt = voe(), - woe; - Xvt("Error.captureStackTrace") - ? (woe = bvt()) - : Xvt("Error.prototype.stack") - ? (woe = Jvt()) - : (woe = Zvt()); - Yvt.exports = woe(); - }); - var tbt = I((Rwn, ebt) => { - m(); - g(); - ebt.exports = Qvt(); - }); - var ibt = I((a0) => { - "use strict"; - m(); - g(); - var rbt = - (a0 && a0.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - eOr = - (a0 && a0.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - tOr = - (a0 && a0.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.hasOwnProperty.call(t, r) && - rbt(e, t, r); - return eOr(e, t), e; - }, - nbt = - (a0 && a0.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && !e.hasOwnProperty(r) && rbt(e, t, r); - }; - Object.defineProperty(a0, "__esModule", { value: !0 }); - a0.keyStores = tOr(cgt()); - nbt(dTe(), a0); - nbt(lvt(), a0); - tbt(); - }); - var abt = I((IH) => { - "use strict"; - m(); - g(); - var WTe = - (IH && IH.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(IH, "__esModule", { value: !0 }); - var obt = S7(), - BH = WTe(Sy()), - Rx = ibt(), - HTe = xv(), - rOr = WTe(Ho()), - nOr = qz(), - iOr = WTe(lH()), - VTe = class extends iOr.default { - constructor(e) { - super(e), - (this.near = this.wallet._near), - (this.base = ["yoctoNEAR", 1e25]); - } - async ready() { - if (!this.wallet.isSignedIn()) - throw new Error("Wallet has not been signed in!"); - let e = new Rx.keyStores.BrowserLocalStorageKeyStore(), - r = this.wallet.account(); - if ( - ((this.keyPair = await e.getKey( - this.wallet._networkId, - r.accountId - )), - !this.keyPair) - ) { - this.keyPair = Rx.KeyPair.fromRandom("ed25519"); - let n = this.keyPair.getPublicKey().toString(); - await e.setKey(this.wallet._networkId, r.accountId, this.keyPair), - await r.addKey(n); - } - (this._address = await this.wallet.getAccountId()), - (this.providerInstance = this.wallet._near.connection.provider); - } - async getTx(e) { - var r; - let n = await this.providerInstance, - [i, o] = e.split(":"), - a = await n.txStatusReceipts((0, HTe.decode)(o), i), - s = await n.block(a.transaction_outcome.block_hash), - c = (await n.block({ finality: "final" })).header.height; - if (a.receipts_outcome[0].outcome.status.SuccessValue !== "") - throw new Error("Transaction failed!"); - let u = - (r = a.receipts[0].receipt.Action.actions[0].Transfer.deposit) !== - null && r !== void 0 - ? r - : 0; - return { - from: i, - to: a.transaction.receiver_id, - amount: new BH.default(u), - blockHeight: new BH.default(s.header.height), - pending: !1, - confirmed: c - s.header.height >= this.minConfirm, - }; - } - ownerToAddress(e) { - let r = typeof e == "string" ? e : (0, HTe.encode)(e); - return (0, HTe.decode)(r.replace("ed25519:", "")).toString("hex"); - } - async sign(e) { - return this.getSigner().sign(e); - } - getSigner() { - return new obt.NearSigner(this.keyPair.secretKey); - } - async verify(e, r, n) { - return obt.NearSigner.verify(e, r, n); - } - async getCurrentHeight() { - let e = await this.providerInstance.status(); - return new BH.default(e.sync_info.latest_block_height); - } - async getFee(e, r) { - let n = await this.providerInstance.gasPrice(null); - return new BH.default(n.gas_price).multipliedBy(45e10); - } - async sendTx(e) { - let r = await this.providerInstance.sendTransaction(e); - return `${this.address}:${r.transaction.hash}`; - } - async createTx(e, r, n) { - let i = await this.providerInstance.query({ - request_type: "view_access_key", - finality: "final", - account_id: this.address, - public_key: this.keyPair.getPublicKey().toString(), - }), - o = ++i.nonce, - a = Rx.utils.serialize.base_decode(i.block_hash), - s = [ - Rx.transactions.transfer( - new rOr.default(new BH.default(e).toString()) - ), - ], - c = Rx.transactions.createTransaction( - this.address, - this.keyPair.getPublicKey(), - r, - o, - s, - a - ), - u = Rx.utils.serialize.serialize(Rx.transactions.SCHEMA, c), - h = new Uint8Array(nOr.sha256.array(u)), - w = this.keyPair.sign(h); - return { - tx: new Rx.transactions.SignedTransaction({ - transaction: c, - signature: new Rx.transactions.Signature({ - keyType: c.publicKey.keyType, - data: w.signature, - }), - }), - txId: void 0, - }; - } - async getPublicKey() { - return Buffer.from(this.keyPair.getPublicKey().data); - } - }; - IH.default = VTe; - }); - var ubt = I((Eg) => { - "use strict"; - m(); - g(); - var oOr = - (Eg && Eg.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - aOr = - (Eg && Eg.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - sOr = - (Eg && Eg.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - oOr(e, t, r); - return aOr(e, t), e; - }, - _oe = - (Eg && Eg.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Eg, "__esModule", { value: !0 }); - var sbt = S7(), - xN = _oe(Sy()), - uOr = _oe(lH()), - CH = sOr(Le()), - cOr = _oe(xv()), - lOr = _oe(WK()), - GTe = class extends uOr.default { - constructor(e) { - super(e), (this.minConfirm = 1), (this.base = ["lamports", 1e9]); - } - async getProvider() { - return ( - this.providerInstance || - (this.providerInstance = new CH.Connection(this.providerUrl, { - confirmTransactionInitialTimeout: 6e4, - commitment: "confirmed", - })), - this.providerInstance - ); - } - async getTx(e) { - let r = await this.getProvider(), - n = await r.getTransaction(e, { commitment: "confirmed" }); - if (!n) throw new Error("Confirmed tx not found"); - let i = await r.getSlot("confirmed"), - o = new xN.default(n.meta.postBalances[1]).minus( - new xN.default(n.meta.preBalances[1]) - ); - return { - from: n.transaction.message.accountKeys[0].toBase58(), - to: n.transaction.message.accountKeys[1].toBase58(), - amount: o, - blockHeight: new xN.default(n.slot), - pending: !1, - confirmed: i - n.slot >= 1, - }; - } - ownerToAddress(e) { - return ( - typeof e == "string" && (e = Buffer.from(e)), cOr.default.encode(e) - ); - } - async sign(e) { - return await (await this.getSigner()).sign(e); - } - getSigner() { - return ( - this.signer || - (this.signer = new sbt.HexInjectedSolanaSigner(this.wallet)), - this.signer - ); - } - verify(e, r, n) { - return sbt.HexInjectedSolanaSigner.verify(e, r, n); - } - async getCurrentHeight() { - return new xN.default( - (await (await this.getProvider()).getEpochInfo()).blockHeight - ); - } - async getFee(e, r) { - return new xN.default(5e3); - } - async sendTx(e) { - return await this.wallet.sendTransaction( - e, - await this.getProvider(), - { skipPreflight: !0 } - ); - } - async createTx(e, r, n) { - let i = new CH.PublicKey(await this.getPublicKey()), - o = await (0, lOr.default)( - async (s) => { - var c; - try { - return (await (await this.getProvider()).getRecentBlockhash()) - .blockhash; - } catch (u) { - throw !((c = u.message) === null || c === void 0) && - c.includes("blockhash") - ? u - : (s(u), new Error("Unreachable")); - } - }, - { retries: 3, minTimeout: 1e3 } - ), - a = new CH.Transaction({ recentBlockhash: o, feePayer: i }); - return ( - a.add( - CH.SystemProgram.transfer({ - fromPubkey: i, - toPubkey: new CH.PublicKey(r), - lamports: +new xN.default(e).toNumber(), - }) - ), - { tx: a, txId: void 0 } - ); - } - async getPublicKey() { - return this.wallet.publicKey.toBuffer(); - } - }; - Eg.default = GTe; - }); - var lbt = I((PE) => { - "use strict"; - m(); - g(); - var cbt = - (PE && PE.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(PE, "__esModule", { value: !0 }); - PE.erc20abi = void 0; - var kE = cbt(Sy()), - fOr = DMe(), - dOr = lH(), - hOr = cbt(jMe()), - JTe = class extends hOr.default { - constructor(e) { - super(e), (this.contractAddress = e.contractAddress); - } - async getContract() { - return ( - this.contractInstance || - ((this.contractInstance = new fOr.ethers.Contract( - this.contractAddress, - PE.erc20abi, - this.w3signer - )), - (this.base = [ - "wei", - Math.pow(10, await this.contractInstance.decimals()), - ])), - this.contractInstance - ); - } - async getTx(e) { - let r = await this.providerInstance.getTransaction(e); - if (!r) throw new Error("Tx doesn't exist"); - if (r.data.length !== 138 || r.data.slice(2, 10) !== "a9059cbb") - throw new Error("Tx isn't a ERC20 transfer"); - let n = `0x${r.data.slice(34, 74)}`, - i = new kE.default(r.data.slice(74), 16); - return { - from: r.from, - to: n, - blockHeight: r.blockNumber ? new kE.default(r.blockNumber) : null, - amount: i, - pending: !r.blockNumber, - confirmed: r.confirmations >= this.minConfirm, - }; - } - async getFee(e, r) { - let n = "0x" + new kE.default(e).toString(16), - i = await this.getContract(), - o = await this.providerInstance.getGasPrice(), - a = await i.estimateGas.transfer(r, n), - s = new kE.default(o.mul(a).toString()), - [c] = await this.getGas(), - u = c.multipliedBy(s), - h = new kE.default(await this.price()); - return new kE.default(u).dividedToIntegerBy(h); - } - async createTx(e, r, n) { - let i = await this.getContract(), - o = "0x" + new kE.default(e).toString(16), - a = await i.populateTransaction.transfer(r, o); - return ( - (a.gasPrice = await this.providerInstance.getGasPrice()), - (a.gasLimit = await i.estimateGas.transfer(r, o)), - (a.chainId = (await this.providerInstance.getNetwork()).chainId), - (a.nonce = await this.providerInstance.getTransactionCount( - this.address - )), - { txId: void 0, tx: a } - ); - } - async getGas() { - return [new kE.default(await (0, dOr.getRedstonePrice)("ETH")), 1e18]; - } - }; - PE.default = JTe; - PE.erc20abi = [ - { - constant: !0, - inputs: [], - name: "name", - outputs: [{ name: "", type: "string" }], - payable: !1, - stateMutability: "view", - type: "function", - }, - { - constant: !1, - inputs: [ - { name: "_spender", type: "address" }, - { name: "_value", type: "uint256" }, - ], - name: "approve", - outputs: [{ name: "", type: "bool" }], - payable: !1, - stateMutability: "nonpayable", - type: "function", - }, - { - constant: !0, - inputs: [], - name: "totalSupply", - outputs: [{ name: "", type: "uint256" }], - payable: !1, - stateMutability: "view", - type: "function", - }, - { - constant: !1, - inputs: [ - { name: "_from", type: "address" }, - { name: "_to", type: "address" }, - { name: "_value", type: "uint256" }, - ], - name: "transferFrom", - outputs: [{ name: "", type: "bool" }], - payable: !1, - stateMutability: "nonpayable", - type: "function", - }, - { - constant: !0, - inputs: [], - name: "decimals", - outputs: [{ name: "", type: "uint8" }], - payable: !1, - stateMutability: "view", - type: "function", - }, - { - constant: !0, - inputs: [{ name: "_owner", type: "address" }], - name: "balanceOf", - outputs: [{ name: "balance", type: "uint256" }], - payable: !1, - stateMutability: "view", - type: "function", - }, - { - constant: !0, - inputs: [], - name: "symbol", - outputs: [{ name: "", type: "string" }], - payable: !1, - stateMutability: "view", - type: "function", - }, - { - constant: !1, - inputs: [ - { name: "_to", type: "address" }, - { name: "_value", type: "uint256" }, - ], - name: "transfer", - outputs: [{ name: "", type: "bool" }], - payable: !1, - stateMutability: "nonpayable", - type: "function", - }, - { - constant: !0, - inputs: [ - { name: "_owner", type: "address" }, - { name: "_spender", type: "address" }, - ], - name: "allowance", - outputs: [{ name: "", type: "uint256" }], - payable: !1, - stateMutability: "view", - type: "function", - }, - { payable: !0, stateMutability: "payable", type: "fallback" }, - { - anonymous: !1, - inputs: [ - { indexed: !0, name: "owner", type: "address" }, - { indexed: !0, name: "spender", type: "address" }, - { indexed: !1, name: "value", type: "uint256" }, - ], - name: "Approval", - type: "event", - }, - { - anonymous: !1, - inputs: [ - { indexed: !0, name: "from", type: "address" }, - { indexed: !0, name: "to", type: "address" }, - { indexed: !1, name: "value", type: "uint256" }, - ], - name: "Transfer", - type: "event", - }, - ]; - }); - var fbt = I((RH) => { - "use strict"; - m(); - g(); - var AN = - (RH && RH.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(RH, "__esModule", { value: !0 }); - var SN = AN(jMe()), - pOr = AN(abt()), - yOr = AN(ubt()), - mOr = AN(lbt()), - gOr = AN(zee()), - vOr = AN(m6()); - function bOr(t, e, r, n) { - switch (t) { - case "ethereum": - return new SN.default({ - name: "ethereum", - ticker: "ETH", - providerUrl: r ?? "https://cloudflare-eth.com/", - wallet: e, - }); - case "matic": - return new SN.default({ - name: "matic", - ticker: "MATIC", - providerUrl: r ?? "https://polygon-rpc.com", - wallet: e, - minConfirm: 1, - }); - case "arbitrum": - return new SN.default({ - name: "arbitrum", - ticker: "ETH", - providerUrl: r ?? "https://arb1.arbitrum.io/rpc", - wallet: e, - }); - case "bnb": - return new SN.default({ - name: "bnb", - ticker: "BNB", - providerUrl: r ?? "https://bsc-dataseed.binance.org", - wallet: e, - }); - case "avalanche": - return new SN.default({ - name: "avalanche", - ticker: "AVAX", - providerUrl: r ?? "https://api.avax.network/ext/bc/C/rpc", - wallet: e, - }); - case "boba-eth": - return new SN.default({ - name: "boba-eth", - ticker: "ETH", - providerUrl: r ?? "https://mainnet.boba.network/", - minConfirm: 1, - wallet: e, - }); - case "boba": { - let i = new mOr.default({ - name: "boba", - ticker: "BOBA", - providerUrl: r ?? "https://mainnet.boba.network/", - contractAddress: n ?? "0xa18bF3994C0Cc6E3b63ac420308E5383f53120D7", - minConfirm: 1, - wallet: e, - }); - return ( - (i.price = async () => { - var o; - let a = await gOr.default.post( - "https://api.livecoinwatch.com/coins/single", - JSON.stringify({ currency: "USD", code: `${i.ticker}` }), - { - headers: { - "x-api-key": "75a7a824-6577-45e6-ad86-511d590c7cc8", - "content-type": "application/json", - }, - } - ); - if ( - (await vOr.default.checkAndThrow(a, "Getting price data"), - !(!((o = a?.data) === null || o === void 0) && o.rate)) - ) - throw new Error(`unable to get price for ${i.name}`); - return +a.data.rate; - }), - i - ); - } - case "solana": - return new yOr.default({ - name: "solana", - ticker: "SOL", - providerUrl: r ?? "https://api.mainnet-beta.solana.com/", - wallet: e, - }); - case "near": - return new pOr.default({ - name: "near", - ticker: "NEAR", - providerUrl: r ?? "https://rpc.mainnet.near.org", - wallet: e, - }); - default: - throw new Error(`Unknown/Unsupported currency ${t}`); - } - } - RH.default = bOr; - }); - var ZTe = I((NH) => { - "use strict"; - m(); - g(); - var EN = - (NH && NH.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(NH, "__esModule", { value: !0 }); - var wOr = EN(grt()), - _Or = EN(q0t()), - xOr = EN(G0t()), - SOr = EN(oyt()), - AOr = EN(m6()), - EOr = EN(fbt()), - $Te = class extends _Or.default { - constructor(e, r, n, i) { - var o; - super(); - let a = new URL(e); - (this.api = new wOr.default({ - protocol: a.protocol.slice(0, -1), - port: a.port, - host: a.hostname, - timeout: (o = i?.timeout) !== null && o !== void 0 ? o : 1e5, - })), - (this.currency = r.toLowerCase()), - (this.currencyConfig = (0, EOr.default)( - r, - n, - i?.providerUrl, - i?.contractAddress - )), - (this.utils = new AOr.default( - this.api, - this.currency, - this.currencyConfig - )), - (this.uploader = new SOr.default( - this.api, - this.utils, - this.currency, - this.currencyConfig - )), - (this.funder = new xOr.default(this.utils)); - } - async ready() { - await this.currencyConfig.ready(), - (this.address = this.currencyConfig.address); - } - }; - NH.default = $Te; - }); - var hbt = I((OE) => { - "use strict"; - m(); - g(); - var dbt = - (OE && OE.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(OE, "__esModule", { value: !0 }); - OE.WebBundlr = OE.default = void 0; - var MOr = ZTe(); - Object.defineProperty(OE, "default", { - enumerable: !0, - get: function () { - return dbt(MOr).default; - }, - }); - var TOr = ZTe(); - Object.defineProperty(OE, "WebBundlr", { - enumerable: !0, - get: function () { - return dbt(TOr).default; - }, - }); - }); - var yl = I((pl) => { - "use strict"; - m(); - g(); - Object.defineProperty(pl, "__esModule", { value: !0 }); - pl.isElementCollectionFixedSizeBeet = - pl.isFixableBeet = - pl.assertFixedSizeBeet = - pl.isFixedSizeBeet = - pl.BEET_TYPE_ARG_INNER = - pl.BEET_TYPE_ARG_LEN = - pl.BEET_PACKAGE = - void 0; - var VOr = Dr(); - pl.BEET_PACKAGE = "@metaplex-foundation/beet"; - pl.BEET_TYPE_ARG_LEN = "len"; - pl.BEET_TYPE_ARG_INNER = "Beet<{innner}>"; - function d1t(t) { - return Object.keys(t).includes("byteSize"); - } - pl.isFixedSizeBeet = d1t; - function WOr(t, e = `${t} should have been a fixed beet`) { - (0, VOr.strict)(d1t(t), e); - } - pl.assertFixedSizeBeet = WOr; - function GOr(t) { - return ( - typeof t.toFixedFromData == "function" && - typeof t.toFixedFromValue == "function" - ); - } - pl.isFixableBeet = GOr; - function JOr(t) { - let e = Object.keys(t); - return ( - e.includes("length") && - e.includes("elementByteSize") && - e.includes("lenPrefixByteSize") - ); - } - pl.isElementCollectionFixedSizeBeet = JOr; - }); - var RE = I((zn) => { - "use strict"; - m(); - g(); - var $Or = - (zn && zn.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(zn, "__esModule", { value: !0 }); - zn.numbersTypeMap = - zn.bool = - zn.i512 = - zn.i256 = - zn.i128 = - zn.i64 = - zn.i32 = - zn.i16 = - zn.i8 = - zn.u512 = - zn.u256 = - zn.u128 = - zn.u64 = - zn.u32 = - zn.u16 = - zn.u8 = - void 0; - var ON = $Or(Ho()), - Sa = yl(); - zn.u8 = { - write: function (t, e, r) { - t.writeUInt8(r, e); - }, - read: function (t, e) { - return t.readUInt8(e); - }, - byteSize: 1, - description: "u8", - }; - zn.u16 = { - write: function (t, e, r) { - t.writeUInt16LE(r, e); - }, - read: function (t, e) { - return t.readUInt16LE(e); - }, - byteSize: 2, - description: "u16", - }; - zn.u32 = { - write: function (t, e, r) { - t.writeUInt32LE(r, e); - }, - read: function (t, e) { - return t.readUInt32LE(e); - }, - byteSize: 4, - description: "u32", - }; - function uae(t, e) { - return { - write: function (r, n, i) { - let a = (ON.default.isBN(i) ? i : new ON.default(i)).toArray( - "le", - this.byteSize - ); - Buffer.from(a).copy(r, n, 0, this.byteSize); - }, - read: function (r, n) { - let i = r.slice(n, n + this.byteSize); - return new ON.default(i, "le"); - }, - byteSize: t, - description: e, - }; - } - zn.u64 = uae(8, "u64"); - zn.u128 = uae(16, "u128"); - zn.u256 = uae(32, "u256"); - zn.u512 = uae(64, "u512"); - zn.i8 = { - write: function (t, e, r) { - t.writeInt8(r, e); - }, - read: function (t, e) { - return t.readInt8(e); - }, - byteSize: 1, - description: "i8", - }; - zn.i16 = { - write: function (t, e, r) { - t.writeInt16LE(r, e); - }, - read: function (t, e) { - return t.readInt16LE(e); - }, - byteSize: 2, - description: "i16", - }; - zn.i32 = { - write: function (t, e, r) { - t.writeInt32LE(r, e); - }, - read: function (t, e) { - return t.readInt32LE(e); - }, - byteSize: 4, - description: "i32", - }; - function cae(t, e) { - let r = t * 8; - return { - write: function (n, i, o) { - let s = (ON.default.isBN(o) ? o : new ON.default(o)) - .toTwos(r) - .toArray("le", this.byteSize); - Buffer.from(s).copy(n, i, 0, this.byteSize); - }, - read: function (n, i) { - let o = n.slice(i, i + this.byteSize); - return new ON.default(o, "le").fromTwos(r); - }, - byteSize: t, - description: e, - }; - } - zn.i64 = cae(8, "i64"); - zn.i128 = cae(16, "i128"); - zn.i256 = cae(32, "i256"); - zn.i512 = cae(64, "i512"); - zn.bool = { - write: function (t, e, r) { - let n = r ? 1 : 0; - zn.u8.write(t, e, n); - }, - read: function (t, e) { - return zn.u8.read(t, e) === 1; - }, - byteSize: 1, - description: "bool", - }; - zn.numbersTypeMap = { - u8: { - beet: "u8", - isFixable: !1, - sourcePack: Sa.BEET_PACKAGE, - ts: "number", - }, - u16: { - beet: "u16", - isFixable: !1, - sourcePack: Sa.BEET_PACKAGE, - ts: "number", - }, - u32: { - beet: "u32", - isFixable: !1, - sourcePack: Sa.BEET_PACKAGE, - ts: "number", - }, - i8: { - beet: "i8", - isFixable: !1, - sourcePack: Sa.BEET_PACKAGE, - ts: "number", - }, - i16: { - beet: "i16", - isFixable: !1, - sourcePack: Sa.BEET_PACKAGE, - ts: "number", - }, - i32: { - beet: "i32", - isFixable: !1, - sourcePack: Sa.BEET_PACKAGE, - ts: "number", - }, - bool: { - beet: "bool", - isFixable: !1, - sourcePack: Sa.BEET_PACKAGE, - ts: "boolean", - }, - u64: { - beet: "u64", - isFixable: !1, - sourcePack: Sa.BEET_PACKAGE, - ts: "bignum", - pack: Sa.BEET_PACKAGE, - }, - u128: { - beet: "u128", - isFixable: !1, - sourcePack: Sa.BEET_PACKAGE, - ts: "bignum", - pack: Sa.BEET_PACKAGE, - }, - u256: { - beet: "u256", - isFixable: !1, - sourcePack: Sa.BEET_PACKAGE, - ts: "bignum", - pack: Sa.BEET_PACKAGE, - }, - u512: { - beet: "u512", - isFixable: !1, - sourcePack: Sa.BEET_PACKAGE, - ts: "bignum", - pack: Sa.BEET_PACKAGE, - }, - i64: { - beet: "i64", - isFixable: !1, - sourcePack: Sa.BEET_PACKAGE, - ts: "bignum", - pack: Sa.BEET_PACKAGE, - }, - i128: { - beet: "i128", - isFixable: !1, - sourcePack: Sa.BEET_PACKAGE, - ts: "bignum", - pack: Sa.BEET_PACKAGE, - }, - i256: { - beet: "i256", - isFixable: !1, - sourcePack: Sa.BEET_PACKAGE, - ts: "bignum", - pack: Sa.BEET_PACKAGE, - }, - i512: { - beet: "i512", - isFixable: !1, - sourcePack: Sa.BEET_PACKAGE, - ts: "bignum", - pack: Sa.BEET_PACKAGE, - }, - }; - }); - var p1t = I((e2n, h1t) => { - m(); - g(); - var BN = 1e3, - IN = BN * 60, - CN = IN * 60, - R6 = CN * 24, - ZOr = R6 * 7, - XOr = R6 * 365.25; - h1t.exports = function (t, e) { - e = e || {}; - var r = typeof t; - if (r === "string" && t.length > 0) return YOr(t); - if (r === "number" && isFinite(t)) return e.long ? eBr(t) : QOr(t); - throw new Error( - "val is not a non-empty string or a valid number. val=" + - JSON.stringify(t) - ); - }; - function YOr(t) { - if (((t = String(t)), !(t.length > 100))) { - var e = - /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec( - t - ); - if (!!e) { - var r = parseFloat(e[1]), - n = (e[2] || "ms").toLowerCase(); - switch (n) { - case "years": - case "year": - case "yrs": - case "yr": - case "y": - return r * XOr; - case "weeks": - case "week": - case "w": - return r * ZOr; - case "days": - case "day": - case "d": - return r * R6; - case "hours": - case "hour": - case "hrs": - case "hr": - case "h": - return r * CN; - case "minutes": - case "minute": - case "mins": - case "min": - case "m": - return r * IN; - case "seconds": - case "second": - case "secs": - case "sec": - case "s": - return r * BN; - case "milliseconds": - case "millisecond": - case "msecs": - case "msec": - case "ms": - return r; - default: - return; - } - } - } - } - function QOr(t) { - var e = Math.abs(t); - return e >= R6 - ? Math.round(t / R6) + "d" - : e >= CN - ? Math.round(t / CN) + "h" - : e >= IN - ? Math.round(t / IN) + "m" - : e >= BN - ? Math.round(t / BN) + "s" - : t + "ms"; - } - function eBr(t) { - var e = Math.abs(t); - return e >= R6 - ? lae(t, e, R6, "day") - : e >= CN - ? lae(t, e, CN, "hour") - : e >= IN - ? lae(t, e, IN, "minute") - : e >= BN - ? lae(t, e, BN, "second") - : t + " ms"; - } - function lae(t, e, r, n) { - var i = e >= r * 1.5; - return Math.round(t / r) + " " + n + (i ? "s" : ""); - } - }); - var m1t = I((t2n, y1t) => { - m(); - g(); - function tBr(t) { - (r.debug = r), - (r.default = r), - (r.coerce = c), - (r.disable = o), - (r.enable = i), - (r.enabled = a), - (r.humanize = p1t()), - (r.destroy = u), - Object.keys(t).forEach((h) => { - r[h] = t[h]; - }), - (r.names = []), - (r.skips = []), - (r.formatters = {}); - function e(h) { - let w = 0; - for (let M = 0; M < h.length; M++) - (w = (w << 5) - w + h.charCodeAt(M)), (w |= 0); - return r.colors[Math.abs(w) % r.colors.length]; - } - r.selectColor = e; - function r(h) { - let w, - M = null, - k, - O; - function D(...F) { - if (!D.enabled) return; - let N = D, - q = Number(new Date()), - z = q - (w || q); - (N.diff = z), - (N.prev = w), - (N.curr = q), - (w = q), - (F[0] = r.coerce(F[0])), - typeof F[0] != "string" && F.unshift("%O"); - let H = 0; - (F[0] = F[0].replace(/%([a-zA-Z%])/g, ($, ue) => { - if ($ === "%%") return "%"; - H++; - let te = r.formatters[ue]; - if (typeof te == "function") { - let ne = F[H]; - ($ = te.call(N, ne)), F.splice(H, 1), H--; - } - return $; - })), - r.formatArgs.call(N, F), - (N.log || r.log).apply(N, F); - } - return ( - (D.namespace = h), - (D.useColors = r.useColors()), - (D.color = r.selectColor(h)), - (D.extend = n), - (D.destroy = r.destroy), - Object.defineProperty(D, "enabled", { - enumerable: !0, - configurable: !1, - get: () => - M !== null - ? M - : (k !== r.namespaces && - ((k = r.namespaces), (O = r.enabled(h))), - O), - set: (F) => { - M = F; - }, - }), - typeof r.init == "function" && r.init(D), - D - ); - } - function n(h, w) { - let M = r(this.namespace + (typeof w > "u" ? ":" : w) + h); - return (M.log = this.log), M; - } - function i(h) { - r.save(h), (r.namespaces = h), (r.names = []), (r.skips = []); - let w, - M = (typeof h == "string" ? h : "").split(/[\s,]+/), - k = M.length; - for (w = 0; w < k; w++) - !M[w] || - ((h = M[w].replace(/\*/g, ".*?")), - h[0] === "-" - ? r.skips.push(new RegExp("^" + h.slice(1) + "$")) - : r.names.push(new RegExp("^" + h + "$"))); - } - function o() { - let h = [...r.names.map(s), ...r.skips.map(s).map((w) => "-" + w)].join( - "," - ); - return r.enable(""), h; - } - function a(h) { - if (h[h.length - 1] === "*") return !0; - let w, M; - for (w = 0, M = r.skips.length; w < M; w++) - if (r.skips[w].test(h)) return !1; - for (w = 0, M = r.names.length; w < M; w++) - if (r.names[w].test(h)) return !0; - return !1; - } - function s(h) { - return h - .toString() - .substring(2, h.toString().length - 2) - .replace(/\.\*\?$/, "*"); - } - function c(h) { - return h instanceof Error ? h.stack || h.message : h; - } - function u() { - console.warn( - "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`." - ); - } - return r.enable(r.load()), r; - } - y1t.exports = tBr; - }); - var Nx = I((s0, fae) => { - m(); - g(); - s0.formatArgs = nBr; - s0.save = iBr; - s0.load = oBr; - s0.useColors = rBr; - s0.storage = aBr(); - s0.destroy = (() => { - let t = !1; - return () => { - t || - ((t = !0), - console.warn( - "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`." - )); - }; - })(); - s0.colors = [ - "#0000CC", - "#0000FF", - "#0033CC", - "#0033FF", - "#0066CC", - "#0066FF", - "#0099CC", - "#0099FF", - "#00CC00", - "#00CC33", - "#00CC66", - "#00CC99", - "#00CCCC", - "#00CCFF", - "#3300CC", - "#3300FF", - "#3333CC", - "#3333FF", - "#3366CC", - "#3366FF", - "#3399CC", - "#3399FF", - "#33CC00", - "#33CC33", - "#33CC66", - "#33CC99", - "#33CCCC", - "#33CCFF", - "#6600CC", - "#6600FF", - "#6633CC", - "#6633FF", - "#66CC00", - "#66CC33", - "#9900CC", - "#9900FF", - "#9933CC", - "#9933FF", - "#99CC00", - "#99CC33", - "#CC0000", - "#CC0033", - "#CC0066", - "#CC0099", - "#CC00CC", - "#CC00FF", - "#CC3300", - "#CC3333", - "#CC3366", - "#CC3399", - "#CC33CC", - "#CC33FF", - "#CC6600", - "#CC6633", - "#CC9900", - "#CC9933", - "#CCCC00", - "#CCCC33", - "#FF0000", - "#FF0033", - "#FF0066", - "#FF0099", - "#FF00CC", - "#FF00FF", - "#FF3300", - "#FF3333", - "#FF3366", - "#FF3399", - "#FF33CC", - "#FF33FF", - "#FF6600", - "#FF6633", - "#FF9900", - "#FF9933", - "#FFCC00", - "#FFCC33", - ]; - function rBr() { - return typeof window < "u" && - window.process && - (window.process.type === "renderer" || window.process.__nwjs) - ? !0 - : typeof navigator < "u" && - navigator.userAgent && - navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/) - ? !1 - : (typeof document < "u" && - document.documentElement && - document.documentElement.style && - document.documentElement.style.WebkitAppearance) || - (typeof window < "u" && - window.console && - (window.console.firebug || - (window.console.exception && window.console.table))) || - (typeof navigator < "u" && - navigator.userAgent && - navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && - parseInt(RegExp.$1, 10) >= 31) || - (typeof navigator < "u" && - navigator.userAgent && - navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/)); - } - function nBr(t) { - if ( - ((t[0] = - (this.useColors ? "%c" : "") + - this.namespace + - (this.useColors ? " %c" : " ") + - t[0] + - (this.useColors ? "%c " : " ") + - "+" + - fae.exports.humanize(this.diff)), - !this.useColors) - ) - return; - let e = "color: " + this.color; - t.splice(1, 0, e, "color: inherit"); - let r = 0, - n = 0; - t[0].replace(/%[a-zA-Z%]/g, (i) => { - i !== "%%" && (r++, i === "%c" && (n = r)); - }), - t.splice(n, 0, e); - } - s0.log = console.debug || console.log || (() => {}); - function iBr(t) { - try { - t ? s0.storage.setItem("debug", t) : s0.storage.removeItem("debug"); - } catch {} - } - function oBr() { - let t; - try { - t = s0.storage.getItem("debug"); - } catch {} - return ( - !t && - typeof process < "u" && - "env" in process && - (t = process.env.DEBUG), - t - ); - } - function aBr() { - try { - return localStorage; - } catch {} - } - fae.exports = m1t()(s0); - var { formatters: sBr } = fae.exports; - sBr.j = function (t) { - try { - return JSON.stringify(t); - } catch (e) { - return "[UnexpectedJSONParseError]: " + e.message; - } - }; - }); - var Mg = I((r2n, b1t) => { - "use strict"; - m(); - g(); - var g1t = { - white: 37, - black: 30, - blue: 34, - cyan: 36, - green: 32, - magenta: 35, - red: 31, - yellow: 33, - brightBlack: 90, - brightRed: 91, - brightGreen: 92, - brightYellow: 93, - brightBlue: 94, - brightMagenta: 95, - brightCyan: 96, - brightWhite: 97, - }, - v1t = { - bgBlack: 40, - bgRed: 41, - bgGreen: 42, - bgYellow: 43, - bgBlue: 44, - bgMagenta: 45, - bgCyan: 46, - bgWhite: 47, - bgBrightBlack: 100, - bgBrightRed: 101, - bgBrightGreen: 102, - bgBrightYellow: 103, - bgBrightBlue: 104, - bgBrightMagenta: 105, - bgBrightCyan: 106, - bgBrightWhite: 107, - }, - h6e = {}, - p6e = {}, - LH = {}; - Object.keys(g1t).forEach(function (t) { - var e = (h6e[t] = "\x1B[" + g1t[t] + "m"), - r = (p6e[t] = "\x1B[39m"); - LH[t] = function (n) { - return e + n + r; - }; - }); - Object.keys(v1t).forEach(function (t) { - var e = (h6e[t] = "\x1B[" + v1t[t] + "m"), - r = (p6e[t] = "\x1B[49m"); - LH[t] = function (n) { - return e + n + r; - }; - }); - b1t.exports = LH; - LH.open = h6e; - LH.close = p6e; - }); - var Dx = I((ks) => { - "use strict"; - m(); - g(); - var _1t = - (ks && ks.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(ks, "__esModule", { value: !0 }); - ks.UnreachableCaseError = - ks.stringify = - ks.bytes = - ks.beetBytes = - ks.logTrace = - ks.logDebug = - ks.logInfo = - ks.logError = - void 0; - var dae = _1t(Nx()), - uBr = _1t(Mg()), - w1t = yl(), - { brightBlack: x1t } = uBr.default; - ks.logError = (0, dae.default)("beet:error"); - ks.logInfo = (0, dae.default)("beet:info"); - ks.logDebug = (0, dae.default)("beet:debug"); - ks.logTrace = (0, dae.default)("beet:trace"); - function cBr(t, e = !1) { - let r; - if ((0, w1t.isFixableBeet)(t)) r = "? B"; - else if ((0, w1t.isElementCollectionFixedSizeBeet)(t)) { - let n = e ? "length" : t.length, - i = t.lenPrefixByteSize; - r = - i > 0 - ? `${i} + (${t.elementByteSize} * ${n}) B (${t.byteSize} B)` - : `(${t.elementByteSize} * ${n}) B (${t.byteSize} B)`; - } else r = `${t.byteSize} B`; - return x1t(r); - } - ks.beetBytes = cBr; - function lBr(t) { - return x1t(`${t} B`); - } - ks.bytes = lBr; - function fBr(t) { - return t.toString === "function" ? t.toString() : t; - } - ks.stringify = fBr; - var y6e = class extends Error { - constructor(e) { - super(`Unreachable case: ${e}`); - } - }; - ks.UnreachableCaseError = y6e; - }); - var NN = I((RN) => { - "use strict"; - m(); - g(); - Object.defineProperty(RN, "__esModule", { value: !0 }); - RN.fixBeetFromValue = RN.fixBeetFromData = void 0; - var hae = yl(), - S1t = Dx(); - function dBr(t, e, r) { - if ((0, hae.isFixedSizeBeet)(t)) return t; - if ((0, hae.isFixableBeet)(t)) return t.toFixedFromData(e, r); - throw new S1t.UnreachableCaseError(t); - } - RN.fixBeetFromData = dBr; - function hBr(t, e) { - if ((0, hae.isFixedSizeBeet)(t)) return t; - if ((0, hae.isFixableBeet)(t)) return t.toFixedFromValue(e); - throw new S1t.UnreachableCaseError(t); - } - RN.fixBeetFromValue = hBr; - }); - var pae = I((ml) => { - "use strict"; - m(); - g(); - Object.defineProperty(ml, "__esModule", { value: !0 }); - ml.collectionsTypeMap = - ml.uint8Array = - ml.fixedSizeUint8Array = - ml.fixedSizeBuffer = - ml.array = - ml.fixedSizeArray = - ml.uniformFixedSizeArray = - void 0; - var DN = yl(), - N6 = Dr(), - NE = RE(), - FN = yl(), - E1t = Dx(), - A1t = NN(); - function pBr(t, e, r = !1) { - let n = t.byteSize * e, - i = r ? 4 + n : n; - return { - write: function (o, a, s) { - N6.strict.equal( - s.length, - e, - `array length ${s.length} should match len ${e}` - ), - r && (NE.u32.write(o, a, e), (a += 4)); - for (let c = 0; c < e; c++) t.write(o, a + c * t.byteSize, s[c]); - }, - read: function (o, a) { - if (r) { - let c = NE.u32.read(o, a); - N6.strict.equal(c, e, "invalid byte size"), (a += 4); - } - let s = new Array(e); - for (let c = 0; c < e; c++) s[c] = t.read(o, a + c * t.byteSize); - return s; - }, - byteSize: i, - length: e, - elementByteSize: t.byteSize, - lenPrefixByteSize: 4, - description: `Array<${t.description}>(${e})`, - }; - } - ml.uniformFixedSizeArray = pBr; - function m6e(t, e) { - let r = t.length, - n = r === 0 ? "" : t[0].description; - return { - write: function (i, o, a) { - N6.strict.equal( - a.length, - r, - `array length ${a.length} should match len ${r}` - ), - NE.u32.write(i, o, r); - let s = o + 4; - for (let c = 0; c < r; c++) { - let u = t[c]; - u.write(i, s, a[c]), (s += u.byteSize); - } - }, - read: function (i, o) { - let a = NE.u32.read(i, o); - N6.strict.equal(a, r, "invalid byte size"); - let s = o + 4, - c = new Array(r); - for (let u = 0; u < r; u++) { - let h = t[u]; - (c[u] = h.read(i, s)), (s += h.byteSize); - } - return c; - }, - byteSize: 4 + e, - length: r, - description: `Array<${n}>(${r})[ 4 + ${e} ]`, - }; - } - ml.fixedSizeArray = m6e; - function yBr(t) { - return { - toFixedFromData(e, r) { - let n = NE.u32.read(e, r); - (0, E1t.logTrace)(`${this.description}[${n}]`); - let i = r + 4, - o = i, - a = new Array(n); - for (let s = 0; s < n; s++) { - let c = (0, A1t.fixBeetFromData)(t, e, o); - (a[s] = c), (o += c.byteSize); - } - return m6e(a, o - i); - }, - toFixedFromValue(e) { - (0, N6.strict)(Array.isArray(e), `${e} should be an array`); - let r = 0, - n = new Array(e.length); - for (let i = 0; i < e.length; i++) { - let o = (0, A1t.fixBeetFromValue)(t, e[i]); - (n[i] = o), (r += o.byteSize); - } - return m6e(n, r); - }, - description: "array", - }; - } - ml.array = yBr; - function M1t(t) { - return { - write: function (e, r, n) { - n.copy(e, r, 0, t); - }, - read: function (e, r) { - return e.slice(r, r + t); - }, - byteSize: t, - description: `Buffer(${t})`, - }; - } - ml.fixedSizeBuffer = M1t; - function g6e(t, e = !1) { - let r = M1t(t), - n = e ? t + 4 : t; - return { - write: function (i, o, a) { - N6.strict.equal( - a.byteLength, - t, - `Uint8Array length ${a.byteLength} should match len ${t}` - ), - e && (NE.u32.write(i, o, t), (o += 4)); - let s = Buffer.from(a); - r.write(i, o, s); - }, - read: function (i, o) { - if (e) { - let s = NE.u32.read(i, o); - N6.strict.equal(s, t, "invalid byte size"), (o += 4); - } - let a = r.read(i, o); - return Uint8Array.from(a); - }, - byteSize: n, - description: `Uint8Array(${t})`, - }; - } - ml.fixedSizeUint8Array = g6e; - ml.uint8Array = { - toFixedFromData(t, e) { - let r = NE.u32.read(t, e); - return (0, E1t.logTrace)(`${this.description}[${r}]`), g6e(r, !0); - }, - toFixedFromValue(t) { - let e = t.byteLength; - return g6e(e, !0); - }, - description: "Uint8Array", - }; - ml.collectionsTypeMap = { - Array: { - beet: "array", - isFixable: !0, - sourcePack: FN.BEET_PACKAGE, - ts: "Array", - arg: DN.BEET_TYPE_ARG_LEN, - }, - FixedSizeArray: { - beet: "fixedSizeArray", - isFixable: !1, - sourcePack: FN.BEET_PACKAGE, - ts: "Array", - arg: DN.BEET_TYPE_ARG_LEN, - }, - UniformFixedSizeArray: { - beet: "uniformFixedSizeArray", - isFixable: !1, - sourcePack: FN.BEET_PACKAGE, - ts: "Array", - arg: DN.BEET_TYPE_ARG_LEN, - }, - Buffer: { - beet: "fixedSizeBuffer", - isFixable: !1, - sourcePack: FN.BEET_PACKAGE, - ts: "Buffer", - arg: DN.BEET_TYPE_ARG_LEN, - }, - FixedSizeUint8Array: { - beet: "fixedSizeUint8Array", - isFixable: !1, - sourcePack: FN.BEET_PACKAGE, - ts: "Uint8Array", - arg: DN.BEET_TYPE_ARG_LEN, - }, - Uint8Array: { - beet: "uint8Array", - isFixable: !0, - sourcePack: FN.BEET_PACKAGE, - ts: "Uint8Array", - arg: DN.BEET_TYPE_ARG_LEN, - }, - }; - }); - var S6e = I((Qh) => { - "use strict"; - m(); - g(); - Object.defineProperty(Qh, "__esModule", { value: !0 }); - Qh.compositesTypeMap = - Qh.coption = - Qh.coptionSome = - Qh.coptionNone = - Qh.isNoneBuffer = - Qh.isSomeBuffer = - void 0; - var qH = Dr(), - v6e = yl(), - T1t = yl(), - P1t = Dx(), - k1t = NN(), - O1t = 0, - B1t = 1; - function _6e(t, e) { - return t[e] === B1t; - } - Qh.isSomeBuffer = _6e; - function x6e(t, e) { - return t[e] === O1t; - } - Qh.isNoneBuffer = x6e; - function b6e(t) { - return ( - (0, P1t.logTrace)(`coptionNone(${t})`), - { - write: function (e, r, n) { - (0, qH.strict)( - n == null, - "coptionNone can only handle `null` values" - ), - (e[r] = O1t); - }, - read: function (e, r) { - return ( - (0, qH.strict)( - x6e(e, r), - "coptionNone can only handle `NONE` data" - ), - null - ); - }, - byteSize: 1, - description: `COption`, - } - ); - } - Qh.coptionNone = b6e; - function w6e(t) { - let e = 1 + t.byteSize, - r = { - write: function (n, i, o) { - (0, v6e.assertFixedSizeBeet)( - t, - `coption inner type ${t.description} needs to be fixed before calling write` - ), - (0, qH.strict)( - o != null, - "coptionSome cannot handle `null` values" - ), - (n[i] = B1t), - t.write(n, i + 1, o); - }, - read: function (n, i) { - return ( - (0, v6e.assertFixedSizeBeet)( - t, - `coption inner type ${t.description} needs to be fixed before calling read` - ), - (0, qH.strict)( - _6e(n, i), - "coptionSome can only handle `SOME` data" - ), - t.read(n, i + 1) - ); - }, - description: `COption<${t.description}>[1 + ${t.byteSize}]`, - byteSize: e, - inner: t, - }; - return (0, P1t.logTrace)(r.description), r; - } - Qh.coptionSome = w6e; - function mBr(t) { - return { - toFixedFromData(e, r) { - if (_6e(e, r)) { - let n = (0, k1t.fixBeetFromData)(t, e, r + 1); - return w6e(n); - } else - return ( - (0, qH.strict)(x6e(e, r), `Expected ${e} to hold a COption`), - b6e(t.description) - ); - }, - toFixedFromValue(e) { - return e == null - ? b6e(t.description) - : w6e((0, k1t.fixBeetFromValue)(t, e)); - }, - description: `COption<${t.description}>`, - }; - } - Qh.coption = mBr; - Qh.compositesTypeMap = { - option: { - beet: "coption", - isFixable: !0, - sourcePack: T1t.BEET_PACKAGE, - ts: "COption", - arg: v6e.BEET_TYPE_ARG_INNER, - pack: T1t.BEET_PACKAGE, - }, - }; - }); - var M6e = I((Vb) => { - "use strict"; - m(); - g(); - Object.defineProperty(Vb, "__esModule", { value: !0 }); - Vb.stringTypeMap = Vb.utf8String = Vb.fixedSizeUtf8String = void 0; - var A6e = yl(), - I1t = Dr(), - E6e = RE(), - gBr = Dx(), - vBr = (t) => ({ - write: function (e, r, n) { - let i = Buffer.from(n, "utf8"); - I1t.strict.equal(i.byteLength, t, `${n} has invalid byte size`), - E6e.u32.write(e, r, t), - i.copy(e, r + 4, 0, t); - }, - read: function (e, r) { - let n = E6e.u32.read(e, r); - return ( - I1t.strict.equal(n, t, "invalid byte size"), - e.slice(r + 4, r + 4 + t).toString("utf8") - ); - }, - elementByteSize: 1, - length: t, - lenPrefixByteSize: 4, - byteSize: 4 + t, - description: `Utf8String(4 + ${t})`, - }); - Vb.fixedSizeUtf8String = vBr; - Vb.utf8String = { - toFixedFromData(t, e) { - let r = E6e.u32.read(t, e); - return ( - (0, gBr.logTrace)(`${this.description}[${r}]`), - (0, Vb.fixedSizeUtf8String)(r) - ); - }, - toFixedFromValue(t) { - let e = Buffer.from(t).byteLength; - return (0, Vb.fixedSizeUtf8String)(e); - }, - description: "Utf8String", - }; - Vb.stringTypeMap = { - fixedSizeString: { - beet: "fixedSizeUtf8String", - isFixable: !1, - sourcePack: A6e.BEET_PACKAGE, - ts: "string", - arg: A6e.BEET_TYPE_ARG_LEN, - }, - string: { - beet: "utf8String", - isFixable: !0, - sourcePack: A6e.BEET_PACKAGE, - ts: "string", - }, - }; - }); - var P6e = I((LN) => { - "use strict"; - m(); - g(); - Object.defineProperty(LN, "__esModule", { value: !0 }); - LN.BeetReader = LN.BeetWriter = void 0; - var bBr = Dr(), - T6e = class { - constructor(e) { - (this.buf = Buffer.alloc(e)), (this._offset = 0); - } - get buffer() { - return this.buf; - } - get offset() { - return this._offset; - } - maybeResize(e) { - this._offset + e > this.buf.length && - bBr.strict.fail( - `We shouldn't ever need to resize, but ${this._offset + e} > ${ - this.buf.length - }` - ); - } - write(e, r) { - this.maybeResize(e.byteSize), - e.write(this.buf, this._offset, r), - (this._offset += e.byteSize); - } - writeStruct(e, r) { - for (let [n, i] of r) { - let o = e[n]; - this.write(i, o); - } - } - }; - LN.BeetWriter = T6e; - var k6e = class { - constructor(e, r = 0) { - (this.buffer = e), (this._offset = r); - } - get offset() { - return this._offset; - } - read(e) { - let r = e.read(this.buffer, this._offset); - return (this._offset += e.byteSize), r; - } - readStruct(e) { - let r = {}; - for (let [n, i] of e) r[n] = this.read(i); - return r; - } - }; - LN.BeetReader = k6e; - }); - var yae = I((DE) => { - "use strict"; - m(); - g(); - Object.defineProperty(DE, "__esModule", { value: !0 }); - DE.BeetArgsStruct = DE.isBeetStruct = DE.BeetStruct = void 0; - var C1t = P6e(), - Fx = Dx(), - Wb = class { - constructor(e, r, n = Wb.description) { - if ( - ((this.fields = e), - (this.construct = r), - (this.description = n), - (this.byteSize = this.getByteSize()), - Fx.logDebug.enabled) - ) { - let i = e.map( - ([o, a]) => - `${String(o)}: ${a.description} ${(0, Fx.beetBytes)(a)}` - ).join(` - `); - (0, Fx.logDebug)(`struct ${n} { - ${i} -} ${(0, Fx.beetBytes)(this)}`); - } - } - read(e, r) { - let [n] = this.deserialize(e, r); - return n; - } - write(e, r, n) { - let [i, o] = this.serialize(n); - i.copy(e, r, 0, o); - } - deserialize(e, r = 0) { - Fx.logTrace.enabled && - ((0, Fx.logTrace)( - "deserializing [%s] from %d bytes buffer", - this.description, - e.byteLength - ), - (0, Fx.logTrace)(e), - (0, Fx.logTrace)(e.toJSON().data)); - let n = new C1t.BeetReader(e, r), - i = n.readStruct(this.fields); - return [this.construct(i), n.offset]; - } - serialize(e, r = this.byteSize) { - (0, Fx.logTrace)( - "serializing [%s] %o to %d bytes buffer", - this.description, - e, - r - ); - let n = new C1t.BeetWriter(r); - return n.writeStruct(e, this.fields), [n.buffer, n.offset]; - } - getByteSize() { - return this.fields.reduce((e, [r, n]) => e + n.byteSize, 0); - } - get type() { - return Wb.TYPE; - } - }; - DE.BeetStruct = Wb; - Wb.description = "BeetStruct"; - Wb.TYPE = "BeetStruct"; - function wBr(t) { - return t.type === Wb.TYPE; - } - DE.isBeetStruct = wBr; - var qN = class extends Wb { - constructor(e, r = qN.description) { - super(e, (n) => n, r); - } - }; - DE.BeetArgsStruct = qN; - qN.description = "BeetArgsStruct"; - }); - var B6e = I((Gb) => { - "use strict"; - m(); - g(); - var _Br = - (Gb && Gb.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Gb, "__esModule", { value: !0 }); - Gb.FixableBeetArgsStruct = - Gb.isFixableBeetStruct = - Gb.FixableBeetStruct = - void 0; - var R1t = NN(), - mae = yae(), - xBr = yl(), - SBr = Dr(), - O6e = Dx(), - ABr = _Br(Mg()), - { brightBlack: EBr } = ABr.default, - nm = class { - constructor(e, r, n = nm.description) { - (this.fields = e), (this.construct = r), (this.description = n); - let i = 0; - if (O6e.logDebug.enabled) { - let o = e.map( - ([s, c]) => ( - (0, xBr.isFixedSizeBeet)(c) && (i += c.byteSize), - `${s}: ${c.description} ${(0, O6e.beetBytes)(c)}` - ) - ).join(` - `), - a = `> ${i} B`; - (0, O6e.logDebug)(`struct ${n} { - ${o} -} ${EBr(a)}`); - } - } - deserialize(e, r = 0) { - return this.toFixedFromData(e, r).deserialize(e, r); - } - serialize(e, r) { - return this.toFixedFromValue(e).serialize(e, r); - } - toFixedFromData(e, r) { - let n = r, - i = new Array(this.fields.length); - for (let o = 0; o < this.fields.length; o++) { - let [a, s] = this.fields[o], - c = (0, R1t.fixBeetFromData)(s, e, n); - (i[o] = [a, c]), (n += c.byteSize); - } - return this.description !== nm.description - ? new mae.BeetStruct(i, this.construct, this.description) - : new mae.BeetStruct(i, this.construct); - } - toFixedFromValue(e) { - let r = Object.keys(e), - n = new Array(this.fields.length); - for (let i = 0; i < this.fields.length; i++) { - let [o, a] = this.fields[i]; - (0, SBr.strict)( - r.includes(o), - `Value with keys [ ${r} ] should include struct key '${o}' but doesn't.` - ); - let s = e[o], - c = (0, R1t.fixBeetFromValue)(a, s); - n[i] = [o, c]; - } - return this.description !== nm.description - ? new mae.BeetStruct(n, this.construct, this.description) - : new mae.BeetStruct(n, this.construct); - } - get type() { - return nm.TYPE; - } - }; - Gb.FixableBeetStruct = nm; - nm.description = "FixableBeetStruct"; - nm.TYPE = "FixableBeetStruct"; - function MBr(t) { - return t.type === nm.TYPE; - } - Gb.isFixableBeetStruct = MBr; - var zN = class extends nm { - constructor(e, r = zN.description) { - super(e, (n) => n, r); - } - }; - Gb.FixableBeetArgsStruct = zN; - zN.description = "FixableBeetArgsStruct"; - }); - var gae = I((jN) => { - "use strict"; - m(); - g(); - Object.defineProperty(jN, "__esModule", { value: !0 }); - jN.unitTypeMap = jN.unit = void 0; - var TBr = yl(); - jN.unit = { - write: function (t, e, r) {}, - read: function (t, e) {}, - byteSize: 0, - description: "unit", - }; - jN.unitTypeMap = { - unit: { - beet: "unit", - isFixable: !1, - sourcePack: TBr.BEET_PACKAGE, - ts: "void", - }, - }; - }); - var I6e = I((Jb) => { - "use strict"; - m(); - g(); - Object.defineProperty(Jb, "__esModule", { value: !0 }); - Jb.enumsTypeMap = - Jb.dataEnum = - Jb.uniformDataEnum = - Jb.fixedScalarEnum = - void 0; - var FE = yl(), - Tg = RE(), - UN = Dr(), - kBr = yae(), - PBr = B6e(), - OBr = gae(); - function N1t(t, e) { - return e ? `${t}` : t; - } - function BBr(t) { - let e = Object.keys(t); - return { - write(r, n, i) { - let o = typeof i == "number", - a = N1t(i, o); - if ( - (e.includes(a) || - UN.strict.fail( - `${i} should be a variant of the provided enum type, i.e. [ ${Object.values( - t - ).join(", ")} ], but isn't` - ), - o) - ) - Tg.u8.write(r, n, i); - else { - let s = t[a]; - Tg.u8.write(r, n, s); - } - }, - read(r, n) { - let i = Tg.u8.read(r, n), - o = typeof i == "number", - a = N1t(i, o); - return ( - e.includes(a) || - UN.strict.fail( - `${i} should be a of a variant of the provided enum type, i.e. [ ${Object.values( - t - ).join(", ")} ], but isn't` - ), - o ? i : t[a] - ); - }, - byteSize: Tg.u8.byteSize, - description: "Enum", - }; - } - Jb.fixedScalarEnum = BBr; - function IBr(t) { - return { - write: function (e, r, n) { - Tg.u8.write(e, r, n.kind), t.write(e, r + 1, n.data); - }, - read: function (e, r) { - let n = Tg.u8.read(e, r), - i = t.read(e, r + 1); - return { kind: n, data: i }; - }, - byteSize: 1 + t.byteSize, - description: `UniformDataEnum<${t.description}>`, - }; - } - Jb.uniformDataEnum = IBr; - function D1t(t, e, r) { - return { - write(n, i, o) { - Tg.u8.write(n, i, e), t.write(n, i + Tg.u8.byteSize, o); - }, - read(n, i) { - let o = t.read(n, i + Tg.u8.byteSize); - return { __kind: r, ...o }; - }, - byteSize: t.byteSize + Tg.u8.byteSize, - description: `EnumData<${t.description}>`, - }; - } - function CBr(t) { - for (let [e, r] of t) - (0, UN.strict)( - (0, kBr.isBeetStruct)(r) || - (0, PBr.isFixableBeetStruct)(r) || - r === OBr.unit, - "dataEnum: variants must be a data beet struct or a scalar unit" - ); - return { - toFixedFromData(e, r) { - let n = Tg.u8.read(e, r), - i = t[n]; - (0, UN.strict)( - i != null, - `Discriminant ${n} out of range for ${t.length} variants` - ); - let [o, a] = i, - s = (0, FE.isFixedSizeBeet)(a) ? a : a.toFixedFromData(e, r + 1); - return D1t(s, n, o); - }, - toFixedFromValue(e) { - if (e.__kind == null) { - let u = Object.keys(e).join(", "), - h = t.map(([w]) => w).join(", "); - UN.strict.fail( - `Value with fields [ ${u} ] is missing __kind, which needs to be set to one of [ ${h} ]` - ); - } - let r = t.findIndex(([u]) => u === e.__kind); - if (r < 0) { - let u = t.map(([h]) => h).join(", "); - UN.strict.fail( - `${e.__kind} is not a valid kind, needs to be one of [ ${u} ]` - ); - } - let n = t[r], - { __kind: i, ...o } = e, - [a, s] = n, - c = (0, FE.isFixedSizeBeet)(s) ? s : s.toFixedFromValue(o); - return D1t(c, r, a); - }, - description: `DataEnum<${t.length} variants>`, - }; - } - Jb.dataEnum = CBr; - Jb.enumsTypeMap = { - fixedScalarEnum: { - beet: "fixedScalarEnum", - isFixable: !1, - sourcePack: FE.BEET_PACKAGE, - ts: "", - arg: FE.BEET_TYPE_ARG_INNER, - pack: FE.BEET_PACKAGE, - }, - dataEnum: { - beet: "dataEnum", - isFixable: !1, - sourcePack: FE.BEET_PACKAGE, - ts: "DataEnum", - arg: FE.BEET_TYPE_ARG_INNER, - pack: FE.BEET_PACKAGE, - }, - }; - }); - var C6e = I((KN) => { - "use strict"; - m(); - g(); - Object.defineProperty(KN, "__esModule", { value: !0 }); - KN.aliasesTypeMap = KN.bytes = void 0; - var F1t = pae(); - KN.bytes = F1t.uint8Array; - KN.aliasesTypeMap = { bytes: F1t.collectionsTypeMap.Uint8Array }; - }); - var D6e = I((LE) => { - "use strict"; - m(); - g(); - Object.defineProperty(LE, "__esModule", { value: !0 }); - LE.tuplesTypeMap = LE.tuple = LE.fixedSizeTuple = void 0; - var L1t = yl(), - R6e = Dr(), - q1t = NN(); - function N6e(t) { - let e = t.length, - r = t.map((o) => o.description), - n = t.map((o) => o.byteSize), - i = n.reduce((o, a) => o + a, 0); - return { - write: function (o, a, s) { - R6e.strict.equal( - s.length, - e, - `tuple value element size ${s.length} should match len ${e}` - ); - let c = a; - for (let u = 0; u < e; u++) { - let h = s[u], - w = t[u]; - w.write(o, c, h), (c += w.byteSize); - } - }, - read: function (o, a) { - let s = [], - c = a; - for (let u = 0; u < e; u++) { - let h = t[u]; - (s[u] = h.read(o, c)), (c += h.byteSize); - } - return s; - }, - byteSize: i, - length: e, - description: `FixedSizeTuple<${r.join(",")}>[ ${n.join(", ")} ]`, - }; - } - LE.fixedSizeTuple = N6e; - function RBr(t) { - let e = t.length, - r = t.map((n) => n.description); - return { - toFixedFromData(n, i) { - let o = i, - a = new Array(e); - for (let s = 0; s < e; s++) { - let c = (0, q1t.fixBeetFromData)(t[s], n, o); - (a[s] = c), (o += c.byteSize); - } - return N6e(a); - }, - toFixedFromValue(n) { - (0, R6e.strict)( - Array.isArray(n), - `${n} should be an array of tuple values` - ), - R6e.strict.equal( - n.length, - e, - `There should be ${e} tuple values, but there are ${n.length}` - ); - let i = new Array(e); - for (let o = 0; o < n.length; o++) { - let a = (0, q1t.fixBeetFromValue)(t[o], n[o]); - i[o] = a; - } - return N6e(i); - }, - description: `Tuple<${r.join(",")}>`, - }; - } - LE.tuple = RBr; - LE.tuplesTypeMap = { - Tuple: { - beet: "tuple", - isFixable: !0, - sourcePack: L1t.BEET_PACKAGE, - ts: "[__tuple_elements__]", - }, - FixedSizeTuple: { - beet: "fixedSizeTuple", - isFixable: !1, - sourcePack: L1t.BEET_PACKAGE, - ts: "[__tuple_elements__]", - }, - }; - }); - var q6e = I((HN) => { - "use strict"; - m(); - g(); - Object.defineProperty(HN, "__esModule", { value: !0 }); - HN.mapsTypeMap = HN.map = void 0; - var zH = yl(), - L6e = RE(), - NBr = Dx(), - F6e = Dr(); - function vae(t, e, r, n) { - let i = (0, zH.isFixedSizeBeet)(t), - o = (0, zH.isFixedSizeBeet)(e); - function a() { - if (i && o) { - let u = t.byteSize + e.byteSize; - return { elementByteSize: u, byteSize: 4 + n * u }; - } else if (i) { - let u = 0; - for (let [w, M] of r.values()) u += M.byteSize; - return { - elementByteSize: t.byteSize + Math.ceil(u / n), - byteSize: 4 + t.byteSize * n + u, - }; - } else if (o) { - let u = 0; - for (let [w, M] of r.values()) u += w.byteSize; - return { - elementByteSize: Math.ceil(u / n) + e.byteSize, - byteSize: 4 + u + e.byteSize * n, - }; - } else { - let u = 0, - h = 0; - for (let [M, k] of r.values()) (u += M.byteSize), (h += k.byteSize); - return { - elementByteSize: Math.ceil(u / n + h / n), - byteSize: 4 + u + h, - }; - } - } - let { elementByteSize: s, byteSize: c } = a(); - return { - write: function (u, h, w) { - let M = h + 4, - k = 0; - for (let [O, D] of w.entries()) { - let F = i ? t : null, - N = o ? e : null; - if (F == null || N == null) { - let q = r.get(O); - (0, F6e.strict)( - q != null, - `Should be able to find beet els for ${(0, NBr.stringify)( - O - )}, but could not` - ), - F ?? (F = q[0]), - N ?? (N = q[1]); - } - F.write(u, M, O), - (M += F.byteSize), - N.write(u, M, D), - (M += N.byteSize), - k++; - } - L6e.u32.write(u, h, k), - F6e.strict.equal( - k, - n, - `Expected map to have size ${n}, but has ${k}.` - ); - }, - read: function (u, h) { - let w = L6e.u32.read(u, h); - F6e.strict.equal( - w, - n, - `Expected map to have size ${n}, but has ${w}.` - ); - let M = h + 4, - k = new Map(); - for (let O = 0; O < w; O++) { - let D = i ? t : t.toFixedFromData(u, M), - F = D.read(u, M); - M += D.byteSize; - let N = o ? e : e.toFixedFromData(u, M), - q = N.read(u, M); - (M += N.byteSize), k.set(F, q); - } - return k; - }, - elementByteSize: s, - byteSize: c, - length: n, - lenPrefixByteSize: 4, - description: `Map<${t.description}, ${e.description}>`, - }; - } - function DBr(t, e) { - let r = (0, zH.isFixedSizeBeet)(t), - n = (0, zH.isFixedSizeBeet)(e); - return { - toFixedFromData(i, o) { - let a = L6e.u32.read(i, o), - s = o + 4; - if (r && n) return vae(t, e, new Map(), a); - let c = new Map(); - for (let u = 0; u < a; u++) { - let h = r ? t : t.toFixedFromData(i, s), - w = h.read(i, s); - s += h.byteSize; - let M = n ? e : e.toFixedFromData(i, s); - (s += M.byteSize), c.set(w, [h, M]); - } - return vae(t, e, c, a); - }, - toFixedFromValue(i) { - let o = i.size; - if (r && n) return vae(t, e, new Map(), o); - let a = new Map(); - for (let [s, c] of i) { - let u = r ? t : t.toFixedFromValue(s), - h = n ? e : e.toFixedFromValue(c); - a.set(s, [u, h]); - } - return vae(t, e, a, o); - }, - description: `FixableMap<${t.description}, ${e.description}>`, - }; - } - HN.map = DBr; - HN.mapsTypeMap = { - Map: { - beet: "map", - isFixable: !0, - sourcePack: zH.BEET_PACKAGE, - ts: "Map", - }, - }; - }); - var K6e = I((VN) => { - "use strict"; - m(); - g(); - Object.defineProperty(VN, "__esModule", { value: !0 }); - VN.setsTypeMap = VN.set = void 0; - var U6e = yl(), - j6e = RE(), - FBr = Dx(), - z6e = Dr(); - function bae(t, e, r) { - let n = (0, U6e.isFixedSizeBeet)(t); - function i() { - if (n) { - let s = t.byteSize; - return { elementByteSize: s, byteSize: 4 + r * s }; - } else { - let s = 0; - for (let u of e.values()) s += u.byteSize; - return { elementByteSize: Math.ceil(s / r), byteSize: 4 + s }; - } - } - let { elementByteSize: o, byteSize: a } = i(); - return { - write: function (s, c, u) { - let h = c + 4, - w = 0; - for (let M of u.keys()) { - let k = n ? t : null; - if (k == null) { - let O = e.get(M); - (0, z6e.strict)( - O != null, - `Should be able to find beet el for ${(0, FBr.stringify)( - M - )}, but could not` - ), - k ?? (k = O); - } - k.write(s, h, M), (h += k.byteSize), w++; - } - j6e.u32.write(s, c, w), - z6e.strict.equal( - w, - r, - `Expected set to have size ${r}, but has ${w}.` - ); - }, - read: function (s, c) { - let u = j6e.u32.read(s, c); - z6e.strict.equal( - u, - r, - `Expected set to have size ${r}, but has ${u}.` - ); - let h = c + 4, - w = new Set(); - for (let M = 0; M < u; M++) { - let k = n ? t : t.toFixedFromData(s, h), - O = k.read(s, h); - (h += k.byteSize), w.add(O); - } - return w; - }, - elementByteSize: o, - byteSize: a, - length: r, - lenPrefixByteSize: 4, - description: `Set<${t.description}>`, - }; - } - function LBr(t) { - let e = (0, U6e.isFixedSizeBeet)(t); - return { - toFixedFromData(r, n) { - let i = j6e.u32.read(r, n), - o = n + 4; - if (e) return bae(t, new Map(), i); - let a = new Map(); - for (let s = 0; s < i; s++) { - let c = e ? t : t.toFixedFromData(r, o), - u = c.read(r, o); - (o += c.byteSize), a.set(u, c); - } - return bae(t, a, i); - }, - toFixedFromValue(r) { - let n = r.size; - if (e) return bae(t, new Map(), n); - let i = new Map(); - for (let o of r) { - let a = e ? t : t.toFixedFromValue(o); - i.set(o, a); - } - return bae(t, i, n); - }, - description: `FixableSet<${t.description}>`, - }; - } - VN.set = LBr; - VN.setsTypeMap = { - Set: { - beet: "set", - isFixable: !0, - sourcePack: U6e.BEET_PACKAGE, - ts: "Set", - }, - }; - }); - var Wt = I((Aa) => { - "use strict"; - m(); - g(); - var qBr = - (Aa && Aa.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Qd = - (Aa && Aa.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - qBr(e, t, r); - }; - Object.defineProperty(Aa, "__esModule", { value: !0 }); - Aa.supportedTypeMap = void 0; - var zBr = pae(), - jBr = S6e(), - UBr = RE(), - KBr = M6e(), - HBr = I6e(), - VBr = C6e(), - WBr = D6e(), - GBr = q6e(), - JBr = gae(), - $Br = K6e(); - Qd(C6e(), Aa); - Qd(pae(), Aa); - Qd(S6e(), Aa); - Qd(I6e(), Aa); - Qd(q6e(), Aa); - Qd(RE(), Aa); - Qd(K6e(), Aa); - Qd(M6e(), Aa); - Qd(D6e(), Aa); - Qd(gae(), Aa); - Qd(NN(), Aa); - Qd(P6e(), Aa); - Qd(yae(), Aa); - Qd(B6e(), Aa); - Qd(yl(), Aa); - Aa.supportedTypeMap = { - ...zBr.collectionsTypeMap, - ...KBr.stringTypeMap, - ...jBr.compositesTypeMap, - ...HBr.enumsTypeMap, - ...UBr.numbersTypeMap, - ...VBr.aliasesTypeMap, - ...WBr.tuplesTypeMap, - ...GBr.mapsTypeMap, - ...$Br.setsTypeMap, - ...JBr.unitTypeMap, - }; - }); - var Z1t = I((Tae) => { - "use strict"; - m(); - g(); - Object.defineProperty(Tae, "__esModule", { value: !0 }); - Tae.errorCodeFromLogs = void 0; - var eIr = /Custom program error: (0x[a-f0-9]+)/i; - function tIr(t) { - for (let e of t) { - let r = e.match(eIr); - if (r == null) continue; - let n = r[1]; - try { - return parseInt(n); - } catch {} - } - return null; - } - Tae.errorCodeFromLogs = tIr; - }); - var X1t = I((Fr) => { - "use strict"; - m(); - g(); - Object.defineProperty(Fr, "__esModule", { value: !0 }); - Fr.LangErrorMessage = Fr.LangErrorCode = void 0; - Fr.LangErrorCode = { - InstructionMissing: 100, - InstructionFallbackNotFound: 101, - InstructionDidNotDeserialize: 102, - InstructionDidNotSerialize: 103, - IdlInstructionStub: 1e3, - IdlInstructionInvalidProgram: 1001, - ConstraintMut: 2e3, - ConstraintHasOne: 2001, - ConstraintSigner: 2002, - ConstraintRaw: 2003, - ConstraintOwner: 2004, - ConstraintRentExempt: 2005, - ConstraintSeeds: 2006, - ConstraintExecutable: 2007, - ConstraintState: 2008, - ConstraintAssociated: 2009, - ConstraintAssociatedInit: 2010, - ConstraintClose: 2011, - ConstraintAddress: 2012, - ConstraintZero: 2013, - ConstraintTokenMint: 2014, - ConstraintTokenOwner: 2015, - ConstraintMintMintAuthority: 2016, - ConstraintMintFreezeAuthority: 2017, - ConstraintMintDecimals: 2018, - ConstraintSpace: 2019, - AccountDiscriminatorAlreadySet: 3e3, - AccountDiscriminatorNotFound: 3001, - AccountDiscriminatorMismatch: 3002, - AccountDidNotDeserialize: 3003, - AccountDidNotSerialize: 3004, - AccountNotEnoughKeys: 3005, - AccountNotMutable: 3006, - AccountOwnedByWrongProgram: 3007, - InvalidProgramId: 3008, - InvalidProgramExecutable: 3009, - AccountNotSigner: 3010, - AccountNotSystemOwned: 3011, - AccountNotInitialized: 3012, - AccountNotProgramData: 3013, - StateInvalidAddress: 4e3, - Deprecated: 5e3, - }; - Fr.LangErrorMessage = new Map([ - [ - Fr.LangErrorCode.InstructionMissing, - "8 byte instruction identifier not provided", - ], - [ - Fr.LangErrorCode.InstructionFallbackNotFound, - "Fallback functions are not supported", - ], - [ - Fr.LangErrorCode.InstructionDidNotDeserialize, - "The program could not deserialize the given instruction", - ], - [ - Fr.LangErrorCode.InstructionDidNotSerialize, - "The program could not serialize the given instruction", - ], - [ - Fr.LangErrorCode.IdlInstructionStub, - "The program was compiled without idl instructions", - ], - [ - Fr.LangErrorCode.IdlInstructionInvalidProgram, - "The transaction was given an invalid program for the IDL instruction", - ], - [Fr.LangErrorCode.ConstraintMut, "A mut constraint was violated"], - [Fr.LangErrorCode.ConstraintHasOne, "A has_one constraint was violated"], - [Fr.LangErrorCode.ConstraintSigner, "A signer constraint was violated"], - [Fr.LangErrorCode.ConstraintRaw, "A raw constraint was violated"], - [Fr.LangErrorCode.ConstraintOwner, "An owner constraint was violated"], - [ - Fr.LangErrorCode.ConstraintRentExempt, - "A rent exempt constraint was violated", - ], - [Fr.LangErrorCode.ConstraintSeeds, "A seeds constraint was violated"], - [ - Fr.LangErrorCode.ConstraintExecutable, - "An executable constraint was violated", - ], - [Fr.LangErrorCode.ConstraintState, "A state constraint was violated"], - [ - Fr.LangErrorCode.ConstraintAssociated, - "An associated constraint was violated", - ], - [ - Fr.LangErrorCode.ConstraintAssociatedInit, - "An associated init constraint was violated", - ], - [Fr.LangErrorCode.ConstraintClose, "A close constraint was violated"], - [ - Fr.LangErrorCode.ConstraintAddress, - "An address constraint was violated", - ], - [Fr.LangErrorCode.ConstraintZero, "Expected zero account discriminant"], - [ - Fr.LangErrorCode.ConstraintTokenMint, - "A token mint constraint was violated", - ], - [ - Fr.LangErrorCode.ConstraintTokenOwner, - "A token owner constraint was violated", - ], - [ - Fr.LangErrorCode.ConstraintMintMintAuthority, - "A mint mint authority constraint was violated", - ], - [ - Fr.LangErrorCode.ConstraintMintFreezeAuthority, - "A mint freeze authority constraint was violated", - ], - [ - Fr.LangErrorCode.ConstraintMintDecimals, - "A mint decimals constraint was violated", - ], - [Fr.LangErrorCode.ConstraintSpace, "A space constraint was violated"], - [ - Fr.LangErrorCode.AccountDiscriminatorAlreadySet, - "The account discriminator was already set on this account", - ], - [ - Fr.LangErrorCode.AccountDiscriminatorNotFound, - "No 8 byte discriminator was found on the account", - ], - [ - Fr.LangErrorCode.AccountDiscriminatorMismatch, - "8 byte discriminator did not match what was expected", - ], - [ - Fr.LangErrorCode.AccountDidNotDeserialize, - "Failed to deserialize the account", - ], - [ - Fr.LangErrorCode.AccountDidNotSerialize, - "Failed to serialize the account", - ], - [ - Fr.LangErrorCode.AccountNotEnoughKeys, - "Not enough account keys given to the instruction", - ], - [Fr.LangErrorCode.AccountNotMutable, "The given account is not mutable"], - [ - Fr.LangErrorCode.AccountOwnedByWrongProgram, - "The given account is owned by a different program than expected", - ], - [Fr.LangErrorCode.InvalidProgramId, "Program ID was not as expected"], - [ - Fr.LangErrorCode.InvalidProgramExecutable, - "Program account is not executable", - ], - [Fr.LangErrorCode.AccountNotSigner, "The given account did not sign"], - [ - Fr.LangErrorCode.AccountNotSystemOwned, - "The given account is not owned by the system program", - ], - [ - Fr.LangErrorCode.AccountNotInitialized, - "The program expected this account to be already initialized", - ], - [ - Fr.LangErrorCode.AccountNotProgramData, - "The given account is not a program data account", - ], - [ - Fr.LangErrorCode.StateInvalidAddress, - "The given state account does not have the correct address", - ], - [ - Fr.LangErrorCode.Deprecated, - "The API being used is deprecated and should no longer be used", - ], - ]); - }); - var Y1t = I((kae) => { - "use strict"; - m(); - g(); - Object.defineProperty(kae, "__esModule", { value: !0 }); - kae.tokenLendingErrors = void 0; - kae.tokenLendingErrors = new Map([ - [ - 0, - { - code: 0, - message: 'Failed to unpack instruction data"', - name: "InstructionUnpackError", - }, - ], - [ - 1, - { - code: 1, - message: 'Account is already initialized"', - name: "AlreadyInitialized", - }, - ], - [ - 2, - { - code: 2, - message: 'Lamport balance below rent-exempt threshold"', - name: "NotRentExempt", - }, - ], - [ - 3, - { - code: 3, - message: 'Market authority is invalid"', - name: "InvalidMarketAuthority", - }, - ], - [ - 4, - { - code: 4, - message: 'Market owner is invalid"', - name: "InvalidMarketOwner", - }, - ], - [ - 5, - { - code: 5, - message: 'Input account owner is not the program address"', - name: "InvalidAccountOwner", - }, - ], - [ - 6, - { - code: 6, - message: - 'Input token account is not owned by the correct token program id"', - name: "InvalidTokenOwner", - }, - ], - [ - 7, - { - code: 7, - message: 'Input token account is not valid"', - name: "InvalidTokenAccount", - }, - ], - [ - 8, - { - code: 8, - message: 'Input token mint account is not valid"', - name: "InvalidTokenMint", - }, - ], - [ - 9, - { - code: 9, - message: 'Input token program account is not valid"', - name: "InvalidTokenProgram", - }, - ], - [ - 10, - { - code: 10, - message: 'Input amount is invalid"', - name: "InvalidAmount", - }, - ], - [ - 11, - { - code: 11, - message: 'Input config value is invalid"', - name: "InvalidConfig", - }, - ], - [ - 12, - { - code: 12, - message: 'Input account must be a signer"', - name: "InvalidSigner", - }, - ], - [ - 13, - { - code: 13, - message: 'Invalid account input"', - name: "InvalidAccountInput", - }, - ], - [ - 14, - { code: 14, message: 'Math operation overflow"', name: "MathOverflow" }, - ], - [ - 15, - { - code: 15, - message: 'Token initialize mint failed"', - name: "TokenInitializeMintFailed", - }, - ], - [ - 16, - { - code: 16, - message: 'Token initialize account failed"', - name: "TokenInitializeAccountFailed", - }, - ], - [ - 17, - { - code: 17, - message: 'Token transfer failed"', - name: "TokenTransferFailed", - }, - ], - [ - 18, - { - code: 18, - message: 'Token mint to failed"', - name: "TokenMintToFailed", - }, - ], - [ - 19, - { code: 19, message: 'Token burn failed"', name: "TokenBurnFailed" }, - ], - [ - 20, - { - code: 20, - message: 'Insufficient liquidity available"', - name: "InsufficientLiquidity", - }, - ], - [ - 21, - { - code: 21, - message: 'Input reserve has collateral disabled"', - name: "ReserveCollateralDisabled", - }, - ], - [ - 22, - { - code: 22, - message: 'Reserve state needs to be refreshed"', - name: "ReserveStale", - }, - ], - [ - 23, - { - code: 23, - message: 'Withdraw amount too small"', - name: "WithdrawTooSmall", - }, - ], - [ - 24, - { - code: 24, - message: 'Withdraw amount too large"', - name: "WithdrawTooLarge", - }, - ], - [ - 25, - { - code: 25, - message: 'Borrow amount too small to receive liquidity after fees"', - name: "BorrowTooSmall", - }, - ], - [ - 26, - { - code: 26, - message: 'Borrow amount too large for deposited collateral"', - name: "BorrowTooLarge", - }, - ], - [ - 27, - { - code: 27, - message: 'Repay amount too small to transfer liquidity"', - name: "RepayTooSmall", - }, - ], - [ - 28, - { - code: 28, - message: 'Liquidation amount too small to receive collateral"', - name: "LiquidationTooSmall", - }, - ], - [ - 29, - { - code: 29, - message: 'Cannot liquidate healthy obligations"', - name: "ObligationHealthy", - }, - ], - [ - 30, - { - code: 30, - message: 'Obligation state needs to be refreshed"', - name: "ObligationStale", - }, - ], - [ - 31, - { - code: 31, - message: 'Obligation reserve limit exceeded"', - name: "ObligationReserveLimit", - }, - ], - [ - 32, - { - code: 32, - message: 'Obligation owner is invalid"', - name: "InvalidObligationOwner", - }, - ], - [ - 33, - { - code: 33, - message: 'Obligation deposits are empty"', - name: "ObligationDepositsEmpty", - }, - ], - [ - 34, - { - code: 34, - message: 'Obligation borrows are empty"', - name: "ObligationBorrowsEmpty", - }, - ], - [ - 35, - { - code: 35, - message: 'Obligation deposits have zero value"', - name: "ObligationDepositsZero", - }, - ], - [ - 36, - { - code: 36, - message: 'Obligation borrows have zero value"', - name: "ObligationBorrowsZero", - }, - ], - [ - 37, - { - code: 37, - message: 'Invalid obligation collateral"', - name: "InvalidObligationCollateral", - }, - ], - [ - 38, - { - code: 38, - message: 'Invalid obligation liquidity"', - name: "InvalidObligationLiquidity", - }, - ], - [ - 39, - { - code: 39, - message: 'Obligation collateral is empty"', - name: "ObligationCollateralEmpty", - }, - ], - [ - 40, - { - code: 40, - message: 'Obligation liquidity is empty"', - name: "ObligationLiquidityEmpty", - }, - ], - [ - 41, - { - code: 41, - message: 'Interest rate is negative"', - name: "NegativeInterestRate", - }, - ], - [ - 42, - { - code: 42, - message: 'Input oracle config is invalid"', - name: "InvalidOracleConfig", - }, - ], - [ - 43, - { - code: 43, - message: 'Input flash loan receiver program account is not valid"', - name: "InvalidFlashLoanReceiverProgram", - }, - ], - [ - 44, - { - code: 44, - message: 'Not enough liquidity after flash loan"', - name: "NotEnoughLiquidityAfterFlashLoan", - }, - ], - ]); - }); - var ewt = I((Os) => { - "use strict"; - m(); - g(); - var rIr = - (Os && Os.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - nIr = - (Os && Os.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - iIr = - (Os && Os.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - rIr(e, t, r); - return nIr(e, t), e; - }; - Object.defineProperty(Os, "__esModule", { value: !0 }); - Os.TokenLendingError = - Os.AnchorError = - Os.CustomProgramError = - Os.CusperUnknownError = - Os.initCusper = - Os.ErrorResolver = - void 0; - var oIr = Z1t(), - Q1t = iIr(X1t()), - aIr = Y1t(), - Pae = class { - constructor(e) { - this.resolveErrorFromCode = e; - } - errorFromCode(e, r, n = !0) { - let i = - this.resolveErrorFromCode != null - ? this.resolveErrorFromCode(e) - : null; - if (i != null) - return this.passPreparedError(i, r ?? this.errorFromCode); - if (((i = qE.fromCode(e)), i != null)) - return this.passPreparedError(i, r ?? this.errorFromCode); - if (((i = zE.fromCode(e)), i != null)) - return this.passPreparedError(i, r ?? this.errorFromCode); - if (n) - return ( - (i = new KH( - e, - "CusperUnknownError", - "cusper does not know this error" - )), - this.passPreparedError(i, r ?? this.errorFromCode) - ); - } - errorFromProgramLogs(e, r = !0) { - let n = (0, oIr.errorCodeFromLogs)(e); - return n == null - ? null - : this.errorFromCode(n, this.errorFromProgramLogs, r); - } - throwError(e) { - let r = - (e.logs != null && this.errorFromProgramLogs(e.logs, !0)) || - new KH( - -1, - "Error created without logs and thus without error code" - ); - throw this.passPreparedError(r, this.throwError); - } - passPreparedError(e, r) { - return e == null - ? null - : (typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(e, r), - e); - } - }; - Os.ErrorResolver = Pae; - function sIr(t) { - return new Pae(t); - } - Os.initCusper = sIr; - var KH = class extends Error { - constructor(e, ...r) { - super(...r), (this.code = e), (this.name = "CusperUnknownError"); - } - }; - Os.CusperUnknownError = KH; - var H6e = class extends Error { - constructor(e, r, ...n) { - super(...n), (this.code = e), (this.name = `CustomProgramError#${r}`); - } - }; - Os.CustomProgramError = H6e; - var qE = class extends Error { - constructor(e, r, ...n) { - super(...n), (this.code = e), (this.name = `AnchorError#${r}`); - } - static fromCode(e) { - let r = qE.errorMap.get(e); - return r != null ? new qE(r.code, r.name, r.message) : null; - } - toString() { - return `${this.name}: ${this.message}`; - } - }; - Os.AnchorError = qE; - qE.errorMap = Object.entries(Q1t.LangErrorCode).reduce( - (t, [e, r]) => ( - t.set(r, { code: r, name: e, message: Q1t.LangErrorMessage.get(r) }), t - ), - new Map() - ); - var zE = class extends Error { - constructor(e, r, ...n) { - super(...n), (this.code = e), (this.name = `TokenLendingError#${r}`); - } - static fromCode(e) { - let r = zE.errorMap.get(e); - return r != null ? new zE(r.code, r.name, r.message) : null; - } - toString() { - return `${this.name}: ${this.message}`; - } - }; - Os.TokenLendingError = zE; - zE.errorMap = aIr.tokenLendingErrors; - }); - var rwt = I((twt) => { - "use strict"; - m(); - g(); - Object.defineProperty(twt, "__esModule", { value: !0 }); - }); - var JN = I((jE) => { - "use strict"; - m(); - g(); - var uIr = - (jE && jE.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - nwt = - (jE && jE.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - uIr(e, t, r); - }; - Object.defineProperty(jE, "__esModule", { value: !0 }); - nwt(ewt(), jE); - nwt(rwt(), jE); - }); - var W6e = I(($N) => { - "use strict"; - m(); - g(); - Object.defineProperty($N, "__esModule", { value: !0 }); - $N.keysTypeMap = $N.publicKey = void 0; - var cIr = Le(), - lIr = Wt(), - fIr = "@metaplex-foundation/beet-solana", - dIr = "@solana/web3.js", - V6e = (0, lIr.fixedSizeUint8Array)(32); - $N.publicKey = { - write: function (t, e, r) { - let n = r.toBytes(); - V6e.write(t, e, n); - }, - read: function (t, e) { - let r = V6e.read(t, e); - return new cIr.PublicKey(r); - }, - byteSize: V6e.byteSize, - description: "PublicKey", - }; - $N.keysTypeMap = { - publicKey: { - beet: "publicKey", - isFixable: !1, - sourcePack: fIr, - ts: "PublicKey", - pack: dIr, - }, - }; - }); - var iwt = I((im) => { - "use strict"; - m(); - g(); - var hIr = - (im && im.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(im, "__esModule", { value: !0 }); - im.logTrace = im.logDebug = im.logInfo = im.logError = void 0; - var Oae = hIr(Nx()); - im.logError = (0, Oae.default)("beet:error"); - im.logInfo = (0, Oae.default)("beet:info"); - im.logDebug = (0, Oae.default)("beet:debug"); - im.logTrace = (0, Oae.default)("beet:trace"); - }); - var awt = I((UAn, owt) => { - "use strict"; - m(); - g(); - function pIr(t) { - if (t.length >= 255) throw new TypeError("Alphabet too long"); - for (var e = new Uint8Array(256), r = 0; r < e.length; r++) e[r] = 255; - for (var n = 0; n < t.length; n++) { - var i = t.charAt(n), - o = i.charCodeAt(0); - if (e[o] !== 255) throw new TypeError(i + " is ambiguous"); - e[o] = n; - } - var a = t.length, - s = t.charAt(0), - c = Math.log(a) / Math.log(256), - u = Math.log(256) / Math.log(a); - function h(k) { - if ( - (k instanceof Uint8Array || - (ArrayBuffer.isView(k) - ? (k = new Uint8Array(k.buffer, k.byteOffset, k.byteLength)) - : Array.isArray(k) && (k = Uint8Array.from(k))), - !(k instanceof Uint8Array)) - ) - throw new TypeError("Expected Uint8Array"); - if (k.length === 0) return ""; - for (var O = 0, D = 0, F = 0, N = k.length; F !== N && k[F] === 0; ) - F++, O++; - for ( - var q = ((N - F) * u + 1) >>> 0, z = new Uint8Array(q); - F !== N; - - ) { - for ( - var H = k[F], Z = 0, $ = q - 1; - (H !== 0 || Z < D) && $ !== -1; - $--, Z++ - ) - (H += (256 * z[$]) >>> 0), - (z[$] = H % a >>> 0), - (H = (H / a) >>> 0); - if (H !== 0) throw new Error("Non-zero carry"); - (D = Z), F++; - } - for (var ue = q - D; ue !== q && z[ue] === 0; ) ue++; - for (var te = s.repeat(O); ue < q; ++ue) te += t.charAt(z[ue]); - return te; - } - function w(k) { - if (typeof k != "string") throw new TypeError("Expected String"); - if (k.length === 0) return new Uint8Array(); - for (var O = 0, D = 0, F = 0; k[O] === s; ) D++, O++; - for ( - var N = ((k.length - O) * c + 1) >>> 0, q = new Uint8Array(N); - k[O]; - - ) { - var z = e[k.charCodeAt(O)]; - if (z === 255) return; - for (var H = 0, Z = N - 1; (z !== 0 || H < F) && Z !== -1; Z--, H++) - (z += (a * q[Z]) >>> 0), - (q[Z] = z % 256 >>> 0), - (z = (z / 256) >>> 0); - if (z !== 0) throw new Error("Non-zero carry"); - (F = H), O++; - } - for (var $ = N - F; $ !== N && q[$] === 0; ) $++; - for (var ue = new Uint8Array(D + (N - $)), te = D; $ !== N; ) - ue[te++] = q[$++]; - return ue; - } - function M(k) { - var O = w(k); - if (O) return O; - throw new Error("Non-base" + a + " character"); - } - return { encode: h, decodeUnsafe: w, decode: M }; - } - owt.exports = pIr; - }); - var G6e = I((KAn, swt) => { - m(); - g(); - var yIr = awt(), - mIr = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"; - swt.exports = yIr(mIr); - }); - var uwt = I((ZN) => { - "use strict"; - m(); - g(); - var gIr = - (ZN && ZN.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(ZN, "__esModule", { value: !0 }); - ZN.encodeFixedBeet = void 0; - var vIr = gIr(G6e()); - function bIr(t, e) { - let r = Buffer.alloc(t.byteSize); - return t.write(r, 0, e), vIr.default.encode(r); - } - ZN.encodeFixedBeet = bIr; - }); - var lwt = I((Bae) => { - "use strict"; - m(); - g(); - Object.defineProperty(Bae, "__esModule", { value: !0 }); - Bae.GpaBuilder = void 0; - var J6e = Wt(), - HH = Dr(), - wIr = iwt(), - cwt = uwt(), - XN = class { - constructor(e, r, n) { - (this.programId = e), - (this.beets = r), - (this.accountSize = n), - (this.config = {}); - } - _addFilter(e) { - return ( - this.config.filters == null && (this.config.filters = []), - this.config.filters.push(e), - this - ); - } - _addInnerFilter(e, r, n) { - (0, wIr.logTrace)(`gpa.addInnerFilter: ${e}.${r}`); - let i = this.beets.get(e); - (0, HH.strict)( - i != null, - "Outer filter key needs to be an existing field name" - ); - let o = i.beet, - a = i.offset, - s = (0, J6e.isFixedSizeBeet)(o) ? o : o.toFixedFromValue(n), - c; - for (let [h, w] of s.fields) { - if (h === r) { - c = w; - break; - } - a += w.byteSize; - } - (0, HH.strict)(c != null, `${r} is not a field of the ${e} struct`); - let u = (0, cwt.encodeFixedBeet)(c, n); - return this._addFilter({ memcmp: { offset: a, bytes: u } }), this; - } - addInnerFilter(e, r) { - let n = e.split("."); - HH.strict.equal( - n.length, - 2, - "inner filters can go only one level deep, i.e. 'outer.inner' is ok, but 'outer.inner.deep' is not" - ); - let [i, o] = n; - return this._addInnerFilter(i, o, r); - } - addFilter(e, r) { - let n = this.beets.get(e); - (0, HH.strict)( - n != null, - "Filter key needs to be an existing field name" - ); - let i = (0, J6e.isFixedSizeBeet)(n.beet) - ? n.beet - : n.beet.toFixedFromValue(r), - o = (0, cwt.encodeFixedBeet)(i, r); - return ( - this._addFilter({ memcmp: { offset: n.offset, bytes: o } }), this - ); - } - dataSize(e) { - return ( - (e = e ?? this.accountSize), - (0, HH.strict)( - e != null, - "for accounts of dynamic size the dataSize arg needs to be provided" - ), - this._addFilter({ dataSize: e }) - ); - } - run(e) { - return e.getProgramAccounts(this.programId, this.config); - } - static fromBeetFields(e, r) { - let n = new Map(), - i = 0, - o = !1; - for (let [s, c] of r) { - if ( - (n.set(s, { beet: c, offset: i }), !(0, J6e.isFixedSizeBeet)(c)) - ) { - o = !0; - break; - } - i += c.byteSize; - } - let a = o ? void 0 : i; - return new XN(e, n, a); - } - static fromStruct(e, r) { - return XN.fromBeetFields(e, r.fields); - } - }; - Bae.GpaBuilder = XN; - }); - var qu = I((Qb) => { - "use strict"; - m(); - g(); - var _Ir = - (Qb && Qb.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - fwt = - (Qb && Qb.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - _Ir(e, t, r); - }; - Object.defineProperty(Qb, "__esModule", { value: !0 }); - Qb.supportedTypeMap = void 0; - var xIr = W6e(); - fwt(W6e(), Qb); - fwt(lwt(), Qb); - Qb.supportedTypeMap = xIr.keysTypeMap; - }); - var c0 = I((u0) => { - "use strict"; - m(); - g(); - var SIr = - (u0 && u0.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - AIr = - (u0 && u0.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - EIr = - (u0 && u0.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - SIr(e, t, r); - return AIr(e, t), e; - }; - Object.defineProperty(u0, "__esModule", { value: !0 }); - u0.keyBeet = u0.Key = void 0; - var MIr = EIr(Wt()), - dwt; - (function (t) { - (t[(t.Uninitialized = 0)] = "Uninitialized"), - (t[(t.EditionV1 = 1)] = "EditionV1"), - (t[(t.MasterEditionV1 = 2)] = "MasterEditionV1"), - (t[(t.ReservationListV1 = 3)] = "ReservationListV1"), - (t[(t.MetadataV1 = 4)] = "MetadataV1"), - (t[(t.ReservationListV2 = 5)] = "ReservationListV2"), - (t[(t.MasterEditionV2 = 6)] = "MasterEditionV2"), - (t[(t.EditionMarker = 7)] = "EditionMarker"), - (t[(t.UseAuthorityRecord = 8)] = "UseAuthorityRecord"), - (t[(t.CollectionAuthorityRecord = 9)] = "CollectionAuthorityRecord"), - (t[(t.TokenOwnedEscrow = 10)] = "TokenOwnedEscrow"); - })((dwt = u0.Key || (u0.Key = {}))); - u0.keyBeet = MIr.fixedScalarEnum(dwt); - }); - var Z6e = I((gl) => { - "use strict"; - m(); - g(); - var TIr = - (gl && gl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - kIr = - (gl && gl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - $6e = - (gl && gl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - TIr(e, t, r); - return kIr(e, t), e; - }; - Object.defineProperty(gl, "__esModule", { value: !0 }); - gl.collectionAuthorityRecordBeet = gl.CollectionAuthorityRecord = void 0; - var hwt = $6e(Wt()), - PIr = $6e(Le()), - OIr = $6e(qu()), - pwt = c0(), - e1 = class { - constructor(e, r) { - (this.key = e), (this.bump = r); - } - static fromArgs(e) { - return new e1(e.key, e.bump); - } - static fromAccountInfo(e, r = 0) { - return e1.deserialize(e.data, r); - } - static async fromAccountAddress(e, r) { - let n = await e.getAccountInfo(r); - if (n == null) - throw new Error( - `Unable to find CollectionAuthorityRecord account at ${r}` - ); - return e1.fromAccountInfo(n, 0)[0]; - } - static gpaBuilder( - e = new PIr.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - return OIr.GpaBuilder.fromStruct(e, gl.collectionAuthorityRecordBeet); - } - static deserialize(e, r = 0) { - return gl.collectionAuthorityRecordBeet.deserialize(e, r); - } - serialize() { - return gl.collectionAuthorityRecordBeet.serialize(this); - } - static get byteSize() { - return gl.collectionAuthorityRecordBeet.byteSize; - } - static async getMinimumBalanceForRentExemption(e, r) { - return e.getMinimumBalanceForRentExemption(e1.byteSize, r); - } - static hasCorrectByteSize(e, r = 0) { - return e.byteLength - r === e1.byteSize; - } - pretty() { - return { key: "Key." + pwt.Key[this.key], bump: this.bump }; - } - }; - gl.CollectionAuthorityRecord = e1; - gl.collectionAuthorityRecordBeet = new hwt.BeetStruct( - [ - ["key", pwt.keyBeet], - ["bump", hwt.u8], - ], - e1.fromArgs, - "CollectionAuthorityRecord" - ); - }); - var Y6e = I((vl) => { - "use strict"; - m(); - g(); - var BIr = - (vl && vl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - IIr = - (vl && vl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - X6e = - (vl && vl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - BIr(e, t, r); - return IIr(e, t), e; - }; - Object.defineProperty(vl, "__esModule", { value: !0 }); - vl.editionBeet = vl.Edition = void 0; - var CIr = X6e(Le()), - ywt = X6e(Wt()), - mwt = X6e(qu()), - gwt = c0(), - t1 = class { - constructor(e, r, n) { - (this.key = e), (this.parent = r), (this.edition = n); - } - static fromArgs(e) { - return new t1(e.key, e.parent, e.edition); - } - static fromAccountInfo(e, r = 0) { - return t1.deserialize(e.data, r); - } - static async fromAccountAddress(e, r) { - let n = await e.getAccountInfo(r); - if (n == null) - throw new Error(`Unable to find Edition account at ${r}`); - return t1.fromAccountInfo(n, 0)[0]; - } - static gpaBuilder( - e = new CIr.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - return mwt.GpaBuilder.fromStruct(e, vl.editionBeet); - } - static deserialize(e, r = 0) { - return vl.editionBeet.deserialize(e, r); - } - serialize() { - return vl.editionBeet.serialize(this); - } - static get byteSize() { - return vl.editionBeet.byteSize; - } - static async getMinimumBalanceForRentExemption(e, r) { - return e.getMinimumBalanceForRentExemption(t1.byteSize, r); - } - static hasCorrectByteSize(e, r = 0) { - return e.byteLength - r === t1.byteSize; - } - pretty() { - return { - key: "Key." + gwt.Key[this.key], - parent: this.parent.toBase58(), - edition: (() => { - let e = this.edition; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - }; - } - }; - vl.Edition = t1; - vl.editionBeet = new ywt.BeetStruct( - [ - ["key", gwt.keyBeet], - ["parent", mwt.publicKey], - ["edition", ywt.u64], - ], - t1.fromArgs, - "Edition" - ); - }); - var t8e = I((bl) => { - "use strict"; - m(); - g(); - var RIr = - (bl && bl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - NIr = - (bl && bl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - e8e = - (bl && bl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - RIr(e, t, r); - return NIr(e, t), e; - }; - Object.defineProperty(bl, "__esModule", { value: !0 }); - bl.editionMarkerBeet = bl.EditionMarker = void 0; - var Q6e = e8e(Wt()), - DIr = e8e(Le()), - FIr = e8e(qu()), - vwt = c0(), - r1 = class { - constructor(e, r) { - (this.key = e), (this.ledger = r); - } - static fromArgs(e) { - return new r1(e.key, e.ledger); - } - static fromAccountInfo(e, r = 0) { - return r1.deserialize(e.data, r); - } - static async fromAccountAddress(e, r) { - let n = await e.getAccountInfo(r); - if (n == null) - throw new Error(`Unable to find EditionMarker account at ${r}`); - return r1.fromAccountInfo(n, 0)[0]; - } - static gpaBuilder( - e = new DIr.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - return FIr.GpaBuilder.fromStruct(e, bl.editionMarkerBeet); - } - static deserialize(e, r = 0) { - return bl.editionMarkerBeet.deserialize(e, r); - } - serialize() { - return bl.editionMarkerBeet.serialize(this); - } - static get byteSize() { - return bl.editionMarkerBeet.byteSize; - } - static async getMinimumBalanceForRentExemption(e, r) { - return e.getMinimumBalanceForRentExemption(r1.byteSize, r); - } - static hasCorrectByteSize(e, r = 0) { - return e.byteLength - r === r1.byteSize; - } - pretty() { - return { key: "Key." + vwt.Key[this.key], ledger: this.ledger }; - } - }; - bl.EditionMarker = r1; - bl.editionMarkerBeet = new Q6e.BeetStruct( - [ - ["key", vwt.keyBeet], - ["ledger", Q6e.uniformFixedSizeArray(Q6e.u8, 31)], - ], - r1.fromArgs, - "EditionMarker" - ); - }); - var i8e = I((wl) => { - "use strict"; - m(); - g(); - var LIr = - (wl && wl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - qIr = - (wl && wl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - n8e = - (wl && wl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - LIr(e, t, r); - return qIr(e, t), e; - }; - Object.defineProperty(wl, "__esModule", { value: !0 }); - wl.masterEditionV1Beet = wl.MasterEditionV1 = void 0; - var Iae = n8e(Wt()), - zIr = n8e(Le()), - r8e = n8e(qu()), - bwt = c0(), - n1 = class { - constructor(e, r, n, i, o) { - (this.key = e), - (this.supply = r), - (this.maxSupply = n), - (this.printingMint = i), - (this.oneTimePrintingAuthorizationMint = o); - } - static fromArgs(e) { - return new n1( - e.key, - e.supply, - e.maxSupply, - e.printingMint, - e.oneTimePrintingAuthorizationMint - ); - } - static fromAccountInfo(e, r = 0) { - return n1.deserialize(e.data, r); - } - static async fromAccountAddress(e, r) { - let n = await e.getAccountInfo(r); - if (n == null) - throw new Error(`Unable to find MasterEditionV1 account at ${r}`); - return n1.fromAccountInfo(n, 0)[0]; - } - static gpaBuilder( - e = new zIr.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - return r8e.GpaBuilder.fromStruct(e, wl.masterEditionV1Beet); - } - static deserialize(e, r = 0) { - return wl.masterEditionV1Beet.deserialize(e, r); - } - serialize() { - return wl.masterEditionV1Beet.serialize(this); - } - static byteSize(e) { - let r = n1.fromArgs(e); - return wl.masterEditionV1Beet.toFixedFromValue(r).byteSize; - } - static async getMinimumBalanceForRentExemption(e, r, n) { - return r.getMinimumBalanceForRentExemption(n1.byteSize(e), n); - } - pretty() { - return { - key: "Key." + bwt.Key[this.key], - supply: (() => { - let e = this.supply; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - maxSupply: this.maxSupply, - printingMint: this.printingMint.toBase58(), - oneTimePrintingAuthorizationMint: - this.oneTimePrintingAuthorizationMint.toBase58(), - }; - } - }; - wl.MasterEditionV1 = n1; - wl.masterEditionV1Beet = new Iae.FixableBeetStruct( - [ - ["key", bwt.keyBeet], - ["supply", Iae.u64], - ["maxSupply", Iae.coption(Iae.u64)], - ["printingMint", r8e.publicKey], - ["oneTimePrintingAuthorizationMint", r8e.publicKey], - ], - n1.fromArgs, - "MasterEditionV1" - ); - }); - var a8e = I((_l) => { - "use strict"; - m(); - g(); - var jIr = - (_l && _l.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - UIr = - (_l && _l.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - o8e = - (_l && _l.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - jIr(e, t, r); - return UIr(e, t), e; - }; - Object.defineProperty(_l, "__esModule", { value: !0 }); - _l.masterEditionV2Beet = _l.MasterEditionV2 = void 0; - var Cae = o8e(Wt()), - KIr = o8e(Le()), - HIr = o8e(qu()), - wwt = c0(), - i1 = class { - constructor(e, r, n) { - (this.key = e), (this.supply = r), (this.maxSupply = n); - } - static fromArgs(e) { - return new i1(e.key, e.supply, e.maxSupply); - } - static fromAccountInfo(e, r = 0) { - return i1.deserialize(e.data, r); - } - static async fromAccountAddress(e, r) { - let n = await e.getAccountInfo(r); - if (n == null) - throw new Error(`Unable to find MasterEditionV2 account at ${r}`); - return i1.fromAccountInfo(n, 0)[0]; - } - static gpaBuilder( - e = new KIr.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - return HIr.GpaBuilder.fromStruct(e, _l.masterEditionV2Beet); - } - static deserialize(e, r = 0) { - return _l.masterEditionV2Beet.deserialize(e, r); - } - serialize() { - return _l.masterEditionV2Beet.serialize(this); - } - static byteSize(e) { - let r = i1.fromArgs(e); - return _l.masterEditionV2Beet.toFixedFromValue(r).byteSize; - } - static async getMinimumBalanceForRentExemption(e, r, n) { - return r.getMinimumBalanceForRentExemption(i1.byteSize(e), n); - } - pretty() { - return { - key: "Key." + wwt.Key[this.key], - supply: (() => { - let e = this.supply; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - maxSupply: this.maxSupply, - }; - } - }; - _l.MasterEditionV2 = i1; - _l.masterEditionV2Beet = new Cae.FixableBeetStruct( - [ - ["key", wwt.keyBeet], - ["supply", Cae.u64], - ["maxSupply", Cae.coption(Cae.u64)], - ], - i1.fromArgs, - "MasterEditionV2" - ); - }); - var Rae = I((o1) => { - "use strict"; - m(); - g(); - var VIr = - (o1 && o1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - WIr = - (o1 && o1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - _wt = - (o1 && o1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - VIr(e, t, r); - return WIr(e, t), e; - }; - Object.defineProperty(o1, "__esModule", { value: !0 }); - o1.creatorBeet = void 0; - var GIr = _wt(qu()), - s8e = _wt(Wt()); - o1.creatorBeet = new s8e.BeetArgsStruct( - [ - ["address", GIr.publicKey], - ["verified", s8e.bool], - ["share", s8e.u8], - ], - "Creator" - ); - }); - var YN = I((a1) => { - "use strict"; - m(); - g(); - var JIr = - (a1 && a1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - $Ir = - (a1 && a1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - ZIr = - (a1 && a1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - JIr(e, t, r); - return $Ir(e, t), e; - }; - Object.defineProperty(a1, "__esModule", { value: !0 }); - a1.dataBeet = void 0; - var D6 = ZIr(Wt()), - XIr = Rae(); - a1.dataBeet = new D6.FixableBeetArgsStruct( - [ - ["name", D6.utf8String], - ["symbol", D6.utf8String], - ["uri", D6.utf8String], - ["sellerFeeBasisPoints", D6.u16], - ["creators", D6.coption(D6.array(XIr.creatorBeet))], - ], - "Data" - ); - }); - var Nae = I((l0) => { - "use strict"; - m(); - g(); - var YIr = - (l0 && l0.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - QIr = - (l0 && l0.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - e5r = - (l0 && l0.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - YIr(e, t, r); - return QIr(e, t), e; - }; - Object.defineProperty(l0, "__esModule", { value: !0 }); - l0.tokenStandardBeet = l0.TokenStandard = void 0; - var t5r = e5r(Wt()), - xwt; - (function (t) { - (t[(t.NonFungible = 0)] = "NonFungible"), - (t[(t.FungibleAsset = 1)] = "FungibleAsset"), - (t[(t.Fungible = 2)] = "Fungible"), - (t[(t.NonFungibleEdition = 3)] = "NonFungibleEdition"); - })((xwt = l0.TokenStandard || (l0.TokenStandard = {}))); - l0.tokenStandardBeet = t5r.fixedScalarEnum(xwt); - }); - var VH = I((s1) => { - "use strict"; - m(); - g(); - var r5r = - (s1 && s1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - n5r = - (s1 && s1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Awt = - (s1 && s1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - r5r(e, t, r); - return n5r(e, t), e; - }; - Object.defineProperty(s1, "__esModule", { value: !0 }); - s1.collectionBeet = void 0; - var Swt = Awt(Wt()), - i5r = Awt(qu()); - s1.collectionBeet = new Swt.BeetArgsStruct( - [ - ["verified", Swt.bool], - ["key", i5r.publicKey], - ], - "Collection" - ); - }); - var u8e = I((f0) => { - "use strict"; - m(); - g(); - var o5r = - (f0 && f0.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - a5r = - (f0 && f0.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - s5r = - (f0 && f0.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - o5r(e, t, r); - return a5r(e, t), e; - }; - Object.defineProperty(f0, "__esModule", { value: !0 }); - f0.useMethodBeet = f0.UseMethod = void 0; - var u5r = s5r(Wt()), - Ewt; - (function (t) { - (t[(t.Burn = 0)] = "Burn"), - (t[(t.Multiple = 1)] = "Multiple"), - (t[(t.Single = 2)] = "Single"); - })((Ewt = f0.UseMethod || (f0.UseMethod = {}))); - f0.useMethodBeet = u5r.fixedScalarEnum(Ewt); - }); - var WH = I((u1) => { - "use strict"; - m(); - g(); - var c5r = - (u1 && u1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - l5r = - (u1 && u1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - f5r = - (u1 && u1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - c5r(e, t, r); - return l5r(e, t), e; - }; - Object.defineProperty(u1, "__esModule", { value: !0 }); - u1.usesBeet = void 0; - var c8e = f5r(Wt()), - d5r = u8e(); - u1.usesBeet = new c8e.BeetArgsStruct( - [ - ["useMethod", d5r.useMethodBeet], - ["remaining", c8e.u64], - ["total", c8e.u64], - ], - "Uses" - ); - }); - var GH = I((om) => { - "use strict"; - m(); - g(); - var h5r = - (om && om.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - p5r = - (om && om.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - y5r = - (om && om.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - h5r(e, t, r); - return p5r(e, t), e; - }; - Object.defineProperty(om, "__esModule", { value: !0 }); - om.collectionDetailsBeet = om.isCollectionDetailsV1 = void 0; - var l8e = y5r(Wt()), - m5r = (t) => t.__kind === "V1"; - om.isCollectionDetailsV1 = m5r; - om.collectionDetailsBeet = l8e.dataEnum([ - [ - "V1", - new l8e.BeetArgsStruct( - [["size", l8e.u64]], - 'CollectionDetailsRecord["V1"]' - ), - ], - ]); - }); - var kwt = I((c1) => { - "use strict"; - m(); - g(); - var g5r = - (c1 && c1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - v5r = - (c1 && c1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Twt = - (c1 && c1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - g5r(e, t, r); - return v5r(e, t), e; - }; - Object.defineProperty(c1, "__esModule", { value: !0 }); - c1.deserialize = void 0; - var kg = Twt(Wt()), - Dae = Twt(qu()), - b5r = qae(), - w5r = VH(), - _5r = GH(), - x5r = YN(), - Mwt = c0(), - S5r = Nae(), - A5r = WH(), - Lae = kg.coptionNone("").byteSize; - function E5r(t, e = 0) { - let r = e, - n = Mwt.keyBeet.read(t, r); - r += Mwt.keyBeet.byteSize; - let i = Dae.publicKey.read(t, r); - r += Dae.publicKey.byteSize; - let o = Dae.publicKey.read(t, r); - r += Dae.publicKey.byteSize; - let [a, s] = x5r.dataBeet.deserialize(t, r); - r = s; - let c = kg.bool.read(t, r); - r += kg.bool.byteSize; - let u = kg.bool.read(t, r); - r += kg.bool.byteSize; - let h = kg.coption(kg.u8).toFixedFromData(t, r), - w = h.read(t, r); - r += h.byteSize; - let [M, k, O] = Fae(kg.coption(S5r.tokenStandardBeet), t, r); - r += k; - let [D, F, N] = O - ? [null, Lae, !0] - : Fae(kg.coption(w5r.collectionBeet), t, r); - r += F; - let [q, z, H] = - O || N ? [null, Lae, !0] : Fae(kg.coption(A5r.usesBeet), t, r); - r += z; - let [Z, $, ue] = - O || N || H - ? [null, Lae, !0] - : Fae(kg.coption(_5r.collectionDetailsBeet), t, r); - r += $; - let te = O || N || H || ue, - ne = { - key: n, - updateAuthority: i, - mint: o, - data: a, - primarySaleHappened: c, - isMutable: u, - editionNonce: w, - tokenStandard: te ? null : M, - collection: te ? null : D, - uses: te ? null : q, - collectionDetails: te ? null : Z, - }; - return [b5r.Metadata.fromArgs(ne), r]; - } - c1.deserialize = E5r; - function Fae(t, e, r) { - try { - let n = t.toFixedFromData(e, r); - return [n.read(e, r), n.byteSize, !1]; - } catch { - return [null, Lae, !0]; - } - } - }); - var qae = I((zu) => { - "use strict"; - m(); - g(); - var M5r = - (zu && zu.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - T5r = - (zu && zu.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - zae = - (zu && zu.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - M5r(e, t, r); - return T5r(e, t), e; - }; - Object.defineProperty(zu, "__esModule", { value: !0 }); - zu.metadataBeet = zu.Metadata = void 0; - var k5r = zae(Le()), - qx = zae(Wt()), - f8e = zae(qu()), - Pwt = c0(), - P5r = YN(), - O5r = Nae(), - B5r = VH(), - I5r = WH(), - C5r = GH(), - R5r = zae(kwt()), - l1 = class { - constructor(e, r, n, i, o, a, s, c, u, h, w) { - (this.key = e), - (this.updateAuthority = r), - (this.mint = n), - (this.data = i), - (this.primarySaleHappened = o), - (this.isMutable = a), - (this.editionNonce = s), - (this.tokenStandard = c), - (this.collection = u), - (this.uses = h), - (this.collectionDetails = w); - } - static fromArgs(e) { - return new l1( - e.key, - e.updateAuthority, - e.mint, - e.data, - e.primarySaleHappened, - e.isMutable, - e.editionNonce, - e.tokenStandard, - e.collection, - e.uses, - e.collectionDetails - ); - } - static fromAccountInfo(e, r = 0) { - return l1.deserialize(e.data, r); - } - static async fromAccountAddress(e, r) { - let n = await e.getAccountInfo(r); - if (n == null) - throw new Error(`Unable to find Metadata account at ${r}`); - return l1.fromAccountInfo(n, 0)[0]; - } - static gpaBuilder( - e = new k5r.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - return f8e.GpaBuilder.fromStruct(e, zu.metadataBeet); - } - static deserialize(e, r = 0) { - return D5r(e, r); - } - serialize() { - return N5r(this); - } - static byteSize(e) { - let r = l1.fromArgs(e); - return zu.metadataBeet.toFixedFromValue(r).byteSize; - } - static async getMinimumBalanceForRentExemption(e, r, n) { - return r.getMinimumBalanceForRentExemption(l1.byteSize(e), n); - } - pretty() { - return { - key: "Key." + Pwt.Key[this.key], - updateAuthority: this.updateAuthority.toBase58(), - mint: this.mint.toBase58(), - data: this.data, - primarySaleHappened: this.primarySaleHappened, - isMutable: this.isMutable, - editionNonce: this.editionNonce, - tokenStandard: this.tokenStandard, - collection: this.collection, - uses: this.uses, - collectionDetails: this.collectionDetails, - }; - } - }; - zu.Metadata = l1; - zu.metadataBeet = new qx.FixableBeetStruct( - [ - ["key", Pwt.keyBeet], - ["updateAuthority", f8e.publicKey], - ["mint", f8e.publicKey], - ["data", P5r.dataBeet], - ["primarySaleHappened", qx.bool], - ["isMutable", qx.bool], - ["editionNonce", qx.coption(qx.u8)], - ["tokenStandard", qx.coption(O5r.tokenStandardBeet)], - ["collection", qx.coption(B5r.collectionBeet)], - ["uses", qx.coption(I5r.usesBeet)], - ["collectionDetails", qx.coption(C5r.collectionDetailsBeet)], - ], - l1.fromArgs, - "Metadata" - ); - var QN = R5r, - N5r = - typeof QN.serialize == "function" - ? QN.serialize.bind(QN) - : zu.metadataBeet.serialize.bind(zu.metadataBeet), - D5r = - typeof QN.deserialize == "function" - ? QN.deserialize.bind(QN) - : zu.metadataBeet.deserialize.bind(zu.metadataBeet); - }); - var h8e = I((f1) => { - "use strict"; - m(); - g(); - var F5r = - (f1 && f1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - L5r = - (f1 && f1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Owt = - (f1 && f1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - F5r(e, t, r); - return L5r(e, t), e; - }; - Object.defineProperty(f1, "__esModule", { value: !0 }); - f1.reservationV1Beet = void 0; - var q5r = Owt(qu()), - d8e = Owt(Wt()); - f1.reservationV1Beet = new d8e.BeetArgsStruct( - [ - ["address", q5r.publicKey], - ["spotsRemaining", d8e.u8], - ["totalSpots", d8e.u8], - ], - "ReservationV1" - ); - }); - var y8e = I((xl) => { - "use strict"; - m(); - g(); - var z5r = - (xl && xl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - j5r = - (xl && xl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - p8e = - (xl && xl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - z5r(e, t, r); - return j5r(e, t), e; - }; - Object.defineProperty(xl, "__esModule", { value: !0 }); - xl.reservationListV1Beet = xl.ReservationListV1 = void 0; - var U5r = p8e(Le()), - jae = p8e(Wt()), - Bwt = p8e(qu()), - Iwt = c0(), - K5r = h8e(), - d1 = class { - constructor(e, r, n, i) { - (this.key = e), - (this.masterEdition = r), - (this.supplySnapshot = n), - (this.reservations = i); - } - static fromArgs(e) { - return new d1( - e.key, - e.masterEdition, - e.supplySnapshot, - e.reservations - ); - } - static fromAccountInfo(e, r = 0) { - return d1.deserialize(e.data, r); - } - static async fromAccountAddress(e, r) { - let n = await e.getAccountInfo(r); - if (n == null) - throw new Error(`Unable to find ReservationListV1 account at ${r}`); - return d1.fromAccountInfo(n, 0)[0]; - } - static gpaBuilder( - e = new U5r.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - return Bwt.GpaBuilder.fromStruct(e, xl.reservationListV1Beet); - } - static deserialize(e, r = 0) { - return xl.reservationListV1Beet.deserialize(e, r); - } - serialize() { - return xl.reservationListV1Beet.serialize(this); - } - static byteSize(e) { - let r = d1.fromArgs(e); - return xl.reservationListV1Beet.toFixedFromValue(r).byteSize; - } - static async getMinimumBalanceForRentExemption(e, r, n) { - return r.getMinimumBalanceForRentExemption(d1.byteSize(e), n); - } - pretty() { - return { - key: "Key." + Iwt.Key[this.key], - masterEdition: this.masterEdition.toBase58(), - supplySnapshot: this.supplySnapshot, - reservations: this.reservations, - }; - } - }; - xl.ReservationListV1 = d1; - xl.reservationListV1Beet = new jae.FixableBeetStruct( - [ - ["key", Iwt.keyBeet], - ["masterEdition", Bwt.publicKey], - ["supplySnapshot", jae.coption(jae.u64)], - ["reservations", jae.array(K5r.reservationV1Beet)], - ], - d1.fromArgs, - "ReservationListV1" - ); - }); - var Uae = I((h1) => { - "use strict"; - m(); - g(); - var H5r = - (h1 && h1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - V5r = - (h1 && h1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Cwt = - (h1 && h1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - H5r(e, t, r); - return V5r(e, t), e; - }; - Object.defineProperty(h1, "__esModule", { value: !0 }); - h1.reservationBeet = void 0; - var m8e = Cwt(Wt()), - W5r = Cwt(qu()); - h1.reservationBeet = new m8e.BeetArgsStruct( - [ - ["address", W5r.publicKey], - ["spotsRemaining", m8e.u64], - ["totalSpots", m8e.u64], - ], - "Reservation" - ); - }); - var v8e = I((Sl) => { - "use strict"; - m(); - g(); - var G5r = - (Sl && Sl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - J5r = - (Sl && Sl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - g8e = - (Sl && Sl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - G5r(e, t, r); - return J5r(e, t), e; - }; - Object.defineProperty(Sl, "__esModule", { value: !0 }); - Sl.reservationListV2Beet = Sl.ReservationListV2 = void 0; - var $5r = g8e(Le()), - e9 = g8e(Wt()), - Rwt = g8e(qu()), - Nwt = c0(), - Z5r = Uae(), - p1 = class { - constructor(e, r, n, i, o, a) { - (this.key = e), - (this.masterEdition = r), - (this.supplySnapshot = n), - (this.reservations = i), - (this.totalReservationSpots = o), - (this.currentReservationSpots = a); - } - static fromArgs(e) { - return new p1( - e.key, - e.masterEdition, - e.supplySnapshot, - e.reservations, - e.totalReservationSpots, - e.currentReservationSpots - ); - } - static fromAccountInfo(e, r = 0) { - return p1.deserialize(e.data, r); - } - static async fromAccountAddress(e, r) { - let n = await e.getAccountInfo(r); - if (n == null) - throw new Error(`Unable to find ReservationListV2 account at ${r}`); - return p1.fromAccountInfo(n, 0)[0]; - } - static gpaBuilder( - e = new $5r.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - return Rwt.GpaBuilder.fromStruct(e, Sl.reservationListV2Beet); - } - static deserialize(e, r = 0) { - return Sl.reservationListV2Beet.deserialize(e, r); - } - serialize() { - return Sl.reservationListV2Beet.serialize(this); - } - static byteSize(e) { - let r = p1.fromArgs(e); - return Sl.reservationListV2Beet.toFixedFromValue(r).byteSize; - } - static async getMinimumBalanceForRentExemption(e, r, n) { - return r.getMinimumBalanceForRentExemption(p1.byteSize(e), n); - } - pretty() { - return { - key: "Key." + Nwt.Key[this.key], - masterEdition: this.masterEdition.toBase58(), - supplySnapshot: this.supplySnapshot, - reservations: this.reservations, - totalReservationSpots: (() => { - let e = this.totalReservationSpots; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - currentReservationSpots: (() => { - let e = this.currentReservationSpots; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - }; - } - }; - Sl.ReservationListV2 = p1; - Sl.reservationListV2Beet = new e9.FixableBeetStruct( - [ - ["key", Nwt.keyBeet], - ["masterEdition", Rwt.publicKey], - ["supplySnapshot", e9.coption(e9.u64)], - ["reservations", e9.array(Z5r.reservationBeet)], - ["totalReservationSpots", e9.u64], - ["currentReservationSpots", e9.u64], - ], - p1.fromArgs, - "ReservationListV2" - ); - }); - var b8e = I((d0) => { - "use strict"; - m(); - g(); - var X5r = - (d0 && d0.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Y5r = - (d0 && d0.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Q5r = - (d0 && d0.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - X5r(e, t, r); - return Y5r(e, t), e; - }; - Object.defineProperty(d0, "__esModule", { value: !0 }); - d0.escrowAuthorityBeet = d0.EscrowAuthority = void 0; - var eCr = Q5r(Wt()), - Dwt; - (function (t) { - (t[(t.TokenOwner = 0)] = "TokenOwner"), (t[(t.Creator = 1)] = "Creator"); - })((Dwt = d0.EscrowAuthority || (d0.EscrowAuthority = {}))); - d0.escrowAuthorityBeet = eCr.fixedScalarEnum(Dwt); - }); - var _8e = I((Al) => { - "use strict"; - m(); - g(); - var tCr = - (Al && Al.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - rCr = - (Al && Al.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - w8e = - (Al && Al.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - tCr(e, t, r); - return rCr(e, t), e; - }; - Object.defineProperty(Al, "__esModule", { value: !0 }); - Al.tokenOwnedEscrowBeet = Al.TokenOwnedEscrow = void 0; - var nCr = w8e(Le()), - Lwt = w8e(qu()), - Fwt = w8e(Wt()), - qwt = c0(), - zwt = b8e(), - y1 = class { - constructor(e, r, n, i) { - (this.key = e), - (this.baseToken = r), - (this.authority = n), - (this.bump = i); - } - static fromArgs(e) { - return new y1(e.key, e.baseToken, e.authority, e.bump); - } - static fromAccountInfo(e, r = 0) { - return y1.deserialize(e.data, r); - } - static async fromAccountAddress(e, r) { - let n = await e.getAccountInfo(r); - if (n == null) - throw new Error(`Unable to find TokenOwnedEscrow account at ${r}`); - return y1.fromAccountInfo(n, 0)[0]; - } - static gpaBuilder( - e = new nCr.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - return Lwt.GpaBuilder.fromStruct(e, Al.tokenOwnedEscrowBeet); - } - static deserialize(e, r = 0) { - return Al.tokenOwnedEscrowBeet.deserialize(e, r); - } - serialize() { - return Al.tokenOwnedEscrowBeet.serialize(this); - } - static get byteSize() { - return Al.tokenOwnedEscrowBeet.byteSize; - } - static async getMinimumBalanceForRentExemption(e, r) { - return e.getMinimumBalanceForRentExemption(y1.byteSize, r); - } - static hasCorrectByteSize(e, r = 0) { - return e.byteLength - r === y1.byteSize; - } - pretty() { - return { - key: "Key." + qwt.Key[this.key], - baseToken: this.baseToken.toBase58(), - authority: "EscrowAuthority." + zwt.EscrowAuthority[this.authority], - bump: this.bump, - }; - } - }; - Al.TokenOwnedEscrow = y1; - Al.tokenOwnedEscrowBeet = new Fwt.BeetStruct( - [ - ["key", qwt.keyBeet], - ["baseToken", Lwt.publicKey], - ["authority", zwt.escrowAuthorityBeet], - ["bump", Fwt.u8], - ], - y1.fromArgs, - "TokenOwnedEscrow" - ); - }); - var A8e = I((El) => { - "use strict"; - m(); - g(); - var iCr = - (El && El.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - oCr = - (El && El.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - S8e = - (El && El.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - iCr(e, t, r); - return oCr(e, t), e; - }; - Object.defineProperty(El, "__esModule", { value: !0 }); - El.useAuthorityRecordBeet = El.UseAuthorityRecord = void 0; - var x8e = S8e(Wt()), - aCr = S8e(Le()), - sCr = S8e(qu()), - jwt = c0(), - m1 = class { - constructor(e, r, n) { - (this.key = e), (this.allowedUses = r), (this.bump = n); - } - static fromArgs(e) { - return new m1(e.key, e.allowedUses, e.bump); - } - static fromAccountInfo(e, r = 0) { - return m1.deserialize(e.data, r); - } - static async fromAccountAddress(e, r) { - let n = await e.getAccountInfo(r); - if (n == null) - throw new Error( - `Unable to find UseAuthorityRecord account at ${r}` - ); - return m1.fromAccountInfo(n, 0)[0]; - } - static gpaBuilder( - e = new aCr.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - return sCr.GpaBuilder.fromStruct(e, El.useAuthorityRecordBeet); - } - static deserialize(e, r = 0) { - return El.useAuthorityRecordBeet.deserialize(e, r); - } - serialize() { - return El.useAuthorityRecordBeet.serialize(this); - } - static get byteSize() { - return El.useAuthorityRecordBeet.byteSize; - } - static async getMinimumBalanceForRentExemption(e, r) { - return e.getMinimumBalanceForRentExemption(m1.byteSize, r); - } - static hasCorrectByteSize(e, r = 0) { - return e.byteLength - r === m1.byteSize; - } - pretty() { - return { - key: "Key." + jwt.Key[this.key], - allowedUses: (() => { - let e = this.allowedUses; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - bump: this.bump, - }; - } - }; - El.UseAuthorityRecord = m1; - El.useAuthorityRecordBeet = new x8e.BeetStruct( - [ - ["key", jwt.keyBeet], - ["allowedUses", x8e.u64], - ["bump", x8e.u8], - ], - m1.fromArgs, - "UseAuthorityRecord" - ); - }); - var Uwt = I((ju) => { - "use strict"; - m(); - g(); - var uCr = - (ju && ju.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - g1 = - (ju && ju.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - uCr(e, t, r); - }; - Object.defineProperty(ju, "__esModule", { value: !0 }); - ju.accountProviders = void 0; - g1(Z6e(), ju); - g1(Y6e(), ju); - g1(t8e(), ju); - g1(i8e(), ju); - g1(a8e(), ju); - g1(qae(), ju); - g1(y8e(), ju); - g1(v8e(), ju); - g1(_8e(), ju); - g1(A8e(), ju); - var cCr = A8e(), - lCr = Z6e(), - fCr = qae(), - dCr = a8e(), - hCr = i8e(), - pCr = Y6e(), - yCr = v8e(), - mCr = y8e(), - gCr = t8e(), - vCr = _8e(); - ju.accountProviders = { - UseAuthorityRecord: cCr.UseAuthorityRecord, - CollectionAuthorityRecord: lCr.CollectionAuthorityRecord, - Metadata: fCr.Metadata, - MasterEditionV2: dCr.MasterEditionV2, - MasterEditionV1: hCr.MasterEditionV1, - Edition: pCr.Edition, - ReservationListV2: yCr.ReservationListV2, - ReservationListV1: mCr.ReservationListV1, - EditionMarker: gCr.EditionMarker, - TokenOwnedEscrow: vCr.TokenOwnedEscrow, - }; - }); - var Kwt = I((Te) => { - "use strict"; - m(); - g(); - Object.defineProperty(Te, "__esModule", { value: !0 }); - Te.ReservationAlreadyMadeError = - Te.ReservationNotSetError = - Te.ReservationDoesNotExistError = - Te.ReservationExistsError = - Te.ShareTotalMustBe100Error = - Te.NoBalanceInAccountForAuthorizationError = - Te.OwnerMismatchError = - Te.PrimarySaleCanOnlyBeFlippedToTrueError = - Te.InvalidBasisPointsError = - Te.CreatorNotFoundError = - Te.NoCreatorsPresentOnMetadataError = - Te.MustBeOneOfCreatorsError = - Te.CreatorsMustBeAtleastOneError = - Te.CreatorsTooLongError = - Te.DisabledError = - Te.AuthorizationTokenAccountOwnerMismatchError = - Te.PrintingMintAuthorizationAccountMismatchError = - Te.NotEnoughTokensError = - Te.TokenAccountMintMismatchV2Error = - Te.TokenAccountMintMismatchError = - Te.OneTimePrintingAuthMintMismatchError = - Te.PrintingMintMismatchError = - Te.DerivedKeyInvalidError = - Te.TokenAccountOneTimeAuthMintMismatchError = - Te.TokenBurnFailedError = - Te.EditionMintDecimalsShouldBeZeroError = - Te.OneTimePrintingAuthorizationMintDecimalsShouldBeZeroError = - Te.PrintingMintDecimalsShouldBeZeroError = - Te.EditionAlreadyMintedError = - Te.DestinationMintMismatchError = - Te.MasterRecordMismatchError = - Te.TokenMintToFailedError = - Te.MaxEditionsMintedAlreadyError = - Te.EditionsMustHaveExactlyOneTokenError = - Te.MintMismatchError = - Te.UpdateAuthorityMustBeEqualToMetadataAuthorityAndSignerError = - Te.UriTooLongError = - Te.SymbolTooLongError = - Te.NameTooLongError = - Te.InvalidMintAuthorityError = - Te.NotMintAuthorityError = - Te.UpdateAuthorityIsNotSignerError = - Te.UpdateAuthorityIncorrectError = - Te.InvalidEditionKeyError = - Te.InvalidMetadataKeyError = - Te.UninitializedError = - Te.AlreadyInitializedError = - Te.NotRentExemptError = - Te.InstructionPackErrorError = - Te.InstructionUnpackErrorError = - void 0; - Te.RevokeCollectionAuthoritySignerIncorrectError = - Te.InvalidUserError = - Te.EditionOverrideCannotBeZeroError = - Te.NotAllowedToChangeSellerFeeBasisPointsError = - Te.CannotWipeVerifiedCreatorsError = - Te.CannotRemoveVerifiedCreatorError = - Te.CannotAdjustVerifiedCreatorError = - Te.InvalidDelegateError = - Te.InvalidFreezeAuthorityError = - Te.InvalidCollectionAuthorityRecordError = - Te.InvalidUseAuthorityRecordError = - Te.CollectionAuthorityDoesNotExistError = - Te.CollectionAuthorityRecordAlreadyExistsError = - Te.NotEnoughUsesError = - Te.UnusableError = - Te.UseAuthorityRecordAlreadyRevokedError = - Te.UseAuthorityRecordAlreadyExistsError = - Te.CollectionMustBeAUniqueMasterEditionError = - Te.InvalidCollectionUpdateAuthorityError = - Te.CollectionNotFoundError = - Te.CannotChangeUsesAfterFirstUseError = - Te.CannotChangeUseMethodAfterFirstUseError = - Te.InvalidUseMethodError = - Te.MustBeBurnedError = - Te.RemovedError = - Te.CollectionCannotBeVerifiedInThisInstructionError = - Te.IsMutableCanOnlyBeFlippedToFalseError = - Te.ReservationArrayShouldBeSizeOneError = - Te.InvalidEditionIndexError = - Te.OneTimeAuthMintSupplyMustBeZeroForConversionError = - Te.PrintingMintSupplyMustBeZeroForConversionError = - Te.InvalidOwnerError = - Te.InvalidOperationError = - Te.TriedToReplaceAnExistingReservationError = - Te.ReservationNotCompleteError = - Te.BeyondAlottedAddressSizeError = - Te.DataTypeMismatchError = - Te.InvalidTokenProgramError = - Te.ReservationSpotsRemainingShouldMatchTotalSpotsAtStartError = - Te.DuplicateCreatorAddressError = - Te.DataIsImmutableError = - Te.PrintingWouldBreachMaximumSupplyError = - Te.IncorrectOwnerError = - Te.SpotMismatchError = - Te.CannotUnverifyAnotherCreatorError = - Te.CannotVerifyAnotherCreatorError = - Te.AddressNotInReservationError = - Te.ReservationBreachesMaximumSupplyError = - Te.NumericalOverflowErrorError = - Te.BeyondMaxAddressSizeError = - void 0; - Te.errorFromName = - Te.errorFromCode = - Te.InvalidCollectionSizeChangeError = - Te.NoFreezeAuthoritySetError = - Te.BorshSerializationErrorError = - Te.InsufficientTokensError = - Te.MustBeNonFungibleError = - Te.InvalidSystemProgramError = - Te.MustBeEscrowAuthorityError = - Te.InvalidEscrowBumpSeedError = - Te.MustUnverifyError = - Te.EditionNumberGreaterThanMaxSupplyError = - Te.PrintEditionDoesNotMatchMasterEditionError = - Te.ReservationListDeprecatedError = - Te.InvalidEditionMarkerError = - Te.InvalidPrintEditionError = - Te.InvalidMasterEditionError = - Te.NotAPrintEditionError = - Te.AlreadyUnverifiedError = - Te.AlreadyVerifiedError = - Te.CollectionMasterEditionAccountInvalidError = - Te.CannotUpdateVerifiedCollectionError = - Te.BorshDeserializationErrorError = - Te.MasterEditionHasPrintsError = - Te.NotAMasterEditionError = - Te.MissingEditionAccountError = - Te.CouldNotDetermineTokenStandardError = - Te.NotACollectionParentError = - Te.NotVerifiedMemberOfCollectionError = - Te.NotAMemberOfCollectionError = - Te.MissingCollectionMetadataError = - Te.SizedCollectionError = - Te.UnsizedCollectionError = - Te.TokenCloseFailedError = - void 0; - var lt = new Map(), - ft = new Map(), - F6 = class extends Error { - constructor() { - super("Failed to unpack instruction data"), - (this.code = 0), - (this.name = "InstructionUnpackError"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, F6); - } - }; - Te.InstructionUnpackErrorError = F6; - lt.set(0, () => new F6()); - ft.set("InstructionUnpackError", () => new F6()); - var L6 = class extends Error { - constructor() { - super("Failed to pack instruction data"), - (this.code = 1), - (this.name = "InstructionPackError"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, L6); - } - }; - Te.InstructionPackErrorError = L6; - lt.set(1, () => new L6()); - ft.set("InstructionPackError", () => new L6()); - var q6 = class extends Error { - constructor() { - super("Lamport balance below rent-exempt threshold"), - (this.code = 2), - (this.name = "NotRentExempt"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, q6); - } - }; - Te.NotRentExemptError = q6; - lt.set(2, () => new q6()); - ft.set("NotRentExempt", () => new q6()); - var z6 = class extends Error { - constructor() { - super("Already initialized"), - (this.code = 3), - (this.name = "AlreadyInitialized"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, z6); - } - }; - Te.AlreadyInitializedError = z6; - lt.set(3, () => new z6()); - ft.set("AlreadyInitialized", () => new z6()); - var j6 = class extends Error { - constructor() { - super("Uninitialized"), - (this.code = 4), - (this.name = "Uninitialized"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, j6); - } - }; - Te.UninitializedError = j6; - lt.set(4, () => new j6()); - ft.set("Uninitialized", () => new j6()); - var U6 = class extends Error { - constructor() { - super( - " Metadata's key must match seed of ['metadata', program id, mint] provided" - ), - (this.code = 5), - (this.name = "InvalidMetadataKey"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, U6); - } - }; - Te.InvalidMetadataKeyError = U6; - lt.set(5, () => new U6()); - ft.set("InvalidMetadataKey", () => new U6()); - var K6 = class extends Error { - constructor() { - super( - "Edition's key must match seed of ['metadata', program id, name, 'edition'] provided" - ), - (this.code = 6), - (this.name = "InvalidEditionKey"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, K6); - } - }; - Te.InvalidEditionKeyError = K6; - lt.set(6, () => new K6()); - ft.set("InvalidEditionKey", () => new K6()); - var H6 = class extends Error { - constructor() { - super("Update Authority given does not match"), - (this.code = 7), - (this.name = "UpdateAuthorityIncorrect"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, H6); - } - }; - Te.UpdateAuthorityIncorrectError = H6; - lt.set(7, () => new H6()); - ft.set("UpdateAuthorityIncorrect", () => new H6()); - var V6 = class extends Error { - constructor() { - super("Update Authority needs to be signer to update metadata"), - (this.code = 8), - (this.name = "UpdateAuthorityIsNotSigner"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, V6); - } - }; - Te.UpdateAuthorityIsNotSignerError = V6; - lt.set(8, () => new V6()); - ft.set("UpdateAuthorityIsNotSigner", () => new V6()); - var W6 = class extends Error { - constructor() { - super("You must be the mint authority and signer on this transaction"), - (this.code = 9), - (this.name = "NotMintAuthority"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, W6); - } - }; - Te.NotMintAuthorityError = W6; - lt.set(9, () => new W6()); - ft.set("NotMintAuthority", () => new W6()); - var G6 = class extends Error { - constructor() { - super( - "Mint authority provided does not match the authority on the mint" - ), - (this.code = 10), - (this.name = "InvalidMintAuthority"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, G6); - } - }; - Te.InvalidMintAuthorityError = G6; - lt.set(10, () => new G6()); - ft.set("InvalidMintAuthority", () => new G6()); - var J6 = class extends Error { - constructor() { - super("Name too long"), - (this.code = 11), - (this.name = "NameTooLong"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, J6); - } - }; - Te.NameTooLongError = J6; - lt.set(11, () => new J6()); - ft.set("NameTooLong", () => new J6()); - var $6 = class extends Error { - constructor() { - super("Symbol too long"), - (this.code = 12), - (this.name = "SymbolTooLong"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, $6); - } - }; - Te.SymbolTooLongError = $6; - lt.set(12, () => new $6()); - ft.set("SymbolTooLong", () => new $6()); - var Z6 = class extends Error { - constructor() { - super("URI too long"), - (this.code = 13), - (this.name = "UriTooLong"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Z6); - } - }; - Te.UriTooLongError = Z6; - lt.set(13, () => new Z6()); - ft.set("UriTooLong", () => new Z6()); - var X6 = class extends Error { - constructor() { - super( - "Update authority must be equivalent to the metadata's authority and also signer of this transaction" - ), - (this.code = 14), - (this.name = - "UpdateAuthorityMustBeEqualToMetadataAuthorityAndSigner"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, X6); - } - }; - Te.UpdateAuthorityMustBeEqualToMetadataAuthorityAndSignerError = X6; - lt.set(14, () => new X6()); - ft.set( - "UpdateAuthorityMustBeEqualToMetadataAuthorityAndSigner", - () => new X6() - ); - var Y6 = class extends Error { - constructor() { - super("Mint given does not match mint on Metadata"), - (this.code = 15), - (this.name = "MintMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Y6); - } - }; - Te.MintMismatchError = Y6; - lt.set(15, () => new Y6()); - ft.set("MintMismatch", () => new Y6()); - var Q6 = class extends Error { - constructor() { - super("Editions must have exactly one token"), - (this.code = 16), - (this.name = "EditionsMustHaveExactlyOneToken"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Q6); - } - }; - Te.EditionsMustHaveExactlyOneTokenError = Q6; - lt.set(16, () => new Q6()); - ft.set("EditionsMustHaveExactlyOneToken", () => new Q6()); - var e8 = class extends Error { - constructor() { - super("Maximum editions printed already"), - (this.code = 17), - (this.name = "MaxEditionsMintedAlready"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, e8); - } - }; - Te.MaxEditionsMintedAlreadyError = e8; - lt.set(17, () => new e8()); - ft.set("MaxEditionsMintedAlready", () => new e8()); - var t8 = class extends Error { - constructor() { - super("Token mint to failed"), - (this.code = 18), - (this.name = "TokenMintToFailed"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, t8); - } - }; - Te.TokenMintToFailedError = t8; - lt.set(18, () => new t8()); - ft.set("TokenMintToFailed", () => new t8()); - var r8 = class extends Error { - constructor() { - super( - "The master edition record passed must match the master record on the edition given" - ), - (this.code = 19), - (this.name = "MasterRecordMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, r8); - } - }; - Te.MasterRecordMismatchError = r8; - lt.set(19, () => new r8()); - ft.set("MasterRecordMismatch", () => new r8()); - var n8 = class extends Error { - constructor() { - super("The destination account does not have the right mint"), - (this.code = 20), - (this.name = "DestinationMintMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, n8); - } - }; - Te.DestinationMintMismatchError = n8; - lt.set(20, () => new n8()); - ft.set("DestinationMintMismatch", () => new n8()); - var i8 = class extends Error { - constructor() { - super("An edition can only mint one of its kind!"), - (this.code = 21), - (this.name = "EditionAlreadyMinted"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, i8); - } - }; - Te.EditionAlreadyMintedError = i8; - lt.set(21, () => new i8()); - ft.set("EditionAlreadyMinted", () => new i8()); - var o8 = class extends Error { - constructor() { - super("Printing mint decimals should be zero"), - (this.code = 22), - (this.name = "PrintingMintDecimalsShouldBeZero"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, o8); - } - }; - Te.PrintingMintDecimalsShouldBeZeroError = o8; - lt.set(22, () => new o8()); - ft.set("PrintingMintDecimalsShouldBeZero", () => new o8()); - var a8 = class extends Error { - constructor() { - super("OneTimePrintingAuthorization mint decimals should be zero"), - (this.code = 23), - (this.name = "OneTimePrintingAuthorizationMintDecimalsShouldBeZero"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, a8); - } - }; - Te.OneTimePrintingAuthorizationMintDecimalsShouldBeZeroError = a8; - lt.set(23, () => new a8()); - ft.set( - "OneTimePrintingAuthorizationMintDecimalsShouldBeZero", - () => new a8() - ); - var s8 = class extends Error { - constructor() { - super("EditionMintDecimalsShouldBeZero"), - (this.code = 24), - (this.name = "EditionMintDecimalsShouldBeZero"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, s8); - } - }; - Te.EditionMintDecimalsShouldBeZeroError = s8; - lt.set(24, () => new s8()); - ft.set("EditionMintDecimalsShouldBeZero", () => new s8()); - var u8 = class extends Error { - constructor() { - super("Token burn failed"), - (this.code = 25), - (this.name = "TokenBurnFailed"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, u8); - } - }; - Te.TokenBurnFailedError = u8; - lt.set(25, () => new u8()); - ft.set("TokenBurnFailed", () => new u8()); - var c8 = class extends Error { - constructor() { - super( - "The One Time authorization mint does not match that on the token account!" - ), - (this.code = 26), - (this.name = "TokenAccountOneTimeAuthMintMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, c8); - } - }; - Te.TokenAccountOneTimeAuthMintMismatchError = c8; - lt.set(26, () => new c8()); - ft.set("TokenAccountOneTimeAuthMintMismatch", () => new c8()); - var l8 = class extends Error { - constructor() { - super("Derived key invalid"), - (this.code = 27), - (this.name = "DerivedKeyInvalid"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, l8); - } - }; - Te.DerivedKeyInvalidError = l8; - lt.set(27, () => new l8()); - ft.set("DerivedKeyInvalid", () => new l8()); - var f8 = class extends Error { - constructor() { - super("The Printing mint does not match that on the master edition!"), - (this.code = 28), - (this.name = "PrintingMintMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, f8); - } - }; - Te.PrintingMintMismatchError = f8; - lt.set(28, () => new f8()); - ft.set("PrintingMintMismatch", () => new f8()); - var d8 = class extends Error { - constructor() { - super( - "The One Time Printing Auth mint does not match that on the master edition!" - ), - (this.code = 29), - (this.name = "OneTimePrintingAuthMintMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, d8); - } - }; - Te.OneTimePrintingAuthMintMismatchError = d8; - lt.set(29, () => new d8()); - ft.set("OneTimePrintingAuthMintMismatch", () => new d8()); - var h8 = class extends Error { - constructor() { - super( - "The mint of the token account does not match the Printing mint!" - ), - (this.code = 30), - (this.name = "TokenAccountMintMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, h8); - } - }; - Te.TokenAccountMintMismatchError = h8; - lt.set(30, () => new h8()); - ft.set("TokenAccountMintMismatch", () => new h8()); - var p8 = class extends Error { - constructor() { - super( - "The mint of the token account does not match the master metadata mint!" - ), - (this.code = 31), - (this.name = "TokenAccountMintMismatchV2"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, p8); - } - }; - Te.TokenAccountMintMismatchV2Error = p8; - lt.set(31, () => new p8()); - ft.set("TokenAccountMintMismatchV2", () => new p8()); - var y8 = class extends Error { - constructor() { - super("Not enough tokens to mint a limited edition"), - (this.code = 32), - (this.name = "NotEnoughTokens"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, y8); - } - }; - Te.NotEnoughTokensError = y8; - lt.set(32, () => new y8()); - ft.set("NotEnoughTokens", () => new y8()); - var m8 = class extends Error { - constructor() { - super( - "The mint on your authorization token holding account does not match your Printing mint!" - ), - (this.code = 33), - (this.name = "PrintingMintAuthorizationAccountMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, m8); - } - }; - Te.PrintingMintAuthorizationAccountMismatchError = m8; - lt.set(33, () => new m8()); - ft.set("PrintingMintAuthorizationAccountMismatch", () => new m8()); - var g8 = class extends Error { - constructor() { - super( - "The authorization token account has a different owner than the update authority for the master edition!" - ), - (this.code = 34), - (this.name = "AuthorizationTokenAccountOwnerMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, g8); - } - }; - Te.AuthorizationTokenAccountOwnerMismatchError = g8; - lt.set(34, () => new g8()); - ft.set("AuthorizationTokenAccountOwnerMismatch", () => new g8()); - var v8 = class extends Error { - constructor() { - super("This feature is currently disabled."), - (this.code = 35), - (this.name = "Disabled"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, v8); - } - }; - Te.DisabledError = v8; - lt.set(35, () => new v8()); - ft.set("Disabled", () => new v8()); - var b8 = class extends Error { - constructor() { - super("Creators list too long"), - (this.code = 36), - (this.name = "CreatorsTooLong"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, b8); - } - }; - Te.CreatorsTooLongError = b8; - lt.set(36, () => new b8()); - ft.set("CreatorsTooLong", () => new b8()); - var w8 = class extends Error { - constructor() { - super("Creators must be at least one if set"), - (this.code = 37), - (this.name = "CreatorsMustBeAtleastOne"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, w8); - } - }; - Te.CreatorsMustBeAtleastOneError = w8; - lt.set(37, () => new w8()); - ft.set("CreatorsMustBeAtleastOne", () => new w8()); - var _8 = class extends Error { - constructor() { - super( - "If using a creators array, you must be one of the creators listed" - ), - (this.code = 38), - (this.name = "MustBeOneOfCreators"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, _8); - } - }; - Te.MustBeOneOfCreatorsError = _8; - lt.set(38, () => new _8()); - ft.set("MustBeOneOfCreators", () => new _8()); - var x8 = class extends Error { - constructor() { - super("This metadata does not have creators"), - (this.code = 39), - (this.name = "NoCreatorsPresentOnMetadata"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, x8); - } - }; - Te.NoCreatorsPresentOnMetadataError = x8; - lt.set(39, () => new x8()); - ft.set("NoCreatorsPresentOnMetadata", () => new x8()); - var S8 = class extends Error { - constructor() { - super("This creator address was not found"), - (this.code = 40), - (this.name = "CreatorNotFound"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, S8); - } - }; - Te.CreatorNotFoundError = S8; - lt.set(40, () => new S8()); - ft.set("CreatorNotFound", () => new S8()); - var A8 = class extends Error { - constructor() { - super("Basis points cannot be more than 10000"), - (this.code = 41), - (this.name = "InvalidBasisPoints"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, A8); - } - }; - Te.InvalidBasisPointsError = A8; - lt.set(41, () => new A8()); - ft.set("InvalidBasisPoints", () => new A8()); - var E8 = class extends Error { - constructor() { - super("Primary sale can only be flipped to true and is immutable"), - (this.code = 42), - (this.name = "PrimarySaleCanOnlyBeFlippedToTrue"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, E8); - } - }; - Te.PrimarySaleCanOnlyBeFlippedToTrueError = E8; - lt.set(42, () => new E8()); - ft.set("PrimarySaleCanOnlyBeFlippedToTrue", () => new E8()); - var M8 = class extends Error { - constructor() { - super("Owner does not match that on the account given"), - (this.code = 43), - (this.name = "OwnerMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, M8); - } - }; - Te.OwnerMismatchError = M8; - lt.set(43, () => new M8()); - ft.set("OwnerMismatch", () => new M8()); - var T8 = class extends Error { - constructor() { - super("This account has no tokens to be used for authorization"), - (this.code = 44), - (this.name = "NoBalanceInAccountForAuthorization"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, T8); - } - }; - Te.NoBalanceInAccountForAuthorizationError = T8; - lt.set(44, () => new T8()); - ft.set("NoBalanceInAccountForAuthorization", () => new T8()); - var k8 = class extends Error { - constructor() { - super("Share total must equal 100 for creator array"), - (this.code = 45), - (this.name = "ShareTotalMustBe100"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, k8); - } - }; - Te.ShareTotalMustBe100Error = k8; - lt.set(45, () => new k8()); - ft.set("ShareTotalMustBe100", () => new k8()); - var P8 = class extends Error { - constructor() { - super("This reservation list already exists!"), - (this.code = 46), - (this.name = "ReservationExists"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, P8); - } - }; - Te.ReservationExistsError = P8; - lt.set(46, () => new P8()); - ft.set("ReservationExists", () => new P8()); - var O8 = class extends Error { - constructor() { - super("This reservation list does not exist!"), - (this.code = 47), - (this.name = "ReservationDoesNotExist"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, O8); - } - }; - Te.ReservationDoesNotExistError = O8; - lt.set(47, () => new O8()); - ft.set("ReservationDoesNotExist", () => new O8()); - var B8 = class extends Error { - constructor() { - super( - "This reservation list exists but was never set with reservations" - ), - (this.code = 48), - (this.name = "ReservationNotSet"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, B8); - } - }; - Te.ReservationNotSetError = B8; - lt.set(48, () => new B8()); - ft.set("ReservationNotSet", () => new B8()); - var I8 = class extends Error { - constructor() { - super("This reservation list has already been set!"), - (this.code = 49), - (this.name = "ReservationAlreadyMade"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, I8); - } - }; - Te.ReservationAlreadyMadeError = I8; - lt.set(49, () => new I8()); - ft.set("ReservationAlreadyMade", () => new I8()); - var C8 = class extends Error { - constructor() { - super("Provided more addresses than max allowed in single reservation"), - (this.code = 50), - (this.name = "BeyondMaxAddressSize"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, C8); - } - }; - Te.BeyondMaxAddressSizeError = C8; - lt.set(50, () => new C8()); - ft.set("BeyondMaxAddressSize", () => new C8()); - var R8 = class extends Error { - constructor() { - super("NumericalOverflowError"), - (this.code = 51), - (this.name = "NumericalOverflowError"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, R8); - } - }; - Te.NumericalOverflowErrorError = R8; - lt.set(51, () => new R8()); - ft.set("NumericalOverflowError", () => new R8()); - var N8 = class extends Error { - constructor() { - super( - "This reservation would go beyond the maximum supply of the master edition!" - ), - (this.code = 52), - (this.name = "ReservationBreachesMaximumSupply"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, N8); - } - }; - Te.ReservationBreachesMaximumSupplyError = N8; - lt.set(52, () => new N8()); - ft.set("ReservationBreachesMaximumSupply", () => new N8()); - var D8 = class extends Error { - constructor() { - super("Address not in reservation!"), - (this.code = 53), - (this.name = "AddressNotInReservation"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, D8); - } - }; - Te.AddressNotInReservationError = D8; - lt.set(53, () => new D8()); - ft.set("AddressNotInReservation", () => new D8()); - var F8 = class extends Error { - constructor() { - super("You cannot unilaterally verify another creator, they must sign"), - (this.code = 54), - (this.name = "CannotVerifyAnotherCreator"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, F8); - } - }; - Te.CannotVerifyAnotherCreatorError = F8; - lt.set(54, () => new F8()); - ft.set("CannotVerifyAnotherCreator", () => new F8()); - var L8 = class extends Error { - constructor() { - super("You cannot unilaterally unverify another creator"), - (this.code = 55), - (this.name = "CannotUnverifyAnotherCreator"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, L8); - } - }; - Te.CannotUnverifyAnotherCreatorError = L8; - lt.set(55, () => new L8()); - ft.set("CannotUnverifyAnotherCreator", () => new L8()); - var q8 = class extends Error { - constructor() { - super( - "In initial reservation setting, spots remaining should equal total spots" - ), - (this.code = 56), - (this.name = "SpotMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, q8); - } - }; - Te.SpotMismatchError = q8; - lt.set(56, () => new q8()); - ft.set("SpotMismatch", () => new q8()); - var z8 = class extends Error { - constructor() { - super("Incorrect account owner"), - (this.code = 57), - (this.name = "IncorrectOwner"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, z8); - } - }; - Te.IncorrectOwnerError = z8; - lt.set(57, () => new z8()); - ft.set("IncorrectOwner", () => new z8()); - var j8 = class extends Error { - constructor() { - super( - "printing these tokens would breach the maximum supply limit of the master edition" - ), - (this.code = 58), - (this.name = "PrintingWouldBreachMaximumSupply"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, j8); - } - }; - Te.PrintingWouldBreachMaximumSupplyError = j8; - lt.set(58, () => new j8()); - ft.set("PrintingWouldBreachMaximumSupply", () => new j8()); - var U8 = class extends Error { - constructor() { - super("Data is immutable"), - (this.code = 59), - (this.name = "DataIsImmutable"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, U8); - } - }; - Te.DataIsImmutableError = U8; - lt.set(59, () => new U8()); - ft.set("DataIsImmutable", () => new U8()); - var K8 = class extends Error { - constructor() { - super("No duplicate creator addresses"), - (this.code = 60), - (this.name = "DuplicateCreatorAddress"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, K8); - } - }; - Te.DuplicateCreatorAddressError = K8; - lt.set(60, () => new K8()); - ft.set("DuplicateCreatorAddress", () => new K8()); - var H8 = class extends Error { - constructor() { - super( - "Reservation spots remaining should match total spots when first being created" - ), - (this.code = 61), - (this.name = "ReservationSpotsRemainingShouldMatchTotalSpotsAtStart"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, H8); - } - }; - Te.ReservationSpotsRemainingShouldMatchTotalSpotsAtStartError = H8; - lt.set(61, () => new H8()); - ft.set( - "ReservationSpotsRemainingShouldMatchTotalSpotsAtStart", - () => new H8() - ); - var V8 = class extends Error { - constructor() { - super("Invalid token program"), - (this.code = 62), - (this.name = "InvalidTokenProgram"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, V8); - } - }; - Te.InvalidTokenProgramError = V8; - lt.set(62, () => new V8()); - ft.set("InvalidTokenProgram", () => new V8()); - var W8 = class extends Error { - constructor() { - super("Data type mismatch"), - (this.code = 63), - (this.name = "DataTypeMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, W8); - } - }; - Te.DataTypeMismatchError = W8; - lt.set(63, () => new W8()); - ft.set("DataTypeMismatch", () => new W8()); - var G8 = class extends Error { - constructor() { - super("Beyond alotted address size in reservation!"), - (this.code = 64), - (this.name = "BeyondAlottedAddressSize"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, G8); - } - }; - Te.BeyondAlottedAddressSizeError = G8; - lt.set(64, () => new G8()); - ft.set("BeyondAlottedAddressSize", () => new G8()); - var J8 = class extends Error { - constructor() { - super("The reservation has only been partially alotted"), - (this.code = 65), - (this.name = "ReservationNotComplete"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, J8); - } - }; - Te.ReservationNotCompleteError = J8; - lt.set(65, () => new J8()); - ft.set("ReservationNotComplete", () => new J8()); - var $8 = class extends Error { - constructor() { - super("You cannot splice over an existing reservation!"), - (this.code = 66), - (this.name = "TriedToReplaceAnExistingReservation"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, $8); - } - }; - Te.TriedToReplaceAnExistingReservationError = $8; - lt.set(66, () => new $8()); - ft.set("TriedToReplaceAnExistingReservation", () => new $8()); - var Z8 = class extends Error { - constructor() { - super("Invalid operation"), - (this.code = 67), - (this.name = "InvalidOperation"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Z8); - } - }; - Te.InvalidOperationError = Z8; - lt.set(67, () => new Z8()); - ft.set("InvalidOperation", () => new Z8()); - var X8 = class extends Error { - constructor() { - super("Invalid Owner"), - (this.code = 68), - (this.name = "InvalidOwner"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, X8); - } - }; - Te.InvalidOwnerError = X8; - lt.set(68, () => new X8()); - ft.set("InvalidOwner", () => new X8()); - var Y8 = class extends Error { - constructor() { - super("Printing mint supply must be zero for conversion"), - (this.code = 69), - (this.name = "PrintingMintSupplyMustBeZeroForConversion"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Y8); - } - }; - Te.PrintingMintSupplyMustBeZeroForConversionError = Y8; - lt.set(69, () => new Y8()); - ft.set("PrintingMintSupplyMustBeZeroForConversion", () => new Y8()); - var Q8 = class extends Error { - constructor() { - super("One Time Auth mint supply must be zero for conversion"), - (this.code = 70), - (this.name = "OneTimeAuthMintSupplyMustBeZeroForConversion"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Q8); - } - }; - Te.OneTimeAuthMintSupplyMustBeZeroForConversionError = Q8; - lt.set(70, () => new Q8()); - ft.set("OneTimeAuthMintSupplyMustBeZeroForConversion", () => new Q8()); - var ek = class extends Error { - constructor() { - super( - "You tried to insert one edition too many into an edition mark pda" - ), - (this.code = 71), - (this.name = "InvalidEditionIndex"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, ek); - } - }; - Te.InvalidEditionIndexError = ek; - lt.set(71, () => new ek()); - ft.set("InvalidEditionIndex", () => new ek()); - var tk = class extends Error { - constructor() { - super( - "In the legacy system the reservation needs to be of size one for cpu limit reasons" - ), - (this.code = 72), - (this.name = "ReservationArrayShouldBeSizeOne"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, tk); - } - }; - Te.ReservationArrayShouldBeSizeOneError = tk; - lt.set(72, () => new tk()); - ft.set("ReservationArrayShouldBeSizeOne", () => new tk()); - var rk = class extends Error { - constructor() { - super("Is Mutable can only be flipped to false"), - (this.code = 73), - (this.name = "IsMutableCanOnlyBeFlippedToFalse"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, rk); - } - }; - Te.IsMutableCanOnlyBeFlippedToFalseError = rk; - lt.set(73, () => new rk()); - ft.set("IsMutableCanOnlyBeFlippedToFalse", () => new rk()); - var nk = class extends Error { - constructor() { - super("Cannont Verify Collection in this Instruction"), - (this.code = 74), - (this.name = "CollectionCannotBeVerifiedInThisInstruction"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, nk); - } - }; - Te.CollectionCannotBeVerifiedInThisInstructionError = nk; - lt.set(74, () => new nk()); - ft.set("CollectionCannotBeVerifiedInThisInstruction", () => new nk()); - var ik = class extends Error { - constructor() { - super( - "This instruction was deprecated in a previous release and is now removed" - ), - (this.code = 75), - (this.name = "Removed"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, ik); - } - }; - Te.RemovedError = ik; - lt.set(75, () => new ik()); - ft.set("Removed", () => new ik()); - var ok = class extends Error { - constructor() { - super( - "This token use method is burn and there are no remaining uses, it must be burned" - ), - (this.code = 76), - (this.name = "MustBeBurned"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, ok); - } - }; - Te.MustBeBurnedError = ok; - lt.set(76, () => new ok()); - ft.set("MustBeBurned", () => new ok()); - var ak = class extends Error { - constructor() { - super("This use method is invalid"), - (this.code = 77), - (this.name = "InvalidUseMethod"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, ak); - } - }; - Te.InvalidUseMethodError = ak; - lt.set(77, () => new ak()); - ft.set("InvalidUseMethod", () => new ak()); - var sk = class extends Error { - constructor() { - super("Cannot Change Use Method after the first use"), - (this.code = 78), - (this.name = "CannotChangeUseMethodAfterFirstUse"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, sk); - } - }; - Te.CannotChangeUseMethodAfterFirstUseError = sk; - lt.set(78, () => new sk()); - ft.set("CannotChangeUseMethodAfterFirstUse", () => new sk()); - var uk = class extends Error { - constructor() { - super("Cannot Change Remaining or Available uses after the first use"), - (this.code = 79), - (this.name = "CannotChangeUsesAfterFirstUse"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, uk); - } - }; - Te.CannotChangeUsesAfterFirstUseError = uk; - lt.set(79, () => new uk()); - ft.set("CannotChangeUsesAfterFirstUse", () => new uk()); - var ck = class extends Error { - constructor() { - super("Collection Not Found on Metadata"), - (this.code = 80), - (this.name = "CollectionNotFound"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, ck); - } - }; - Te.CollectionNotFoundError = ck; - lt.set(80, () => new ck()); - ft.set("CollectionNotFound", () => new ck()); - var lk = class extends Error { - constructor() { - super("Collection Update Authority is invalid"), - (this.code = 81), - (this.name = "InvalidCollectionUpdateAuthority"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, lk); - } - }; - Te.InvalidCollectionUpdateAuthorityError = lk; - lt.set(81, () => new lk()); - ft.set("InvalidCollectionUpdateAuthority", () => new lk()); - var fk = class extends Error { - constructor() { - super("Collection Must Be a Unique Master Edition v2"), - (this.code = 82), - (this.name = "CollectionMustBeAUniqueMasterEdition"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, fk); - } - }; - Te.CollectionMustBeAUniqueMasterEditionError = fk; - lt.set(82, () => new fk()); - ft.set("CollectionMustBeAUniqueMasterEdition", () => new fk()); - var dk = class extends Error { - constructor() { - super( - "The Use Authority Record Already Exists, to modify it Revoke, then Approve" - ), - (this.code = 83), - (this.name = "UseAuthorityRecordAlreadyExists"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, dk); - } - }; - Te.UseAuthorityRecordAlreadyExistsError = dk; - lt.set(83, () => new dk()); - ft.set("UseAuthorityRecordAlreadyExists", () => new dk()); - var hk = class extends Error { - constructor() { - super("The Use Authority Record is empty or already revoked"), - (this.code = 84), - (this.name = "UseAuthorityRecordAlreadyRevoked"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, hk); - } - }; - Te.UseAuthorityRecordAlreadyRevokedError = hk; - lt.set(84, () => new hk()); - ft.set("UseAuthorityRecordAlreadyRevoked", () => new hk()); - var pk = class extends Error { - constructor() { - super("This token has no uses"), - (this.code = 85), - (this.name = "Unusable"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, pk); - } - }; - Te.UnusableError = pk; - lt.set(85, () => new pk()); - ft.set("Unusable", () => new pk()); - var yk = class extends Error { - constructor() { - super("There are not enough Uses left on this token."), - (this.code = 86), - (this.name = "NotEnoughUses"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, yk); - } - }; - Te.NotEnoughUsesError = yk; - lt.set(86, () => new yk()); - ft.set("NotEnoughUses", () => new yk()); - var mk = class extends Error { - constructor() { - super("This Collection Authority Record Already Exists."), - (this.code = 87), - (this.name = "CollectionAuthorityRecordAlreadyExists"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, mk); - } - }; - Te.CollectionAuthorityRecordAlreadyExistsError = mk; - lt.set(87, () => new mk()); - ft.set("CollectionAuthorityRecordAlreadyExists", () => new mk()); - var gk = class extends Error { - constructor() { - super("This Collection Authority Record Does Not Exist."), - (this.code = 88), - (this.name = "CollectionAuthorityDoesNotExist"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, gk); - } - }; - Te.CollectionAuthorityDoesNotExistError = gk; - lt.set(88, () => new gk()); - ft.set("CollectionAuthorityDoesNotExist", () => new gk()); - var vk = class extends Error { - constructor() { - super("This Use Authority Record is invalid."), - (this.code = 89), - (this.name = "InvalidUseAuthorityRecord"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, vk); - } - }; - Te.InvalidUseAuthorityRecordError = vk; - lt.set(89, () => new vk()); - ft.set("InvalidUseAuthorityRecord", () => new vk()); - var bk = class extends Error { - constructor() { - super("This Collection Authority Record is invalid."), - (this.code = 90), - (this.name = "InvalidCollectionAuthorityRecord"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, bk); - } - }; - Te.InvalidCollectionAuthorityRecordError = bk; - lt.set(90, () => new bk()); - ft.set("InvalidCollectionAuthorityRecord", () => new bk()); - var wk = class extends Error { - constructor() { - super("Metadata does not match the freeze authority on the mint"), - (this.code = 91), - (this.name = "InvalidFreezeAuthority"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, wk); - } - }; - Te.InvalidFreezeAuthorityError = wk; - lt.set(91, () => new wk()); - ft.set("InvalidFreezeAuthority", () => new wk()); - var _k = class extends Error { - constructor() { - super( - "All tokens in this account have not been delegated to this user." - ), - (this.code = 92), - (this.name = "InvalidDelegate"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, _k); - } - }; - Te.InvalidDelegateError = _k; - lt.set(92, () => new _k()); - ft.set("InvalidDelegate", () => new _k()); - var xk = class extends Error { - constructor() { - super("Creator can not be adjusted once they are verified."), - (this.code = 93), - (this.name = "CannotAdjustVerifiedCreator"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, xk); - } - }; - Te.CannotAdjustVerifiedCreatorError = xk; - lt.set(93, () => new xk()); - ft.set("CannotAdjustVerifiedCreator", () => new xk()); - var Sk = class extends Error { - constructor() { - super("Verified creators cannot be removed."), - (this.code = 94), - (this.name = "CannotRemoveVerifiedCreator"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Sk); - } - }; - Te.CannotRemoveVerifiedCreatorError = Sk; - lt.set(94, () => new Sk()); - ft.set("CannotRemoveVerifiedCreator", () => new Sk()); - var Ak = class extends Error { - constructor() { - super("Can not wipe verified creators."), - (this.code = 95), - (this.name = "CannotWipeVerifiedCreators"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Ak); - } - }; - Te.CannotWipeVerifiedCreatorsError = Ak; - lt.set(95, () => new Ak()); - ft.set("CannotWipeVerifiedCreators", () => new Ak()); - var Ek = class extends Error { - constructor() { - super("Not allowed to change seller fee basis points."), - (this.code = 96), - (this.name = "NotAllowedToChangeSellerFeeBasisPoints"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Ek); - } - }; - Te.NotAllowedToChangeSellerFeeBasisPointsError = Ek; - lt.set(96, () => new Ek()); - ft.set("NotAllowedToChangeSellerFeeBasisPoints", () => new Ek()); - var Mk = class extends Error { - constructor() { - super("Edition override cannot be zero"), - (this.code = 97), - (this.name = "EditionOverrideCannotBeZero"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Mk); - } - }; - Te.EditionOverrideCannotBeZeroError = Mk; - lt.set(97, () => new Mk()); - ft.set("EditionOverrideCannotBeZero", () => new Mk()); - var Tk = class extends Error { - constructor() { - super("Invalid User"), - (this.code = 98), - (this.name = "InvalidUser"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Tk); - } - }; - Te.InvalidUserError = Tk; - lt.set(98, () => new Tk()); - ft.set("InvalidUser", () => new Tk()); - var kk = class extends Error { - constructor() { - super("Revoke Collection Authority signer is incorrect"), - (this.code = 99), - (this.name = "RevokeCollectionAuthoritySignerIncorrect"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, kk); - } - }; - Te.RevokeCollectionAuthoritySignerIncorrectError = kk; - lt.set(99, () => new kk()); - ft.set("RevokeCollectionAuthoritySignerIncorrect", () => new kk()); - var Pk = class extends Error { - constructor() { - super("Token close failed"), - (this.code = 100), - (this.name = "TokenCloseFailed"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Pk); - } - }; - Te.TokenCloseFailedError = Pk; - lt.set(100, () => new Pk()); - ft.set("TokenCloseFailed", () => new Pk()); - var Ok = class extends Error { - constructor() { - super("Can't use this function on unsized collection"), - (this.code = 101), - (this.name = "UnsizedCollection"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Ok); - } - }; - Te.UnsizedCollectionError = Ok; - lt.set(101, () => new Ok()); - ft.set("UnsizedCollection", () => new Ok()); - var Bk = class extends Error { - constructor() { - super("Can't use this function on a sized collection"), - (this.code = 102), - (this.name = "SizedCollection"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Bk); - } - }; - Te.SizedCollectionError = Bk; - lt.set(102, () => new Bk()); - ft.set("SizedCollection", () => new Bk()); - var Ik = class extends Error { - constructor() { - super( - "Can't burn a verified member of a collection w/o providing collection metadata account" - ), - (this.code = 103), - (this.name = "MissingCollectionMetadata"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Ik); - } - }; - Te.MissingCollectionMetadataError = Ik; - lt.set(103, () => new Ik()); - ft.set("MissingCollectionMetadata", () => new Ik()); - var Ck = class extends Error { - constructor() { - super("This NFT is not a member of the specified collection."), - (this.code = 104), - (this.name = "NotAMemberOfCollection"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Ck); - } - }; - Te.NotAMemberOfCollectionError = Ck; - lt.set(104, () => new Ck()); - ft.set("NotAMemberOfCollection", () => new Ck()); - var Rk = class extends Error { - constructor() { - super("This NFT is not a verified member of the specified collection."), - (this.code = 105), - (this.name = "NotVerifiedMemberOfCollection"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Rk); - } - }; - Te.NotVerifiedMemberOfCollectionError = Rk; - lt.set(105, () => new Rk()); - ft.set("NotVerifiedMemberOfCollection", () => new Rk()); - var Nk = class extends Error { - constructor() { - super("This NFT is not a collection parent NFT."), - (this.code = 106), - (this.name = "NotACollectionParent"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Nk); - } - }; - Te.NotACollectionParentError = Nk; - lt.set(106, () => new Nk()); - ft.set("NotACollectionParent", () => new Nk()); - var Dk = class extends Error { - constructor() { - super("Could not determine a TokenStandard type."), - (this.code = 107), - (this.name = "CouldNotDetermineTokenStandard"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Dk); - } - }; - Te.CouldNotDetermineTokenStandardError = Dk; - lt.set(107, () => new Dk()); - ft.set("CouldNotDetermineTokenStandard", () => new Dk()); - var Fk = class extends Error { - constructor() { - super("This mint account has an edition but none was provided."), - (this.code = 108), - (this.name = "MissingEditionAccount"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Fk); - } - }; - Te.MissingEditionAccountError = Fk; - lt.set(108, () => new Fk()); - ft.set("MissingEditionAccount", () => new Fk()); - var Lk = class extends Error { - constructor() { - super("This edition is not a Master Edition"), - (this.code = 109), - (this.name = "NotAMasterEdition"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Lk); - } - }; - Te.NotAMasterEditionError = Lk; - lt.set(109, () => new Lk()); - ft.set("NotAMasterEdition", () => new Lk()); - var qk = class extends Error { - constructor() { - super("This Master Edition has existing prints"), - (this.code = 110), - (this.name = "MasterEditionHasPrints"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, qk); - } - }; - Te.MasterEditionHasPrintsError = qk; - lt.set(110, () => new qk()); - ft.set("MasterEditionHasPrints", () => new qk()); - var zk = class extends Error { - constructor() { - super("Borsh Deserialization Error"), - (this.code = 111), - (this.name = "BorshDeserializationError"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, zk); - } - }; - Te.BorshDeserializationErrorError = zk; - lt.set(111, () => new zk()); - ft.set("BorshDeserializationError", () => new zk()); - var jk = class extends Error { - constructor() { - super("Cannot update a verified colleciton in this command"), - (this.code = 112), - (this.name = "CannotUpdateVerifiedCollection"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, jk); - } - }; - Te.CannotUpdateVerifiedCollectionError = jk; - lt.set(112, () => new jk()); - ft.set("CannotUpdateVerifiedCollection", () => new jk()); - var Uk = class extends Error { - constructor() { - super("Edition account doesnt match collection "), - (this.code = 113), - (this.name = "CollectionMasterEditionAccountInvalid"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Uk); - } - }; - Te.CollectionMasterEditionAccountInvalidError = Uk; - lt.set(113, () => new Uk()); - ft.set("CollectionMasterEditionAccountInvalid", () => new Uk()); - var Kk = class extends Error { - constructor() { - super("Item is already verified."), - (this.code = 114), - (this.name = "AlreadyVerified"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Kk); - } - }; - Te.AlreadyVerifiedError = Kk; - lt.set(114, () => new Kk()); - ft.set("AlreadyVerified", () => new Kk()); - var Hk = class extends Error { - constructor() { - super("Item is already unverified."), - (this.code = 115), - (this.name = "AlreadyUnverified"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Hk); - } - }; - Te.AlreadyUnverifiedError = Hk; - lt.set(115, () => new Hk()); - ft.set("AlreadyUnverified", () => new Hk()); - var Vk = class extends Error { - constructor() { - super("This edition is not a Print Edition"), - (this.code = 116), - (this.name = "NotAPrintEdition"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Vk); - } - }; - Te.NotAPrintEditionError = Vk; - lt.set(116, () => new Vk()); - ft.set("NotAPrintEdition", () => new Vk()); - var Wk = class extends Error { - constructor() { - super("Invalid Master Edition"), - (this.code = 117), - (this.name = "InvalidMasterEdition"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Wk); - } - }; - Te.InvalidMasterEditionError = Wk; - lt.set(117, () => new Wk()); - ft.set("InvalidMasterEdition", () => new Wk()); - var Gk = class extends Error { - constructor() { - super("Invalid Print Edition"), - (this.code = 118), - (this.name = "InvalidPrintEdition"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Gk); - } - }; - Te.InvalidPrintEditionError = Gk; - lt.set(118, () => new Gk()); - ft.set("InvalidPrintEdition", () => new Gk()); - var Jk = class extends Error { - constructor() { - super("Invalid Edition Marker"), - (this.code = 119), - (this.name = "InvalidEditionMarker"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Jk); - } - }; - Te.InvalidEditionMarkerError = Jk; - lt.set(119, () => new Jk()); - ft.set("InvalidEditionMarker", () => new Jk()); - var $k = class extends Error { - constructor() { - super("Reservation List is Deprecated"), - (this.code = 120), - (this.name = "ReservationListDeprecated"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, $k); - } - }; - Te.ReservationListDeprecatedError = $k; - lt.set(120, () => new $k()); - ft.set("ReservationListDeprecated", () => new $k()); - var Zk = class extends Error { - constructor() { - super("Print Edition does not match Master Edition"), - (this.code = 121), - (this.name = "PrintEditionDoesNotMatchMasterEdition"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Zk); - } - }; - Te.PrintEditionDoesNotMatchMasterEditionError = Zk; - lt.set(121, () => new Zk()); - ft.set("PrintEditionDoesNotMatchMasterEdition", () => new Zk()); - var Xk = class extends Error { - constructor() { - super("Edition Number greater than max supply"), - (this.code = 122), - (this.name = "EditionNumberGreaterThanMaxSupply"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Xk); - } - }; - Te.EditionNumberGreaterThanMaxSupplyError = Xk; - lt.set(122, () => new Xk()); - ft.set("EditionNumberGreaterThanMaxSupply", () => new Xk()); - var Yk = class extends Error { - constructor() { - super("Must unverify before migrating collections."), - (this.code = 123), - (this.name = "MustUnverify"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Yk); - } - }; - Te.MustUnverifyError = Yk; - lt.set(123, () => new Yk()); - ft.set("MustUnverify", () => new Yk()); - var Qk = class extends Error { - constructor() { - super("Invalid Escrow Account Bump Seed"), - (this.code = 124), - (this.name = "InvalidEscrowBumpSeed"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Qk); - } - }; - Te.InvalidEscrowBumpSeedError = Qk; - lt.set(124, () => new Qk()); - ft.set("InvalidEscrowBumpSeed", () => new Qk()); - var eP = class extends Error { - constructor() { - super("Must Escrow Authority"), - (this.code = 125), - (this.name = "MustBeEscrowAuthority"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, eP); - } - }; - Te.MustBeEscrowAuthorityError = eP; - lt.set(125, () => new eP()); - ft.set("MustBeEscrowAuthority", () => new eP()); - var tP = class extends Error { - constructor() { - super("Invalid System Program"), - (this.code = 126), - (this.name = "InvalidSystemProgram"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, tP); - } - }; - Te.InvalidSystemProgramError = tP; - lt.set(126, () => new tP()); - ft.set("InvalidSystemProgram", () => new tP()); - var rP = class extends Error { - constructor() { - super("Must be a Non Fungible Token"), - (this.code = 127), - (this.name = "MustBeNonFungible"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, rP); - } - }; - Te.MustBeNonFungibleError = rP; - lt.set(127, () => new rP()); - ft.set("MustBeNonFungible", () => new rP()); - var nP = class extends Error { - constructor() { - super("Insufficient tokens for transfer"), - (this.code = 128), - (this.name = "InsufficientTokens"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, nP); - } - }; - Te.InsufficientTokensError = nP; - lt.set(128, () => new nP()); - ft.set("InsufficientTokens", () => new nP()); - var iP = class extends Error { - constructor() { - super("Borsh Serialization Error"), - (this.code = 129), - (this.name = "BorshSerializationError"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, iP); - } - }; - Te.BorshSerializationErrorError = iP; - lt.set(129, () => new iP()); - ft.set("BorshSerializationError", () => new iP()); - var oP = class extends Error { - constructor() { - super("Cannot create NFT with no Freeze Authority."), - (this.code = 130), - (this.name = "NoFreezeAuthoritySet"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, oP); - } - }; - Te.NoFreezeAuthoritySetError = oP; - lt.set(130, () => new oP()); - ft.set("NoFreezeAuthoritySet", () => new oP()); - var aP = class extends Error { - constructor() { - super("Invalid collection size change"), - (this.code = 131), - (this.name = "InvalidCollectionSizeChange"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, aP); - } - }; - Te.InvalidCollectionSizeChangeError = aP; - lt.set(131, () => new aP()); - ft.set("InvalidCollectionSizeChange", () => new aP()); - function bCr(t) { - let e = lt.get(t); - return e != null ? e() : null; - } - Te.errorFromCode = bCr; - function wCr(t) { - let e = ft.get(t); - return e != null ? e() : null; - } - Te.errorFromName = wCr; - }); - var Wwt = I((Ml) => { - "use strict"; - m(); - g(); - var _Cr = - (Ml && Ml.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - xCr = - (Ml && Ml.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Vwt = - (Ml && Ml.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - _Cr(e, t, r); - return xCr(e, t), e; - }; - Object.defineProperty(Ml, "__esModule", { value: !0 }); - Ml.createApproveCollectionAuthorityInstruction = - Ml.approveCollectionAuthorityInstructionDiscriminator = - Ml.ApproveCollectionAuthorityStruct = - void 0; - var Hwt = Vwt(Wt()), - E8e = Vwt(Le()); - Ml.ApproveCollectionAuthorityStruct = new Hwt.BeetArgsStruct( - [["instructionDiscriminator", Hwt.u8]], - "ApproveCollectionAuthorityInstructionArgs" - ); - Ml.approveCollectionAuthorityInstructionDiscriminator = 23; - function SCr( - t, - e = new E8e.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - var r; - let [n] = Ml.ApproveCollectionAuthorityStruct.serialize({ - instructionDiscriminator: - Ml.approveCollectionAuthorityInstructionDiscriminator, - }), - i = [ - { pubkey: t.collectionAuthorityRecord, isWritable: !0, isSigner: !1 }, - { pubkey: t.newCollectionAuthority, isWritable: !1, isSigner: !1 }, - { pubkey: t.updateAuthority, isWritable: !0, isSigner: !0 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.mint, isWritable: !1, isSigner: !1 }, - { - pubkey: - (r = t.systemProgram) !== null && r !== void 0 - ? r - : E8e.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - ]; - return ( - t.rent != null && - i.push({ pubkey: t.rent, isWritable: !1, isSigner: !1 }), - new E8e.TransactionInstruction({ programId: e, keys: i, data: n }) - ); - } - Ml.createApproveCollectionAuthorityInstruction = SCr; - }); - var Bs = I((JH) => { - "use strict"; - m(); - g(); - Object.defineProperty(JH, "__esModule", { value: !0 }); - JH.TokenInstruction = void 0; - var ACr; - (function (t) { - (t[(t.InitializeMint = 0)] = "InitializeMint"), - (t[(t.InitializeAccount = 1)] = "InitializeAccount"), - (t[(t.InitializeMultisig = 2)] = "InitializeMultisig"), - (t[(t.Transfer = 3)] = "Transfer"), - (t[(t.Approve = 4)] = "Approve"), - (t[(t.Revoke = 5)] = "Revoke"), - (t[(t.SetAuthority = 6)] = "SetAuthority"), - (t[(t.MintTo = 7)] = "MintTo"), - (t[(t.Burn = 8)] = "Burn"), - (t[(t.CloseAccount = 9)] = "CloseAccount"), - (t[(t.FreezeAccount = 10)] = "FreezeAccount"), - (t[(t.ThawAccount = 11)] = "ThawAccount"), - (t[(t.TransferChecked = 12)] = "TransferChecked"), - (t[(t.ApproveChecked = 13)] = "ApproveChecked"), - (t[(t.MintToChecked = 14)] = "MintToChecked"), - (t[(t.BurnChecked = 15)] = "BurnChecked"), - (t[(t.InitializeAccount2 = 16)] = "InitializeAccount2"), - (t[(t.SyncNative = 17)] = "SyncNative"), - (t[(t.InitializeAccount3 = 18)] = "InitializeAccount3"), - (t[(t.InitializeMultisig2 = 19)] = "InitializeMultisig2"), - (t[(t.InitializeMint2 = 20)] = "InitializeMint2"); - })((ACr = JH.TokenInstruction || (JH.TokenInstruction = {}))); - }); - var t9 = I((Kae) => { - "use strict"; - m(); - g(); - Object.defineProperty(Kae, "__esModule", { value: !0 }); - Kae.encodeDecode = void 0; - var ECr = (t) => { - let e = t.decode.bind(t), - r = t.encode.bind(t); - return { decode: e, encode: r }; - }; - Kae.encodeDecode = ECr; - }); - var M8e = I((Qi) => { - "use strict"; - m(); - g(); - Object.defineProperty(Qi, "__esModule", { value: !0 }); - Qi.u256be = - Qi.u256 = - Qi.u192be = - Qi.u192 = - Qi.u128be = - Qi.u128 = - Qi.u64be = - Qi.u64 = - Qi.bigIntBE = - Qi.bigInt = - void 0; - var Gwt = Sn(), - Hae = uY(), - Jwt = t9(), - MCr = (t) => (e) => { - let r = (0, Gwt.blob)(t, e), - { encode: n, decode: i } = (0, Jwt.encodeDecode)(r), - o = r; - return ( - (o.decode = (a, s) => { - let c = i(a, s); - return (0, Hae.toBigIntLE)(Buffer.from(c)); - }), - (o.encode = (a, s, c) => { - let u = (0, Hae.toBufferLE)(a, t); - return n(u, s, c); - }), - o - ); - }; - Qi.bigInt = MCr; - var TCr = (t) => (e) => { - let r = (0, Gwt.blob)(t, e), - { encode: n, decode: i } = (0, Jwt.encodeDecode)(r), - o = r; - return ( - (o.decode = (a, s) => { - let c = i(a, s); - return (0, Hae.toBigIntBE)(Buffer.from(c)); - }), - (o.encode = (a, s, c) => { - let u = (0, Hae.toBufferBE)(a, t); - return n(u, s, c); - }), - o - ); - }; - Qi.bigIntBE = TCr; - Qi.u64 = (0, Qi.bigInt)(8); - Qi.u64be = (0, Qi.bigIntBE)(8); - Qi.u128 = (0, Qi.bigInt)(16); - Qi.u128be = (0, Qi.bigIntBE)(16); - Qi.u192 = (0, Qi.bigInt)(24); - Qi.u192be = (0, Qi.bigIntBE)(24); - Qi.u256 = (0, Qi.bigInt)(32); - Qi.u256be = (0, Qi.bigIntBE)(32); - }); - var Zwt = I((v1) => { - "use strict"; - m(); - g(); - var kCr = - (v1 && v1.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(v1, "__esModule", { value: !0 }); - v1.decimal = v1.WAD = void 0; - var $wt = kCr(Sy()), - PCr = t9(), - OCr = M8e(); - v1.WAD = new $wt.default("1e+18"); - var BCr = (t) => { - let e = (0, OCr.u128)(t), - { encode: r, decode: n } = (0, PCr.encodeDecode)(e), - i = e; - return ( - (i.decode = (o, a) => { - let s = n(o, a).toString(); - return new $wt.default(s).div(v1.WAD); - }), - (i.encode = (o, a, s) => { - let c = BigInt(o.times(v1.WAD).integerValue().toString()); - return r(c, a, s); - }), - i - ); - }; - v1.decimal = BCr; - }); - var Xwt = I((Vae) => { - "use strict"; - m(); - g(); - Object.defineProperty(Vae, "__esModule", { value: !0 }); - Vae.bool = void 0; - var ICr = Sn(), - CCr = t9(), - RCr = (t) => { - let e = (0, ICr.u8)(t), - { encode: r, decode: n } = (0, CCr.encodeDecode)(e), - i = e; - return ( - (i.decode = (o, a) => !!n(o, a)), - (i.encode = (o, a, s) => { - let c = Number(o); - return r(c, a, s); - }), - i - ); - }; - Vae.bool = RCr; - }); - var Ywt = I((Wae) => { - "use strict"; - m(); - g(); - Object.defineProperty(Wae, "__esModule", { value: !0 }); - Wae.publicKey = void 0; - var NCr = Sn(), - DCr = Le(), - FCr = t9(), - LCr = (t) => { - let e = (0, NCr.blob)(32, t), - { encode: r, decode: n } = (0, FCr.encodeDecode)(e), - i = e; - return ( - (i.decode = (o, a) => { - let s = n(o, a); - return new DCr.PublicKey(s); - }), - (i.encode = (o, a, s) => { - let c = o.toBuffer(); - return r(c, a, s); - }), - i - ); - }; - Wae.publicKey = LCr; - }); - var ep = I((Pg) => { - "use strict"; - m(); - g(); - var qCr = - (Pg && Pg.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - $H = - (Pg && Pg.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - qCr(e, t, r); - }; - Object.defineProperty(Pg, "__esModule", { value: !0 }); - $H(t9(), Pg); - $H(M8e(), Pg); - $H(Zwt(), Pg); - $H(Xwt(), Pg); - $H(Ywt(), Pg); - }); - var sn = I((UE) => { - "use strict"; - m(); - g(); - Object.defineProperty(UE, "__esModule", { value: !0 }); - UE.NATIVE_MINT = - UE.ASSOCIATED_TOKEN_PROGRAM_ID = - UE.TOKEN_PROGRAM_ID = - void 0; - var T8e = Le(); - UE.TOKEN_PROGRAM_ID = new T8e.PublicKey( - "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA" - ); - UE.ASSOCIATED_TOKEN_PROGRAM_ID = new T8e.PublicKey( - "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL" - ); - UE.NATIVE_MINT = new T8e.PublicKey( - "So11111111111111111111111111111111111111112" - ); - }); - var fa = I((la) => { - "use strict"; - m(); - g(); - Object.defineProperty(la, "__esModule", { value: !0 }); - la.TokenInvalidInstructionTypeError = - la.TokenInvalidInstructionDataError = - la.TokenInvalidInstructionKeysError = - la.TokenInvalidInstructionProgramError = - la.TokenOwnerOffCurveError = - la.TokenInvalidOwnerError = - la.TokenInvalidMintError = - la.TokenInvalidAccountSizeError = - la.TokenInvalidAccountOwnerError = - la.TokenAccountNotFoundError = - la.TokenError = - void 0; - var h0 = class extends Error { - constructor(e) { - super(e); - } - }; - la.TokenError = h0; - var k8e = class extends h0 { - constructor() { - super(...arguments), (this.name = "TokenAccountNotFoundError"); - } - }; - la.TokenAccountNotFoundError = k8e; - var P8e = class extends h0 { - constructor() { - super(...arguments), (this.name = "TokenInvalidAccountOwnerError"); - } - }; - la.TokenInvalidAccountOwnerError = P8e; - var O8e = class extends h0 { - constructor() { - super(...arguments), (this.name = "TokenInvalidAccountSizeError"); - } - }; - la.TokenInvalidAccountSizeError = O8e; - var B8e = class extends h0 { - constructor() { - super(...arguments), (this.name = "TokenInvalidMintError"); - } - }; - la.TokenInvalidMintError = B8e; - var I8e = class extends h0 { - constructor() { - super(...arguments), (this.name = "TokenInvalidOwnerError"); - } - }; - la.TokenInvalidOwnerError = I8e; - var C8e = class extends h0 { - constructor() { - super(...arguments), (this.name = "TokenOwnerOffCurveError"); - } - }; - la.TokenOwnerOffCurveError = C8e; - var R8e = class extends h0 { - constructor() { - super(...arguments), - (this.name = "TokenInvalidInstructionProgramError"); - } - }; - la.TokenInvalidInstructionProgramError = R8e; - var N8e = class extends h0 { - constructor() { - super(...arguments), (this.name = "TokenInvalidInstructionKeysError"); - } - }; - la.TokenInvalidInstructionKeysError = N8e; - var D8e = class extends h0 { - constructor() { - super(...arguments), (this.name = "TokenInvalidInstructionDataError"); - } - }; - la.TokenInvalidInstructionDataError = D8e; - var F8e = class extends h0 { - constructor() { - super(...arguments), (this.name = "TokenInvalidInstructionTypeError"); - } - }; - la.TokenInvalidInstructionTypeError = F8e; - }); - var q8e = I((tp) => { - "use strict"; - m(); - g(); - Object.defineProperty(tp, "__esModule", { value: !0 }); - tp.decodeInitializeMintInstructionUnchecked = - tp.decodeInitializeMintInstruction = - tp.createInitializeMintInstruction = - tp.initializeMintInstructionData = - void 0; - var Gae = Sn(), - Qwt = ep(), - L8e = Le(), - e_t = sn(), - Jae = fa(), - t_t = Bs(); - tp.initializeMintInstructionData = (0, Gae.struct)([ - (0, Gae.u8)("instruction"), - (0, Gae.u8)("decimals"), - (0, Qwt.publicKey)("mintAuthority"), - (0, Gae.u8)("freezeAuthorityOption"), - (0, Qwt.publicKey)("freezeAuthority"), - ]); - function zCr(t, e, r, n, i = e_t.TOKEN_PROGRAM_ID) { - let o = [ - { pubkey: t, isSigner: !1, isWritable: !0 }, - { pubkey: L8e.SYSVAR_RENT_PUBKEY, isSigner: !1, isWritable: !1 }, - ], - a = Buffer.alloc(tp.initializeMintInstructionData.span); - return ( - tp.initializeMintInstructionData.encode( - { - instruction: t_t.TokenInstruction.InitializeMint, - decimals: e, - mintAuthority: r, - freezeAuthorityOption: n ? 1 : 0, - freezeAuthority: n || new L8e.PublicKey(0), - }, - a - ), - new L8e.TransactionInstruction({ keys: o, programId: i, data: a }) - ); - } - tp.createInitializeMintInstruction = zCr; - function jCr(t, e = e_t.TOKEN_PROGRAM_ID) { - if (!t.programId.equals(e)) - throw new Jae.TokenInvalidInstructionProgramError(); - if (t.data.length !== tp.initializeMintInstructionData.span) - throw new Jae.TokenInvalidInstructionDataError(); - let { - keys: { mint: r, rent: n }, - data: i, - } = r_t(t); - if (i.instruction !== t_t.TokenInstruction.InitializeMint) - throw new Jae.TokenInvalidInstructionTypeError(); - if (!r || !n) throw new Jae.TokenInvalidInstructionKeysError(); - return { programId: e, keys: { mint: r, rent: n }, data: i }; - } - tp.decodeInitializeMintInstruction = jCr; - function r_t({ programId: t, keys: [e, r], data: n }) { - let { - instruction: i, - decimals: o, - mintAuthority: a, - freezeAuthorityOption: s, - freezeAuthority: c, - } = tp.initializeMintInstructionData.decode(n); - return { - programId: t, - keys: { mint: e, rent: r }, - data: { - instruction: i, - decimals: o, - mintAuthority: a, - freezeAuthority: s ? c : null, - }, - }; - } - tp.decodeInitializeMintInstructionUnchecked = r_t; - }); - var z8e = I((rp) => { - "use strict"; - m(); - g(); - Object.defineProperty(rp, "__esModule", { value: !0 }); - rp.decodeInitializeAccountInstructionUnchecked = - rp.decodeInitializeAccountInstruction = - rp.createInitializeAccountInstruction = - rp.initializeAccountInstructionData = - void 0; - var n_t = Sn(), - i_t = Le(), - o_t = sn(), - $ae = fa(), - a_t = Bs(); - rp.initializeAccountInstructionData = (0, n_t.struct)([ - (0, n_t.u8)("instruction"), - ]); - function UCr(t, e, r, n = o_t.TOKEN_PROGRAM_ID) { - let i = [ - { pubkey: t, isSigner: !1, isWritable: !0 }, - { pubkey: e, isSigner: !1, isWritable: !1 }, - { pubkey: r, isSigner: !1, isWritable: !1 }, - { pubkey: i_t.SYSVAR_RENT_PUBKEY, isSigner: !1, isWritable: !1 }, - ], - o = Buffer.alloc(rp.initializeAccountInstructionData.span); - return ( - rp.initializeAccountInstructionData.encode( - { instruction: a_t.TokenInstruction.InitializeAccount }, - o - ), - new i_t.TransactionInstruction({ keys: i, programId: n, data: o }) - ); - } - rp.createInitializeAccountInstruction = UCr; - function KCr(t, e = o_t.TOKEN_PROGRAM_ID) { - if (!t.programId.equals(e)) - throw new $ae.TokenInvalidInstructionProgramError(); - if (t.data.length !== rp.initializeAccountInstructionData.span) - throw new $ae.TokenInvalidInstructionDataError(); - let { - keys: { account: r, mint: n, owner: i, rent: o }, - data: a, - } = s_t(t); - if (a.instruction !== a_t.TokenInstruction.InitializeAccount) - throw new $ae.TokenInvalidInstructionTypeError(); - if (!r || !n || !i || !o) - throw new $ae.TokenInvalidInstructionKeysError(); - return { - programId: e, - keys: { account: r, mint: n, owner: i, rent: o }, - data: a, - }; - } - rp.decodeInitializeAccountInstruction = KCr; - function s_t({ programId: t, keys: [e, r, n, i], data: o }) { - return { - programId: t, - keys: { account: e, mint: r, owner: n, rent: i }, - data: rp.initializeAccountInstructionData.decode(o), - }; - } - rp.decodeInitializeAccountInstructionUnchecked = s_t; - }); - var U8e = I((np) => { - "use strict"; - m(); - g(); - Object.defineProperty(np, "__esModule", { value: !0 }); - np.decodeInitializeMultisigInstructionUnchecked = - np.decodeInitializeMultisigInstruction = - np.createInitializeMultisigInstruction = - np.initializeMultisigInstructionData = - void 0; - var j8e = Sn(), - u_t = Le(), - c_t = sn(), - Zae = fa(), - l_t = Bs(); - np.initializeMultisigInstructionData = (0, j8e.struct)([ - (0, j8e.u8)("instruction"), - (0, j8e.u8)("m"), - ]); - function HCr(t, e, r, n = c_t.TOKEN_PROGRAM_ID) { - let i = [ - { pubkey: t, isSigner: !1, isWritable: !0 }, - { pubkey: u_t.SYSVAR_RENT_PUBKEY, isSigner: !1, isWritable: !1 }, - ]; - for (let a of e) i.push({ pubkey: a, isSigner: !1, isWritable: !1 }); - let o = Buffer.alloc(np.initializeMultisigInstructionData.span); - return ( - np.initializeMultisigInstructionData.encode( - { instruction: l_t.TokenInstruction.InitializeMultisig, m: r }, - o - ), - new u_t.TransactionInstruction({ keys: i, programId: n, data: o }) - ); - } - np.createInitializeMultisigInstruction = HCr; - function VCr(t, e = c_t.TOKEN_PROGRAM_ID) { - if (!t.programId.equals(e)) - throw new Zae.TokenInvalidInstructionProgramError(); - if (t.data.length !== np.initializeMultisigInstructionData.span) - throw new Zae.TokenInvalidInstructionDataError(); - let { - keys: { account: r, rent: n, signers: i }, - data: o, - } = f_t(t); - if (o.instruction !== l_t.TokenInstruction.InitializeMultisig) - throw new Zae.TokenInvalidInstructionTypeError(); - if (!r || !n || !i.length) - throw new Zae.TokenInvalidInstructionKeysError(); - return { - programId: e, - keys: { account: r, rent: n, signers: i }, - data: o, - }; - } - np.decodeInitializeMultisigInstruction = VCr; - function f_t({ programId: t, keys: [e, r, ...n], data: i }) { - return { - programId: t, - keys: { account: e, rent: r, signers: n }, - data: np.initializeMultisigInstructionData.decode(i), - }; - } - np.decodeInitializeMultisigInstructionUnchecked = f_t; - }); - var ip = I((Xae) => { - "use strict"; - m(); - g(); - Object.defineProperty(Xae, "__esModule", { value: !0 }); - Xae.addSigners = void 0; - function WCr(t, e, r) { - if (r.length) { - t.push({ pubkey: e, isSigner: !1, isWritable: !1 }); - for (let n of r) - t.push({ pubkey: n.publicKey, isSigner: !0, isWritable: !1 }); - } else t.push({ pubkey: e, isSigner: !0, isWritable: !1 }); - return t; - } - Xae.addSigners = WCr; - }); - var K8e = I((op) => { - "use strict"; - m(); - g(); - Object.defineProperty(op, "__esModule", { value: !0 }); - op.decodeTransferInstructionUnchecked = - op.decodeTransferInstruction = - op.createTransferInstruction = - op.transferInstructionData = - void 0; - var d_t = Sn(), - GCr = ep(), - JCr = Le(), - h_t = sn(), - Yae = fa(), - $Cr = ip(), - p_t = Bs(); - op.transferInstructionData = (0, d_t.struct)([ - (0, d_t.u8)("instruction"), - (0, GCr.u64)("amount"), - ]); - function ZCr(t, e, r, n, i = [], o = h_t.TOKEN_PROGRAM_ID) { - let a = (0, $Cr.addSigners)( - [ - { pubkey: t, isSigner: !1, isWritable: !0 }, - { pubkey: e, isSigner: !1, isWritable: !0 }, - ], - r, - i - ), - s = Buffer.alloc(op.transferInstructionData.span); - return ( - op.transferInstructionData.encode( - { instruction: p_t.TokenInstruction.Transfer, amount: BigInt(n) }, - s - ), - new JCr.TransactionInstruction({ keys: a, programId: o, data: s }) - ); - } - op.createTransferInstruction = ZCr; - function XCr(t, e = h_t.TOKEN_PROGRAM_ID) { - if (!t.programId.equals(e)) - throw new Yae.TokenInvalidInstructionProgramError(); - if (t.data.length !== op.transferInstructionData.span) - throw new Yae.TokenInvalidInstructionDataError(); - let { - keys: { source: r, destination: n, owner: i, multiSigners: o }, - data: a, - } = y_t(t); - if (a.instruction !== p_t.TokenInstruction.Transfer) - throw new Yae.TokenInvalidInstructionTypeError(); - if (!r || !n || !i) throw new Yae.TokenInvalidInstructionKeysError(); - return { - programId: e, - keys: { source: r, destination: n, owner: i, multiSigners: o }, - data: a, - }; - } - op.decodeTransferInstruction = XCr; - function y_t({ programId: t, keys: [e, r, n, ...i], data: o }) { - return { - programId: t, - keys: { source: e, destination: r, owner: n, multiSigners: i }, - data: op.transferInstructionData.decode(o), - }; - } - op.decodeTransferInstructionUnchecked = y_t; - }); - var H8e = I((ap) => { - "use strict"; - m(); - g(); - Object.defineProperty(ap, "__esModule", { value: !0 }); - ap.decodeApproveInstructionUnchecked = - ap.decodeApproveInstruction = - ap.createApproveInstruction = - ap.approveInstructionData = - void 0; - var m_t = Sn(), - YCr = ep(), - QCr = Le(), - g_t = sn(), - Qae = fa(), - eRr = ip(), - v_t = Bs(); - ap.approveInstructionData = (0, m_t.struct)([ - (0, m_t.u8)("instruction"), - (0, YCr.u64)("amount"), - ]); - function tRr(t, e, r, n, i = [], o = g_t.TOKEN_PROGRAM_ID) { - let a = (0, eRr.addSigners)( - [ - { pubkey: t, isSigner: !1, isWritable: !0 }, - { pubkey: e, isSigner: !1, isWritable: !1 }, - ], - r, - i - ), - s = Buffer.alloc(ap.approveInstructionData.span); - return ( - ap.approveInstructionData.encode( - { instruction: v_t.TokenInstruction.Approve, amount: BigInt(n) }, - s - ), - new QCr.TransactionInstruction({ keys: a, programId: o, data: s }) - ); - } - ap.createApproveInstruction = tRr; - function rRr(t, e = g_t.TOKEN_PROGRAM_ID) { - if (!t.programId.equals(e)) - throw new Qae.TokenInvalidInstructionProgramError(); - if (t.data.length !== ap.approveInstructionData.span) - throw new Qae.TokenInvalidInstructionDataError(); - let { - keys: { account: r, delegate: n, owner: i, multiSigners: o }, - data: a, - } = b_t(t); - if (a.instruction !== v_t.TokenInstruction.Approve) - throw new Qae.TokenInvalidInstructionTypeError(); - if (!r || !n || !i) throw new Qae.TokenInvalidInstructionKeysError(); - return { - programId: e, - keys: { account: r, delegate: n, owner: i, multiSigners: o }, - data: a, - }; - } - ap.decodeApproveInstruction = rRr; - function b_t({ programId: t, keys: [e, r, n, ...i], data: o }) { - return { - programId: t, - keys: { account: e, delegate: r, owner: n, multiSigners: i }, - data: ap.approveInstructionData.decode(o), - }; - } - ap.decodeApproveInstructionUnchecked = b_t; - }); - var V8e = I((sp) => { - "use strict"; - m(); - g(); - Object.defineProperty(sp, "__esModule", { value: !0 }); - sp.decodeRevokeInstructionUnchecked = - sp.decodeRevokeInstruction = - sp.createRevokeInstruction = - sp.revokeInstructionData = - void 0; - var w_t = Sn(), - nRr = Le(), - __t = sn(), - ese = fa(), - iRr = ip(), - x_t = Bs(); - sp.revokeInstructionData = (0, w_t.struct)([(0, w_t.u8)("instruction")]); - function oRr(t, e, r = [], n = __t.TOKEN_PROGRAM_ID) { - let i = (0, iRr.addSigners)( - [{ pubkey: t, isSigner: !1, isWritable: !0 }], - e, - r - ), - o = Buffer.alloc(sp.revokeInstructionData.span); - return ( - sp.revokeInstructionData.encode( - { instruction: x_t.TokenInstruction.Revoke }, - o - ), - new nRr.TransactionInstruction({ keys: i, programId: n, data: o }) - ); - } - sp.createRevokeInstruction = oRr; - function aRr(t, e = __t.TOKEN_PROGRAM_ID) { - if (!t.programId.equals(e)) - throw new ese.TokenInvalidInstructionProgramError(); - if (t.data.length !== sp.revokeInstructionData.span) - throw new ese.TokenInvalidInstructionDataError(); - let { - keys: { account: r, owner: n, multiSigners: i }, - data: o, - } = S_t(t); - if (o.instruction !== x_t.TokenInstruction.Revoke) - throw new ese.TokenInvalidInstructionTypeError(); - if (!r || !n) throw new ese.TokenInvalidInstructionKeysError(); - return { - programId: e, - keys: { account: r, owner: n, multiSigners: i }, - data: o, - }; - } - sp.decodeRevokeInstruction = aRr; - function S_t({ programId: t, keys: [e, r, ...n], data: i }) { - return { - programId: t, - keys: { account: e, owner: r, multiSigners: n }, - data: sp.revokeInstructionData.decode(i), - }; - } - sp.decodeRevokeInstructionUnchecked = S_t; - }); - var W8e = I((_c) => { - "use strict"; - m(); - g(); - Object.defineProperty(_c, "__esModule", { value: !0 }); - _c.decodeSetAuthorityInstructionUnchecked = - _c.decodeSetAuthorityInstruction = - _c.createSetAuthorityInstruction = - _c.setAuthorityInstructionData = - _c.AuthorityType = - void 0; - var tse = Sn(), - sRr = ep(), - A_t = Le(), - E_t = sn(), - rse = fa(), - uRr = ip(), - M_t = Bs(), - cRr; - (function (t) { - (t[(t.MintTokens = 0)] = "MintTokens"), - (t[(t.FreezeAccount = 1)] = "FreezeAccount"), - (t[(t.AccountOwner = 2)] = "AccountOwner"), - (t[(t.CloseAccount = 3)] = "CloseAccount"); - })((cRr = _c.AuthorityType || (_c.AuthorityType = {}))); - _c.setAuthorityInstructionData = (0, tse.struct)([ - (0, tse.u8)("instruction"), - (0, tse.u8)("authorityType"), - (0, tse.u8)("newAuthorityOption"), - (0, sRr.publicKey)("newAuthority"), - ]); - function lRr(t, e, r, n, i = [], o = E_t.TOKEN_PROGRAM_ID) { - let a = (0, uRr.addSigners)( - [{ pubkey: t, isSigner: !1, isWritable: !0 }], - e, - i - ), - s = Buffer.alloc(_c.setAuthorityInstructionData.span); - return ( - _c.setAuthorityInstructionData.encode( - { - instruction: M_t.TokenInstruction.SetAuthority, - authorityType: r, - newAuthorityOption: n ? 1 : 0, - newAuthority: n || new A_t.PublicKey(0), - }, - s - ), - new A_t.TransactionInstruction({ keys: a, programId: o, data: s }) - ); - } - _c.createSetAuthorityInstruction = lRr; - function fRr(t, e = E_t.TOKEN_PROGRAM_ID) { - if (!t.programId.equals(e)) - throw new rse.TokenInvalidInstructionProgramError(); - if (t.data.length !== _c.setAuthorityInstructionData.span) - throw new rse.TokenInvalidInstructionDataError(); - let { - keys: { account: r, currentAuthority: n, multiSigners: i }, - data: o, - } = T_t(t); - if (o.instruction !== M_t.TokenInstruction.SetAuthority) - throw new rse.TokenInvalidInstructionTypeError(); - if (!r || !n) throw new rse.TokenInvalidInstructionKeysError(); - return { - programId: e, - keys: { account: r, currentAuthority: n, multiSigners: i }, - data: o, - }; - } - _c.decodeSetAuthorityInstruction = fRr; - function T_t({ programId: t, keys: [e, r, ...n], data: i }) { - let { - instruction: o, - authorityType: a, - newAuthorityOption: s, - newAuthority: c, - } = _c.setAuthorityInstructionData.decode(i); - return { - programId: t, - keys: { account: e, currentAuthority: r, multiSigners: n }, - data: { instruction: o, authorityType: a, newAuthority: s ? c : null }, - }; - } - _c.decodeSetAuthorityInstructionUnchecked = T_t; - }); - var G8e = I((up) => { - "use strict"; - m(); - g(); - Object.defineProperty(up, "__esModule", { value: !0 }); - up.decodeMintToInstructionUnchecked = - up.decodeMintToInstruction = - up.createMintToInstruction = - up.mintToInstructionData = - void 0; - var k_t = Sn(), - dRr = ep(), - hRr = Le(), - P_t = sn(), - nse = fa(), - pRr = ip(), - O_t = Bs(); - up.mintToInstructionData = (0, k_t.struct)([ - (0, k_t.u8)("instruction"), - (0, dRr.u64)("amount"), - ]); - function yRr(t, e, r, n, i = [], o = P_t.TOKEN_PROGRAM_ID) { - let a = (0, pRr.addSigners)( - [ - { pubkey: t, isSigner: !1, isWritable: !0 }, - { pubkey: e, isSigner: !1, isWritable: !0 }, - ], - r, - i - ), - s = Buffer.alloc(up.mintToInstructionData.span); - return ( - up.mintToInstructionData.encode( - { instruction: O_t.TokenInstruction.MintTo, amount: BigInt(n) }, - s - ), - new hRr.TransactionInstruction({ keys: a, programId: o, data: s }) - ); - } - up.createMintToInstruction = yRr; - function mRr(t, e = P_t.TOKEN_PROGRAM_ID) { - if (!t.programId.equals(e)) - throw new nse.TokenInvalidInstructionProgramError(); - if (t.data.length !== up.mintToInstructionData.span) - throw new nse.TokenInvalidInstructionDataError(); - let { - keys: { mint: r, destination: n, authority: i, multiSigners: o }, - data: a, - } = B_t(t); - if (a.instruction !== O_t.TokenInstruction.MintTo) - throw new nse.TokenInvalidInstructionTypeError(); - if (!r || !n || !i) throw new nse.TokenInvalidInstructionKeysError(); - return { - programId: e, - keys: { mint: r, destination: n, authority: i, multiSigners: o }, - data: a, - }; - } - up.decodeMintToInstruction = mRr; - function B_t({ programId: t, keys: [e, r, n, ...i], data: o }) { - return { - programId: t, - keys: { mint: e, destination: r, authority: n, multiSigners: i }, - data: up.mintToInstructionData.decode(o), - }; - } - up.decodeMintToInstructionUnchecked = B_t; - }); - var J8e = I((cp) => { - "use strict"; - m(); - g(); - Object.defineProperty(cp, "__esModule", { value: !0 }); - cp.decodeBurnInstructionUnchecked = - cp.decodeBurnInstruction = - cp.createBurnInstruction = - cp.burnInstructionData = - void 0; - var I_t = Sn(), - gRr = ep(), - vRr = Le(), - C_t = sn(), - ise = fa(), - bRr = ip(), - R_t = Bs(); - cp.burnInstructionData = (0, I_t.struct)([ - (0, I_t.u8)("instruction"), - (0, gRr.u64)("amount"), - ]); - function wRr(t, e, r, n, i = [], o = C_t.TOKEN_PROGRAM_ID) { - let a = (0, bRr.addSigners)( - [ - { pubkey: t, isSigner: !1, isWritable: !0 }, - { pubkey: e, isSigner: !1, isWritable: !0 }, - ], - r, - i - ), - s = Buffer.alloc(cp.burnInstructionData.span); - return ( - cp.burnInstructionData.encode( - { instruction: R_t.TokenInstruction.Burn, amount: BigInt(n) }, - s - ), - new vRr.TransactionInstruction({ keys: a, programId: o, data: s }) - ); - } - cp.createBurnInstruction = wRr; - function _Rr(t, e = C_t.TOKEN_PROGRAM_ID) { - if (!t.programId.equals(e)) - throw new ise.TokenInvalidInstructionProgramError(); - if (t.data.length !== cp.burnInstructionData.span) - throw new ise.TokenInvalidInstructionDataError(); - let { - keys: { account: r, mint: n, owner: i, multiSigners: o }, - data: a, - } = N_t(t); - if (a.instruction !== R_t.TokenInstruction.Burn) - throw new ise.TokenInvalidInstructionTypeError(); - if (!r || !n || !i) throw new ise.TokenInvalidInstructionKeysError(); - return { - programId: e, - keys: { account: r, mint: n, owner: i, multiSigners: o }, - data: a, - }; - } - cp.decodeBurnInstruction = _Rr; - function N_t({ programId: t, keys: [e, r, n, ...i], data: o }) { - return { - programId: t, - keys: { account: e, mint: r, owner: n, multiSigners: i }, - data: cp.burnInstructionData.decode(o), - }; - } - cp.decodeBurnInstructionUnchecked = N_t; - }); - var $8e = I((lp) => { - "use strict"; - m(); - g(); - Object.defineProperty(lp, "__esModule", { value: !0 }); - lp.decodeCloseAccountInstructionUnchecked = - lp.decodeCloseAccountInstruction = - lp.createCloseAccountInstruction = - lp.closeAccountInstructionData = - void 0; - var D_t = Sn(), - xRr = Le(), - F_t = sn(), - ose = fa(), - SRr = ip(), - L_t = Bs(); - lp.closeAccountInstructionData = (0, D_t.struct)([ - (0, D_t.u8)("instruction"), - ]); - function ARr(t, e, r, n = [], i = F_t.TOKEN_PROGRAM_ID) { - let o = (0, SRr.addSigners)( - [ - { pubkey: t, isSigner: !1, isWritable: !0 }, - { pubkey: e, isSigner: !1, isWritable: !0 }, - ], - r, - n - ), - a = Buffer.alloc(lp.closeAccountInstructionData.span); - return ( - lp.closeAccountInstructionData.encode( - { instruction: L_t.TokenInstruction.CloseAccount }, - a - ), - new xRr.TransactionInstruction({ keys: o, programId: i, data: a }) - ); - } - lp.createCloseAccountInstruction = ARr; - function ERr(t, e = F_t.TOKEN_PROGRAM_ID) { - if (!t.programId.equals(e)) - throw new ose.TokenInvalidInstructionProgramError(); - if (t.data.length !== lp.closeAccountInstructionData.span) - throw new ose.TokenInvalidInstructionDataError(); - let { - keys: { account: r, destination: n, authority: i, multiSigners: o }, - data: a, - } = q_t(t); - if (a.instruction !== L_t.TokenInstruction.CloseAccount) - throw new ose.TokenInvalidInstructionTypeError(); - if (!r || !n || !i) throw new ose.TokenInvalidInstructionKeysError(); - return { - programId: e, - keys: { account: r, destination: n, authority: i, multiSigners: o }, - data: a, - }; - } - lp.decodeCloseAccountInstruction = ERr; - function q_t({ programId: t, keys: [e, r, n, ...i], data: o }) { - return { - programId: t, - keys: { account: e, destination: r, authority: n, multiSigners: i }, - data: lp.closeAccountInstructionData.decode(o), - }; - } - lp.decodeCloseAccountInstructionUnchecked = q_t; - }); - var Z8e = I((fp) => { - "use strict"; - m(); - g(); - Object.defineProperty(fp, "__esModule", { value: !0 }); - fp.decodeFreezeAccountInstructionUnchecked = - fp.decodeFreezeAccountInstruction = - fp.createFreezeAccountInstruction = - fp.freezeAccountInstructionData = - void 0; - var z_t = Sn(), - MRr = Le(), - j_t = sn(), - ase = fa(), - TRr = ip(), - U_t = Bs(); - fp.freezeAccountInstructionData = (0, z_t.struct)([ - (0, z_t.u8)("instruction"), - ]); - function kRr(t, e, r, n = [], i = j_t.TOKEN_PROGRAM_ID) { - let o = (0, TRr.addSigners)( - [ - { pubkey: t, isSigner: !1, isWritable: !0 }, - { pubkey: e, isSigner: !1, isWritable: !1 }, - ], - r, - n - ), - a = Buffer.alloc(fp.freezeAccountInstructionData.span); - return ( - fp.freezeAccountInstructionData.encode( - { instruction: U_t.TokenInstruction.FreezeAccount }, - a - ), - new MRr.TransactionInstruction({ keys: o, programId: i, data: a }) - ); - } - fp.createFreezeAccountInstruction = kRr; - function PRr(t, e = j_t.TOKEN_PROGRAM_ID) { - if (!t.programId.equals(e)) - throw new ase.TokenInvalidInstructionProgramError(); - if (t.data.length !== fp.freezeAccountInstructionData.span) - throw new ase.TokenInvalidInstructionDataError(); - let { - keys: { account: r, mint: n, authority: i, multiSigners: o }, - data: a, - } = K_t(t); - if (a.instruction !== U_t.TokenInstruction.FreezeAccount) - throw new ase.TokenInvalidInstructionTypeError(); - if (!r || !n || !i) throw new ase.TokenInvalidInstructionKeysError(); - return { - programId: e, - keys: { account: r, mint: n, authority: i, multiSigners: o }, - data: a, - }; - } - fp.decodeFreezeAccountInstruction = PRr; - function K_t({ programId: t, keys: [e, r, n, ...i], data: o }) { - return { - programId: t, - keys: { account: e, mint: r, authority: n, multiSigners: i }, - data: fp.freezeAccountInstructionData.decode(o), - }; - } - fp.decodeFreezeAccountInstructionUnchecked = K_t; - }); - var X8e = I((dp) => { - "use strict"; - m(); - g(); - Object.defineProperty(dp, "__esModule", { value: !0 }); - dp.decodeThawAccountInstructionUnchecked = - dp.decodeThawAccountInstruction = - dp.createThawAccountInstruction = - dp.thawAccountInstructionData = - void 0; - var H_t = Sn(), - ORr = Le(), - V_t = sn(), - sse = fa(), - BRr = ip(), - W_t = Bs(); - dp.thawAccountInstructionData = (0, H_t.struct)([ - (0, H_t.u8)("instruction"), - ]); - function IRr(t, e, r, n = [], i = V_t.TOKEN_PROGRAM_ID) { - let o = (0, BRr.addSigners)( - [ - { pubkey: t, isSigner: !1, isWritable: !0 }, - { pubkey: e, isSigner: !1, isWritable: !1 }, - ], - r, - n - ), - a = Buffer.alloc(dp.thawAccountInstructionData.span); - return ( - dp.thawAccountInstructionData.encode( - { instruction: W_t.TokenInstruction.ThawAccount }, - a - ), - new ORr.TransactionInstruction({ keys: o, programId: i, data: a }) - ); - } - dp.createThawAccountInstruction = IRr; - function CRr(t, e = V_t.TOKEN_PROGRAM_ID) { - if (!t.programId.equals(e)) - throw new sse.TokenInvalidInstructionProgramError(); - if (t.data.length !== dp.thawAccountInstructionData.span) - throw new sse.TokenInvalidInstructionDataError(); - let { - keys: { account: r, mint: n, authority: i, multiSigners: o }, - data: a, - } = G_t(t); - if (a.instruction !== W_t.TokenInstruction.ThawAccount) - throw new sse.TokenInvalidInstructionTypeError(); - if (!r || !n || !i) throw new sse.TokenInvalidInstructionKeysError(); - return { - programId: e, - keys: { account: r, mint: n, authority: i, multiSigners: o }, - data: a, - }; - } - dp.decodeThawAccountInstruction = CRr; - function G_t({ programId: t, keys: [e, r, n, ...i], data: o }) { - return { - programId: t, - keys: { account: e, mint: r, authority: n, multiSigners: i }, - data: dp.thawAccountInstructionData.decode(o), - }; - } - dp.decodeThawAccountInstructionUnchecked = G_t; - }); - var Q8e = I((hp) => { - "use strict"; - m(); - g(); - Object.defineProperty(hp, "__esModule", { value: !0 }); - hp.decodeTransferCheckedInstructionUnchecked = - hp.decodeTransferCheckedInstruction = - hp.createTransferCheckedInstruction = - hp.transferCheckedInstructionData = - void 0; - var Y8e = Sn(), - RRr = ep(), - NRr = Le(), - J_t = sn(), - use = fa(), - DRr = ip(), - $_t = Bs(); - hp.transferCheckedInstructionData = (0, Y8e.struct)([ - (0, Y8e.u8)("instruction"), - (0, RRr.u64)("amount"), - (0, Y8e.u8)("decimals"), - ]); - function FRr(t, e, r, n, i, o, a = [], s = J_t.TOKEN_PROGRAM_ID) { - let c = (0, DRr.addSigners)( - [ - { pubkey: t, isSigner: !1, isWritable: !0 }, - { pubkey: e, isSigner: !1, isWritable: !1 }, - { pubkey: r, isSigner: !1, isWritable: !0 }, - ], - n, - a - ), - u = Buffer.alloc(hp.transferCheckedInstructionData.span); - return ( - hp.transferCheckedInstructionData.encode( - { - instruction: $_t.TokenInstruction.TransferChecked, - amount: BigInt(i), - decimals: o, - }, - u - ), - new NRr.TransactionInstruction({ keys: c, programId: s, data: u }) - ); - } - hp.createTransferCheckedInstruction = FRr; - function LRr(t, e = J_t.TOKEN_PROGRAM_ID) { - if (!t.programId.equals(e)) - throw new use.TokenInvalidInstructionProgramError(); - if (t.data.length !== hp.transferCheckedInstructionData.span) - throw new use.TokenInvalidInstructionDataError(); - let { - keys: { source: r, mint: n, destination: i, owner: o, multiSigners: a }, - data: s, - } = Z_t(t); - if (s.instruction !== $_t.TokenInstruction.TransferChecked) - throw new use.TokenInvalidInstructionTypeError(); - if (!r || !n || !i || !o) - throw new use.TokenInvalidInstructionKeysError(); - return { - programId: e, - keys: { source: r, mint: n, destination: i, owner: o, multiSigners: a }, - data: s, - }; - } - hp.decodeTransferCheckedInstruction = LRr; - function Z_t({ programId: t, keys: [e, r, n, i, ...o], data: a }) { - return { - programId: t, - keys: { source: e, mint: r, destination: n, owner: i, multiSigners: o }, - data: hp.transferCheckedInstructionData.decode(a), - }; - } - hp.decodeTransferCheckedInstructionUnchecked = Z_t; - }); - var tke = I((pp) => { - "use strict"; - m(); - g(); - Object.defineProperty(pp, "__esModule", { value: !0 }); - pp.decodeApproveCheckedInstructionUnchecked = - pp.decodeApproveCheckedInstruction = - pp.createApproveCheckedInstruction = - pp.approveCheckedInstructionData = - void 0; - var eke = Sn(), - qRr = ep(), - zRr = Le(), - X_t = sn(), - cse = fa(), - jRr = ip(), - Y_t = Bs(); - pp.approveCheckedInstructionData = (0, eke.struct)([ - (0, eke.u8)("instruction"), - (0, qRr.u64)("amount"), - (0, eke.u8)("decimals"), - ]); - function URr(t, e, r, n, i, o, a = [], s = X_t.TOKEN_PROGRAM_ID) { - let c = (0, jRr.addSigners)( - [ - { pubkey: t, isSigner: !1, isWritable: !0 }, - { pubkey: e, isSigner: !1, isWritable: !1 }, - { pubkey: r, isSigner: !1, isWritable: !1 }, - ], - n, - a - ), - u = Buffer.alloc(pp.approveCheckedInstructionData.span); - return ( - pp.approveCheckedInstructionData.encode( - { - instruction: Y_t.TokenInstruction.ApproveChecked, - amount: BigInt(i), - decimals: o, - }, - u - ), - new zRr.TransactionInstruction({ keys: c, programId: s, data: u }) - ); - } - pp.createApproveCheckedInstruction = URr; - function KRr(t, e = X_t.TOKEN_PROGRAM_ID) { - if (!t.programId.equals(e)) - throw new cse.TokenInvalidInstructionProgramError(); - if (t.data.length !== pp.approveCheckedInstructionData.span) - throw new cse.TokenInvalidInstructionDataError(); - let { - keys: { account: r, mint: n, delegate: i, owner: o, multiSigners: a }, - data: s, - } = Q_t(t); - if (s.instruction !== Y_t.TokenInstruction.ApproveChecked) - throw new cse.TokenInvalidInstructionTypeError(); - if (!r || !n || !i || !o) - throw new cse.TokenInvalidInstructionKeysError(); - return { - programId: e, - keys: { account: r, mint: n, delegate: i, owner: o, multiSigners: a }, - data: s, - }; - } - pp.decodeApproveCheckedInstruction = KRr; - function Q_t({ programId: t, keys: [e, r, n, i, ...o], data: a }) { - return { - programId: t, - keys: { account: e, mint: r, delegate: n, owner: i, multiSigners: o }, - data: pp.approveCheckedInstructionData.decode(a), - }; - } - pp.decodeApproveCheckedInstructionUnchecked = Q_t; - }); - var nke = I((yp) => { - "use strict"; - m(); - g(); - Object.defineProperty(yp, "__esModule", { value: !0 }); - yp.decodeMintToCheckedInstructionUnchecked = - yp.decodeMintToCheckedInstruction = - yp.createMintToCheckedInstruction = - yp.mintToCheckedInstructionData = - void 0; - var rke = Sn(), - HRr = ep(), - VRr = Le(), - ext = sn(), - lse = fa(), - WRr = ip(), - txt = Bs(); - yp.mintToCheckedInstructionData = (0, rke.struct)([ - (0, rke.u8)("instruction"), - (0, HRr.u64)("amount"), - (0, rke.u8)("decimals"), - ]); - function GRr(t, e, r, n, i, o = [], a = ext.TOKEN_PROGRAM_ID) { - let s = (0, WRr.addSigners)( - [ - { pubkey: t, isSigner: !1, isWritable: !0 }, - { pubkey: e, isSigner: !1, isWritable: !0 }, - ], - r, - o - ), - c = Buffer.alloc(yp.mintToCheckedInstructionData.span); - return ( - yp.mintToCheckedInstructionData.encode( - { - instruction: txt.TokenInstruction.MintToChecked, - amount: BigInt(n), - decimals: i, - }, - c - ), - new VRr.TransactionInstruction({ keys: s, programId: a, data: c }) - ); - } - yp.createMintToCheckedInstruction = GRr; - function JRr(t, e = ext.TOKEN_PROGRAM_ID) { - if (!t.programId.equals(e)) - throw new lse.TokenInvalidInstructionProgramError(); - if (t.data.length !== yp.mintToCheckedInstructionData.span) - throw new lse.TokenInvalidInstructionDataError(); - let { - keys: { mint: r, destination: n, authority: i, multiSigners: o }, - data: a, - } = rxt(t); - if (a.instruction !== txt.TokenInstruction.MintToChecked) - throw new lse.TokenInvalidInstructionTypeError(); - if (!r || !n || !i) throw new lse.TokenInvalidInstructionKeysError(); - return { - programId: e, - keys: { mint: r, destination: n, authority: i, multiSigners: o }, - data: a, - }; - } - yp.decodeMintToCheckedInstruction = JRr; - function rxt({ programId: t, keys: [e, r, n, ...i], data: o }) { - return { - programId: t, - keys: { mint: e, destination: r, authority: n, multiSigners: i }, - data: yp.mintToCheckedInstructionData.decode(o), - }; - } - yp.decodeMintToCheckedInstructionUnchecked = rxt; - }); - var oke = I((mp) => { - "use strict"; - m(); - g(); - Object.defineProperty(mp, "__esModule", { value: !0 }); - mp.decodeBurnCheckedInstructionUnchecked = - mp.decodeBurnCheckedInstruction = - mp.createBurnCheckedInstruction = - mp.burnCheckedInstructionData = - void 0; - var ike = Sn(), - $Rr = ep(), - ZRr = Le(), - nxt = sn(), - fse = fa(), - XRr = ip(), - ixt = Bs(); - mp.burnCheckedInstructionData = (0, ike.struct)([ - (0, ike.u8)("instruction"), - (0, $Rr.u64)("amount"), - (0, ike.u8)("decimals"), - ]); - function YRr(t, e, r, n, i, o = [], a = nxt.TOKEN_PROGRAM_ID) { - let s = (0, XRr.addSigners)( - [ - { pubkey: t, isSigner: !1, isWritable: !0 }, - { pubkey: e, isSigner: !1, isWritable: !0 }, - ], - r, - o - ), - c = Buffer.alloc(mp.burnCheckedInstructionData.span); - return ( - mp.burnCheckedInstructionData.encode( - { - instruction: ixt.TokenInstruction.BurnChecked, - amount: BigInt(n), - decimals: i, - }, - c - ), - new ZRr.TransactionInstruction({ keys: s, programId: a, data: c }) - ); - } - mp.createBurnCheckedInstruction = YRr; - function QRr(t, e = nxt.TOKEN_PROGRAM_ID) { - if (!t.programId.equals(e)) - throw new fse.TokenInvalidInstructionProgramError(); - if (t.data.length !== mp.burnCheckedInstructionData.span) - throw new fse.TokenInvalidInstructionDataError(); - let { - keys: { account: r, mint: n, owner: i, multiSigners: o }, - data: a, - } = oxt(t); - if (a.instruction !== ixt.TokenInstruction.BurnChecked) - throw new fse.TokenInvalidInstructionTypeError(); - if (!r || !n || !i) throw new fse.TokenInvalidInstructionKeysError(); - return { - programId: e, - keys: { account: r, mint: n, owner: i, multiSigners: o }, - data: a, - }; - } - mp.decodeBurnCheckedInstruction = QRr; - function oxt({ programId: t, keys: [e, r, n, ...i], data: o }) { - return { - programId: t, - keys: { account: e, mint: r, owner: n, multiSigners: i }, - data: mp.burnCheckedInstructionData.decode(o), - }; - } - mp.decodeBurnCheckedInstructionUnchecked = oxt; - }); - var sxt = I((axt) => { - "use strict"; - m(); - g(); - Object.defineProperty(axt, "__esModule", { value: !0 }); - }); - var ake = I((gp) => { - "use strict"; - m(); - g(); - Object.defineProperty(gp, "__esModule", { value: !0 }); - gp.decodeSyncNativeInstructionUnchecked = - gp.decodeSyncNativeInstruction = - gp.createSyncNativeInstruction = - gp.syncNativeInstructionData = - void 0; - var uxt = Sn(), - e7r = Le(), - cxt = sn(), - dse = fa(), - lxt = Bs(); - gp.syncNativeInstructionData = (0, uxt.struct)([ - (0, uxt.u8)("instruction"), - ]); - function t7r(t, e = cxt.TOKEN_PROGRAM_ID) { - let r = [{ pubkey: t, isSigner: !1, isWritable: !0 }], - n = Buffer.alloc(gp.syncNativeInstructionData.span); - return ( - gp.syncNativeInstructionData.encode( - { instruction: lxt.TokenInstruction.SyncNative }, - n - ), - new e7r.TransactionInstruction({ keys: r, programId: e, data: n }) - ); - } - gp.createSyncNativeInstruction = t7r; - function r7r(t, e = cxt.TOKEN_PROGRAM_ID) { - if (!t.programId.equals(e)) - throw new dse.TokenInvalidInstructionProgramError(); - if (t.data.length !== gp.syncNativeInstructionData.span) - throw new dse.TokenInvalidInstructionDataError(); - let { - keys: { account: r }, - data: n, - } = fxt(t); - if (n.instruction !== lxt.TokenInstruction.SyncNative) - throw new dse.TokenInvalidInstructionTypeError(); - if (!r) throw new dse.TokenInvalidInstructionKeysError(); - return { programId: e, keys: { account: r }, data: n }; - } - gp.decodeSyncNativeInstruction = r7r; - function fxt({ programId: t, keys: [e], data: r }) { - return { - programId: t, - keys: { account: e }, - data: gp.syncNativeInstructionData.decode(r), - }; - } - gp.decodeSyncNativeInstructionUnchecked = fxt; - }); - var hxt = I((dxt) => { - "use strict"; - m(); - g(); - Object.defineProperty(dxt, "__esModule", { value: !0 }); - }); - var yxt = I((pxt) => { - "use strict"; - m(); - g(); - Object.defineProperty(pxt, "__esModule", { value: !0 }); - }); - var gxt = I((mxt) => { - "use strict"; - m(); - g(); - Object.defineProperty(mxt, "__esModule", { value: !0 }); - }); - var vxt = I((Un) => { - "use strict"; - m(); - g(); - Object.defineProperty(Un, "__esModule", { value: !0 }); - Un.isSyncNativeInstruction = - Un.isBurnCheckedInstruction = - Un.isMintToCheckedInstruction = - Un.isApproveCheckedInstruction = - Un.isTransferCheckedInstruction = - Un.isThawAccountInstruction = - Un.isFreezeAccountInstruction = - Un.isCloseAccountInstruction = - Un.isBurnInstruction = - Un.isMintToInstruction = - Un.isSetAuthorityInstruction = - Un.isRevokeInstruction = - Un.isApproveInstruction = - Un.isTransferInstruction = - Un.isInitializeMultisigInstruction = - Un.isInitializeAccountInstruction = - Un.isInitializeMintInstruction = - Un.decodeInstruction = - void 0; - var n7r = Sn(), - i7r = sn(), - r9 = fa(), - o7r = H8e(), - a7r = tke(), - s7r = J8e(), - u7r = oke(), - c7r = $8e(), - l7r = Z8e(), - f7r = z8e(), - d7r = q8e(), - h7r = U8e(), - p7r = G8e(), - y7r = nke(), - m7r = V8e(), - g7r = W8e(), - v7r = ake(), - b7r = X8e(), - w7r = K8e(), - _7r = Q8e(), - jn = Bs(); - function x7r(t, e = i7r.TOKEN_PROGRAM_ID) { - if (!t.data.length) throw new r9.TokenInvalidInstructionDataError(); - let r = (0, n7r.u8)().decode(t.data); - if (r === jn.TokenInstruction.InitializeMint) - return (0, d7r.decodeInitializeMintInstruction)(t, e); - if (r === jn.TokenInstruction.InitializeAccount) - return (0, f7r.decodeInitializeAccountInstruction)(t, e); - if (r === jn.TokenInstruction.InitializeMultisig) - return (0, h7r.decodeInitializeMultisigInstruction)(t, e); - if (r === jn.TokenInstruction.Transfer) - return (0, w7r.decodeTransferInstruction)(t, e); - if (r === jn.TokenInstruction.Approve) - return (0, o7r.decodeApproveInstruction)(t, e); - if (r === jn.TokenInstruction.Revoke) - return (0, m7r.decodeRevokeInstruction)(t, e); - if (r === jn.TokenInstruction.SetAuthority) - return (0, g7r.decodeSetAuthorityInstruction)(t, e); - if (r === jn.TokenInstruction.MintTo) - return (0, p7r.decodeMintToInstruction)(t, e); - if (r === jn.TokenInstruction.Burn) - return (0, s7r.decodeBurnInstruction)(t, e); - if (r === jn.TokenInstruction.CloseAccount) - return (0, c7r.decodeCloseAccountInstruction)(t, e); - if (r === jn.TokenInstruction.FreezeAccount) - return (0, l7r.decodeFreezeAccountInstruction)(t, e); - if (r === jn.TokenInstruction.ThawAccount) - return (0, b7r.decodeThawAccountInstruction)(t, e); - if (r === jn.TokenInstruction.TransferChecked) - return (0, _7r.decodeTransferCheckedInstruction)(t, e); - if (r === jn.TokenInstruction.ApproveChecked) - return (0, a7r.decodeApproveCheckedInstruction)(t, e); - if (r === jn.TokenInstruction.MintToChecked) - return (0, y7r.decodeMintToCheckedInstruction)(t, e); - if (r === jn.TokenInstruction.BurnChecked) - return (0, u7r.decodeBurnCheckedInstruction)(t, e); - if (r === jn.TokenInstruction.InitializeAccount2) - throw new r9.TokenInvalidInstructionTypeError(); - if (r === jn.TokenInstruction.SyncNative) - return (0, v7r.decodeSyncNativeInstruction)(t, e); - throw r === jn.TokenInstruction.InitializeAccount3 - ? new r9.TokenInvalidInstructionTypeError() - : r === jn.TokenInstruction.InitializeMultisig2 - ? new r9.TokenInvalidInstructionTypeError() - : r === jn.TokenInstruction.InitializeMint2 - ? new r9.TokenInvalidInstructionTypeError() - : new r9.TokenInvalidInstructionTypeError(); - } - Un.decodeInstruction = x7r; - function S7r(t) { - return t.data.instruction === jn.TokenInstruction.InitializeMint; - } - Un.isInitializeMintInstruction = S7r; - function A7r(t) { - return t.data.instruction === jn.TokenInstruction.InitializeAccount; - } - Un.isInitializeAccountInstruction = A7r; - function E7r(t) { - return t.data.instruction === jn.TokenInstruction.InitializeMultisig; - } - Un.isInitializeMultisigInstruction = E7r; - function M7r(t) { - return t.data.instruction === jn.TokenInstruction.Transfer; - } - Un.isTransferInstruction = M7r; - function T7r(t) { - return t.data.instruction === jn.TokenInstruction.Approve; - } - Un.isApproveInstruction = T7r; - function k7r(t) { - return t.data.instruction === jn.TokenInstruction.Revoke; - } - Un.isRevokeInstruction = k7r; - function P7r(t) { - return t.data.instruction === jn.TokenInstruction.SetAuthority; - } - Un.isSetAuthorityInstruction = P7r; - function O7r(t) { - return t.data.instruction === jn.TokenInstruction.MintTo; - } - Un.isMintToInstruction = O7r; - function B7r(t) { - return t.data.instruction === jn.TokenInstruction.Burn; - } - Un.isBurnInstruction = B7r; - function I7r(t) { - return t.data.instruction === jn.TokenInstruction.CloseAccount; - } - Un.isCloseAccountInstruction = I7r; - function C7r(t) { - return t.data.instruction === jn.TokenInstruction.FreezeAccount; - } - Un.isFreezeAccountInstruction = C7r; - function R7r(t) { - return t.data.instruction === jn.TokenInstruction.ThawAccount; - } - Un.isThawAccountInstruction = R7r; - function N7r(t) { - return t.data.instruction === jn.TokenInstruction.TransferChecked; - } - Un.isTransferCheckedInstruction = N7r; - function D7r(t) { - return t.data.instruction === jn.TokenInstruction.ApproveChecked; - } - Un.isApproveCheckedInstruction = D7r; - function F7r(t) { - return t.data.instruction === jn.TokenInstruction.MintToChecked; - } - Un.isMintToCheckedInstruction = F7r; - function L7r(t) { - return t.data.instruction === jn.TokenInstruction.BurnChecked; - } - Un.isBurnCheckedInstruction = L7r; - function q7r(t) { - return t.data.instruction === jn.TokenInstruction.SyncNative; - } - Un.isSyncNativeInstruction = q7r; - }); - var wxt = I((hse) => { - "use strict"; - m(); - g(); - Object.defineProperty(hse, "__esModule", { value: !0 }); - hse.createAssociatedTokenAccountInstruction = void 0; - var ske = Le(), - bxt = sn(); - function z7r( - t, - e, - r, - n, - i = bxt.TOKEN_PROGRAM_ID, - o = bxt.ASSOCIATED_TOKEN_PROGRAM_ID - ) { - let a = [ - { pubkey: t, isSigner: !0, isWritable: !0 }, - { pubkey: e, isSigner: !1, isWritable: !0 }, - { pubkey: r, isSigner: !1, isWritable: !1 }, - { pubkey: n, isSigner: !1, isWritable: !1 }, - { pubkey: ske.SystemProgram.programId, isSigner: !1, isWritable: !1 }, - { pubkey: i, isSigner: !1, isWritable: !1 }, - { pubkey: ske.SYSVAR_RENT_PUBKEY, isSigner: !1, isWritable: !1 }, - ]; - return new ske.TransactionInstruction({ - keys: a, - programId: o, - data: Buffer.alloc(0), - }); - } - hse.createAssociatedTokenAccountInstruction = z7r; - }); - var Va = I((eo) => { - "use strict"; - m(); - g(); - var j7r = - (eo && eo.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - da = - (eo && eo.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - j7r(e, t, r); - }; - Object.defineProperty(eo, "__esModule", { value: !0 }); - da(Bs(), eo); - da(q8e(), eo); - da(z8e(), eo); - da(U8e(), eo); - da(K8e(), eo); - da(H8e(), eo); - da(V8e(), eo); - da(W8e(), eo); - da(G8e(), eo); - da(J8e(), eo); - da($8e(), eo); - da(Z8e(), eo); - da(X8e(), eo); - da(Q8e(), eo); - da(tke(), eo); - da(nke(), eo); - da(oke(), eo); - da(sxt(), eo); - da(ake(), eo); - da(hxt(), eo); - da(yxt(), eo); - da(gxt(), eo); - da(vxt(), eo); - da(wxt(), eo); - }); - var xxt = I((nu) => { - "use strict"; - m(); - g(); - var _xt = - (nu && nu.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(nu, "__esModule", { value: !0 }); - nu.getMinimumBalanceForRentExemptAccount = - nu.getAccount = - nu.ACCOUNT_SIZE = - nu.AccountLayout = - nu.AccountState = - void 0; - var ZH = Sn(), - sP = ep(), - U7r = sn(), - uke = fa(), - cke; - (function (t) { - (t[(t.Uninitialized = 0)] = "Uninitialized"), - (t[(t.Initialized = 1)] = "Initialized"), - (t[(t.Frozen = 2)] = "Frozen"); - })((cke = nu.AccountState || (nu.AccountState = {}))); - nu.AccountLayout = (0, ZH.struct)([ - (0, sP.publicKey)("mint"), - (0, sP.publicKey)("owner"), - (0, sP.u64)("amount"), - (0, ZH.u32)("delegateOption"), - (0, sP.publicKey)("delegate"), - (0, ZH.u8)("state"), - (0, ZH.u32)("isNativeOption"), - (0, sP.u64)("isNative"), - (0, sP.u64)("delegatedAmount"), - (0, ZH.u32)("closeAuthorityOption"), - (0, sP.publicKey)("closeAuthority"), - ]); - nu.ACCOUNT_SIZE = nu.AccountLayout.span; - function K7r(t, e, r, n = U7r.TOKEN_PROGRAM_ID) { - return _xt(this, void 0, void 0, function* () { - let i = yield t.getAccountInfo(e, r); - if (!i) throw new uke.TokenAccountNotFoundError(); - if (!i.owner.equals(n)) throw new uke.TokenInvalidAccountOwnerError(); - if (i.data.length != nu.ACCOUNT_SIZE) - throw new uke.TokenInvalidAccountSizeError(); - let o = nu.AccountLayout.decode(i.data); - return { - address: e, - mint: o.mint, - owner: o.owner, - amount: o.amount, - delegate: o.delegateOption ? o.delegate : null, - delegatedAmount: o.delegatedAmount, - isInitialized: o.state !== cke.Uninitialized, - isFrozen: o.state === cke.Frozen, - isNative: !!o.isNativeOption, - rentExemptReserve: o.isNativeOption ? o.isNative : null, - closeAuthority: o.closeAuthorityOption ? o.closeAuthority : null, - }; - }); - } - nu.getAccount = K7r; - function H7r(t, e) { - return _xt(this, void 0, void 0, function* () { - return yield t.getMinimumBalanceForRentExemption(nu.ACCOUNT_SIZE, e); - }); - } - nu.getMinimumBalanceForRentExemptAccount = H7r; - }); - var Axt = I((Uu) => { - "use strict"; - m(); - g(); - var fke = - (Uu && Uu.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(Uu, "__esModule", { value: !0 }); - Uu.getAssociatedTokenAddress = - Uu.getMinimumBalanceForRentExemptMint = - Uu.getMint = - Uu.MINT_SIZE = - Uu.MintLayout = - void 0; - var pse = Sn(), - yse = ep(), - Sxt = Le(), - lke = sn(), - mse = fa(); - Uu.MintLayout = (0, pse.struct)([ - (0, pse.u32)("mintAuthorityOption"), - (0, yse.publicKey)("mintAuthority"), - (0, yse.u64)("supply"), - (0, pse.u8)("decimals"), - (0, yse.bool)("isInitialized"), - (0, pse.u32)("freezeAuthorityOption"), - (0, yse.publicKey)("freezeAuthority"), - ]); - Uu.MINT_SIZE = Uu.MintLayout.span; - function V7r(t, e, r, n = lke.TOKEN_PROGRAM_ID) { - return fke(this, void 0, void 0, function* () { - let i = yield t.getAccountInfo(e, r); - if (!i) throw new mse.TokenAccountNotFoundError(); - if (!i.owner.equals(n)) throw new mse.TokenInvalidAccountOwnerError(); - if (i.data.length != Uu.MINT_SIZE) - throw new mse.TokenInvalidAccountSizeError(); - let o = Uu.MintLayout.decode(i.data); - return { - address: e, - mintAuthority: o.mintAuthorityOption ? o.mintAuthority : null, - supply: o.supply, - decimals: o.decimals, - isInitialized: o.isInitialized, - freezeAuthority: o.freezeAuthorityOption ? o.freezeAuthority : null, - }; - }); - } - Uu.getMint = V7r; - function W7r(t, e) { - return fke(this, void 0, void 0, function* () { - return yield t.getMinimumBalanceForRentExemption(Uu.MINT_SIZE, e); - }); - } - Uu.getMinimumBalanceForRentExemptMint = W7r; - function G7r( - t, - e, - r = !1, - n = lke.TOKEN_PROGRAM_ID, - i = lke.ASSOCIATED_TOKEN_PROGRAM_ID - ) { - return fke(this, void 0, void 0, function* () { - if (!r && !Sxt.PublicKey.isOnCurve(e.toBuffer())) - throw new mse.TokenOwnerOffCurveError(); - let [o] = yield Sxt.PublicKey.findProgramAddress( - [e.toBuffer(), n.toBuffer(), t.toBuffer()], - i - ); - return o; - }); - } - Uu.getAssociatedTokenAddress = G7r; - }); - var Mxt = I((Tl) => { - "use strict"; - m(); - g(); - var Ext = - (Tl && Tl.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(Tl, "__esModule", { value: !0 }); - Tl.getMinimumBalanceForRentExemptMultisig = - Tl.getMultisig = - Tl.MULTISIG_SIZE = - Tl.MultisigLayout = - void 0; - var dke = Sn(), - am = ep(), - J7r = sn(), - hke = fa(); - Tl.MultisigLayout = (0, dke.struct)([ - (0, dke.u8)("m"), - (0, dke.u8)("n"), - (0, am.bool)("isInitialized"), - (0, am.publicKey)("signer1"), - (0, am.publicKey)("signer2"), - (0, am.publicKey)("signer3"), - (0, am.publicKey)("signer4"), - (0, am.publicKey)("signer5"), - (0, am.publicKey)("signer6"), - (0, am.publicKey)("signer7"), - (0, am.publicKey)("signer8"), - (0, am.publicKey)("signer9"), - (0, am.publicKey)("signer10"), - (0, am.publicKey)("signer11"), - ]); - Tl.MULTISIG_SIZE = Tl.MultisigLayout.span; - function $7r(t, e, r, n = J7r.TOKEN_PROGRAM_ID) { - return Ext(this, void 0, void 0, function* () { - let i = yield t.getAccountInfo(e, r); - if (!i) throw new hke.TokenAccountNotFoundError(); - if (!i.owner.equals(n)) throw new hke.TokenInvalidAccountOwnerError(); - if (i.data.length != Tl.MULTISIG_SIZE) - throw new hke.TokenInvalidAccountSizeError(); - return Object.assign({ address: e }, Tl.MultisigLayout.decode(i.data)); - }); - } - Tl.getMultisig = $7r; - function Z7r(t, e) { - return Ext(this, void 0, void 0, function* () { - return yield t.getMinimumBalanceForRentExemption(Tl.MULTISIG_SIZE, e); - }); - } - Tl.getMinimumBalanceForRentExemptMultisig = Z7r; - }); - var KE = I((zx) => { - "use strict"; - m(); - g(); - var X7r = - (zx && zx.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - pke = - (zx && zx.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - X7r(e, t, r); - }; - Object.defineProperty(zx, "__esModule", { value: !0 }); - pke(xxt(), zx); - pke(Axt(), zx); - pke(Mxt(), zx); - }); - var kxt = I((n9) => { - "use strict"; - m(); - g(); - var Y7r = - (n9 && n9.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(n9, "__esModule", { value: !0 }); - n9.createMint = void 0; - var gse = Le(), - Q7r = sn(), - eNr = Va(), - Txt = KE(); - function tNr( - t, - e, - r, - n, - i, - o = gse.Keypair.generate(), - a, - s = Q7r.TOKEN_PROGRAM_ID - ) { - return Y7r(this, void 0, void 0, function* () { - let c = yield (0, Txt.getMinimumBalanceForRentExemptMint)(t), - u = new gse.Transaction().add( - gse.SystemProgram.createAccount({ - fromPubkey: e.publicKey, - newAccountPubkey: o.publicKey, - space: Txt.MINT_SIZE, - lamports: c, - programId: s, - }), - (0, eNr.createInitializeMintInstruction)(o.publicKey, i, r, n, s) - ); - return ( - yield (0, gse.sendAndConfirmTransaction)(t, u, [e, o], a), o.publicKey - ); - }); - } - n9.createMint = tNr; - }); - var yke = I((i9) => { - "use strict"; - m(); - g(); - var rNr = - (i9 && i9.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(i9, "__esModule", { value: !0 }); - i9.createAssociatedTokenAccount = void 0; - var Pxt = Le(), - Oxt = sn(), - nNr = Va(), - iNr = KE(); - function oNr( - t, - e, - r, - n, - i, - o = Oxt.TOKEN_PROGRAM_ID, - a = Oxt.ASSOCIATED_TOKEN_PROGRAM_ID - ) { - return rNr(this, void 0, void 0, function* () { - let s = yield (0, iNr.getAssociatedTokenAddress)(r, n, !1, o, a), - c = new Pxt.Transaction().add( - (0, nNr.createAssociatedTokenAccountInstruction)( - e.publicKey, - s, - n, - r, - o, - a - ) - ); - return yield (0, Pxt.sendAndConfirmTransaction)(t, c, [e], i), s; - }); - } - i9.createAssociatedTokenAccount = oNr; - }); - var gke = I((o9) => { - "use strict"; - m(); - g(); - var aNr = - (o9 && o9.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(o9, "__esModule", { value: !0 }); - o9.createAccount = void 0; - var mke = Le(), - sNr = sn(), - uNr = Va(), - Bxt = KE(), - cNr = yke(); - function lNr(t, e, r, n, i, o, a = sNr.TOKEN_PROGRAM_ID) { - return aNr(this, void 0, void 0, function* () { - if (!i) - return yield (0, cNr.createAssociatedTokenAccount)(t, e, r, n, o, a); - let s = yield (0, Bxt.getMinimumBalanceForRentExemptAccount)(t), - c = new mke.Transaction().add( - mke.SystemProgram.createAccount({ - fromPubkey: e.publicKey, - newAccountPubkey: i.publicKey, - space: Bxt.ACCOUNT_SIZE, - lamports: s, - programId: a, - }), - (0, uNr.createInitializeAccountInstruction)(i.publicKey, r, n, a) - ); - return ( - yield (0, mke.sendAndConfirmTransaction)(t, c, [e, i], o), i.publicKey - ); - }); - } - o9.createAccount = lNr; - }); - var Ixt = I((a9) => { - "use strict"; - m(); - g(); - var fNr = - (a9 && a9.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(a9, "__esModule", { value: !0 }); - a9.createWrappedNativeAccount = void 0; - var uP = Le(), - cP = sn(), - vke = Va(), - bke = KE(), - dNr = gke(); - function hNr(t, e, r, n, i, o, a = cP.TOKEN_PROGRAM_ID) { - return fNr(this, void 0, void 0, function* () { - if (!n) - return yield (0, dNr.createAccount)(t, e, cP.NATIVE_MINT, r, i, o, a); - if (!i) { - let u = yield (0, bke.getAssociatedTokenAddress)( - cP.NATIVE_MINT, - r, - !1, - a, - cP.ASSOCIATED_TOKEN_PROGRAM_ID - ), - h = new uP.Transaction().add( - (0, vke.createAssociatedTokenAccountInstruction)( - e.publicKey, - u, - r, - cP.NATIVE_MINT, - a, - cP.ASSOCIATED_TOKEN_PROGRAM_ID - ), - uP.SystemProgram.transfer({ - fromPubkey: e.publicKey, - toPubkey: u, - lamports: n, - }), - (0, vke.createSyncNativeInstruction)(u, a) - ); - return yield (0, uP.sendAndConfirmTransaction)(t, h, [e], o), u; - } - let s = yield (0, bke.getMinimumBalanceForRentExemptAccount)(t), - c = new uP.Transaction().add( - uP.SystemProgram.createAccount({ - fromPubkey: e.publicKey, - newAccountPubkey: i.publicKey, - space: bke.ACCOUNT_SIZE, - lamports: s, - programId: a, - }), - uP.SystemProgram.transfer({ - fromPubkey: e.publicKey, - toPubkey: i.publicKey, - lamports: n, - }), - (0, vke.createInitializeAccountInstruction)( - i.publicKey, - cP.NATIVE_MINT, - r, - a - ) - ); - return ( - yield (0, uP.sendAndConfirmTransaction)(t, c, [e, i], o), i.publicKey - ); - }); - } - a9.createWrappedNativeAccount = hNr; - }); - var Rxt = I((s9) => { - "use strict"; - m(); - g(); - var pNr = - (s9 && s9.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(s9, "__esModule", { value: !0 }); - s9.createMultisig = void 0; - var vse = Le(), - yNr = sn(), - mNr = Va(), - Cxt = KE(); - function gNr( - t, - e, - r, - n, - i = vse.Keypair.generate(), - o, - a = yNr.TOKEN_PROGRAM_ID - ) { - return pNr(this, void 0, void 0, function* () { - let s = yield (0, Cxt.getMinimumBalanceForRentExemptMultisig)(t), - c = new vse.Transaction().add( - vse.SystemProgram.createAccount({ - fromPubkey: e.publicKey, - newAccountPubkey: i.publicKey, - space: Cxt.MULTISIG_SIZE, - lamports: s, - programId: a, - }), - (0, mNr.createInitializeMultisigInstruction)(i.publicKey, r, n, a) - ); - return ( - yield (0, vse.sendAndConfirmTransaction)(t, c, [e, i], o), i.publicKey - ); - }); - } - s9.createMultisig = gNr; - }); - var vp = I((bse) => { - "use strict"; - m(); - g(); - Object.defineProperty(bse, "__esModule", { value: !0 }); - bse.getSigners = void 0; - var vNr = Le(); - function bNr(t, e) { - return t instanceof vNr.PublicKey ? [t, e] : [t.publicKey, [t]]; - } - bse.getSigners = bNr; - }); - var Dxt = I((u9) => { - "use strict"; - m(); - g(); - var wNr = - (u9 && u9.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(u9, "__esModule", { value: !0 }); - u9.transfer = void 0; - var Nxt = Le(), - _Nr = sn(), - xNr = Va(), - SNr = vp(); - function ANr(t, e, r, n, i, o, a = [], s, c = _Nr.TOKEN_PROGRAM_ID) { - return wNr(this, void 0, void 0, function* () { - let [u, h] = (0, SNr.getSigners)(i, a), - w = new Nxt.Transaction().add( - (0, xNr.createTransferInstruction)(r, n, u, o, a, c) - ); - return yield (0, Nxt.sendAndConfirmTransaction)(t, w, [e, ...h], s); - }); - } - u9.transfer = ANr; - }); - var Lxt = I((c9) => { - "use strict"; - m(); - g(); - var ENr = - (c9 && c9.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(c9, "__esModule", { value: !0 }); - c9.approve = void 0; - var Fxt = Le(), - MNr = sn(), - TNr = Va(), - kNr = vp(); - function PNr(t, e, r, n, i, o, a = [], s, c = MNr.TOKEN_PROGRAM_ID) { - return ENr(this, void 0, void 0, function* () { - let [u, h] = (0, kNr.getSigners)(i, a), - w = new Fxt.Transaction().add( - (0, TNr.createApproveInstruction)(r, n, u, o, a, c) - ); - return yield (0, Fxt.sendAndConfirmTransaction)(t, w, [e, ...h], s); - }); - } - c9.approve = PNr; - }); - var zxt = I((l9) => { - "use strict"; - m(); - g(); - var ONr = - (l9 && l9.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(l9, "__esModule", { value: !0 }); - l9.revoke = void 0; - var qxt = Le(), - BNr = sn(), - INr = Va(), - CNr = vp(); - function RNr(t, e, r, n, i = [], o, a = BNr.TOKEN_PROGRAM_ID) { - return ONr(this, void 0, void 0, function* () { - let [s, c] = (0, CNr.getSigners)(n, i), - u = new qxt.Transaction().add( - (0, INr.createRevokeInstruction)(r, s, i, a) - ); - return yield (0, qxt.sendAndConfirmTransaction)(t, u, [e, ...c], o); - }); - } - l9.revoke = RNr; - }); - var Uxt = I((f9) => { - "use strict"; - m(); - g(); - var NNr = - (f9 && f9.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(f9, "__esModule", { value: !0 }); - f9.setAuthority = void 0; - var jxt = Le(), - DNr = sn(), - FNr = Va(), - LNr = vp(); - function qNr(t, e, r, n, i, o, a = [], s, c = DNr.TOKEN_PROGRAM_ID) { - return NNr(this, void 0, void 0, function* () { - let [u, h] = (0, LNr.getSigners)(n, a), - w = new jxt.Transaction().add( - (0, FNr.createSetAuthorityInstruction)(r, u, i, o, a, c) - ); - return yield (0, jxt.sendAndConfirmTransaction)(t, w, [e, ...h], s); - }); - } - f9.setAuthority = qNr; - }); - var Hxt = I((d9) => { - "use strict"; - m(); - g(); - var zNr = - (d9 && d9.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(d9, "__esModule", { value: !0 }); - d9.mintTo = void 0; - var Kxt = Le(), - jNr = sn(), - UNr = Va(), - KNr = vp(); - function HNr(t, e, r, n, i, o, a = [], s, c = jNr.TOKEN_PROGRAM_ID) { - return zNr(this, void 0, void 0, function* () { - let [u, h] = (0, KNr.getSigners)(i, a), - w = new Kxt.Transaction().add( - (0, UNr.createMintToInstruction)(r, n, u, o, a, c) - ); - return yield (0, Kxt.sendAndConfirmTransaction)(t, w, [e, ...h], s); - }); - } - d9.mintTo = HNr; - }); - var Wxt = I((h9) => { - "use strict"; - m(); - g(); - var VNr = - (h9 && h9.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(h9, "__esModule", { value: !0 }); - h9.burn = void 0; - var Vxt = Le(), - WNr = sn(), - GNr = Va(), - JNr = vp(); - function $Nr(t, e, r, n, i, o, a = [], s, c = WNr.TOKEN_PROGRAM_ID) { - return VNr(this, void 0, void 0, function* () { - let [u, h] = (0, JNr.getSigners)(i, a), - w = new Vxt.Transaction().add( - (0, GNr.createBurnInstruction)(r, n, u, o, a, c) - ); - return yield (0, Vxt.sendAndConfirmTransaction)(t, w, [e, ...h], s); - }); - } - h9.burn = $Nr; - }); - var Jxt = I((p9) => { - "use strict"; - m(); - g(); - var ZNr = - (p9 && p9.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(p9, "__esModule", { value: !0 }); - p9.closeAccount = void 0; - var Gxt = Le(), - XNr = sn(), - YNr = Va(), - QNr = vp(); - function e9r(t, e, r, n, i, o = [], a, s = XNr.TOKEN_PROGRAM_ID) { - return ZNr(this, void 0, void 0, function* () { - let [c, u] = (0, QNr.getSigners)(i, o), - h = new Gxt.Transaction().add( - (0, YNr.createCloseAccountInstruction)(r, n, c, o, s) - ); - return yield (0, Gxt.sendAndConfirmTransaction)(t, h, [e, ...u], a); - }); - } - p9.closeAccount = e9r; - }); - var Zxt = I((y9) => { - "use strict"; - m(); - g(); - var t9r = - (y9 && y9.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(y9, "__esModule", { value: !0 }); - y9.freezeAccount = void 0; - var $xt = Le(), - r9r = sn(), - n9r = Va(), - i9r = vp(); - function o9r(t, e, r, n, i, o = [], a, s = r9r.TOKEN_PROGRAM_ID) { - return t9r(this, void 0, void 0, function* () { - let [c, u] = (0, i9r.getSigners)(i, o), - h = new $xt.Transaction().add( - (0, n9r.createFreezeAccountInstruction)(r, n, c, o, s) - ); - return yield (0, $xt.sendAndConfirmTransaction)(t, h, [e, ...u], a); - }); - } - y9.freezeAccount = o9r; - }); - var Yxt = I((m9) => { - "use strict"; - m(); - g(); - var a9r = - (m9 && m9.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(m9, "__esModule", { value: !0 }); - m9.thawAccount = void 0; - var Xxt = Le(), - s9r = sn(), - u9r = Va(), - c9r = vp(); - function l9r(t, e, r, n, i, o = [], a, s = s9r.TOKEN_PROGRAM_ID) { - return a9r(this, void 0, void 0, function* () { - let [c, u] = (0, c9r.getSigners)(i, o), - h = new Xxt.Transaction().add( - (0, u9r.createThawAccountInstruction)(r, n, c, o, s) - ); - return yield (0, Xxt.sendAndConfirmTransaction)(t, h, [e, ...u], a); - }); - } - m9.thawAccount = l9r; - }); - var eSt = I((g9) => { - "use strict"; - m(); - g(); - var f9r = - (g9 && g9.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(g9, "__esModule", { value: !0 }); - g9.transferChecked = void 0; - var Qxt = Le(), - d9r = sn(), - h9r = Va(), - p9r = vp(); - function y9r(t, e, r, n, i, o, a, s, c = [], u, h = d9r.TOKEN_PROGRAM_ID) { - return f9r(this, void 0, void 0, function* () { - let [w, M] = (0, p9r.getSigners)(o, c), - k = new Qxt.Transaction().add( - (0, h9r.createTransferCheckedInstruction)(r, n, i, w, a, s, c, h) - ); - return yield (0, Qxt.sendAndConfirmTransaction)(t, k, [e, ...M], u); - }); - } - g9.transferChecked = y9r; - }); - var rSt = I((v9) => { - "use strict"; - m(); - g(); - var m9r = - (v9 && v9.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(v9, "__esModule", { value: !0 }); - v9.approveChecked = void 0; - var tSt = Le(), - g9r = sn(), - v9r = Va(), - b9r = vp(); - function w9r(t, e, r, n, i, o, a, s, c = [], u, h = g9r.TOKEN_PROGRAM_ID) { - return m9r(this, void 0, void 0, function* () { - let [w, M] = (0, b9r.getSigners)(o, c), - k = new tSt.Transaction().add( - (0, v9r.createApproveCheckedInstruction)(n, r, i, w, a, s, c, h) - ); - return yield (0, tSt.sendAndConfirmTransaction)(t, k, [e, ...M], u); - }); - } - v9.approveChecked = w9r; - }); - var iSt = I((b9) => { - "use strict"; - m(); - g(); - var _9r = - (b9 && b9.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(b9, "__esModule", { value: !0 }); - b9.mintToChecked = void 0; - var nSt = Le(), - x9r = sn(), - S9r = Va(), - A9r = vp(); - function E9r(t, e, r, n, i, o, a, s = [], c, u = x9r.TOKEN_PROGRAM_ID) { - return _9r(this, void 0, void 0, function* () { - let [h, w] = (0, A9r.getSigners)(i, s), - M = new nSt.Transaction().add( - (0, S9r.createMintToCheckedInstruction)(r, n, h, o, a, s, u) - ); - return yield (0, nSt.sendAndConfirmTransaction)(t, M, [e, ...w], c); - }); - } - b9.mintToChecked = E9r; - }); - var aSt = I((w9) => { - "use strict"; - m(); - g(); - var M9r = - (w9 && w9.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(w9, "__esModule", { value: !0 }); - w9.burnChecked = void 0; - var oSt = Le(), - T9r = sn(), - k9r = Va(), - P9r = vp(); - function O9r(t, e, r, n, i, o, a, s = [], c, u = T9r.TOKEN_PROGRAM_ID) { - return M9r(this, void 0, void 0, function* () { - let [h, w] = (0, P9r.getSigners)(i, s), - M = new oSt.Transaction().add( - (0, k9r.createBurnCheckedInstruction)(r, n, h, o, a, s, u) - ); - return yield (0, oSt.sendAndConfirmTransaction)(t, M, [e, ...w], c); - }); - } - w9.burnChecked = O9r; - }); - var uSt = I((_9) => { - "use strict"; - m(); - g(); - var B9r = - (_9 && _9.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(_9, "__esModule", { value: !0 }); - _9.syncNative = void 0; - var sSt = Le(), - I9r = sn(), - C9r = Va(); - function R9r(t, e, r, n, i = I9r.TOKEN_PROGRAM_ID) { - return B9r(this, void 0, void 0, function* () { - let o = new sSt.Transaction().add( - (0, C9r.createSyncNativeInstruction)(r, i) - ); - return yield (0, sSt.sendAndConfirmTransaction)(t, o, [e], n); - }); - } - _9.syncNative = R9r; - }); - var fSt = I((x9) => { - "use strict"; - m(); - g(); - var N9r = - (x9 && x9.__awaiter) || - function (t, e, r, n) { - function i(o) { - return o instanceof r - ? o - : new r(function (a) { - a(o); - }); - } - return new (r || (r = Promise))(function (o, a) { - function s(h) { - try { - u(n.next(h)); - } catch (w) { - a(w); - } - } - function c(h) { - try { - u(n.throw(h)); - } catch (w) { - a(w); - } - } - function u(h) { - h.done ? o(h.value) : i(h.value).then(s, c); - } - u((n = n.apply(t, e || [])).next()); - }); - }; - Object.defineProperty(x9, "__esModule", { value: !0 }); - x9.getOrCreateAssociatedTokenAccount = void 0; - var cSt = Le(), - lSt = sn(), - wse = fa(), - D9r = Va(), - wke = KE(); - function F9r( - t, - e, - r, - n, - i = !1, - o, - a, - s = lSt.TOKEN_PROGRAM_ID, - c = lSt.ASSOCIATED_TOKEN_PROGRAM_ID - ) { - return N9r(this, void 0, void 0, function* () { - let u = yield (0, wke.getAssociatedTokenAddress)(r, n, i, s, c), - h; - try { - h = yield (0, wke.getAccount)(t, u, o, s); - } catch (w) { - if ( - w instanceof wse.TokenAccountNotFoundError || - w instanceof wse.TokenInvalidAccountOwnerError - ) { - try { - let M = new cSt.Transaction().add( - (0, D9r.createAssociatedTokenAccountInstruction)( - e.publicKey, - u, - n, - r, - s, - c - ) - ); - yield (0, cSt.sendAndConfirmTransaction)(t, M, [e], a); - } catch {} - h = yield (0, wke.getAccount)(t, u, o, s); - } else throw w; - } - if (!h.mint.equals(r)) throw new wse.TokenInvalidMintError(); - if (!h.owner.equals(n)) throw new wse.TokenInvalidOwnerError(); - return h; - }); - } - x9.getOrCreateAssociatedTokenAccount = F9r; - }); - var dSt = I((Fo) => { - "use strict"; - m(); - g(); - var L9r = - (Fo && Fo.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Is = - (Fo && Fo.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - L9r(e, t, r); - }; - Object.defineProperty(Fo, "__esModule", { value: !0 }); - Is(kxt(), Fo); - Is(gke(), Fo); - Is(Ixt(), Fo); - Is(Rxt(), Fo); - Is(Dxt(), Fo); - Is(Lxt(), Fo); - Is(zxt(), Fo); - Is(Uxt(), Fo); - Is(Hxt(), Fo); - Is(Wxt(), Fo); - Is(Jxt(), Fo); - Is(Zxt(), Fo); - Is(Yxt(), Fo); - Is(eSt(), Fo); - Is(rSt(), Fo); - Is(iSt(), Fo); - Is(aSt(), Fo); - Is(uSt(), Fo); - Is(yke(), Fo); - Is(fSt(), Fo); - }); - var eh = I((Og) => { - "use strict"; - m(); - g(); - var q9r = - (Og && Og.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r), - Object.defineProperty(t, n, { - enumerable: !0, - get: function () { - return e[r]; - }, - }); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - XH = - (Og && Og.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - q9r(e, t, r); - }; - Object.defineProperty(Og, "__esModule", { value: !0 }); - XH(Va(), Og); - XH(KE(), Og); - XH(dSt(), Og); - XH(sn(), Og); - XH(fa(), Og); - }); - var _ke = I((b1) => { - "use strict"; - m(); - g(); - var z9r = - (b1 && b1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - j9r = - (b1 && b1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - U9r = - (b1 && b1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - z9r(e, t, r); - return j9r(e, t), e; - }; - Object.defineProperty(b1, "__esModule", { value: !0 }); - b1.approveUseAuthorityArgsBeet = void 0; - var hSt = U9r(Wt()); - b1.approveUseAuthorityArgsBeet = new hSt.BeetArgsStruct( - [["numberOfUses", hSt.u64]], - "ApproveUseAuthorityArgs" - ); - }); - var ySt = I((kl) => { - "use strict"; - m(); - g(); - var K9r = - (kl && kl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - H9r = - (kl && kl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Ske = - (kl && kl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - K9r(e, t, r); - return H9r(e, t), e; - }; - Object.defineProperty(kl, "__esModule", { value: !0 }); - kl.createApproveUseAuthorityInstruction = - kl.approveUseAuthorityInstructionDiscriminator = - kl.ApproveUseAuthorityStruct = - void 0; - var V9r = Ske(eh()), - pSt = Ske(Wt()), - xke = Ske(Le()), - W9r = _ke(); - kl.ApproveUseAuthorityStruct = new pSt.BeetArgsStruct( - [ - ["instructionDiscriminator", pSt.u8], - ["approveUseAuthorityArgs", W9r.approveUseAuthorityArgsBeet], - ], - "ApproveUseAuthorityInstructionArgs" - ); - kl.approveUseAuthorityInstructionDiscriminator = 20; - function G9r( - t, - e, - r = new xke.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - var n, i; - let [o] = kl.ApproveUseAuthorityStruct.serialize({ - instructionDiscriminator: - kl.approveUseAuthorityInstructionDiscriminator, - ...e, - }), - a = [ - { pubkey: t.useAuthorityRecord, isWritable: !0, isSigner: !1 }, - { pubkey: t.owner, isWritable: !0, isSigner: !0 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { pubkey: t.user, isWritable: !1, isSigner: !1 }, - { pubkey: t.ownerTokenAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.mint, isWritable: !1, isSigner: !1 }, - { pubkey: t.burner, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : V9r.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : xke.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - ]; - return ( - t.rent != null && - a.push({ pubkey: t.rent, isWritable: !1, isSigner: !1 }), - new xke.TransactionInstruction({ programId: r, keys: a, data: o }) - ); - } - kl.createApproveUseAuthorityInstruction = G9r; - }); - var _se = I((w1) => { - "use strict"; - m(); - g(); - var J9r = - (w1 && w1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - $9r = - (w1 && w1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Z9r = - (w1 && w1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - J9r(e, t, r); - return $9r(e, t), e; - }; - Object.defineProperty(w1, "__esModule", { value: !0 }); - w1.setCollectionSizeArgsBeet = void 0; - var mSt = Z9r(Wt()); - w1.setCollectionSizeArgsBeet = new mSt.BeetArgsStruct( - [["size", mSt.u64]], - "SetCollectionSizeArgs" - ); - }); - var wSt = I((Pl) => { - "use strict"; - m(); - g(); - var X9r = - (Pl && Pl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Y9r = - (Pl && Pl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - bSt = - (Pl && Pl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - X9r(e, t, r); - return Y9r(e, t), e; - }; - Object.defineProperty(Pl, "__esModule", { value: !0 }); - Pl.createBubblegumSetCollectionSizeInstruction = - Pl.bubblegumSetCollectionSizeInstructionDiscriminator = - Pl.BubblegumSetCollectionSizeStruct = - void 0; - var gSt = bSt(Wt()), - vSt = bSt(Le()), - Q9r = _se(); - Pl.BubblegumSetCollectionSizeStruct = new gSt.BeetArgsStruct( - [ - ["instructionDiscriminator", gSt.u8], - ["setCollectionSizeArgs", Q9r.setCollectionSizeArgsBeet], - ], - "BubblegumSetCollectionSizeInstructionArgs" - ); - Pl.bubblegumSetCollectionSizeInstructionDiscriminator = 36; - function eDr( - t, - e, - r = new vSt.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - let [n] = Pl.BubblegumSetCollectionSizeStruct.serialize({ - instructionDiscriminator: - Pl.bubblegumSetCollectionSizeInstructionDiscriminator, - ...e, - }), - i = [ - { pubkey: t.collectionMetadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.collectionAuthority, isWritable: !0, isSigner: !0 }, - { pubkey: t.collectionMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.bubblegumSigner, isWritable: !1, isSigner: !0 }, - ]; - return ( - t.collectionAuthorityRecord != null && - i.push({ - pubkey: t.collectionAuthorityRecord, - isWritable: !1, - isSigner: !1, - }), - new vSt.TransactionInstruction({ programId: r, keys: i, data: n }) - ); - } - Pl.createBubblegumSetCollectionSizeInstruction = eDr; - }); - var ASt = I((Ol) => { - "use strict"; - m(); - g(); - var tDr = - (Ol && Ol.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - rDr = - (Ol && Ol.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - SSt = - (Ol && Ol.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - tDr(e, t, r); - return rDr(e, t), e; - }; - Object.defineProperty(Ol, "__esModule", { value: !0 }); - Ol.createBurnEditionNftInstruction = - Ol.burnEditionNftInstructionDiscriminator = - Ol.BurnEditionNftStruct = - void 0; - var _St = SSt(Wt()), - xSt = SSt(Le()); - Ol.BurnEditionNftStruct = new _St.BeetArgsStruct( - [["instructionDiscriminator", _St.u8]], - "BurnEditionNftInstructionArgs" - ); - Ol.burnEditionNftInstructionDiscriminator = 37; - function nDr( - t, - e = new xSt.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - let [r] = Ol.BurnEditionNftStruct.serialize({ - instructionDiscriminator: Ol.burnEditionNftInstructionDiscriminator, - }), - n = [ - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.owner, isWritable: !0, isSigner: !0 }, - { pubkey: t.printEditionMint, isWritable: !0, isSigner: !1 }, - { pubkey: t.masterEditionMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.printEditionTokenAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.masterEditionTokenAccount, isWritable: !1, isSigner: !1 }, - { pubkey: t.masterEditionAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.printEditionAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.editionMarkerAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.splTokenProgram, isWritable: !1, isSigner: !1 }, - ]; - return new xSt.TransactionInstruction({ programId: e, keys: n, data: r }); - } - Ol.createBurnEditionNftInstruction = nDr; - }); - var kSt = I((Bl) => { - "use strict"; - m(); - g(); - var iDr = - (Bl && Bl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - oDr = - (Bl && Bl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - TSt = - (Bl && Bl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - iDr(e, t, r); - return oDr(e, t), e; - }; - Object.defineProperty(Bl, "__esModule", { value: !0 }); - Bl.createBurnNftInstruction = - Bl.burnNftInstructionDiscriminator = - Bl.BurnNftStruct = - void 0; - var ESt = TSt(Wt()), - MSt = TSt(Le()); - Bl.BurnNftStruct = new ESt.BeetArgsStruct( - [["instructionDiscriminator", ESt.u8]], - "BurnNftInstructionArgs" - ); - Bl.burnNftInstructionDiscriminator = 29; - function aDr( - t, - e = new MSt.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - let [r] = Bl.BurnNftStruct.serialize({ - instructionDiscriminator: Bl.burnNftInstructionDiscriminator, - }), - n = [ - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.owner, isWritable: !0, isSigner: !0 }, - { pubkey: t.mint, isWritable: !0, isSigner: !1 }, - { pubkey: t.tokenAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.masterEditionAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.splTokenProgram, isWritable: !1, isSigner: !1 }, - ]; - return ( - t.collectionMetadata != null && - n.push({ - pubkey: t.collectionMetadata, - isWritable: !0, - isSigner: !1, - }), - new MSt.TransactionInstruction({ programId: e, keys: n, data: r }) - ); - } - Bl.createBurnNftInstruction = aDr; - }); - var BSt = I((Il) => { - "use strict"; - m(); - g(); - var sDr = - (Il && Il.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - uDr = - (Il && Il.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - OSt = - (Il && Il.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - sDr(e, t, r); - return uDr(e, t), e; - }; - Object.defineProperty(Il, "__esModule", { value: !0 }); - Il.createCloseEscrowAccountInstruction = - Il.closeEscrowAccountInstructionDiscriminator = - Il.CloseEscrowAccountStruct = - void 0; - var PSt = OSt(Wt()), - Ake = OSt(Le()); - Il.CloseEscrowAccountStruct = new PSt.BeetArgsStruct( - [["instructionDiscriminator", PSt.u8]], - "CloseEscrowAccountInstructionArgs" - ); - Il.closeEscrowAccountInstructionDiscriminator = 39; - function cDr( - t, - e = new Ake.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - var r; - let [n] = Il.CloseEscrowAccountStruct.serialize({ - instructionDiscriminator: - Il.closeEscrowAccountInstructionDiscriminator, - }), - i = [ - { pubkey: t.escrow, isWritable: !0, isSigner: !1 }, - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.mint, isWritable: !1, isSigner: !1 }, - { pubkey: t.tokenAccount, isWritable: !1, isSigner: !1 }, - { pubkey: t.edition, isWritable: !1, isSigner: !1 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { - pubkey: - (r = t.systemProgram) !== null && r !== void 0 - ? r - : Ake.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.sysvarInstructions, isWritable: !1, isSigner: !1 }, - ]; - return new Ake.TransactionInstruction({ programId: e, keys: i, data: n }); - } - Il.createCloseEscrowAccountInstruction = cDr; - }); - var NSt = I((Cl) => { - "use strict"; - m(); - g(); - var lDr = - (Cl && Cl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - fDr = - (Cl && Cl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - RSt = - (Cl && Cl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - lDr(e, t, r); - return fDr(e, t), e; - }; - Object.defineProperty(Cl, "__esModule", { value: !0 }); - Cl.createConvertMasterEditionV1ToV2Instruction = - Cl.convertMasterEditionV1ToV2InstructionDiscriminator = - Cl.ConvertMasterEditionV1ToV2Struct = - void 0; - var ISt = RSt(Wt()), - CSt = RSt(Le()); - Cl.ConvertMasterEditionV1ToV2Struct = new ISt.BeetArgsStruct( - [["instructionDiscriminator", ISt.u8]], - "ConvertMasterEditionV1ToV2InstructionArgs" - ); - Cl.convertMasterEditionV1ToV2InstructionDiscriminator = 12; - function dDr( - t, - e = new CSt.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - let [r] = Cl.ConvertMasterEditionV1ToV2Struct.serialize({ - instructionDiscriminator: - Cl.convertMasterEditionV1ToV2InstructionDiscriminator, - }), - n = [ - { pubkey: t.masterEdition, isWritable: !0, isSigner: !1 }, - { pubkey: t.oneTimeAuth, isWritable: !0, isSigner: !1 }, - { pubkey: t.printingMint, isWritable: !0, isSigner: !1 }, - ]; - return new CSt.TransactionInstruction({ programId: e, keys: n, data: r }); - } - Cl.createConvertMasterEditionV1ToV2Instruction = dDr; - }); - var LSt = I((Rl) => { - "use strict"; - m(); - g(); - var hDr = - (Rl && Rl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - pDr = - (Rl && Rl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - FSt = - (Rl && Rl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - hDr(e, t, r); - return pDr(e, t), e; - }; - Object.defineProperty(Rl, "__esModule", { value: !0 }); - Rl.createCreateEscrowAccountInstruction = - Rl.createEscrowAccountInstructionDiscriminator = - Rl.CreateEscrowAccountStruct = - void 0; - var DSt = FSt(Wt()), - Eke = FSt(Le()); - Rl.CreateEscrowAccountStruct = new DSt.BeetArgsStruct( - [["instructionDiscriminator", DSt.u8]], - "CreateEscrowAccountInstructionArgs" - ); - Rl.createEscrowAccountInstructionDiscriminator = 38; - function yDr( - t, - e = new Eke.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - var r; - let [n] = Rl.CreateEscrowAccountStruct.serialize({ - instructionDiscriminator: - Rl.createEscrowAccountInstructionDiscriminator, - }), - i = [ - { pubkey: t.escrow, isWritable: !0, isSigner: !1 }, - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.mint, isWritable: !1, isSigner: !1 }, - { pubkey: t.tokenAccount, isWritable: !1, isSigner: !1 }, - { pubkey: t.edition, isWritable: !1, isSigner: !1 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { - pubkey: - (r = t.systemProgram) !== null && r !== void 0 - ? r - : Eke.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.sysvarInstructions, isWritable: !1, isSigner: !1 }, - ]; - return ( - t.authority != null && - i.push({ pubkey: t.authority, isWritable: !1, isSigner: !0 }), - new Eke.TransactionInstruction({ programId: e, keys: i, data: n }) - ); - } - Rl.createCreateEscrowAccountInstruction = yDr; - }); - var YH = I((_1) => { - "use strict"; - m(); - g(); - var mDr = - (_1 && _1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - gDr = - (_1 && _1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - vDr = - (_1 && _1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - mDr(e, t, r); - return gDr(e, t), e; - }; - Object.defineProperty(_1, "__esModule", { value: !0 }); - _1.createMasterEditionArgsBeet = void 0; - var Mke = vDr(Wt()); - _1.createMasterEditionArgsBeet = new Mke.FixableBeetArgsStruct( - [["maxSupply", Mke.coption(Mke.u64)]], - "CreateMasterEditionArgs" - ); - }); - var zSt = I((Nl) => { - "use strict"; - m(); - g(); - var bDr = - (Nl && Nl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - wDr = - (Nl && Nl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Tke = - (Nl && Nl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - bDr(e, t, r); - return wDr(e, t), e; - }; - Object.defineProperty(Nl, "__esModule", { value: !0 }); - Nl.createCreateMasterEditionInstruction = - Nl.createMasterEditionInstructionDiscriminator = - Nl.CreateMasterEditionStruct = - void 0; - var _Dr = Tke(eh()), - qSt = Tke(Wt()), - xse = Tke(Le()), - xDr = YH(); - Nl.CreateMasterEditionStruct = new qSt.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", qSt.u8], - ["createMasterEditionArgs", xDr.createMasterEditionArgsBeet], - ], - "CreateMasterEditionInstructionArgs" - ); - Nl.createMasterEditionInstructionDiscriminator = 10; - function SDr( - t, - e, - r = new xse.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - var n, i, o; - let [a] = Nl.CreateMasterEditionStruct.serialize({ - instructionDiscriminator: - Nl.createMasterEditionInstructionDiscriminator, - ...e, - }), - s = [ - { pubkey: t.edition, isWritable: !0, isSigner: !1 }, - { pubkey: t.mint, isWritable: !0, isSigner: !1 }, - { pubkey: t.updateAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.mintAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : _Dr.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : xse.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (o = t.rent) !== null && o !== void 0 - ? o - : xse.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - return new xse.TransactionInstruction({ programId: r, keys: s, data: a }); - } - Nl.createCreateMasterEditionInstruction = SDr; - }); - var USt = I((Dl) => { - "use strict"; - m(); - g(); - var ADr = - (Dl && Dl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - EDr = - (Dl && Dl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Pke = - (Dl && Dl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - ADr(e, t, r); - return EDr(e, t), e; - }; - Object.defineProperty(Dl, "__esModule", { value: !0 }); - Dl.createCreateMasterEditionV3Instruction = - Dl.createMasterEditionV3InstructionDiscriminator = - Dl.CreateMasterEditionV3Struct = - void 0; - var MDr = Pke(eh()), - jSt = Pke(Wt()), - kke = Pke(Le()), - TDr = YH(); - Dl.CreateMasterEditionV3Struct = new jSt.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", jSt.u8], - ["createMasterEditionArgs", TDr.createMasterEditionArgsBeet], - ], - "CreateMasterEditionV3InstructionArgs" - ); - Dl.createMasterEditionV3InstructionDiscriminator = 17; - function kDr( - t, - e, - r = new kke.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - var n, i; - let [o] = Dl.CreateMasterEditionV3Struct.serialize({ - instructionDiscriminator: - Dl.createMasterEditionV3InstructionDiscriminator, - ...e, - }), - a = [ - { pubkey: t.edition, isWritable: !0, isSigner: !1 }, - { pubkey: t.mint, isWritable: !0, isSigner: !1 }, - { pubkey: t.updateAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.mintAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : MDr.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : kke.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - ]; - return ( - t.rent != null && - a.push({ pubkey: t.rent, isWritable: !1, isSigner: !1 }), - new kke.TransactionInstruction({ programId: r, keys: a, data: o }) - ); - } - Dl.createCreateMasterEditionV3Instruction = kDr; - }); - var Oke = I((x1) => { - "use strict"; - m(); - g(); - var PDr = - (x1 && x1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - ODr = - (x1 && x1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - BDr = - (x1 && x1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - PDr(e, t, r); - return ODr(e, t), e; - }; - Object.defineProperty(x1, "__esModule", { value: !0 }); - x1.createMetadataAccountArgsBeet = void 0; - var KSt = BDr(Wt()), - IDr = YN(); - x1.createMetadataAccountArgsBeet = new KSt.FixableBeetArgsStruct( - [ - ["data", IDr.dataBeet], - ["isMutable", KSt.bool], - ], - "CreateMetadataAccountArgs" - ); - }); - var WSt = I((Fl) => { - "use strict"; - m(); - g(); - var CDr = - (Fl && Fl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - RDr = - (Fl && Fl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - VSt = - (Fl && Fl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - CDr(e, t, r); - return RDr(e, t), e; - }; - Object.defineProperty(Fl, "__esModule", { value: !0 }); - Fl.createCreateMetadataAccountInstruction = - Fl.createMetadataAccountInstructionDiscriminator = - Fl.CreateMetadataAccountStruct = - void 0; - var HSt = VSt(Wt()), - Sse = VSt(Le()), - NDr = Oke(); - Fl.CreateMetadataAccountStruct = new HSt.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", HSt.u8], - ["createMetadataAccountArgs", NDr.createMetadataAccountArgsBeet], - ], - "CreateMetadataAccountInstructionArgs" - ); - Fl.createMetadataAccountInstructionDiscriminator = 0; - function DDr( - t, - e, - r = new Sse.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - var n, i; - let [o] = Fl.CreateMetadataAccountStruct.serialize({ - instructionDiscriminator: - Fl.createMetadataAccountInstructionDiscriminator, - ...e, - }), - a = [ - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.mint, isWritable: !1, isSigner: !1 }, - { pubkey: t.mintAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { pubkey: t.updateAuthority, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.systemProgram) !== null && n !== void 0 - ? n - : Sse.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.rent) !== null && i !== void 0 - ? i - : Sse.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - return new Sse.TransactionInstruction({ programId: r, keys: a, data: o }); - } - Fl.createCreateMetadataAccountInstruction = DDr; - }); - var QH = I((S1) => { - "use strict"; - m(); - g(); - var FDr = - (S1 && S1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - LDr = - (S1 && S1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - qDr = - (S1 && S1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - FDr(e, t, r); - return LDr(e, t), e; - }; - Object.defineProperty(S1, "__esModule", { value: !0 }); - S1.dataV2Beet = void 0; - var jx = qDr(Wt()), - zDr = Rae(), - jDr = VH(), - UDr = WH(); - S1.dataV2Beet = new jx.FixableBeetArgsStruct( - [ - ["name", jx.utf8String], - ["symbol", jx.utf8String], - ["uri", jx.utf8String], - ["sellerFeeBasisPoints", jx.u16], - ["creators", jx.coption(jx.array(zDr.creatorBeet))], - ["collection", jx.coption(jDr.collectionBeet)], - ["uses", jx.coption(UDr.usesBeet)], - ], - "DataV2" - ); - }); - var Bke = I((A1) => { - "use strict"; - m(); - g(); - var KDr = - (A1 && A1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - HDr = - (A1 && A1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - VDr = - (A1 && A1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - KDr(e, t, r); - return HDr(e, t), e; - }; - Object.defineProperty(A1, "__esModule", { value: !0 }); - A1.createMetadataAccountArgsV2Beet = void 0; - var GSt = VDr(Wt()), - WDr = QH(); - A1.createMetadataAccountArgsV2Beet = new GSt.FixableBeetArgsStruct( - [ - ["data", WDr.dataV2Beet], - ["isMutable", GSt.bool], - ], - "CreateMetadataAccountArgsV2" - ); - }); - var ZSt = I((Ll) => { - "use strict"; - m(); - g(); - var GDr = - (Ll && Ll.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - JDr = - (Ll && Ll.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - $St = - (Ll && Ll.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - GDr(e, t, r); - return JDr(e, t), e; - }; - Object.defineProperty(Ll, "__esModule", { value: !0 }); - Ll.createCreateMetadataAccountV2Instruction = - Ll.createMetadataAccountV2InstructionDiscriminator = - Ll.CreateMetadataAccountV2Struct = - void 0; - var JSt = $St(Wt()), - Ike = $St(Le()), - $Dr = Bke(); - Ll.CreateMetadataAccountV2Struct = new JSt.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", JSt.u8], - ["createMetadataAccountArgsV2", $Dr.createMetadataAccountArgsV2Beet], - ], - "CreateMetadataAccountV2InstructionArgs" - ); - Ll.createMetadataAccountV2InstructionDiscriminator = 16; - function ZDr( - t, - e, - r = new Ike.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - var n; - let [i] = Ll.CreateMetadataAccountV2Struct.serialize({ - instructionDiscriminator: - Ll.createMetadataAccountV2InstructionDiscriminator, - ...e, - }), - o = [ - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.mint, isWritable: !1, isSigner: !1 }, - { pubkey: t.mintAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { pubkey: t.updateAuthority, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.systemProgram) !== null && n !== void 0 - ? n - : Ike.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - ]; - return ( - t.rent != null && - o.push({ pubkey: t.rent, isWritable: !1, isSigner: !1 }), - new Ike.TransactionInstruction({ programId: r, keys: o, data: i }) - ); - } - Ll.createCreateMetadataAccountV2Instruction = ZDr; - }); - var Rke = I((E1) => { - "use strict"; - m(); - g(); - var XDr = - (E1 && E1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - YDr = - (E1 && E1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - QDr = - (E1 && E1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - XDr(e, t, r); - return YDr(e, t), e; - }; - Object.defineProperty(E1, "__esModule", { value: !0 }); - E1.createMetadataAccountArgsV3Beet = void 0; - var Cke = QDr(Wt()), - eFr = QH(), - tFr = GH(); - E1.createMetadataAccountArgsV3Beet = new Cke.FixableBeetArgsStruct( - [ - ["data", eFr.dataV2Beet], - ["isMutable", Cke.bool], - ["collectionDetails", Cke.coption(tFr.collectionDetailsBeet)], - ], - "CreateMetadataAccountArgsV3" - ); - }); - var QSt = I((ql) => { - "use strict"; - m(); - g(); - var rFr = - (ql && ql.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - nFr = - (ql && ql.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - YSt = - (ql && ql.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - rFr(e, t, r); - return nFr(e, t), e; - }; - Object.defineProperty(ql, "__esModule", { value: !0 }); - ql.createCreateMetadataAccountV3Instruction = - ql.createMetadataAccountV3InstructionDiscriminator = - ql.CreateMetadataAccountV3Struct = - void 0; - var XSt = YSt(Wt()), - Nke = YSt(Le()), - iFr = Rke(); - ql.CreateMetadataAccountV3Struct = new XSt.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", XSt.u8], - ["createMetadataAccountArgsV3", iFr.createMetadataAccountArgsV3Beet], - ], - "CreateMetadataAccountV3InstructionArgs" - ); - ql.createMetadataAccountV3InstructionDiscriminator = 33; - function oFr( - t, - e, - r = new Nke.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - var n; - let [i] = ql.CreateMetadataAccountV3Struct.serialize({ - instructionDiscriminator: - ql.createMetadataAccountV3InstructionDiscriminator, - ...e, - }), - o = [ - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.mint, isWritable: !1, isSigner: !1 }, - { pubkey: t.mintAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { pubkey: t.updateAuthority, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.systemProgram) !== null && n !== void 0 - ? n - : Nke.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - ]; - return ( - t.rent != null && - o.push({ pubkey: t.rent, isWritable: !1, isSigner: !1 }), - new Nke.TransactionInstruction({ programId: r, keys: o, data: i }) - ); - } - ql.createCreateMetadataAccountV3Instruction = oFr; - }); - var t2t = I((zl) => { - "use strict"; - m(); - g(); - var aFr = - (zl && zl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - sFr = - (zl && zl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Dke = - (zl && zl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - aFr(e, t, r); - return sFr(e, t), e; - }; - Object.defineProperty(zl, "__esModule", { value: !0 }); - zl.createDeprecatedCreateMasterEditionInstruction = - zl.deprecatedCreateMasterEditionInstructionDiscriminator = - zl.DeprecatedCreateMasterEditionStruct = - void 0; - var uFr = Dke(eh()), - e2t = Dke(Wt()), - Ase = Dke(Le()), - cFr = YH(); - zl.DeprecatedCreateMasterEditionStruct = new e2t.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", e2t.u8], - ["createMasterEditionArgs", cFr.createMasterEditionArgsBeet], - ], - "DeprecatedCreateMasterEditionInstructionArgs" - ); - zl.deprecatedCreateMasterEditionInstructionDiscriminator = 2; - function lFr( - t, - e, - r = new Ase.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - var n, i, o; - let [a] = zl.DeprecatedCreateMasterEditionStruct.serialize({ - instructionDiscriminator: - zl.deprecatedCreateMasterEditionInstructionDiscriminator, - ...e, - }), - s = [ - { pubkey: t.edition, isWritable: !0, isSigner: !1 }, - { pubkey: t.mint, isWritable: !0, isSigner: !1 }, - { pubkey: t.printingMint, isWritable: !0, isSigner: !1 }, - { - pubkey: t.oneTimePrintingAuthorizationMint, - isWritable: !0, - isSigner: !1, - }, - { pubkey: t.updateAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.printingMintAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.mintAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.payer, isWritable: !1, isSigner: !0 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : uFr.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : Ase.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (o = t.rent) !== null && o !== void 0 - ? o - : Ase.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: t.oneTimePrintingAuthorizationMintAuthority, - isWritable: !1, - isSigner: !0, - }, - ]; - return new Ase.TransactionInstruction({ programId: r, keys: s, data: a }); - } - zl.createDeprecatedCreateMasterEditionInstruction = lFr; - }); - var i2t = I((jl) => { - "use strict"; - m(); - g(); - var fFr = - (jl && jl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - dFr = - (jl && jl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - n2t = - (jl && jl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - fFr(e, t, r); - return dFr(e, t), e; - }; - Object.defineProperty(jl, "__esModule", { value: !0 }); - jl.createDeprecatedCreateReservationListInstruction = - jl.deprecatedCreateReservationListInstructionDiscriminator = - jl.DeprecatedCreateReservationListStruct = - void 0; - var r2t = n2t(Wt()), - Ese = n2t(Le()); - jl.DeprecatedCreateReservationListStruct = new r2t.BeetArgsStruct( - [["instructionDiscriminator", r2t.u8]], - "DeprecatedCreateReservationListInstructionArgs" - ); - jl.deprecatedCreateReservationListInstructionDiscriminator = 6; - function hFr( - t, - e = new Ese.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - var r, n; - let [i] = jl.DeprecatedCreateReservationListStruct.serialize({ - instructionDiscriminator: - jl.deprecatedCreateReservationListInstructionDiscriminator, - }), - o = [ - { pubkey: t.reservationList, isWritable: !0, isSigner: !1 }, - { pubkey: t.payer, isWritable: !1, isSigner: !0 }, - { pubkey: t.updateAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.masterEdition, isWritable: !1, isSigner: !1 }, - { pubkey: t.resource, isWritable: !1, isSigner: !1 }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { - pubkey: - (r = t.systemProgram) !== null && r !== void 0 - ? r - : Ese.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (n = t.rent) !== null && n !== void 0 - ? n - : Ese.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - return new Ese.TransactionInstruction({ programId: e, keys: o, data: i }); - } - jl.createDeprecatedCreateReservationListInstruction = hFr; - }); - var a2t = I((Ul) => { - "use strict"; - m(); - g(); - var pFr = - (Ul && Ul.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - yFr = - (Ul && Ul.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Fke = - (Ul && Ul.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - pFr(e, t, r); - return yFr(e, t), e; - }; - Object.defineProperty(Ul, "__esModule", { value: !0 }); - Ul.createDeprecatedMintNewEditionFromMasterEditionViaPrintingTokenInstruction = - Ul.deprecatedMintNewEditionFromMasterEditionViaPrintingTokenInstructionDiscriminator = - Ul.DeprecatedMintNewEditionFromMasterEditionViaPrintingTokenStruct = - void 0; - var mFr = Fke(eh()), - o2t = Fke(Wt()), - Mse = Fke(Le()); - Ul.DeprecatedMintNewEditionFromMasterEditionViaPrintingTokenStruct = - new o2t.BeetArgsStruct( - [["instructionDiscriminator", o2t.u8]], - "DeprecatedMintNewEditionFromMasterEditionViaPrintingTokenInstructionArgs" - ); - Ul.deprecatedMintNewEditionFromMasterEditionViaPrintingTokenInstructionDiscriminator = 3; - function gFr( - t, - e = new Mse.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - var r, n, i; - let [o] = - Ul.DeprecatedMintNewEditionFromMasterEditionViaPrintingTokenStruct.serialize( - { - instructionDiscriminator: - Ul.deprecatedMintNewEditionFromMasterEditionViaPrintingTokenInstructionDiscriminator, - } - ), - a = [ - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.edition, isWritable: !0, isSigner: !1 }, - { pubkey: t.masterEdition, isWritable: !0, isSigner: !1 }, - { pubkey: t.mint, isWritable: !0, isSigner: !1 }, - { pubkey: t.mintAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.printingMint, isWritable: !0, isSigner: !1 }, - { pubkey: t.masterTokenAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.editionMarker, isWritable: !0, isSigner: !1 }, - { pubkey: t.burnAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.payer, isWritable: !1, isSigner: !0 }, - { pubkey: t.masterUpdateAuthority, isWritable: !1, isSigner: !1 }, - { pubkey: t.masterMetadata, isWritable: !1, isSigner: !1 }, - { - pubkey: - (r = t.tokenProgram) !== null && r !== void 0 - ? r - : mFr.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (n = t.systemProgram) !== null && n !== void 0 - ? n - : Mse.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.rent) !== null && i !== void 0 - ? i - : Mse.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - return ( - t.reservationList != null && - a.push({ pubkey: t.reservationList, isWritable: !0, isSigner: !1 }), - new Mse.TransactionInstruction({ programId: e, keys: a, data: o }) - ); - } - Ul.createDeprecatedMintNewEditionFromMasterEditionViaPrintingTokenInstruction = - gFr; - }); - var Tse = I((M1) => { - "use strict"; - m(); - g(); - var vFr = - (M1 && M1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - bFr = - (M1 && M1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - wFr = - (M1 && M1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - vFr(e, t, r); - return bFr(e, t), e; - }; - Object.defineProperty(M1, "__esModule", { value: !0 }); - M1.mintPrintingTokensViaTokenArgsBeet = void 0; - var s2t = wFr(Wt()); - M1.mintPrintingTokensViaTokenArgsBeet = new s2t.BeetArgsStruct( - [["supply", s2t.u64]], - "MintPrintingTokensViaTokenArgs" - ); - }); - var c2t = I((Kl) => { - "use strict"; - m(); - g(); - var _Fr = - (Kl && Kl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - xFr = - (Kl && Kl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - qke = - (Kl && Kl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - _Fr(e, t, r); - return xFr(e, t), e; - }; - Object.defineProperty(Kl, "__esModule", { value: !0 }); - Kl.createDeprecatedMintPrintingTokensInstruction = - Kl.deprecatedMintPrintingTokensInstructionDiscriminator = - Kl.DeprecatedMintPrintingTokensStruct = - void 0; - var SFr = qke(eh()), - u2t = qke(Wt()), - Lke = qke(Le()), - AFr = Tse(); - Kl.DeprecatedMintPrintingTokensStruct = new u2t.BeetArgsStruct( - [ - ["instructionDiscriminator", u2t.u8], - [ - "mintPrintingTokensViaTokenArgs", - AFr.mintPrintingTokensViaTokenArgsBeet, - ], - ], - "DeprecatedMintPrintingTokensInstructionArgs" - ); - Kl.deprecatedMintPrintingTokensInstructionDiscriminator = 9; - function EFr( - t, - e, - r = new Lke.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - var n, i; - let [o] = Kl.DeprecatedMintPrintingTokensStruct.serialize({ - instructionDiscriminator: - Kl.deprecatedMintPrintingTokensInstructionDiscriminator, - ...e, - }), - a = [ - { pubkey: t.destination, isWritable: !0, isSigner: !1 }, - { pubkey: t.printingMint, isWritable: !0, isSigner: !1 }, - { pubkey: t.updateAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.masterEdition, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : SFr.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.rent) !== null && i !== void 0 - ? i - : Lke.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - return new Lke.TransactionInstruction({ programId: r, keys: a, data: o }); - } - Kl.createDeprecatedMintPrintingTokensInstruction = EFr; - }); - var f2t = I((Hl) => { - "use strict"; - m(); - g(); - var MFr = - (Hl && Hl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - TFr = - (Hl && Hl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - jke = - (Hl && Hl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - MFr(e, t, r); - return TFr(e, t), e; - }; - Object.defineProperty(Hl, "__esModule", { value: !0 }); - Hl.createDeprecatedMintPrintingTokensViaTokenInstruction = - Hl.deprecatedMintPrintingTokensViaTokenInstructionDiscriminator = - Hl.DeprecatedMintPrintingTokensViaTokenStruct = - void 0; - var kFr = jke(eh()), - l2t = jke(Wt()), - zke = jke(Le()), - PFr = Tse(); - Hl.DeprecatedMintPrintingTokensViaTokenStruct = new l2t.BeetArgsStruct( - [ - ["instructionDiscriminator", l2t.u8], - [ - "mintPrintingTokensViaTokenArgs", - PFr.mintPrintingTokensViaTokenArgsBeet, - ], - ], - "DeprecatedMintPrintingTokensViaTokenInstructionArgs" - ); - Hl.deprecatedMintPrintingTokensViaTokenInstructionDiscriminator = 8; - function OFr( - t, - e, - r = new zke.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - var n, i; - let [o] = Hl.DeprecatedMintPrintingTokensViaTokenStruct.serialize({ - instructionDiscriminator: - Hl.deprecatedMintPrintingTokensViaTokenInstructionDiscriminator, - ...e, - }), - a = [ - { pubkey: t.destination, isWritable: !0, isSigner: !1 }, - { pubkey: t.token, isWritable: !0, isSigner: !1 }, - { - pubkey: t.oneTimePrintingAuthorizationMint, - isWritable: !0, - isSigner: !1, - }, - { pubkey: t.printingMint, isWritable: !0, isSigner: !1 }, - { pubkey: t.burnAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.masterEdition, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : kFr.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.rent) !== null && i !== void 0 - ? i - : zke.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - return new zke.TransactionInstruction({ programId: r, keys: a, data: o }); - } - Hl.createDeprecatedMintPrintingTokensViaTokenInstruction = OFr; - }); - var Uke = I((T1) => { - "use strict"; - m(); - g(); - var BFr = - (T1 && T1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - IFr = - (T1 && T1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - CFr = - (T1 && T1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - BFr(e, t, r); - return IFr(e, t), e; - }; - Object.defineProperty(T1, "__esModule", { value: !0 }); - T1.setReservationListArgsBeet = void 0; - var S9 = CFr(Wt()), - RFr = Uae(); - T1.setReservationListArgsBeet = new S9.FixableBeetArgsStruct( - [ - ["reservations", S9.array(RFr.reservationBeet)], - ["totalReservationSpots", S9.coption(S9.u64)], - ["offset", S9.u64], - ["totalSpotOffset", S9.u64], - ], - "SetReservationListArgs" - ); - }); - var y2t = I((Vl) => { - "use strict"; - m(); - g(); - var NFr = - (Vl && Vl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - DFr = - (Vl && Vl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - p2t = - (Vl && Vl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - NFr(e, t, r); - return DFr(e, t), e; - }; - Object.defineProperty(Vl, "__esModule", { value: !0 }); - Vl.createDeprecatedSetReservationListInstruction = - Vl.deprecatedSetReservationListInstructionDiscriminator = - Vl.DeprecatedSetReservationListStruct = - void 0; - var d2t = p2t(Wt()), - h2t = p2t(Le()), - FFr = Uke(); - Vl.DeprecatedSetReservationListStruct = new d2t.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", d2t.u8], - ["setReservationListArgs", FFr.setReservationListArgsBeet], - ], - "DeprecatedSetReservationListInstructionArgs" - ); - Vl.deprecatedSetReservationListInstructionDiscriminator = 5; - function LFr( - t, - e, - r = new h2t.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - let [n] = Vl.DeprecatedSetReservationListStruct.serialize({ - instructionDiscriminator: - Vl.deprecatedSetReservationListInstructionDiscriminator, - ...e, - }), - i = [ - { pubkey: t.masterEdition, isWritable: !0, isSigner: !1 }, - { pubkey: t.reservationList, isWritable: !0, isSigner: !1 }, - { pubkey: t.resource, isWritable: !1, isSigner: !0 }, - ]; - return new h2t.TransactionInstruction({ programId: r, keys: i, data: n }); - } - Vl.createDeprecatedSetReservationListInstruction = LFr; - }); - var v2t = I((Wl) => { - "use strict"; - m(); - g(); - var qFr = - (Wl && Wl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - zFr = - (Wl && Wl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Kke = - (Wl && Wl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - qFr(e, t, r); - return zFr(e, t), e; - }; - Object.defineProperty(Wl, "__esModule", { value: !0 }); - Wl.createFreezeDelegatedAccountInstruction = - Wl.freezeDelegatedAccountInstructionDiscriminator = - Wl.FreezeDelegatedAccountStruct = - void 0; - var jFr = Kke(eh()), - m2t = Kke(Wt()), - g2t = Kke(Le()); - Wl.FreezeDelegatedAccountStruct = new m2t.BeetArgsStruct( - [["instructionDiscriminator", m2t.u8]], - "FreezeDelegatedAccountInstructionArgs" - ); - Wl.freezeDelegatedAccountInstructionDiscriminator = 26; - function UFr( - t, - e = new g2t.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - var r; - let [n] = Wl.FreezeDelegatedAccountStruct.serialize({ - instructionDiscriminator: - Wl.freezeDelegatedAccountInstructionDiscriminator, - }), - i = [ - { pubkey: t.delegate, isWritable: !0, isSigner: !0 }, - { pubkey: t.tokenAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.edition, isWritable: !1, isSigner: !1 }, - { pubkey: t.mint, isWritable: !1, isSigner: !1 }, - { - pubkey: - (r = t.tokenProgram) !== null && r !== void 0 - ? r - : jFr.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - ]; - return new g2t.TransactionInstruction({ programId: e, keys: i, data: n }); - } - Wl.createFreezeDelegatedAccountInstruction = UFr; - }); - var kse = I((k1) => { - "use strict"; - m(); - g(); - var KFr = - (k1 && k1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - HFr = - (k1 && k1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - VFr = - (k1 && k1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - KFr(e, t, r); - return HFr(e, t), e; - }; - Object.defineProperty(k1, "__esModule", { value: !0 }); - k1.mintNewEditionFromMasterEditionViaTokenArgsBeet = void 0; - var b2t = VFr(Wt()); - k1.mintNewEditionFromMasterEditionViaTokenArgsBeet = new b2t.BeetArgsStruct( - [["edition", b2t.u64]], - "MintNewEditionFromMasterEditionViaTokenArgs" - ); - }); - var _2t = I((Gl) => { - "use strict"; - m(); - g(); - var WFr = - (Gl && Gl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - GFr = - (Gl && Gl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Vke = - (Gl && Gl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - WFr(e, t, r); - return GFr(e, t), e; - }; - Object.defineProperty(Gl, "__esModule", { value: !0 }); - Gl.createMintNewEditionFromMasterEditionViaTokenInstruction = - Gl.mintNewEditionFromMasterEditionViaTokenInstructionDiscriminator = - Gl.MintNewEditionFromMasterEditionViaTokenStruct = - void 0; - var JFr = Vke(eh()), - w2t = Vke(Wt()), - Hke = Vke(Le()), - $Fr = kse(); - Gl.MintNewEditionFromMasterEditionViaTokenStruct = new w2t.BeetArgsStruct( - [ - ["instructionDiscriminator", w2t.u8], - [ - "mintNewEditionFromMasterEditionViaTokenArgs", - $Fr.mintNewEditionFromMasterEditionViaTokenArgsBeet, - ], - ], - "MintNewEditionFromMasterEditionViaTokenInstructionArgs" - ); - Gl.mintNewEditionFromMasterEditionViaTokenInstructionDiscriminator = 11; - function ZFr( - t, - e, - r = new Hke.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - var n, i; - let [o] = Gl.MintNewEditionFromMasterEditionViaTokenStruct.serialize({ - instructionDiscriminator: - Gl.mintNewEditionFromMasterEditionViaTokenInstructionDiscriminator, - ...e, - }), - a = [ - { pubkey: t.newMetadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.newEdition, isWritable: !0, isSigner: !1 }, - { pubkey: t.masterEdition, isWritable: !0, isSigner: !1 }, - { pubkey: t.newMint, isWritable: !0, isSigner: !1 }, - { pubkey: t.editionMarkPda, isWritable: !0, isSigner: !1 }, - { pubkey: t.newMintAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { pubkey: t.tokenAccountOwner, isWritable: !1, isSigner: !0 }, - { pubkey: t.tokenAccount, isWritable: !1, isSigner: !1 }, - { - pubkey: t.newMetadataUpdateAuthority, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : JFr.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : Hke.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - ]; - return ( - t.rent != null && - a.push({ pubkey: t.rent, isWritable: !1, isSigner: !1 }), - new Hke.TransactionInstruction({ programId: r, keys: a, data: o }) - ); - } - Gl.createMintNewEditionFromMasterEditionViaTokenInstruction = ZFr; - }); - var S2t = I((Jl) => { - "use strict"; - m(); - g(); - var XFr = - (Jl && Jl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - YFr = - (Jl && Jl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Gke = - (Jl && Jl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - XFr(e, t, r); - return YFr(e, t), e; - }; - Object.defineProperty(Jl, "__esModule", { value: !0 }); - Jl.createMintNewEditionFromMasterEditionViaVaultProxyInstruction = - Jl.mintNewEditionFromMasterEditionViaVaultProxyInstructionDiscriminator = - Jl.MintNewEditionFromMasterEditionViaVaultProxyStruct = - void 0; - var QFr = Gke(eh()), - x2t = Gke(Wt()), - Wke = Gke(Le()), - eLr = kse(); - Jl.MintNewEditionFromMasterEditionViaVaultProxyStruct = - new x2t.BeetArgsStruct( - [ - ["instructionDiscriminator", x2t.u8], - [ - "mintNewEditionFromMasterEditionViaTokenArgs", - eLr.mintNewEditionFromMasterEditionViaTokenArgsBeet, - ], - ], - "MintNewEditionFromMasterEditionViaVaultProxyInstructionArgs" - ); - Jl.mintNewEditionFromMasterEditionViaVaultProxyInstructionDiscriminator = 13; - function tLr( - t, - e, - r = new Wke.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - var n, i; - let [o] = Jl.MintNewEditionFromMasterEditionViaVaultProxyStruct.serialize( - { - instructionDiscriminator: - Jl.mintNewEditionFromMasterEditionViaVaultProxyInstructionDiscriminator, - ...e, - } - ), - a = [ - { pubkey: t.newMetadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.newEdition, isWritable: !0, isSigner: !1 }, - { pubkey: t.masterEdition, isWritable: !0, isSigner: !1 }, - { pubkey: t.newMint, isWritable: !0, isSigner: !1 }, - { pubkey: t.editionMarkPda, isWritable: !0, isSigner: !1 }, - { pubkey: t.newMintAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { pubkey: t.vaultAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.safetyDepositStore, isWritable: !1, isSigner: !1 }, - { pubkey: t.safetyDepositBox, isWritable: !1, isSigner: !1 }, - { pubkey: t.vault, isWritable: !1, isSigner: !1 }, - { - pubkey: t.newMetadataUpdateAuthority, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : QFr.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.tokenVaultProgram, isWritable: !1, isSigner: !1 }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : Wke.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - ]; - return ( - t.rent != null && - a.push({ pubkey: t.rent, isWritable: !1, isSigner: !1 }), - new Wke.TransactionInstruction({ programId: r, keys: a, data: o }) - ); - } - Jl.createMintNewEditionFromMasterEditionViaVaultProxyInstruction = tLr; - }); - var T2t = I(($l) => { - "use strict"; - m(); - g(); - var rLr = - ($l && $l.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - nLr = - ($l && $l.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - M2t = - ($l && $l.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - rLr(e, t, r); - return nLr(e, t), e; - }; - Object.defineProperty($l, "__esModule", { value: !0 }); - $l.createPuffMetadataInstruction = - $l.puffMetadataInstructionDiscriminator = - $l.PuffMetadataStruct = - void 0; - var A2t = M2t(Wt()), - E2t = M2t(Le()); - $l.PuffMetadataStruct = new A2t.BeetArgsStruct( - [["instructionDiscriminator", A2t.u8]], - "PuffMetadataInstructionArgs" - ); - $l.puffMetadataInstructionDiscriminator = 14; - function iLr( - t, - e = new E2t.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - let [r] = $l.PuffMetadataStruct.serialize({ - instructionDiscriminator: $l.puffMetadataInstructionDiscriminator, - }), - n = [{ pubkey: t.metadata, isWritable: !0, isSigner: !1 }]; - return new E2t.TransactionInstruction({ programId: e, keys: n, data: r }); - } - $l.createPuffMetadataInstruction = iLr; - }); - var B2t = I((Zl) => { - "use strict"; - m(); - g(); - var oLr = - (Zl && Zl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - aLr = - (Zl && Zl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - O2t = - (Zl && Zl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - oLr(e, t, r); - return aLr(e, t), e; - }; - Object.defineProperty(Zl, "__esModule", { value: !0 }); - Zl.createRemoveCreatorVerificationInstruction = - Zl.removeCreatorVerificationInstructionDiscriminator = - Zl.RemoveCreatorVerificationStruct = - void 0; - var k2t = O2t(Wt()), - P2t = O2t(Le()); - Zl.RemoveCreatorVerificationStruct = new k2t.BeetArgsStruct( - [["instructionDiscriminator", k2t.u8]], - "RemoveCreatorVerificationInstructionArgs" - ); - Zl.removeCreatorVerificationInstructionDiscriminator = 28; - function sLr( - t, - e = new P2t.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - let [r] = Zl.RemoveCreatorVerificationStruct.serialize({ - instructionDiscriminator: - Zl.removeCreatorVerificationInstructionDiscriminator, - }), - n = [ - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.creator, isWritable: !1, isSigner: !0 }, - ]; - return new P2t.TransactionInstruction({ programId: e, keys: n, data: r }); - } - Zl.createRemoveCreatorVerificationInstruction = sLr; - }); - var N2t = I((Xl) => { - "use strict"; - m(); - g(); - var uLr = - (Xl && Xl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - cLr = - (Xl && Xl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - R2t = - (Xl && Xl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - uLr(e, t, r); - return cLr(e, t), e; - }; - Object.defineProperty(Xl, "__esModule", { value: !0 }); - Xl.createRevokeCollectionAuthorityInstruction = - Xl.revokeCollectionAuthorityInstructionDiscriminator = - Xl.RevokeCollectionAuthorityStruct = - void 0; - var I2t = R2t(Wt()), - C2t = R2t(Le()); - Xl.RevokeCollectionAuthorityStruct = new I2t.BeetArgsStruct( - [["instructionDiscriminator", I2t.u8]], - "RevokeCollectionAuthorityInstructionArgs" - ); - Xl.revokeCollectionAuthorityInstructionDiscriminator = 24; - function lLr( - t, - e = new C2t.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - let [r] = Xl.RevokeCollectionAuthorityStruct.serialize({ - instructionDiscriminator: - Xl.revokeCollectionAuthorityInstructionDiscriminator, - }), - n = [ - { pubkey: t.collectionAuthorityRecord, isWritable: !0, isSigner: !1 }, - { pubkey: t.delegateAuthority, isWritable: !0, isSigner: !1 }, - { pubkey: t.revokeAuthority, isWritable: !0, isSigner: !0 }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.mint, isWritable: !1, isSigner: !1 }, - ]; - return new C2t.TransactionInstruction({ programId: e, keys: n, data: r }); - } - Xl.createRevokeCollectionAuthorityInstruction = lLr; - }); - var F2t = I((Yl) => { - "use strict"; - m(); - g(); - var fLr = - (Yl && Yl.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - dLr = - (Yl && Yl.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - $ke = - (Yl && Yl.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - fLr(e, t, r); - return dLr(e, t), e; - }; - Object.defineProperty(Yl, "__esModule", { value: !0 }); - Yl.createRevokeUseAuthorityInstruction = - Yl.revokeUseAuthorityInstructionDiscriminator = - Yl.RevokeUseAuthorityStruct = - void 0; - var hLr = $ke(eh()), - D2t = $ke(Wt()), - Jke = $ke(Le()); - Yl.RevokeUseAuthorityStruct = new D2t.BeetArgsStruct( - [["instructionDiscriminator", D2t.u8]], - "RevokeUseAuthorityInstructionArgs" - ); - Yl.revokeUseAuthorityInstructionDiscriminator = 21; - function pLr( - t, - e = new Jke.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - var r, n; - let [i] = Yl.RevokeUseAuthorityStruct.serialize({ - instructionDiscriminator: - Yl.revokeUseAuthorityInstructionDiscriminator, - }), - o = [ - { pubkey: t.useAuthorityRecord, isWritable: !0, isSigner: !1 }, - { pubkey: t.owner, isWritable: !0, isSigner: !0 }, - { pubkey: t.user, isWritable: !1, isSigner: !1 }, - { pubkey: t.ownerTokenAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.mint, isWritable: !1, isSigner: !1 }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { - pubkey: - (r = t.tokenProgram) !== null && r !== void 0 - ? r - : hLr.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (n = t.systemProgram) !== null && n !== void 0 - ? n - : Jke.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - ]; - return ( - t.rent != null && - o.push({ pubkey: t.rent, isWritable: !1, isSigner: !1 }), - new Jke.TransactionInstruction({ programId: e, keys: o, data: i }) - ); - } - Yl.createRevokeUseAuthorityInstruction = pLr; - }); - var j2t = I((Ql) => { - "use strict"; - m(); - g(); - var yLr = - (Ql && Ql.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - mLr = - (Ql && Ql.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - z2t = - (Ql && Ql.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - yLr(e, t, r); - return mLr(e, t), e; - }; - Object.defineProperty(Ql, "__esModule", { value: !0 }); - Ql.createSetAndVerifyCollectionInstruction = - Ql.setAndVerifyCollectionInstructionDiscriminator = - Ql.SetAndVerifyCollectionStruct = - void 0; - var L2t = z2t(Wt()), - q2t = z2t(Le()); - Ql.SetAndVerifyCollectionStruct = new L2t.BeetArgsStruct( - [["instructionDiscriminator", L2t.u8]], - "SetAndVerifyCollectionInstructionArgs" - ); - Ql.setAndVerifyCollectionInstructionDiscriminator = 25; - function gLr( - t, - e = new q2t.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - let [r] = Ql.SetAndVerifyCollectionStruct.serialize({ - instructionDiscriminator: - Ql.setAndVerifyCollectionInstructionDiscriminator, - }), - n = [ - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.collectionAuthority, isWritable: !0, isSigner: !0 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { pubkey: t.updateAuthority, isWritable: !1, isSigner: !1 }, - { pubkey: t.collectionMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.collection, isWritable: !1, isSigner: !1 }, - { - pubkey: t.collectionMasterEditionAccount, - isWritable: !1, - isSigner: !1, - }, - ]; - return ( - t.collectionAuthorityRecord != null && - n.push({ - pubkey: t.collectionAuthorityRecord, - isWritable: !1, - isSigner: !1, - }), - new q2t.TransactionInstruction({ programId: e, keys: n, data: r }) - ); - } - Ql.createSetAndVerifyCollectionInstruction = gLr; - }); - var V2t = I((ef) => { - "use strict"; - m(); - g(); - var vLr = - (ef && ef.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - bLr = - (ef && ef.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - H2t = - (ef && ef.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - vLr(e, t, r); - return bLr(e, t), e; - }; - Object.defineProperty(ef, "__esModule", { value: !0 }); - ef.createSetAndVerifySizedCollectionItemInstruction = - ef.setAndVerifySizedCollectionItemInstructionDiscriminator = - ef.SetAndVerifySizedCollectionItemStruct = - void 0; - var U2t = H2t(Wt()), - K2t = H2t(Le()); - ef.SetAndVerifySizedCollectionItemStruct = new U2t.BeetArgsStruct( - [["instructionDiscriminator", U2t.u8]], - "SetAndVerifySizedCollectionItemInstructionArgs" - ); - ef.setAndVerifySizedCollectionItemInstructionDiscriminator = 32; - function wLr( - t, - e = new K2t.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - let [r] = ef.SetAndVerifySizedCollectionItemStruct.serialize({ - instructionDiscriminator: - ef.setAndVerifySizedCollectionItemInstructionDiscriminator, - }), - n = [ - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.collectionAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { pubkey: t.updateAuthority, isWritable: !1, isSigner: !1 }, - { pubkey: t.collectionMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.collection, isWritable: !0, isSigner: !1 }, - { - pubkey: t.collectionMasterEditionAccount, - isWritable: !0, - isSigner: !1, - }, - ]; - return ( - t.collectionAuthorityRecord != null && - n.push({ - pubkey: t.collectionAuthorityRecord, - isWritable: !1, - isSigner: !1, - }), - new K2t.TransactionInstruction({ programId: e, keys: n, data: r }) - ); - } - ef.createSetAndVerifySizedCollectionItemInstruction = wLr; - }); - var $2t = I((tf) => { - "use strict"; - m(); - g(); - var _Lr = - (tf && tf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - xLr = - (tf && tf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - J2t = - (tf && tf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - _Lr(e, t, r); - return xLr(e, t), e; - }; - Object.defineProperty(tf, "__esModule", { value: !0 }); - tf.createSetCollectionSizeInstruction = - tf.setCollectionSizeInstructionDiscriminator = - tf.SetCollectionSizeStruct = - void 0; - var W2t = J2t(Wt()), - G2t = J2t(Le()), - SLr = _se(); - tf.SetCollectionSizeStruct = new W2t.BeetArgsStruct( - [ - ["instructionDiscriminator", W2t.u8], - ["setCollectionSizeArgs", SLr.setCollectionSizeArgsBeet], - ], - "SetCollectionSizeInstructionArgs" - ); - tf.setCollectionSizeInstructionDiscriminator = 34; - function ALr( - t, - e, - r = new G2t.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - let [n] = tf.SetCollectionSizeStruct.serialize({ - instructionDiscriminator: - tf.setCollectionSizeInstructionDiscriminator, - ...e, - }), - i = [ - { pubkey: t.collectionMetadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.collectionAuthority, isWritable: !0, isSigner: !0 }, - { pubkey: t.collectionMint, isWritable: !1, isSigner: !1 }, - ]; - return ( - t.collectionAuthorityRecord != null && - i.push({ - pubkey: t.collectionAuthorityRecord, - isWritable: !1, - isSigner: !1, - }), - new G2t.TransactionInstruction({ programId: r, keys: i, data: n }) - ); - } - tf.createSetCollectionSizeInstruction = ALr; - }); - var Q2t = I((rf) => { - "use strict"; - m(); - g(); - var ELr = - (rf && rf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - MLr = - (rf && rf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Y2t = - (rf && rf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - ELr(e, t, r); - return MLr(e, t), e; - }; - Object.defineProperty(rf, "__esModule", { value: !0 }); - rf.createSetTokenStandardInstruction = - rf.setTokenStandardInstructionDiscriminator = - rf.SetTokenStandardStruct = - void 0; - var Z2t = Y2t(Wt()), - X2t = Y2t(Le()); - rf.SetTokenStandardStruct = new Z2t.BeetArgsStruct( - [["instructionDiscriminator", Z2t.u8]], - "SetTokenStandardInstructionArgs" - ); - rf.setTokenStandardInstructionDiscriminator = 35; - function TLr( - t, - e = new X2t.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - let [r] = rf.SetTokenStandardStruct.serialize({ - instructionDiscriminator: rf.setTokenStandardInstructionDiscriminator, - }), - n = [ - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.updateAuthority, isWritable: !0, isSigner: !0 }, - { pubkey: t.mint, isWritable: !1, isSigner: !1 }, - ]; - return ( - t.edition != null && - n.push({ pubkey: t.edition, isWritable: !1, isSigner: !1 }), - new X2t.TransactionInstruction({ programId: e, keys: n, data: r }) - ); - } - rf.createSetTokenStandardInstruction = TLr; - }); - var nAt = I((nf) => { - "use strict"; - m(); - g(); - var kLr = - (nf && nf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - PLr = - (nf && nf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - rAt = - (nf && nf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - kLr(e, t, r); - return PLr(e, t), e; - }; - Object.defineProperty(nf, "__esModule", { value: !0 }); - nf.createSignMetadataInstruction = - nf.signMetadataInstructionDiscriminator = - nf.SignMetadataStruct = - void 0; - var eAt = rAt(Wt()), - tAt = rAt(Le()); - nf.SignMetadataStruct = new eAt.BeetArgsStruct( - [["instructionDiscriminator", eAt.u8]], - "SignMetadataInstructionArgs" - ); - nf.signMetadataInstructionDiscriminator = 7; - function OLr( - t, - e = new tAt.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - let [r] = nf.SignMetadataStruct.serialize({ - instructionDiscriminator: nf.signMetadataInstructionDiscriminator, - }), - n = [ - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.creator, isWritable: !1, isSigner: !0 }, - ]; - return new tAt.TransactionInstruction({ programId: e, keys: n, data: r }); - } - nf.createSignMetadataInstruction = OLr; - }); - var aAt = I((of) => { - "use strict"; - m(); - g(); - var BLr = - (of && of.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - ILr = - (of && of.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Zke = - (of && of.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - BLr(e, t, r); - return ILr(e, t), e; - }; - Object.defineProperty(of, "__esModule", { value: !0 }); - of.createThawDelegatedAccountInstruction = - of.thawDelegatedAccountInstructionDiscriminator = - of.ThawDelegatedAccountStruct = - void 0; - var CLr = Zke(eh()), - iAt = Zke(Wt()), - oAt = Zke(Le()); - of.ThawDelegatedAccountStruct = new iAt.BeetArgsStruct( - [["instructionDiscriminator", iAt.u8]], - "ThawDelegatedAccountInstructionArgs" - ); - of.thawDelegatedAccountInstructionDiscriminator = 27; - function RLr( - t, - e = new oAt.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - var r; - let [n] = of.ThawDelegatedAccountStruct.serialize({ - instructionDiscriminator: - of.thawDelegatedAccountInstructionDiscriminator, - }), - i = [ - { pubkey: t.delegate, isWritable: !0, isSigner: !0 }, - { pubkey: t.tokenAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.edition, isWritable: !1, isSigner: !1 }, - { pubkey: t.mint, isWritable: !1, isSigner: !1 }, - { - pubkey: - (r = t.tokenProgram) !== null && r !== void 0 - ? r - : CLr.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - ]; - return new oAt.TransactionInstruction({ programId: e, keys: i, data: n }); - } - of.createThawDelegatedAccountInstruction = RLr; - }); - var Xke = I((P1) => { - "use strict"; - m(); - g(); - var NLr = - (P1 && P1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - DLr = - (P1 && P1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - FLr = - (P1 && P1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - NLr(e, t, r); - return DLr(e, t), e; - }; - Object.defineProperty(P1, "__esModule", { value: !0 }); - P1.transferOutOfEscrowArgsBeet = void 0; - var sAt = FLr(Wt()); - P1.transferOutOfEscrowArgsBeet = new sAt.BeetArgsStruct( - [["amount", sAt.u64]], - "TransferOutOfEscrowArgs" - ); - }); - var lAt = I((af) => { - "use strict"; - m(); - g(); - var LLr = - (af && af.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - qLr = - (af && af.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Qke = - (af && af.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - LLr(e, t, r); - return qLr(e, t), e; - }; - Object.defineProperty(af, "__esModule", { value: !0 }); - af.createTransferOutOfEscrowInstruction = - af.transferOutOfEscrowInstructionDiscriminator = - af.TransferOutOfEscrowStruct = - void 0; - var uAt = Qke(eh()), - cAt = Qke(Wt()), - Yke = Qke(Le()), - zLr = Xke(); - af.TransferOutOfEscrowStruct = new cAt.BeetArgsStruct( - [ - ["instructionDiscriminator", cAt.u8], - ["transferOutOfEscrowArgs", zLr.transferOutOfEscrowArgsBeet], - ], - "TransferOutOfEscrowInstructionArgs" - ); - af.transferOutOfEscrowInstructionDiscriminator = 40; - function jLr( - t, - e, - r = new Yke.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - var n, i, o; - let [a] = af.TransferOutOfEscrowStruct.serialize({ - instructionDiscriminator: - af.transferOutOfEscrowInstructionDiscriminator, - ...e, - }), - s = [ - { pubkey: t.escrow, isWritable: !1, isSigner: !1 }, - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { pubkey: t.attributeMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.attributeSrc, isWritable: !0, isSigner: !1 }, - { pubkey: t.attributeDst, isWritable: !0, isSigner: !1 }, - { pubkey: t.escrowMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.escrowAccount, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.systemProgram) !== null && n !== void 0 - ? n - : Yke.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.ataProgram) !== null && i !== void 0 - ? i - : uAt.ASSOCIATED_TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (o = t.tokenProgram) !== null && o !== void 0 - ? o - : uAt.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.sysvarInstructions, isWritable: !1, isSigner: !1 }, - ]; - return ( - t.authority != null && - s.push({ pubkey: t.authority, isWritable: !1, isSigner: !0 }), - new Yke.TransactionInstruction({ programId: r, keys: s, data: a }) - ); - } - af.createTransferOutOfEscrowInstruction = jLr; - }); - var pAt = I((sf) => { - "use strict"; - m(); - g(); - var ULr = - (sf && sf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - KLr = - (sf && sf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - hAt = - (sf && sf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - ULr(e, t, r); - return KLr(e, t), e; - }; - Object.defineProperty(sf, "__esModule", { value: !0 }); - sf.createUnverifyCollectionInstruction = - sf.unverifyCollectionInstructionDiscriminator = - sf.UnverifyCollectionStruct = - void 0; - var fAt = hAt(Wt()), - dAt = hAt(Le()); - sf.UnverifyCollectionStruct = new fAt.BeetArgsStruct( - [["instructionDiscriminator", fAt.u8]], - "UnverifyCollectionInstructionArgs" - ); - sf.unverifyCollectionInstructionDiscriminator = 22; - function HLr( - t, - e = new dAt.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - let [r] = sf.UnverifyCollectionStruct.serialize({ - instructionDiscriminator: - sf.unverifyCollectionInstructionDiscriminator, - }), - n = [ - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.collectionAuthority, isWritable: !0, isSigner: !0 }, - { pubkey: t.collectionMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.collection, isWritable: !1, isSigner: !1 }, - { - pubkey: t.collectionMasterEditionAccount, - isWritable: !1, - isSigner: !1, - }, - ]; - return ( - t.collectionAuthorityRecord != null && - n.push({ - pubkey: t.collectionAuthorityRecord, - isWritable: !1, - isSigner: !1, - }), - new dAt.TransactionInstruction({ programId: e, keys: n, data: r }) - ); - } - sf.createUnverifyCollectionInstruction = HLr; - }); - var vAt = I((uf) => { - "use strict"; - m(); - g(); - var VLr = - (uf && uf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - WLr = - (uf && uf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - gAt = - (uf && uf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - VLr(e, t, r); - return WLr(e, t), e; - }; - Object.defineProperty(uf, "__esModule", { value: !0 }); - uf.createUnverifySizedCollectionItemInstruction = - uf.unverifySizedCollectionItemInstructionDiscriminator = - uf.UnverifySizedCollectionItemStruct = - void 0; - var yAt = gAt(Wt()), - mAt = gAt(Le()); - uf.UnverifySizedCollectionItemStruct = new yAt.BeetArgsStruct( - [["instructionDiscriminator", yAt.u8]], - "UnverifySizedCollectionItemInstructionArgs" - ); - uf.unverifySizedCollectionItemInstructionDiscriminator = 31; - function GLr( - t, - e = new mAt.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - let [r] = uf.UnverifySizedCollectionItemStruct.serialize({ - instructionDiscriminator: - uf.unverifySizedCollectionItemInstructionDiscriminator, - }), - n = [ - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.collectionAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { pubkey: t.collectionMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.collection, isWritable: !0, isSigner: !1 }, - { - pubkey: t.collectionMasterEditionAccount, - isWritable: !1, - isSigner: !1, - }, - ]; - return ( - t.collectionAuthorityRecord != null && - n.push({ - pubkey: t.collectionAuthorityRecord, - isWritable: !1, - isSigner: !1, - }), - new mAt.TransactionInstruction({ programId: e, keys: n, data: r }) - ); - } - uf.createUnverifySizedCollectionItemInstruction = GLr; - }); - var ePe = I((O1) => { - "use strict"; - m(); - g(); - var JLr = - (O1 && O1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - $Lr = - (O1 && O1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - bAt = - (O1 && O1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - JLr(e, t, r); - return $Lr(e, t), e; - }; - Object.defineProperty(O1, "__esModule", { value: !0 }); - O1.updateMetadataAccountArgsBeet = void 0; - var eV = bAt(Wt()), - ZLr = bAt(qu()), - XLr = YN(); - O1.updateMetadataAccountArgsBeet = new eV.FixableBeetArgsStruct( - [ - ["data", eV.coption(XLr.dataBeet)], - ["updateAuthority", eV.coption(ZLr.publicKey)], - ["primarySaleHappened", eV.coption(eV.bool)], - ], - "UpdateMetadataAccountArgs" - ); - }); - var SAt = I((cf) => { - "use strict"; - m(); - g(); - var YLr = - (cf && cf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - QLr = - (cf && cf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - xAt = - (cf && cf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - YLr(e, t, r); - return QLr(e, t), e; - }; - Object.defineProperty(cf, "__esModule", { value: !0 }); - cf.createUpdateMetadataAccountInstruction = - cf.updateMetadataAccountInstructionDiscriminator = - cf.UpdateMetadataAccountStruct = - void 0; - var wAt = xAt(Wt()), - _At = xAt(Le()), - eqr = ePe(); - cf.UpdateMetadataAccountStruct = new wAt.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", wAt.u8], - ["updateMetadataAccountArgs", eqr.updateMetadataAccountArgsBeet], - ], - "UpdateMetadataAccountInstructionArgs" - ); - cf.updateMetadataAccountInstructionDiscriminator = 1; - function tqr( - t, - e, - r = new _At.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - let [n] = cf.UpdateMetadataAccountStruct.serialize({ - instructionDiscriminator: - cf.updateMetadataAccountInstructionDiscriminator, - ...e, - }), - i = [ - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.updateAuthority, isWritable: !1, isSigner: !0 }, - ]; - return new _At.TransactionInstruction({ programId: r, keys: i, data: n }); - } - cf.createUpdateMetadataAccountInstruction = tqr; - }); - var tPe = I((B1) => { - "use strict"; - m(); - g(); - var rqr = - (B1 && B1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - nqr = - (B1 && B1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - AAt = - (B1 && B1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - rqr(e, t, r); - return nqr(e, t), e; - }; - Object.defineProperty(B1, "__esModule", { value: !0 }); - B1.updateMetadataAccountArgsV2Beet = void 0; - var lP = AAt(Wt()), - iqr = AAt(qu()), - oqr = QH(); - B1.updateMetadataAccountArgsV2Beet = new lP.FixableBeetArgsStruct( - [ - ["data", lP.coption(oqr.dataV2Beet)], - ["updateAuthority", lP.coption(iqr.publicKey)], - ["primarySaleHappened", lP.coption(lP.bool)], - ["isMutable", lP.coption(lP.bool)], - ], - "UpdateMetadataAccountArgsV2" - ); - }); - var kAt = I((lf) => { - "use strict"; - m(); - g(); - var aqr = - (lf && lf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - sqr = - (lf && lf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - TAt = - (lf && lf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - aqr(e, t, r); - return sqr(e, t), e; - }; - Object.defineProperty(lf, "__esModule", { value: !0 }); - lf.createUpdateMetadataAccountV2Instruction = - lf.updateMetadataAccountV2InstructionDiscriminator = - lf.UpdateMetadataAccountV2Struct = - void 0; - var EAt = TAt(Wt()), - MAt = TAt(Le()), - uqr = tPe(); - lf.UpdateMetadataAccountV2Struct = new EAt.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", EAt.u8], - ["updateMetadataAccountArgsV2", uqr.updateMetadataAccountArgsV2Beet], - ], - "UpdateMetadataAccountV2InstructionArgs" - ); - lf.updateMetadataAccountV2InstructionDiscriminator = 15; - function cqr( - t, - e, - r = new MAt.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - let [n] = lf.UpdateMetadataAccountV2Struct.serialize({ - instructionDiscriminator: - lf.updateMetadataAccountV2InstructionDiscriminator, - ...e, - }), - i = [ - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.updateAuthority, isWritable: !1, isSigner: !0 }, - ]; - return new MAt.TransactionInstruction({ programId: r, keys: i, data: n }); - } - lf.createUpdateMetadataAccountV2Instruction = cqr; - }); - var IAt = I((ff) => { - "use strict"; - m(); - g(); - var lqr = - (ff && ff.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - fqr = - (ff && ff.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - BAt = - (ff && ff.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - lqr(e, t, r); - return fqr(e, t), e; - }; - Object.defineProperty(ff, "__esModule", { value: !0 }); - ff.createUpdatePrimarySaleHappenedViaTokenInstruction = - ff.updatePrimarySaleHappenedViaTokenInstructionDiscriminator = - ff.UpdatePrimarySaleHappenedViaTokenStruct = - void 0; - var PAt = BAt(Wt()), - OAt = BAt(Le()); - ff.UpdatePrimarySaleHappenedViaTokenStruct = new PAt.BeetArgsStruct( - [["instructionDiscriminator", PAt.u8]], - "UpdatePrimarySaleHappenedViaTokenInstructionArgs" - ); - ff.updatePrimarySaleHappenedViaTokenInstructionDiscriminator = 4; - function dqr( - t, - e = new OAt.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - let [r] = ff.UpdatePrimarySaleHappenedViaTokenStruct.serialize({ - instructionDiscriminator: - ff.updatePrimarySaleHappenedViaTokenInstructionDiscriminator, - }), - n = [ - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.owner, isWritable: !1, isSigner: !0 }, - { pubkey: t.token, isWritable: !1, isSigner: !1 }, - ]; - return new OAt.TransactionInstruction({ programId: e, keys: n, data: r }); - } - ff.createUpdatePrimarySaleHappenedViaTokenInstruction = dqr; - }); - var rPe = I((I1) => { - "use strict"; - m(); - g(); - var hqr = - (I1 && I1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - pqr = - (I1 && I1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - yqr = - (I1 && I1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - hqr(e, t, r); - return pqr(e, t), e; - }; - Object.defineProperty(I1, "__esModule", { value: !0 }); - I1.utilizeArgsBeet = void 0; - var CAt = yqr(Wt()); - I1.utilizeArgsBeet = new CAt.BeetArgsStruct( - [["numberOfUses", CAt.u64]], - "UtilizeArgs" - ); - }); - var DAt = I((df) => { - "use strict"; - m(); - g(); - var mqr = - (df && df.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - gqr = - (df && df.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - nPe = - (df && df.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - mqr(e, t, r); - return gqr(e, t), e; - }; - Object.defineProperty(df, "__esModule", { value: !0 }); - df.createUtilizeInstruction = - df.utilizeInstructionDiscriminator = - df.UtilizeStruct = - void 0; - var RAt = nPe(eh()), - NAt = nPe(Wt()), - Pse = nPe(Le()), - vqr = rPe(); - df.UtilizeStruct = new NAt.BeetArgsStruct( - [ - ["instructionDiscriminator", NAt.u8], - ["utilizeArgs", vqr.utilizeArgsBeet], - ], - "UtilizeInstructionArgs" - ); - df.utilizeInstructionDiscriminator = 19; - function bqr( - t, - e, - r = new Pse.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - var n, i, o, a; - let [s] = df.UtilizeStruct.serialize({ - instructionDiscriminator: df.utilizeInstructionDiscriminator, - ...e, - }), - c = [ - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.tokenAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.mint, isWritable: !0, isSigner: !1 }, - { pubkey: t.useAuthority, isWritable: !0, isSigner: !0 }, - { pubkey: t.owner, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : RAt.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.ataProgram) !== null && i !== void 0 - ? i - : RAt.ASSOCIATED_TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (o = t.systemProgram) !== null && o !== void 0 - ? o - : Pse.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (a = t.rent) !== null && a !== void 0 - ? a - : Pse.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - if ( - (t.useAuthorityRecord != null && - c.push({ - pubkey: t.useAuthorityRecord, - isWritable: !0, - isSigner: !1, - }), - t.burner != null) - ) { - if (t.useAuthorityRecord == null) - throw new Error( - "When providing 'burner' then 'accounts.useAuthorityRecord' need(s) to be provided as well." - ); - c.push({ pubkey: t.burner, isWritable: !1, isSigner: !1 }); - } - return new Pse.TransactionInstruction({ programId: r, keys: c, data: s }); - } - df.createUtilizeInstruction = bqr; - }); - var zAt = I((hf) => { - "use strict"; - m(); - g(); - var wqr = - (hf && hf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - _qr = - (hf && hf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - qAt = - (hf && hf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - wqr(e, t, r); - return _qr(e, t), e; - }; - Object.defineProperty(hf, "__esModule", { value: !0 }); - hf.createVerifyCollectionInstruction = - hf.verifyCollectionInstructionDiscriminator = - hf.VerifyCollectionStruct = - void 0; - var FAt = qAt(Wt()), - LAt = qAt(Le()); - hf.VerifyCollectionStruct = new FAt.BeetArgsStruct( - [["instructionDiscriminator", FAt.u8]], - "VerifyCollectionInstructionArgs" - ); - hf.verifyCollectionInstructionDiscriminator = 18; - function xqr( - t, - e = new LAt.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - let [r] = hf.VerifyCollectionStruct.serialize({ - instructionDiscriminator: hf.verifyCollectionInstructionDiscriminator, - }), - n = [ - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.collectionAuthority, isWritable: !0, isSigner: !0 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { pubkey: t.collectionMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.collection, isWritable: !1, isSigner: !1 }, - { - pubkey: t.collectionMasterEditionAccount, - isWritable: !1, - isSigner: !1, - }, - ]; - return new LAt.TransactionInstruction({ programId: e, keys: n, data: r }); - } - hf.createVerifyCollectionInstruction = xqr; - }); - var HAt = I((pf) => { - "use strict"; - m(); - g(); - var Sqr = - (pf && pf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Aqr = - (pf && pf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - KAt = - (pf && pf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - Sqr(e, t, r); - return Aqr(e, t), e; - }; - Object.defineProperty(pf, "__esModule", { value: !0 }); - pf.createVerifySizedCollectionItemInstruction = - pf.verifySizedCollectionItemInstructionDiscriminator = - pf.VerifySizedCollectionItemStruct = - void 0; - var jAt = KAt(Wt()), - UAt = KAt(Le()); - pf.VerifySizedCollectionItemStruct = new jAt.BeetArgsStruct( - [["instructionDiscriminator", jAt.u8]], - "VerifySizedCollectionItemInstructionArgs" - ); - pf.verifySizedCollectionItemInstructionDiscriminator = 30; - function Eqr( - t, - e = new UAt.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s") - ) { - let [r] = pf.VerifySizedCollectionItemStruct.serialize({ - instructionDiscriminator: - pf.verifySizedCollectionItemInstructionDiscriminator, - }), - n = [ - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.collectionAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { pubkey: t.collectionMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.collection, isWritable: !0, isSigner: !1 }, - { - pubkey: t.collectionMasterEditionAccount, - isWritable: !1, - isSigner: !1, - }, - ]; - return ( - t.collectionAuthorityRecord != null && - n.push({ - pubkey: t.collectionAuthorityRecord, - isWritable: !1, - isSigner: !1, - }), - new UAt.TransactionInstruction({ programId: e, keys: n, data: r }) - ); - } - pf.createVerifySizedCollectionItemInstruction = Eqr; - }); - var VAt = I((zr) => { - "use strict"; - m(); - g(); - var Mqr = - (zr && zr.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - bn = - (zr && zr.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - Mqr(e, t, r); - }; - Object.defineProperty(zr, "__esModule", { value: !0 }); - bn(Wwt(), zr); - bn(ySt(), zr); - bn(wSt(), zr); - bn(ASt(), zr); - bn(kSt(), zr); - bn(BSt(), zr); - bn(NSt(), zr); - bn(LSt(), zr); - bn(zSt(), zr); - bn(USt(), zr); - bn(WSt(), zr); - bn(ZSt(), zr); - bn(QSt(), zr); - bn(t2t(), zr); - bn(i2t(), zr); - bn(a2t(), zr); - bn(c2t(), zr); - bn(f2t(), zr); - bn(y2t(), zr); - bn(v2t(), zr); - bn(_2t(), zr); - bn(S2t(), zr); - bn(T2t(), zr); - bn(B2t(), zr); - bn(N2t(), zr); - bn(F2t(), zr); - bn(j2t(), zr); - bn(V2t(), zr); - bn($2t(), zr); - bn(Q2t(), zr); - bn(nAt(), zr); - bn(aAt(), zr); - bn(lAt(), zr); - bn(pAt(), zr); - bn(vAt(), zr); - bn(SAt(), zr); - bn(kAt(), zr); - bn(IAt(), zr); - bn(DAt(), zr); - bn(zAt(), zr); - bn(HAt(), zr); - }); - var WAt = I((Vi) => { - "use strict"; - m(); - g(); - var Tqr = - (Vi && Vi.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - $o = - (Vi && Vi.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - Tqr(e, t, r); - }; - Object.defineProperty(Vi, "__esModule", { value: !0 }); - $o(_ke(), Vi); - $o(VH(), Vi); - $o(GH(), Vi); - $o(YH(), Vi); - $o(Oke(), Vi); - $o(Bke(), Vi); - $o(Rke(), Vi); - $o(Rae(), Vi); - $o(YN(), Vi); - $o(QH(), Vi); - $o(b8e(), Vi); - $o(c0(), Vi); - $o(kse(), Vi); - $o(Tse(), Vi); - $o(Uae(), Vi); - $o(h8e(), Vi); - $o(_se(), Vi); - $o(Uke(), Vi); - $o(Nae(), Vi); - $o(Xke(), Vi); - $o(ePe(), Vi); - $o(tPe(), Vi); - $o(u8e(), Vi); - $o(WH(), Vi); - $o(rPe(), Vi); - }); - var iPe = I((th) => { - "use strict"; - m(); - g(); - var kqr = - (th && th.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Ose = - (th && th.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - kqr(e, t, r); - }; - Object.defineProperty(th, "__esModule", { value: !0 }); - th.PROGRAM_ID = th.PROGRAM_ADDRESS = void 0; - var Pqr = Le(); - Ose(Uwt(), th); - Ose(Kwt(), th); - Ose(VAt(), th); - Ose(WAt(), th); - th.PROGRAM_ADDRESS = "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"; - th.PROGRAM_ID = new Pqr.PublicKey(th.PROGRAM_ADDRESS); - }); - var GAt = I((Bse) => { - "use strict"; - m(); - g(); - Object.defineProperty(Bse, "__esModule", { value: !0 }); - Bse.cusper = void 0; - var Oqr = JN(), - Bqr = iPe(); - Bse.cusper = (0, Oqr.initCusper)(Bqr.errorFromCode); - }); - var hs = I((HE) => { - "use strict"; - m(); - g(); - var Iqr = - (HE && HE.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - JAt = - (HE && HE.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - Iqr(e, t, r); - }; - Object.defineProperty(HE, "__esModule", { value: !0 }); - JAt(GAt(), HE); - JAt(iPe(), HE); - }); - var Jse = I((rV, M9) => { - m(); - g(); - var Hqr = 200, - EPe = "__lodash_hash_undefined__", - Hse = 1, - xEt = 2, - SEt = 9007199254740991, - Fse = "[object Arguments]", - vPe = "[object Array]", - Vqr = "[object AsyncFunction]", - AEt = "[object Boolean]", - EEt = "[object Date]", - MEt = "[object Error]", - TEt = "[object Function]", - Wqr = "[object GeneratorFunction]", - Lse = "[object Map]", - kEt = "[object Number]", - Gqr = "[object Null]", - E9 = "[object Object]", - fEt = "[object Promise]", - Jqr = "[object Proxy]", - PEt = "[object RegExp]", - qse = "[object Set]", - OEt = "[object String]", - $qr = "[object Symbol]", - Zqr = "[object Undefined]", - bPe = "[object WeakMap]", - BEt = "[object ArrayBuffer]", - zse = "[object DataView]", - Xqr = "[object Float32Array]", - Yqr = "[object Float64Array]", - Qqr = "[object Int8Array]", - ezr = "[object Int16Array]", - tzr = "[object Int32Array]", - rzr = "[object Uint8Array]", - nzr = "[object Uint8ClampedArray]", - izr = "[object Uint16Array]", - ozr = "[object Uint32Array]", - azr = /[\\^$.*+?()[\]{}|]/g, - szr = /^\[object .+?Constructor\]$/, - uzr = /^(?:0|[1-9]\d*)$/, - Zo = {}; - Zo[Xqr] = - Zo[Yqr] = - Zo[Qqr] = - Zo[ezr] = - Zo[tzr] = - Zo[rzr] = - Zo[nzr] = - Zo[izr] = - Zo[ozr] = - !0; - Zo[Fse] = - Zo[vPe] = - Zo[BEt] = - Zo[AEt] = - Zo[zse] = - Zo[EEt] = - Zo[MEt] = - Zo[TEt] = - Zo[Lse] = - Zo[kEt] = - Zo[E9] = - Zo[PEt] = - Zo[qse] = - Zo[OEt] = - Zo[bPe] = - !1; - var IEt = - typeof window == "object" && - window && - window.Object === Object && - window, - czr = typeof self == "object" && self && self.Object === Object && self, - Ux = IEt || czr || Function("return this")(), - CEt = typeof rV == "object" && rV && !rV.nodeType && rV, - dEt = CEt && typeof M9 == "object" && M9 && !M9.nodeType && M9, - REt = dEt && dEt.exports === CEt, - yPe = REt && IEt.process, - hEt = (function () { - try { - return yPe && yPe.binding && yPe.binding("util"); - } catch {} - })(), - pEt = hEt && hEt.isTypedArray; - function lzr(t, e) { - for (var r = -1, n = t == null ? 0 : t.length, i = 0, o = []; ++r < n; ) { - var a = t[r]; - e(a, r, t) && (o[i++] = a); - } - return o; - } - function fzr(t, e) { - for (var r = -1, n = e.length, i = t.length; ++r < n; ) t[i + r] = e[r]; - return t; - } - function dzr(t, e) { - for (var r = -1, n = t == null ? 0 : t.length; ++r < n; ) - if (e(t[r], r, t)) return !0; - return !1; - } - function hzr(t, e) { - for (var r = -1, n = Array(t); ++r < t; ) n[r] = e(r); - return n; - } - function pzr(t) { - return function (e) { - return t(e); - }; - } - function yzr(t, e) { - return t.has(e); - } - function mzr(t, e) { - return t?.[e]; - } - function gzr(t) { - var e = -1, - r = Array(t.size); - return ( - t.forEach(function (n, i) { - r[++e] = [i, n]; - }), - r - ); - } - function vzr(t, e) { - return function (r) { - return t(e(r)); - }; - } - function bzr(t) { - var e = -1, - r = Array(t.size); - return ( - t.forEach(function (n) { - r[++e] = n; - }), - r - ); - } - var wzr = Array.prototype, - _zr = Function.prototype, - Vse = Object.prototype, - mPe = Ux["__core-js_shared__"], - NEt = _zr.toString, - C1 = Vse.hasOwnProperty, - yEt = (function () { - var t = /[^.]+$/.exec((mPe && mPe.keys && mPe.keys.IE_PROTO) || ""); - return t ? "Symbol(src)_1." + t : ""; - })(), - DEt = Vse.toString, - xzr = RegExp( - "^" + - NEt.call(C1) - .replace(azr, "\\$&") - .replace( - /hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, - "$1.*?" - ) + - "$" - ), - mEt = REt ? Ux.Buffer : void 0, - jse = Ux.Symbol, - gEt = Ux.Uint8Array, - FEt = Vse.propertyIsEnumerable, - Szr = wzr.splice, - fP = jse ? jse.toStringTag : void 0, - vEt = Object.getOwnPropertySymbols, - Azr = mEt ? mEt.isBuffer : void 0, - Ezr = vzr(Object.keys, Object), - wPe = T9(Ux, "DataView"), - nV = T9(Ux, "Map"), - _Pe = T9(Ux, "Promise"), - xPe = T9(Ux, "Set"), - SPe = T9(Ux, "WeakMap"), - iV = T9(Object, "create"), - Mzr = pP(wPe), - Tzr = pP(nV), - kzr = pP(_Pe), - Pzr = pP(xPe), - Ozr = pP(SPe), - bEt = jse ? jse.prototype : void 0, - gPe = bEt ? bEt.valueOf : void 0; - function dP(t) { - var e = -1, - r = t == null ? 0 : t.length; - for (this.clear(); ++e < r; ) { - var n = t[e]; - this.set(n[0], n[1]); - } - } - function Bzr() { - (this.__data__ = iV ? iV(null) : {}), (this.size = 0); - } - function Izr(t) { - var e = this.has(t) && delete this.__data__[t]; - return (this.size -= e ? 1 : 0), e; - } - function Czr(t) { - var e = this.__data__; - if (iV) { - var r = e[t]; - return r === EPe ? void 0 : r; - } - return C1.call(e, t) ? e[t] : void 0; - } - function Rzr(t) { - var e = this.__data__; - return iV ? e[t] !== void 0 : C1.call(e, t); - } - function Nzr(t, e) { - var r = this.__data__; - return ( - (this.size += this.has(t) ? 0 : 1), - (r[t] = iV && e === void 0 ? EPe : e), - this - ); - } - dP.prototype.clear = Bzr; - dP.prototype.delete = Izr; - dP.prototype.get = Czr; - dP.prototype.has = Rzr; - dP.prototype.set = Nzr; - function Kx(t) { - var e = -1, - r = t == null ? 0 : t.length; - for (this.clear(); ++e < r; ) { - var n = t[e]; - this.set(n[0], n[1]); - } - } - function Dzr() { - (this.__data__ = []), (this.size = 0); - } - function Fzr(t) { - var e = this.__data__, - r = Wse(e, t); - if (r < 0) return !1; - var n = e.length - 1; - return r == n ? e.pop() : Szr.call(e, r, 1), --this.size, !0; - } - function Lzr(t) { - var e = this.__data__, - r = Wse(e, t); - return r < 0 ? void 0 : e[r][1]; - } - function qzr(t) { - return Wse(this.__data__, t) > -1; - } - function zzr(t, e) { - var r = this.__data__, - n = Wse(r, t); - return n < 0 ? (++this.size, r.push([t, e])) : (r[n][1] = e), this; - } - Kx.prototype.clear = Dzr; - Kx.prototype.delete = Fzr; - Kx.prototype.get = Lzr; - Kx.prototype.has = qzr; - Kx.prototype.set = zzr; - function hP(t) { - var e = -1, - r = t == null ? 0 : t.length; - for (this.clear(); ++e < r; ) { - var n = t[e]; - this.set(n[0], n[1]); - } - } - function jzr() { - (this.size = 0), - (this.__data__ = { - hash: new dP(), - map: new (nV || Kx)(), - string: new dP(), - }); - } - function Uzr(t) { - var e = Gse(this, t).delete(t); - return (this.size -= e ? 1 : 0), e; - } - function Kzr(t) { - return Gse(this, t).get(t); - } - function Hzr(t) { - return Gse(this, t).has(t); - } - function Vzr(t, e) { - var r = Gse(this, t), - n = r.size; - return r.set(t, e), (this.size += r.size == n ? 0 : 1), this; - } - hP.prototype.clear = jzr; - hP.prototype.delete = Uzr; - hP.prototype.get = Kzr; - hP.prototype.has = Hzr; - hP.prototype.set = Vzr; - function Use(t) { - var e = -1, - r = t == null ? 0 : t.length; - for (this.__data__ = new hP(); ++e < r; ) this.add(t[e]); - } - function Wzr(t) { - return this.__data__.set(t, EPe), this; - } - function Gzr(t) { - return this.__data__.has(t); - } - Use.prototype.add = Use.prototype.push = Wzr; - Use.prototype.has = Gzr; - function WE(t) { - var e = (this.__data__ = new Kx(t)); - this.size = e.size; - } - function Jzr() { - (this.__data__ = new Kx()), (this.size = 0); - } - function $zr(t) { - var e = this.__data__, - r = e.delete(t); - return (this.size = e.size), r; - } - function Zzr(t) { - return this.__data__.get(t); - } - function Xzr(t) { - return this.__data__.has(t); - } - function Yzr(t, e) { - var r = this.__data__; - if (r instanceof Kx) { - var n = r.__data__; - if (!nV || n.length < Hqr - 1) - return n.push([t, e]), (this.size = ++r.size), this; - r = this.__data__ = new hP(n); - } - return r.set(t, e), (this.size = r.size), this; - } - WE.prototype.clear = Jzr; - WE.prototype.delete = $zr; - WE.prototype.get = Zzr; - WE.prototype.has = Xzr; - WE.prototype.set = Yzr; - function Qzr(t, e) { - var r = Kse(t), - n = !r && pjr(t), - i = !r && !n && APe(t), - o = !r && !n && !i && HEt(t), - a = r || n || i || o, - s = a ? hzr(t.length, String) : [], - c = s.length; - for (var u in t) - (e || C1.call(t, u)) && - !( - a && - (u == "length" || - (i && (u == "offset" || u == "parent")) || - (o && - (u == "buffer" || u == "byteLength" || u == "byteOffset")) || - cjr(u, c)) - ) && - s.push(u); - return s; - } - function Wse(t, e) { - for (var r = t.length; r--; ) if (zEt(t[r][0], e)) return r; - return -1; - } - function ejr(t, e, r) { - var n = e(t); - return Kse(t) ? n : fzr(n, r(t)); - } - function aV(t) { - return t == null - ? t === void 0 - ? Zqr - : Gqr - : fP && fP in Object(t) - ? sjr(t) - : hjr(t); - } - function wEt(t) { - return oV(t) && aV(t) == Fse; - } - function LEt(t, e, r, n, i) { - return t === e - ? !0 - : t == null || e == null || (!oV(t) && !oV(e)) - ? t !== t && e !== e - : tjr(t, e, r, n, LEt, i); - } - function tjr(t, e, r, n, i, o) { - var a = Kse(t), - s = Kse(e), - c = a ? vPe : VE(t), - u = s ? vPe : VE(e); - (c = c == Fse ? E9 : c), (u = u == Fse ? E9 : u); - var h = c == E9, - w = u == E9, - M = c == u; - if (M && APe(t)) { - if (!APe(e)) return !1; - (a = !0), (h = !1); - } - if (M && !h) - return ( - o || (o = new WE()), - a || HEt(t) ? qEt(t, e, r, n, i, o) : ojr(t, e, c, r, n, i, o) - ); - if (!(r & Hse)) { - var k = h && C1.call(t, "__wrapped__"), - O = w && C1.call(e, "__wrapped__"); - if (k || O) { - var D = k ? t.value() : t, - F = O ? e.value() : e; - return o || (o = new WE()), i(D, F, r, n, o); - } - } - return M ? (o || (o = new WE()), ajr(t, e, r, n, i, o)) : !1; - } - function rjr(t) { - if (!KEt(t) || fjr(t)) return !1; - var e = jEt(t) ? xzr : szr; - return e.test(pP(t)); - } - function njr(t) { - return oV(t) && UEt(t.length) && !!Zo[aV(t)]; - } - function ijr(t) { - if (!djr(t)) return Ezr(t); - var e = []; - for (var r in Object(t)) C1.call(t, r) && r != "constructor" && e.push(r); - return e; - } - function qEt(t, e, r, n, i, o) { - var a = r & Hse, - s = t.length, - c = e.length; - if (s != c && !(a && c > s)) return !1; - var u = o.get(t); - if (u && o.get(e)) return u == e; - var h = -1, - w = !0, - M = r & xEt ? new Use() : void 0; - for (o.set(t, e), o.set(e, t); ++h < s; ) { - var k = t[h], - O = e[h]; - if (n) var D = a ? n(O, k, h, e, t, o) : n(k, O, h, t, e, o); - if (D !== void 0) { - if (D) continue; - w = !1; - break; - } - if (M) { - if ( - !dzr(e, function (F, N) { - if (!yzr(M, N) && (k === F || i(k, F, r, n, o))) return M.push(N); - }) - ) { - w = !1; - break; - } - } else if (!(k === O || i(k, O, r, n, o))) { - w = !1; - break; - } - } - return o.delete(t), o.delete(e), w; - } - function ojr(t, e, r, n, i, o, a) { - switch (r) { - case zse: - if (t.byteLength != e.byteLength || t.byteOffset != e.byteOffset) - return !1; - (t = t.buffer), (e = e.buffer); - case BEt: - return !(t.byteLength != e.byteLength || !o(new gEt(t), new gEt(e))); - case AEt: - case EEt: - case kEt: - return zEt(+t, +e); - case MEt: - return t.name == e.name && t.message == e.message; - case PEt: - case OEt: - return t == e + ""; - case Lse: - var s = gzr; - case qse: - var c = n & Hse; - if ((s || (s = bzr), t.size != e.size && !c)) return !1; - var u = a.get(t); - if (u) return u == e; - (n |= xEt), a.set(t, e); - var h = qEt(s(t), s(e), n, i, o, a); - return a.delete(t), h; - case $qr: - if (gPe) return gPe.call(t) == gPe.call(e); - } - return !1; - } - function ajr(t, e, r, n, i, o) { - var a = r & Hse, - s = _Et(t), - c = s.length, - u = _Et(e), - h = u.length; - if (c != h && !a) return !1; - for (var w = c; w--; ) { - var M = s[w]; - if (!(a ? M in e : C1.call(e, M))) return !1; - } - var k = o.get(t); - if (k && o.get(e)) return k == e; - var O = !0; - o.set(t, e), o.set(e, t); - for (var D = a; ++w < c; ) { - M = s[w]; - var F = t[M], - N = e[M]; - if (n) var q = a ? n(N, F, M, e, t, o) : n(F, N, M, t, e, o); - if (!(q === void 0 ? F === N || i(F, N, r, n, o) : q)) { - O = !1; - break; - } - D || (D = M == "constructor"); - } - if (O && !D) { - var z = t.constructor, - H = e.constructor; - z != H && - "constructor" in t && - "constructor" in e && - !( - typeof z == "function" && - z instanceof z && - typeof H == "function" && - H instanceof H - ) && - (O = !1); - } - return o.delete(t), o.delete(e), O; - } - function _Et(t) { - return ejr(t, gjr, ujr); - } - function Gse(t, e) { - var r = t.__data__; - return ljr(e) ? r[typeof e == "string" ? "string" : "hash"] : r.map; - } - function T9(t, e) { - var r = mzr(t, e); - return rjr(r) ? r : void 0; - } - function sjr(t) { - var e = C1.call(t, fP), - r = t[fP]; - try { - t[fP] = void 0; - var n = !0; - } catch {} - var i = DEt.call(t); - return n && (e ? (t[fP] = r) : delete t[fP]), i; - } - var ujr = vEt - ? function (t) { - return t == null - ? [] - : ((t = Object(t)), - lzr(vEt(t), function (e) { - return FEt.call(t, e); - })); - } - : vjr, - VE = aV; - ((wPe && VE(new wPe(new ArrayBuffer(1))) != zse) || - (nV && VE(new nV()) != Lse) || - (_Pe && VE(_Pe.resolve()) != fEt) || - (xPe && VE(new xPe()) != qse) || - (SPe && VE(new SPe()) != bPe)) && - (VE = function (t) { - var e = aV(t), - r = e == E9 ? t.constructor : void 0, - n = r ? pP(r) : ""; - if (n) - switch (n) { - case Mzr: - return zse; - case Tzr: - return Lse; - case kzr: - return fEt; - case Pzr: - return qse; - case Ozr: - return bPe; - } - return e; - }); - function cjr(t, e) { - return ( - (e = e ?? SEt), - !!e && - (typeof t == "number" || uzr.test(t)) && - t > -1 && - t % 1 == 0 && - t < e - ); - } - function ljr(t) { - var e = typeof t; - return e == "string" || e == "number" || e == "symbol" || e == "boolean" - ? t !== "__proto__" - : t === null; - } - function fjr(t) { - return !!yEt && yEt in t; - } - function djr(t) { - var e = t && t.constructor, - r = (typeof e == "function" && e.prototype) || Vse; - return t === r; - } - function hjr(t) { - return DEt.call(t); - } - function pP(t) { - if (t != null) { - try { - return NEt.call(t); - } catch {} - try { - return t + ""; - } catch {} - } - return ""; - } - function zEt(t, e) { - return t === e || (t !== t && e !== e); - } - var pjr = wEt( - (function () { - return arguments; - })() - ) - ? wEt - : function (t) { - return oV(t) && C1.call(t, "callee") && !FEt.call(t, "callee"); - }, - Kse = Array.isArray; - function yjr(t) { - return t != null && UEt(t.length) && !jEt(t); - } - var APe = Azr || bjr; - function mjr(t, e) { - return LEt(t, e); - } - function jEt(t) { - if (!KEt(t)) return !1; - var e = aV(t); - return e == TEt || e == Wqr || e == Vqr || e == Jqr; - } - function UEt(t) { - return typeof t == "number" && t > -1 && t % 1 == 0 && t <= SEt; - } - function KEt(t) { - var e = typeof t; - return t != null && (e == "object" || e == "function"); - } - function oV(t) { - return t != null && typeof t == "object"; - } - var HEt = pEt ? pzr(pEt) : njr; - function gjr(t) { - return yjr(t) ? Qzr(t) : ijr(t); - } - function vjr() { - return []; - } - function bjr() { - return !1; - } - M9.exports = mjr; - }); - var mMt = I((sV, P9) => { - m(); - g(); - var Ujr = 200, - z3t = "__lodash_hash_undefined__", - j3t = 9007199254740991, - i4e = "[object Arguments]", - Kjr = "[object Array]", - U3t = "[object Boolean]", - K3t = "[object Date]", - Hjr = "[object Error]", - o4e = "[object Function]", - H3t = "[object GeneratorFunction]", - Eue = "[object Map]", - V3t = "[object Number]", - a4e = "[object Object]", - P3t = "[object Promise]", - W3t = "[object RegExp]", - Mue = "[object Set]", - G3t = "[object String]", - J3t = "[object Symbol]", - YPe = "[object WeakMap]", - $3t = "[object ArrayBuffer]", - Tue = "[object DataView]", - Z3t = "[object Float32Array]", - X3t = "[object Float64Array]", - Y3t = "[object Int8Array]", - Q3t = "[object Int16Array]", - eMt = "[object Int32Array]", - tMt = "[object Uint8Array]", - rMt = "[object Uint8ClampedArray]", - nMt = "[object Uint16Array]", - iMt = "[object Uint32Array]", - Vjr = /[\\^$.*+?()[\]{}|]/g, - Wjr = /\w*$/, - Gjr = /^\[object .+?Constructor\]$/, - Jjr = /^(?:0|[1-9]\d*)$/, - Lo = {}; - Lo[i4e] = - Lo[Kjr] = - Lo[$3t] = - Lo[Tue] = - Lo[U3t] = - Lo[K3t] = - Lo[Z3t] = - Lo[X3t] = - Lo[Y3t] = - Lo[Q3t] = - Lo[eMt] = - Lo[Eue] = - Lo[V3t] = - Lo[a4e] = - Lo[W3t] = - Lo[Mue] = - Lo[G3t] = - Lo[J3t] = - Lo[tMt] = - Lo[rMt] = - Lo[nMt] = - Lo[iMt] = - !0; - Lo[Hjr] = Lo[o4e] = Lo[YPe] = !1; - var $jr = - typeof window == "object" && - window && - window.Object === Object && - window, - Zjr = typeof self == "object" && self && self.Object === Object && self, - Hx = $jr || Zjr || Function("return this")(), - oMt = typeof sV == "object" && sV && !sV.nodeType && sV, - O3t = oMt && typeof P9 == "object" && P9 && !P9.nodeType && P9, - Xjr = O3t && O3t.exports === oMt; - function Yjr(t, e) { - return t.set(e[0], e[1]), t; - } - function Qjr(t, e) { - return t.add(e), t; - } - function eUr(t, e) { - for (var r = -1, n = t ? t.length : 0; ++r < n && e(t[r], r, t) !== !1; ); - return t; - } - function tUr(t, e) { - for (var r = -1, n = e.length, i = t.length; ++r < n; ) t[i + r] = e[r]; - return t; - } - function aMt(t, e, r, n) { - var i = -1, - o = t ? t.length : 0; - for (n && o && (r = t[++i]); ++i < o; ) r = e(r, t[i], i, t); - return r; - } - function rUr(t, e) { - for (var r = -1, n = Array(t); ++r < t; ) n[r] = e(r); - return n; - } - function nUr(t, e) { - return t?.[e]; - } - function sMt(t) { - var e = !1; - if (t != null && typeof t.toString != "function") - try { - e = !!(t + ""); - } catch {} - return e; - } - function B3t(t) { - var e = -1, - r = Array(t.size); - return ( - t.forEach(function (n, i) { - r[++e] = [i, n]; - }), - r - ); - } - function s4e(t, e) { - return function (r) { - return t(e(r)); - }; - } - function I3t(t) { - var e = -1, - r = Array(t.size); - return ( - t.forEach(function (n) { - r[++e] = n; - }), - r - ); - } - var iUr = Array.prototype, - oUr = Function.prototype, - kue = Object.prototype, - XPe = Hx["__core-js_shared__"], - C3t = (function () { - var t = /[^.]+$/.exec((XPe && XPe.keys && XPe.keys.IE_PROTO) || ""); - return t ? "Symbol(src)_1." + t : ""; - })(), - uMt = oUr.toString, - $E = kue.hasOwnProperty, - Pue = kue.toString, - aUr = RegExp( - "^" + - uMt - .call($E) - .replace(Vjr, "\\$&") - .replace( - /hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, - "$1.*?" - ) + - "$" - ), - R3t = Xjr ? Hx.Buffer : void 0, - N3t = Hx.Symbol, - D3t = Hx.Uint8Array, - sUr = s4e(Object.getPrototypeOf, Object), - uUr = Object.create, - cUr = kue.propertyIsEnumerable, - lUr = iUr.splice, - F3t = Object.getOwnPropertySymbols, - fUr = R3t ? R3t.isBuffer : void 0, - dUr = s4e(Object.keys, Object), - QPe = I9(Hx, "DataView"), - uV = I9(Hx, "Map"), - e4e = I9(Hx, "Promise"), - t4e = I9(Hx, "Set"), - r4e = I9(Hx, "WeakMap"), - cV = I9(Object, "create"), - hUr = gP(QPe), - pUr = gP(uV), - yUr = gP(e4e), - mUr = gP(t4e), - gUr = gP(r4e), - L3t = N3t ? N3t.prototype : void 0, - q3t = L3t ? L3t.valueOf : void 0; - function mP(t) { - var e = -1, - r = t ? t.length : 0; - for (this.clear(); ++e < r; ) { - var n = t[e]; - this.set(n[0], n[1]); - } - } - function vUr() { - this.__data__ = cV ? cV(null) : {}; - } - function bUr(t) { - return this.has(t) && delete this.__data__[t]; - } - function wUr(t) { - var e = this.__data__; - if (cV) { - var r = e[t]; - return r === z3t ? void 0 : r; - } - return $E.call(e, t) ? e[t] : void 0; - } - function _Ur(t) { - var e = this.__data__; - return cV ? e[t] !== void 0 : $E.call(e, t); - } - function xUr(t, e) { - var r = this.__data__; - return (r[t] = cV && e === void 0 ? z3t : e), this; - } - mP.prototype.clear = vUr; - mP.prototype.delete = bUr; - mP.prototype.get = wUr; - mP.prototype.has = _Ur; - mP.prototype.set = xUr; - function Vx(t) { - var e = -1, - r = t ? t.length : 0; - for (this.clear(); ++e < r; ) { - var n = t[e]; - this.set(n[0], n[1]); - } - } - function SUr() { - this.__data__ = []; - } - function AUr(t) { - var e = this.__data__, - r = Oue(e, t); - if (r < 0) return !1; - var n = e.length - 1; - return r == n ? e.pop() : lUr.call(e, r, 1), !0; - } - function EUr(t) { - var e = this.__data__, - r = Oue(e, t); - return r < 0 ? void 0 : e[r][1]; - } - function MUr(t) { - return Oue(this.__data__, t) > -1; - } - function TUr(t, e) { - var r = this.__data__, - n = Oue(r, t); - return n < 0 ? r.push([t, e]) : (r[n][1] = e), this; - } - Vx.prototype.clear = SUr; - Vx.prototype.delete = AUr; - Vx.prototype.get = EUr; - Vx.prototype.has = MUr; - Vx.prototype.set = TUr; - function O9(t) { - var e = -1, - r = t ? t.length : 0; - for (this.clear(); ++e < r; ) { - var n = t[e]; - this.set(n[0], n[1]); - } - } - function kUr() { - this.__data__ = { - hash: new mP(), - map: new (uV || Vx)(), - string: new mP(), - }; - } - function PUr(t) { - return Bue(this, t).delete(t); - } - function OUr(t) { - return Bue(this, t).get(t); - } - function BUr(t) { - return Bue(this, t).has(t); - } - function IUr(t, e) { - return Bue(this, t).set(t, e), this; - } - O9.prototype.clear = kUr; - O9.prototype.delete = PUr; - O9.prototype.get = OUr; - O9.prototype.has = BUr; - O9.prototype.set = IUr; - function B9(t) { - this.__data__ = new Vx(t); - } - function CUr() { - this.__data__ = new Vx(); - } - function RUr(t) { - return this.__data__.delete(t); - } - function NUr(t) { - return this.__data__.get(t); - } - function DUr(t) { - return this.__data__.has(t); - } - function FUr(t, e) { - var r = this.__data__; - if (r instanceof Vx) { - var n = r.__data__; - if (!uV || n.length < Ujr - 1) return n.push([t, e]), this; - r = this.__data__ = new O9(n); - } - return r.set(t, e), this; - } - B9.prototype.clear = CUr; - B9.prototype.delete = RUr; - B9.prototype.get = NUr; - B9.prototype.has = DUr; - B9.prototype.set = FUr; - function LUr(t, e) { - var r = c4e(t) || uKr(t) ? rUr(t.length, String) : [], - n = r.length, - i = !!n; - for (var o in t) - (e || $E.call(t, o)) && - !(i && (o == "length" || iKr(o, n))) && - r.push(o); - return r; - } - function cMt(t, e, r) { - var n = t[e]; - (!($E.call(t, e) && hMt(n, r)) || (r === void 0 && !(e in t))) && - (t[e] = r); - } - function Oue(t, e) { - for (var r = t.length; r--; ) if (hMt(t[r][0], e)) return r; - return -1; - } - function qUr(t, e) { - return t && lMt(e, l4e(e), t); - } - function n4e(t, e, r, n, i, o, a) { - var s; - if ((n && (s = o ? n(t, i, o, a) : n(t)), s !== void 0)) return s; - if (!Iue(t)) return t; - var c = c4e(t); - if (c) { - if (((s = tKr(t)), !e)) return YUr(t, s); - } else { - var u = yP(t), - h = u == o4e || u == H3t; - if (lKr(t)) return VUr(t, e); - if (u == a4e || u == i4e || (h && !o)) { - if (sMt(t)) return o ? t : {}; - if (((s = rKr(h ? {} : t)), !e)) return QUr(t, qUr(s, t)); - } else { - if (!Lo[u]) return o ? t : {}; - s = nKr(t, u, n4e, e); - } - } - a || (a = new B9()); - var w = a.get(t); - if (w) return w; - if ((a.set(t, s), !c)) var M = r ? eKr(t) : l4e(t); - return ( - eUr(M || t, function (k, O) { - M && ((O = k), (k = t[O])), cMt(s, O, n4e(k, e, r, n, O, t, a)); - }), - s - ); - } - function zUr(t) { - return Iue(t) ? uUr(t) : {}; - } - function jUr(t, e, r) { - var n = e(t); - return c4e(t) ? n : tUr(n, r(t)); - } - function UUr(t) { - return Pue.call(t); - } - function KUr(t) { - if (!Iue(t) || aKr(t)) return !1; - var e = yMt(t) || sMt(t) ? aUr : Gjr; - return e.test(gP(t)); - } - function HUr(t) { - if (!dMt(t)) return dUr(t); - var e = []; - for (var r in Object(t)) $E.call(t, r) && r != "constructor" && e.push(r); - return e; - } - function VUr(t, e) { - if (e) return t.slice(); - var r = new t.constructor(t.length); - return t.copy(r), r; - } - function u4e(t) { - var e = new t.constructor(t.byteLength); - return new D3t(e).set(new D3t(t)), e; - } - function WUr(t, e) { - var r = e ? u4e(t.buffer) : t.buffer; - return new t.constructor(r, t.byteOffset, t.byteLength); - } - function GUr(t, e, r) { - var n = e ? r(B3t(t), !0) : B3t(t); - return aMt(n, Yjr, new t.constructor()); - } - function JUr(t) { - var e = new t.constructor(t.source, Wjr.exec(t)); - return (e.lastIndex = t.lastIndex), e; - } - function $Ur(t, e, r) { - var n = e ? r(I3t(t), !0) : I3t(t); - return aMt(n, Qjr, new t.constructor()); - } - function ZUr(t) { - return q3t ? Object(q3t.call(t)) : {}; - } - function XUr(t, e) { - var r = e ? u4e(t.buffer) : t.buffer; - return new t.constructor(r, t.byteOffset, t.length); - } - function YUr(t, e) { - var r = -1, - n = t.length; - for (e || (e = Array(n)); ++r < n; ) e[r] = t[r]; - return e; - } - function lMt(t, e, r, n) { - r || (r = {}); - for (var i = -1, o = e.length; ++i < o; ) { - var a = e[i], - s = n ? n(r[a], t[a], a, r, t) : void 0; - cMt(r, a, s === void 0 ? t[a] : s); - } - return r; - } - function QUr(t, e) { - return lMt(t, fMt(t), e); - } - function eKr(t) { - return jUr(t, l4e, fMt); - } - function Bue(t, e) { - var r = t.__data__; - return oKr(e) ? r[typeof e == "string" ? "string" : "hash"] : r.map; - } - function I9(t, e) { - var r = nUr(t, e); - return KUr(r) ? r : void 0; - } - var fMt = F3t ? s4e(F3t, Object) : hKr, - yP = UUr; - ((QPe && yP(new QPe(new ArrayBuffer(1))) != Tue) || - (uV && yP(new uV()) != Eue) || - (e4e && yP(e4e.resolve()) != P3t) || - (t4e && yP(new t4e()) != Mue) || - (r4e && yP(new r4e()) != YPe)) && - (yP = function (t) { - var e = Pue.call(t), - r = e == a4e ? t.constructor : void 0, - n = r ? gP(r) : void 0; - if (n) - switch (n) { - case hUr: - return Tue; - case pUr: - return Eue; - case yUr: - return P3t; - case mUr: - return Mue; - case gUr: - return YPe; - } - return e; - }); - function tKr(t) { - var e = t.length, - r = t.constructor(e); - return ( - e && - typeof t[0] == "string" && - $E.call(t, "index") && - ((r.index = t.index), (r.input = t.input)), - r - ); - } - function rKr(t) { - return typeof t.constructor == "function" && !dMt(t) ? zUr(sUr(t)) : {}; - } - function nKr(t, e, r, n) { - var i = t.constructor; - switch (e) { - case $3t: - return u4e(t); - case U3t: - case K3t: - return new i(+t); - case Tue: - return WUr(t, n); - case Z3t: - case X3t: - case Y3t: - case Q3t: - case eMt: - case tMt: - case rMt: - case nMt: - case iMt: - return XUr(t, n); - case Eue: - return GUr(t, n, r); - case V3t: - case G3t: - return new i(t); - case W3t: - return JUr(t); - case Mue: - return $Ur(t, n, r); - case J3t: - return ZUr(t); - } - } - function iKr(t, e) { - return ( - (e = e ?? j3t), - !!e && - (typeof t == "number" || Jjr.test(t)) && - t > -1 && - t % 1 == 0 && - t < e - ); - } - function oKr(t) { - var e = typeof t; - return e == "string" || e == "number" || e == "symbol" || e == "boolean" - ? t !== "__proto__" - : t === null; - } - function aKr(t) { - return !!C3t && C3t in t; - } - function dMt(t) { - var e = t && t.constructor, - r = (typeof e == "function" && e.prototype) || kue; - return t === r; - } - function gP(t) { - if (t != null) { - try { - return uMt.call(t); - } catch {} - try { - return t + ""; - } catch {} - } - return ""; - } - function sKr(t) { - return n4e(t, !0, !0); - } - function hMt(t, e) { - return t === e || (t !== t && e !== e); - } - function uKr(t) { - return ( - cKr(t) && - $E.call(t, "callee") && - (!cUr.call(t, "callee") || Pue.call(t) == i4e) - ); - } - var c4e = Array.isArray; - function pMt(t) { - return t != null && fKr(t.length) && !yMt(t); - } - function cKr(t) { - return dKr(t) && pMt(t); - } - var lKr = fUr || pKr; - function yMt(t) { - var e = Iue(t) ? Pue.call(t) : ""; - return e == o4e || e == H3t; - } - function fKr(t) { - return typeof t == "number" && t > -1 && t % 1 == 0 && t <= j3t; - } - function Iue(t) { - var e = typeof t; - return !!t && (e == "object" || e == "function"); - } - function dKr(t) { - return !!t && typeof t == "object"; - } - function l4e(t) { - return pMt(t) ? LUr(t) : HUr(t); - } - function hKr() { - return []; - } - function pKr() { - return !1; - } - P9.exports = sKr; - }); - var f4e = I((rh) => { - "use strict"; - m(); - g(); - Object.defineProperty(rh, "__esModule", { value: !0 }); - rh.ERROR_ACCOUNT_NOT_FOUND = - rh.ERROR_DEPRECATED_ACCOUNT_DATA = - rh.ERROR_INVALID_ACCOUNT_DATA = - rh.ERROR_INVALID_OWNER = - rh.MetaplexError = - rh.ErrorCode = - void 0; - var lV; - (function (t) { - (t[(t.ERROR_INVALID_OWNER = 0)] = "ERROR_INVALID_OWNER"), - (t[(t.ERROR_INVALID_ACCOUNT_DATA = 1)] = "ERROR_INVALID_ACCOUNT_DATA"), - (t[(t.ERROR_DEPRECATED_ACCOUNT_DATA = 2)] = - "ERROR_DEPRECATED_ACCOUNT_DATA"), - (t[(t.ERROR_ACCOUNT_NOT_FOUND = 3)] = "ERROR_ACCOUNT_NOT_FOUND"); - })((lV = rh.ErrorCode || (rh.ErrorCode = {}))); - var vP = class extends Error { - constructor(e, r) { - super(r), (this.errorCode = e); - } - }; - rh.MetaplexError = vP; - var vKr = () => new vP(lV.ERROR_INVALID_OWNER, "Invalid owner"); - rh.ERROR_INVALID_OWNER = vKr; - var bKr = () => new vP(lV.ERROR_INVALID_ACCOUNT_DATA, "Invalid data"); - rh.ERROR_INVALID_ACCOUNT_DATA = bKr; - var wKr = () => - new vP(lV.ERROR_DEPRECATED_ACCOUNT_DATA, "Account data is deprecated"); - rh.ERROR_DEPRECATED_ACCOUNT_DATA = wKr; - var _Kr = (t) => - new vP(lV.ERROR_ACCOUNT_NOT_FOUND, `Unable to find account: ${t}`); - rh.ERROR_ACCOUNT_NOT_FOUND = _Kr; - }); - var _Mt = I((Fue) => { - "use strict"; - m(); - g(); - Object.defineProperty(Fue, "__esModule", { value: !0 }); - Fue.Account = void 0; - var Due = Le(), - wMt = Qr(), - xKr = f4e(), - bP = class { - constructor(e, r) { - (this.pubkey = new Due.PublicKey(e)), (this.info = r); - } - static from(e) { - return new bP(e.pubkey, e.info); - } - static async load(e, r) { - let n = await bP.getInfo(e, r); - return new this(r, n); - } - static isCompatible(e) { - throw new Error("method 'isCompatible' is not implemented"); - } - static async getInfo(e, r) { - let n = await e.getAccountInfo(new Due.PublicKey(r)); - if (!n) throw (0, xKr.ERROR_ACCOUNT_NOT_FOUND)(r); - return { ...n, data: wMt.Buffer.from(n?.data) }; - } - static async getInfos(e, r, n = "recent") { - let o = []; - for (let s = 0; s < r.length; s += 99) - o.push( - bP.getMultipleAccounts( - e, - r.slice(s, Math.min(r.length, s + 99)), - n - ) - ); - let a = new Map(); - return ( - (await Promise.all(o)).forEach((s) => { - var c; - return [ - ...((c = s?.entries()) !== null && c !== void 0 ? c : []), - ].forEach(([u, h]) => a.set(u, h)); - }), - a - ); - } - static async getMultipleAccounts(e, r, n) { - let i = e._buildArgs([r.map((s) => s.toString())], n, "base64"), - o = await e._rpcRequest("getMultipleAccounts", i); - if (o.error) - throw new Error( - "failed to get info about accounts " + o.error.message - ); - return o.result.value - ? o.result.value.reduce( - (s, c, u) => ( - c && - s.set(r[u], { - ...c, - data: wMt.Buffer.from(c.data[0], "base64"), - }), - s - ), - new Map() - ) - : void 0; - } - assertOwner(e) { - var r; - return (r = this.info) === null || r === void 0 - ? void 0 - : r.owner.equals(new Due.PublicKey(e)); - } - toJSON() { - var e, r, n, i, o; - return { - pubkey: this.pubkey.toString(), - info: { - executable: !!( - !((e = this.info) === null || e === void 0) && e.executable - ), - owner: - !((r = this.info) === null || r === void 0) && r.owner - ? new Due.PublicKey( - (n = this.info) === null || n === void 0 - ? void 0 - : n.owner - ) - : null, - lamports: - (i = this.info) === null || i === void 0 ? void 0 : i.lamports, - data: - (o = this.info) === null || o === void 0 - ? void 0 - : o.data.toJSON(), - }, - data: this.data, - }; - } - toString() { - return JSON.stringify(this.toJSON()); - } - }; - Fue.Account = bP; - }); - var d4e = I((wP) => { - "use strict"; - m(); - g(); - var SKr = - (wP && wP.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - AKr = - (wP && wP.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - SKr(e, t, r); - }; - Object.defineProperty(wP, "__esModule", { value: !0 }); - AKr(_Mt(), wP); - }); - var xMt = I((Lue) => { - "use strict"; - m(); - g(); - Object.defineProperty(Lue, "__esModule", { value: !0 }); - Lue.config = void 0; - Lue.config = { - arweaveWallet: "HvwC9QSAzvGXhhVrgPmauVwFWcYZhne3hVot9EbHuFTm", - programs: { - auction: "auctxRXPeJoc4817jDhf4HbjnhEcr1cCXenosMhK5R8", - metadata: "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s", - metaplex: "p1exdMJcjVao65QdewkaZRUnU6VPSXhus9n2GzWfh98", - vault: "vau1zxA2LbssAUEF7Gpw91zMM1LvXrvpzJtmZ58rPsn", - packs: "BNRmGgciUJuyznkYHnmitA9an1BcDDiU9JmjEQwvBYVR", - auctionHouse: "hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk", - candyMachine: "cndy3Z4yapfJBmL3ShUp5exZKqR3z33thTzeNMm2gRZ", - memo: "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr", - token: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", - }, - maxCreatorLimit: 5, - }; - }); - var SMt = I((que) => { - "use strict"; - m(); - g(); - Object.defineProperty(que, "__esModule", { value: !0 }); - que.Program = void 0; - var h4e = Le(), - EKr = d4e(), - MKr = Qr(), - p4e = class { - static async findProgramAddress(e) { - return (await h4e.PublicKey.findProgramAddress(e, this.PUBKEY))[0]; - } - static async getProgramAccounts(e, r) { - let n = {}, - i; - r && - (typeof r == "string" - ? (i = r) - : ((i = r.commitment), - r.dataSlice && (n.dataSlice = r.dataSlice), - r.filters && (n.filters = r.filters))); - let o = e._buildArgs([this.PUBKEY.toBase58()], i, "base64", n); - return (await e._rpcRequest("getProgramAccounts", o)).result - .map( - ({ - account: { data: s, executable: c, lamports: u, owner: h }, - pubkey: w, - }) => ({ - account: { - data: MKr.Buffer.from(s[0], "base64"), - executable: c, - lamports: u, - owner: new h4e.PublicKey(h), - }, - pubkey: new h4e.PublicKey(w), - }) - ) - .map(({ pubkey: s, account: c }) => new EKr.Account(s, c)); - } - }; - que.Program = p4e; - }); - var AMt = I((zue) => { - "use strict"; - m(); - g(); - Object.defineProperty(zue, "__esModule", { value: !0 }); - zue.Transaction = void 0; - var TKr = Le(), - fV = class extends TKr.Transaction { - constructor(e) { - super(e); - } - static fromCombined(e, r = {}) { - let n = new fV(r); - return ( - e.forEach((i) => - i.instructions.forEach((o) => { - n.add(o); - }) - ), - n - ); - } - }; - zue.Transaction = fV; - }); - var MMt = I((EMt) => { - "use strict"; - m(); - g(); - Object.defineProperty(EMt, "__esModule", { value: !0 }); - }); - var kMt = I((Ku) => { - "use strict"; - m(); - g(); - var kKr = - (Ku && Ku.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Ku, "__esModule", { value: !0 }); - Ku.serialize = - Ku.deserializeUnchecked = - Ku.deserialize = - Ku.struct = - Ku.Data = - Ku.extendBorsh = - void 0; - var PKr = Le(), - Wx = _E(); - Object.defineProperty(Ku, "deserializeUnchecked", { - enumerable: !0, - get: function () { - return Wx.deserializeUnchecked; - }, - }); - Object.defineProperty(Ku, "serialize", { - enumerable: !0, - get: function () { - return Wx.serialize; - }, - }); - Object.defineProperty(Ku, "deserialize", { - enumerable: !0, - get: function () { - return Wx.deserialize; - }, - }); - var TMt = kKr(xv()), - OKr = () => { - (Wx.BinaryReader.prototype.readPubkey = function () { - let t = this.readFixedArray(32); - return new PKr.PublicKey(t); - }), - (Wx.BinaryWriter.prototype.writePubkey = function (t) { - this.writeFixedArray(t.toBuffer()); - }), - (Wx.BinaryReader.prototype.readPubkeyAsString = function () { - let t = this.readFixedArray(32); - return TMt.default.encode(t); - }), - (Wx.BinaryWriter.prototype.writePubkeyAsString = function (t) { - this.writeFixedArray(TMt.default.decode(t)); - }); - }; - Ku.extendBorsh = OKr; - (0, Ku.extendBorsh)(); - var y4e = class { - constructor(e = {}) { - Object.assign(this, e); - } - static struct(e) { - return (0, Ku.struct)(this, e); - } - static serialize(e = {}) { - return Buffer.from((0, Wx.serialize)(this.SCHEMA, new this(e))); - } - static deserialize(e) { - return (0, Wx.deserializeUnchecked)(this.SCHEMA, this, e); - } - }; - Ku.Data = y4e; - var BKr = (t, e) => new Map([[t, { kind: "struct", fields: e }]]); - Ku.struct = BKr; - }); - var PMt = I((Gx) => { - "use strict"; - m(); - g(); - var IKr = - (Gx && Gx.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Gx, "__esModule", { value: !0 }); - Gx.getBNFromData = Gx.TupleNumericType = void 0; - var jue = IKr(Ho()), - dV; - (function (t) { - (t[(t.U8 = 1)] = "U8"), - (t[(t.U16 = 2)] = "U16"), - (t[(t.U32 = 4)] = "U32"), - (t[(t.U64 = 8)] = "U64"); - })((dV = Gx.TupleNumericType || (Gx.TupleNumericType = {}))); - var CKr = (t, e, r) => { - switch (r) { - case dV.U8: - return new jue.default(t[e], "le"); - case dV.U16: - return new jue.default(t.slice(e, e + 2), "le"); - case dV.U32: - return new jue.default(t.slice(e, e + 4), "le"); - case dV.U64: - return new jue.default(t.slice(e, e + 8), "le"); - } - }; - Gx.getBNFromData = CKr; - }); - var BMt = I((m0) => { - "use strict"; - m(); - g(); - var OMt = - (m0 && m0.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - RKr = - (m0 && m0.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - NKr = - (m0 && m0.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - OMt(e, t, r); - return RKr(e, t), e; - }, - DKr = - (m0 && m0.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - OMt(e, t, r); - }; - Object.defineProperty(m0, "__esModule", { value: !0 }); - m0.Borsh = void 0; - m0.Borsh = NKr(kMt()); - DKr(PMt(), m0); - }); - var IMt = I((g0) => { - "use strict"; - m(); - g(); - var FKr = - (g0 && g0.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - _P = - (g0 && g0.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - FKr(e, t, r); - }; - Object.defineProperty(g0, "__esModule", { value: !0 }); - _P(d4e(), g0); - _P(xMt(), g0); - _P(f4e(), g0); - _P(SMt(), g0); - _P(AMt(), g0); - _P(MMt(), g0); - _P(BMt(), g0); - }); - var m4e = I((Tt) => { - "use strict"; - m(); - g(); - Object.defineProperty(Tt, "__esModule", { value: !0 }); - Tt.NoUnlockWithNFTsStillFrozenError = - Tt.InvalidFreezeWithdrawTokenAddressError = - Tt.MissingRemoveFreezeTokenAccountsError = - Tt.NoWithdrawWithFrozenFundsError = - Tt.NoWithdrawWithFreezeError = - Tt.EnteredFreezeIsMoreThanMaxFreezeError = - Tt.FreezePDAMismatchError = - Tt.IncorrectFreezeAtaError = - Tt.MissingFreezeAtaError = - Tt.IncorrectRemainingAccountsLenError = - Tt.InvalidThawNftError = - Tt.NoChangingTokenWithFreezeError = - Tt.NoChangingAuthorityWithCollectionError = - Tt.NoChangingFreezeDuringMintError = - Tt.GatewayProgramErrorError = - Tt.CandyCollectionRequiresRetainAuthorityError = - Tt.NoChangingCollectionDuringMintError = - Tt.MissingSetCollectionDuringMintError = - Tt.MetadataAccountMustBeEmptyError = - Tt.SlotHashesEmptyError = - Tt.MismatchedCollectionMintError = - Tt.MismatchedCollectionPDAError = - Tt.IncorrectCollectionAuthorityError = - Tt.IncorrectSlotHashesPubkeyError = - Tt.CannotSwitchToHiddenSettingsError = - Tt.SuspiciousTransactionError = - Tt.InvalidStringError = - Tt.CannotFindUsableConfigLineError = - Tt.NetworkExpireFeatureMissingError = - Tt.GatewayTokenExpireTimeInvalidError = - Tt.GatewayTokenMissingError = - Tt.GatewayAppMissingError = - Tt.TokenBurnFailedError = - Tt.NoWhitelistTokenError = - Tt.PublicKeyMismatchError = - Tt.DerivedKeyInvalidError = - Tt.CannotChangeNumberOfLinesError = - Tt.HiddenSettingsConfigsDoNotHaveConfigLinesError = - Tt.CandyMachineNotLiveError = - Tt.CandyMachineEmptyError = - Tt.TokenTransferFailedError = - Tt.NotEnoughSOLError = - Tt.NotEnoughTokensError = - Tt.UuidMustBeExactly6LengthError = - Tt.TooManyCreatorsError = - Tt.NumericalOverflowErrorError = - Tt.IndexGreaterThanLengthError = - Tt.MintMismatchError = - Tt.UninitializedError = - Tt.IncorrectOwnerError = - void 0; - Tt.errorFromName = - Tt.errorFromCode = - Tt.CannotSwitchFromHiddenSettingsError = - Tt.SizedCollectionMetadataMustBeMutableError = - void 0; - var Er = new Map(), - Mr = new Map(), - xP = class extends Error { - constructor() { - super("Account does not have correct owner!"), - (this.code = 6e3), - (this.name = "IncorrectOwner"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, xP); - } - }; - Tt.IncorrectOwnerError = xP; - Er.set(6e3, () => new xP()); - Mr.set("IncorrectOwner", () => new xP()); - var SP = class extends Error { - constructor() { - super("Account is not initialized!"), - (this.code = 6001), - (this.name = "Uninitialized"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, SP); - } - }; - Tt.UninitializedError = SP; - Er.set(6001, () => new SP()); - Mr.set("Uninitialized", () => new SP()); - var AP = class extends Error { - constructor() { - super("Mint Mismatch!"), - (this.code = 6002), - (this.name = "MintMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, AP); - } - }; - Tt.MintMismatchError = AP; - Er.set(6002, () => new AP()); - Mr.set("MintMismatch", () => new AP()); - var EP = class extends Error { - constructor() { - super("Index greater than length!"), - (this.code = 6003), - (this.name = "IndexGreaterThanLength"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, EP); - } - }; - Tt.IndexGreaterThanLengthError = EP; - Er.set(6003, () => new EP()); - Mr.set("IndexGreaterThanLength", () => new EP()); - var MP = class extends Error { - constructor() { - super("Numerical overflow error!"), - (this.code = 6004), - (this.name = "NumericalOverflowError"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, MP); - } - }; - Tt.NumericalOverflowErrorError = MP; - Er.set(6004, () => new MP()); - Mr.set("NumericalOverflowError", () => new MP()); - var TP = class extends Error { - constructor() { - super( - "Can only provide up to 4 creators to candy machine (because candy machine is one)!" - ), - (this.code = 6005), - (this.name = "TooManyCreators"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, TP); - } - }; - Tt.TooManyCreatorsError = TP; - Er.set(6005, () => new TP()); - Mr.set("TooManyCreators", () => new TP()); - var kP = class extends Error { - constructor() { - super("Uuid must be exactly of 6 length"), - (this.code = 6006), - (this.name = "UuidMustBeExactly6Length"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, kP); - } - }; - Tt.UuidMustBeExactly6LengthError = kP; - Er.set(6006, () => new kP()); - Mr.set("UuidMustBeExactly6Length", () => new kP()); - var PP = class extends Error { - constructor() { - super("Not enough tokens to pay for this minting"), - (this.code = 6007), - (this.name = "NotEnoughTokens"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, PP); - } - }; - Tt.NotEnoughTokensError = PP; - Er.set(6007, () => new PP()); - Mr.set("NotEnoughTokens", () => new PP()); - var OP = class extends Error { - constructor() { - super("Not enough SOL to pay for this minting"), - (this.code = 6008), - (this.name = "NotEnoughSOL"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, OP); - } - }; - Tt.NotEnoughSOLError = OP; - Er.set(6008, () => new OP()); - Mr.set("NotEnoughSOL", () => new OP()); - var BP = class extends Error { - constructor() { - super("Token transfer failed"), - (this.code = 6009), - (this.name = "TokenTransferFailed"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, BP); - } - }; - Tt.TokenTransferFailedError = BP; - Er.set(6009, () => new BP()); - Mr.set("TokenTransferFailed", () => new BP()); - var IP = class extends Error { - constructor() { - super("Candy machine is empty!"), - (this.code = 6010), - (this.name = "CandyMachineEmpty"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, IP); - } - }; - Tt.CandyMachineEmptyError = IP; - Er.set(6010, () => new IP()); - Mr.set("CandyMachineEmpty", () => new IP()); - var CP = class extends Error { - constructor() { - super("Candy machine is not live!"), - (this.code = 6011), - (this.name = "CandyMachineNotLive"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, CP); - } - }; - Tt.CandyMachineNotLiveError = CP; - Er.set(6011, () => new CP()); - Mr.set("CandyMachineNotLive", () => new CP()); - var RP = class extends Error { - constructor() { - super( - "Configs that are using hidden uris do not have config lines, they have a single hash representing hashed order" - ), - (this.code = 6012), - (this.name = "HiddenSettingsConfigsDoNotHaveConfigLines"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, RP); - } - }; - Tt.HiddenSettingsConfigsDoNotHaveConfigLinesError = RP; - Er.set(6012, () => new RP()); - Mr.set("HiddenSettingsConfigsDoNotHaveConfigLines", () => new RP()); - var NP = class extends Error { - constructor() { - super("Cannot change number of lines unless is a hidden config"), - (this.code = 6013), - (this.name = "CannotChangeNumberOfLines"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, NP); - } - }; - Tt.CannotChangeNumberOfLinesError = NP; - Er.set(6013, () => new NP()); - Mr.set("CannotChangeNumberOfLines", () => new NP()); - var DP = class extends Error { - constructor() { - super("Derived key invalid"), - (this.code = 6014), - (this.name = "DerivedKeyInvalid"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, DP); - } - }; - Tt.DerivedKeyInvalidError = DP; - Er.set(6014, () => new DP()); - Mr.set("DerivedKeyInvalid", () => new DP()); - var FP = class extends Error { - constructor() { - super("Public key mismatch"), - (this.code = 6015), - (this.name = "PublicKeyMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, FP); - } - }; - Tt.PublicKeyMismatchError = FP; - Er.set(6015, () => new FP()); - Mr.set("PublicKeyMismatch", () => new FP()); - var LP = class extends Error { - constructor() { - super("No whitelist token present"), - (this.code = 6016), - (this.name = "NoWhitelistToken"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, LP); - } - }; - Tt.NoWhitelistTokenError = LP; - Er.set(6016, () => new LP()); - Mr.set("NoWhitelistToken", () => new LP()); - var qP = class extends Error { - constructor() { - super("Token burn failed"), - (this.code = 6017), - (this.name = "TokenBurnFailed"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, qP); - } - }; - Tt.TokenBurnFailedError = qP; - Er.set(6017, () => new qP()); - Mr.set("TokenBurnFailed", () => new qP()); - var zP = class extends Error { - constructor() { - super("Missing gateway app when required"), - (this.code = 6018), - (this.name = "GatewayAppMissing"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, zP); - } - }; - Tt.GatewayAppMissingError = zP; - Er.set(6018, () => new zP()); - Mr.set("GatewayAppMissing", () => new zP()); - var jP = class extends Error { - constructor() { - super("Missing gateway token when required"), - (this.code = 6019), - (this.name = "GatewayTokenMissing"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, jP); - } - }; - Tt.GatewayTokenMissingError = jP; - Er.set(6019, () => new jP()); - Mr.set("GatewayTokenMissing", () => new jP()); - var UP = class extends Error { - constructor() { - super("Invalid gateway token expire time"), - (this.code = 6020), - (this.name = "GatewayTokenExpireTimeInvalid"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, UP); - } - }; - Tt.GatewayTokenExpireTimeInvalidError = UP; - Er.set(6020, () => new UP()); - Mr.set("GatewayTokenExpireTimeInvalid", () => new UP()); - var KP = class extends Error { - constructor() { - super("Missing gateway network expire feature when required"), - (this.code = 6021), - (this.name = "NetworkExpireFeatureMissing"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, KP); - } - }; - Tt.NetworkExpireFeatureMissingError = KP; - Er.set(6021, () => new KP()); - Mr.set("NetworkExpireFeatureMissing", () => new KP()); - var HP = class extends Error { - constructor() { - super( - "Unable to find an unused config line near your random number index" - ), - (this.code = 6022), - (this.name = "CannotFindUsableConfigLine"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, HP); - } - }; - Tt.CannotFindUsableConfigLineError = HP; - Er.set(6022, () => new HP()); - Mr.set("CannotFindUsableConfigLine", () => new HP()); - var VP = class extends Error { - constructor() { - super("Invalid string"), - (this.code = 6023), - (this.name = "InvalidString"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, VP); - } - }; - Tt.InvalidStringError = VP; - Er.set(6023, () => new VP()); - Mr.set("InvalidString", () => new VP()); - var WP = class extends Error { - constructor() { - super("Suspicious transaction detected"), - (this.code = 6024), - (this.name = "SuspiciousTransaction"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, WP); - } - }; - Tt.SuspiciousTransactionError = WP; - Er.set(6024, () => new WP()); - Mr.set("SuspiciousTransaction", () => new WP()); - var GP = class extends Error { - constructor() { - super( - "Cannot Switch to Hidden Settings after items available is greater than 0" - ), - (this.code = 6025), - (this.name = "CannotSwitchToHiddenSettings"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, GP); - } - }; - Tt.CannotSwitchToHiddenSettingsError = GP; - Er.set(6025, () => new GP()); - Mr.set("CannotSwitchToHiddenSettings", () => new GP()); - var JP = class extends Error { - constructor() { - super("Incorrect SlotHashes PubKey"), - (this.code = 6026), - (this.name = "IncorrectSlotHashesPubkey"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, JP); - } - }; - Tt.IncorrectSlotHashesPubkeyError = JP; - Er.set(6026, () => new JP()); - Mr.set("IncorrectSlotHashesPubkey", () => new JP()); - var $P = class extends Error { - constructor() { - super("Incorrect collection NFT authority"), - (this.code = 6027), - (this.name = "IncorrectCollectionAuthority"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, $P); - } - }; - Tt.IncorrectCollectionAuthorityError = $P; - Er.set(6027, () => new $P()); - Mr.set("IncorrectCollectionAuthority", () => new $P()); - var ZP = class extends Error { - constructor() { - super("Collection PDA address is invalid"), - (this.code = 6028), - (this.name = "MismatchedCollectionPDA"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, ZP); - } - }; - Tt.MismatchedCollectionPDAError = ZP; - Er.set(6028, () => new ZP()); - Mr.set("MismatchedCollectionPDA", () => new ZP()); - var XP = class extends Error { - constructor() { - super("Provided mint account doesn't match collection PDA mint"), - (this.code = 6029), - (this.name = "MismatchedCollectionMint"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, XP); - } - }; - Tt.MismatchedCollectionMintError = XP; - Er.set(6029, () => new XP()); - Mr.set("MismatchedCollectionMint", () => new XP()); - var YP = class extends Error { - constructor() { - super("Slot hashes Sysvar is empty"), - (this.code = 6030), - (this.name = "SlotHashesEmpty"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, YP); - } - }; - Tt.SlotHashesEmptyError = YP; - Er.set(6030, () => new YP()); - Mr.set("SlotHashesEmpty", () => new YP()); - var QP = class extends Error { - constructor() { - super( - "The metadata account has data in it, and this must be empty to mint a new NFT" - ), - (this.code = 6031), - (this.name = "MetadataAccountMustBeEmpty"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, QP); - } - }; - Tt.MetadataAccountMustBeEmptyError = QP; - Er.set(6031, () => new QP()); - Mr.set("MetadataAccountMustBeEmpty", () => new QP()); - var e4 = class extends Error { - constructor() { - super( - "Missing set collection during mint IX for Candy Machine with collection set" - ), - (this.code = 6032), - (this.name = "MissingSetCollectionDuringMint"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, e4); - } - }; - Tt.MissingSetCollectionDuringMintError = e4; - Er.set(6032, () => new e4()); - Mr.set("MissingSetCollectionDuringMint", () => new e4()); - var t4 = class extends Error { - constructor() { - super( - "Can't change collection settings after items have begun to be minted" - ), - (this.code = 6033), - (this.name = "NoChangingCollectionDuringMint"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, t4); - } - }; - Tt.NoChangingCollectionDuringMintError = t4; - Er.set(6033, () => new t4()); - Mr.set("NoChangingCollectionDuringMint", () => new t4()); - var r4 = class extends Error { - constructor() { - super( - "Retain authority must be true for Candy Machines with a collection set" - ), - (this.code = 6034), - (this.name = "CandyCollectionRequiresRetainAuthority"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, r4); - } - }; - Tt.CandyCollectionRequiresRetainAuthorityError = r4; - Er.set(6034, () => new r4()); - Mr.set("CandyCollectionRequiresRetainAuthority", () => new r4()); - var n4 = class extends Error { - constructor() { - super("Error within Gateway program"), - (this.code = 6035), - (this.name = "GatewayProgramError"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, n4); - } - }; - Tt.GatewayProgramErrorError = n4; - Er.set(6035, () => new n4()); - Mr.set("GatewayProgramError", () => new n4()); - var i4 = class extends Error { - constructor() { - super( - "Can't change freeze settings after items have begun to be minted. You can only disable." - ), - (this.code = 6036), - (this.name = "NoChangingFreezeDuringMint"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, i4); - } - }; - Tt.NoChangingFreezeDuringMintError = i4; - Er.set(6036, () => new i4()); - Mr.set("NoChangingFreezeDuringMint", () => new i4()); - var o4 = class extends Error { - constructor() { - super( - "Can't change authority while collection is enabled. Disable collection first." - ), - (this.code = 6037), - (this.name = "NoChangingAuthorityWithCollection"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, o4); - } - }; - Tt.NoChangingAuthorityWithCollectionError = o4; - Er.set(6037, () => new o4()); - Mr.set("NoChangingAuthorityWithCollection", () => new o4()); - var a4 = class extends Error { - constructor() { - super( - "Can't change token while freeze is enabled. Disable freeze first." - ), - (this.code = 6038), - (this.name = "NoChangingTokenWithFreeze"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, a4); - } - }; - Tt.NoChangingTokenWithFreezeError = a4; - Er.set(6038, () => new a4()); - Mr.set("NoChangingTokenWithFreeze", () => new a4()); - var s4 = class extends Error { - constructor() { - super( - "Cannot thaw NFT unless all NFTs are minted or Candy Machine authority enables thawing" - ), - (this.code = 6039), - (this.name = "InvalidThawNft"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, s4); - } - }; - Tt.InvalidThawNftError = s4; - Er.set(6039, () => new s4()); - Mr.set("InvalidThawNft", () => new s4()); - var u4 = class extends Error { - constructor() { - super( - "The number of remaining accounts passed in doesn't match the Candy Machine settings" - ), - (this.code = 6040), - (this.name = "IncorrectRemainingAccountsLen"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, u4); - } - }; - Tt.IncorrectRemainingAccountsLenError = u4; - Er.set(6040, () => new u4()); - Mr.set("IncorrectRemainingAccountsLen", () => new u4()); - var c4 = class extends Error { - constructor() { - super("FreezePDA ATA needs to be passed in if token mint is enabled."), - (this.code = 6041), - (this.name = "MissingFreezeAta"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, c4); - } - }; - Tt.MissingFreezeAtaError = c4; - Er.set(6041, () => new c4()); - Mr.set("MissingFreezeAta", () => new c4()); - var l4 = class extends Error { - constructor() { - super("Incorrect freeze ATA address."), - (this.code = 6042), - (this.name = "IncorrectFreezeAta"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, l4); - } - }; - Tt.IncorrectFreezeAtaError = l4; - Er.set(6042, () => new l4()); - Mr.set("IncorrectFreezeAta", () => new l4()); - var f4 = class extends Error { - constructor() { - super("FreezePDA doesn't belong to this Candy Machine."), - (this.code = 6043), - (this.name = "FreezePDAMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, f4); - } - }; - Tt.FreezePDAMismatchError = f4; - Er.set(6043, () => new f4()); - Mr.set("FreezePDAMismatch", () => new f4()); - var d4 = class extends Error { - constructor() { - super("Freeze time can't be longer than MAX_FREEZE_TIME."), - (this.code = 6044), - (this.name = "EnteredFreezeIsMoreThanMaxFreeze"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, d4); - } - }; - Tt.EnteredFreezeIsMoreThanMaxFreezeError = d4; - Er.set(6044, () => new d4()); - Mr.set("EnteredFreezeIsMoreThanMaxFreeze", () => new d4()); - var h4 = class extends Error { - constructor() { - super( - "Can't withdraw Candy Machine while freeze is active. Disable freeze first." - ), - (this.code = 6045), - (this.name = "NoWithdrawWithFreeze"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, h4); - } - }; - Tt.NoWithdrawWithFreezeError = h4; - Er.set(6045, () => new h4()); - Mr.set("NoWithdrawWithFreeze", () => new h4()); - var p4 = class extends Error { - constructor() { - super( - "Can't withdraw Candy Machine while frozen funds need to be redeemed. Unlock funds first." - ), - (this.code = 6046), - (this.name = "NoWithdrawWithFrozenFunds"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, p4); - } - }; - Tt.NoWithdrawWithFrozenFundsError = p4; - Er.set(6046, () => new p4()); - Mr.set("NoWithdrawWithFrozenFunds", () => new p4()); - var y4 = class extends Error { - constructor() { - super( - "Missing required remaining accounts for remove_freeze with token mint." - ), - (this.code = 6047), - (this.name = "MissingRemoveFreezeTokenAccounts"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, y4); - } - }; - Tt.MissingRemoveFreezeTokenAccountsError = y4; - Er.set(6047, () => new y4()); - Mr.set("MissingRemoveFreezeTokenAccounts", () => new y4()); - var m4 = class extends Error { - constructor() { - super("Can't withdraw SPL Token from freeze PDA into itself"), - (this.code = 6048), - (this.name = "InvalidFreezeWithdrawTokenAddress"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, m4); - } - }; - Tt.InvalidFreezeWithdrawTokenAddressError = m4; - Er.set(6048, () => new m4()); - Mr.set("InvalidFreezeWithdrawTokenAddress", () => new m4()); - var g4 = class extends Error { - constructor() { - super( - "Can't unlock funds while NFTs are still frozen. Run thaw on all NFTs first." - ), - (this.code = 6049), - (this.name = "NoUnlockWithNFTsStillFrozen"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, g4); - } - }; - Tt.NoUnlockWithNFTsStillFrozenError = g4; - Er.set(6049, () => new g4()); - Mr.set("NoUnlockWithNFTsStillFrozen", () => new g4()); - var v4 = class extends Error { - constructor() { - super( - "Setting a sized collection requires the collection metadata to be mutable." - ), - (this.code = 6050), - (this.name = "SizedCollectionMetadataMustBeMutable"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, v4); - } - }; - Tt.SizedCollectionMetadataMustBeMutableError = v4; - Er.set(6050, () => new v4()); - Mr.set("SizedCollectionMetadataMustBeMutable", () => new v4()); - var b4 = class extends Error { - constructor() { - super("Cannot remove Hidden Settings."), - (this.code = 6051), - (this.name = "CannotSwitchFromHiddenSettings"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, b4); - } - }; - Tt.CannotSwitchFromHiddenSettingsError = b4; - Er.set(6051, () => new b4()); - Mr.set("CannotSwitchFromHiddenSettings", () => new b4()); - function LKr(t) { - let e = Er.get(t); - return e != null ? e() : null; - } - Tt.errorFromCode = LKr; - function qKr(t) { - let e = Mr.get(t); - return e != null ? e() : null; - } - Tt.errorFromName = qKr; - }); - var sm = I((mf) => { - "use strict"; - m(); - g(); - Object.defineProperty(mf, "__esModule", { value: !0 }); - mf.isElementCollectionFixedSizeBeet = - mf.isFixableBeet = - mf.assertFixedSizeBeet = - mf.isFixedSizeBeet = - mf.BEET_TYPE_ARG_INNER = - mf.BEET_TYPE_ARG_LEN = - mf.BEET_PACKAGE = - void 0; - var zKr = Dr(); - mf.BEET_PACKAGE = "@metaplex-foundation/beet"; - mf.BEET_TYPE_ARG_LEN = "len"; - mf.BEET_TYPE_ARG_INNER = "Beet<{innner}>"; - function CMt(t) { - return Object.keys(t).includes("byteSize"); - } - mf.isFixedSizeBeet = CMt; - function jKr(t, e = `${t} should have been a fixed beet`) { - (0, zKr.strict)(CMt(t), e); - } - mf.assertFixedSizeBeet = jKr; - function UKr(t) { - return ( - typeof t.toFixedFromData == "function" && - typeof t.toFixedFromValue == "function" - ); - } - mf.isFixableBeet = UKr; - function KKr(t) { - let e = Object.keys(t); - return ( - e.includes("length") && - e.includes("elementByteSize") && - e.includes("lenPrefixByteSize") - ); - } - mf.isElementCollectionFixedSizeBeet = KKr; - }); - var R9 = I((Kn) => { - "use strict"; - m(); - g(); - var HKr = - (Kn && Kn.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Kn, "__esModule", { value: !0 }); - Kn.numbersTypeMap = - Kn.bool = - Kn.i512 = - Kn.i256 = - Kn.i128 = - Kn.i64 = - Kn.i32 = - Kn.i16 = - Kn.i8 = - Kn.u512 = - Kn.u256 = - Kn.u128 = - Kn.u64 = - Kn.u32 = - Kn.u16 = - Kn.u8 = - void 0; - var C9 = HKr(Ho()), - Ea = sm(); - Kn.u8 = { - write: function (t, e, r) { - t.writeUInt8(r, e); - }, - read: function (t, e) { - return t.readUInt8(e); - }, - byteSize: 1, - description: "u8", - }; - Kn.u16 = { - write: function (t, e, r) { - t.writeUInt16LE(r, e); - }, - read: function (t, e) { - return t.readUInt16LE(e); - }, - byteSize: 2, - description: "u16", - }; - Kn.u32 = { - write: function (t, e, r) { - t.writeUInt32LE(r, e); - }, - read: function (t, e) { - return t.readUInt32LE(e); - }, - byteSize: 4, - description: "u32", - }; - function Uue(t, e) { - return { - write: function (r, n, i) { - let a = (C9.default.isBN(i) ? i : new C9.default(i)).toArray( - "le", - this.byteSize - ); - Buffer.from(a).copy(r, n, 0, this.byteSize); - }, - read: function (r, n) { - let i = r.slice(n, n + this.byteSize); - return new C9.default(i, "le"); - }, - byteSize: t, - description: e, - }; - } - Kn.u64 = Uue(8, "u64"); - Kn.u128 = Uue(16, "u128"); - Kn.u256 = Uue(32, "u256"); - Kn.u512 = Uue(64, "u512"); - Kn.i8 = { - write: function (t, e, r) { - t.writeInt8(r, e); - }, - read: function (t, e) { - return t.readInt8(e); - }, - byteSize: 1, - description: "i8", - }; - Kn.i16 = { - write: function (t, e, r) { - t.writeInt16LE(r, e); - }, - read: function (t, e) { - return t.readInt16LE(e); - }, - byteSize: 2, - description: "i16", - }; - Kn.i32 = { - write: function (t, e, r) { - t.writeInt32LE(r, e); - }, - read: function (t, e) { - return t.readInt32LE(e); - }, - byteSize: 4, - description: "i32", - }; - function Kue(t, e) { - let r = t * 8; - return { - write: function (n, i, o) { - let s = (C9.default.isBN(o) ? o : new C9.default(o)) - .toTwos(r) - .toArray("le", this.byteSize); - Buffer.from(s).copy(n, i, 0, this.byteSize); - }, - read: function (n, i) { - let o = n.slice(i, i + this.byteSize); - return new C9.default(o, "le").fromTwos(r); - }, - byteSize: t, - description: e, - }; - } - Kn.i64 = Kue(8, "i64"); - Kn.i128 = Kue(16, "i128"); - Kn.i256 = Kue(32, "i256"); - Kn.i512 = Kue(64, "i512"); - Kn.bool = { - write: function (t, e, r) { - let n = r ? 1 : 0; - Kn.u8.write(t, e, n); - }, - read: function (t, e) { - return Kn.u8.read(t, e) === 1; - }, - byteSize: 1, - description: "bool", - }; - Kn.numbersTypeMap = { - u8: { - beet: "u8", - isFixable: !1, - sourcePack: Ea.BEET_PACKAGE, - ts: "number", - }, - u16: { - beet: "u16", - isFixable: !1, - sourcePack: Ea.BEET_PACKAGE, - ts: "number", - }, - u32: { - beet: "u32", - isFixable: !1, - sourcePack: Ea.BEET_PACKAGE, - ts: "number", - }, - i8: { - beet: "i8", - isFixable: !1, - sourcePack: Ea.BEET_PACKAGE, - ts: "number", - }, - i16: { - beet: "i16", - isFixable: !1, - sourcePack: Ea.BEET_PACKAGE, - ts: "number", - }, - i32: { - beet: "i32", - isFixable: !1, - sourcePack: Ea.BEET_PACKAGE, - ts: "number", - }, - bool: { - beet: "bool", - isFixable: !1, - sourcePack: Ea.BEET_PACKAGE, - ts: "boolean", - }, - u64: { - beet: "u64", - isFixable: !1, - sourcePack: Ea.BEET_PACKAGE, - ts: "bignum", - pack: Ea.BEET_PACKAGE, - }, - u128: { - beet: "u128", - isFixable: !1, - sourcePack: Ea.BEET_PACKAGE, - ts: "bignum", - pack: Ea.BEET_PACKAGE, - }, - u256: { - beet: "u256", - isFixable: !1, - sourcePack: Ea.BEET_PACKAGE, - ts: "bignum", - pack: Ea.BEET_PACKAGE, - }, - u512: { - beet: "u512", - isFixable: !1, - sourcePack: Ea.BEET_PACKAGE, - ts: "bignum", - pack: Ea.BEET_PACKAGE, - }, - i64: { - beet: "i64", - isFixable: !1, - sourcePack: Ea.BEET_PACKAGE, - ts: "bignum", - pack: Ea.BEET_PACKAGE, - }, - i128: { - beet: "i128", - isFixable: !1, - sourcePack: Ea.BEET_PACKAGE, - ts: "bignum", - pack: Ea.BEET_PACKAGE, - }, - i256: { - beet: "i256", - isFixable: !1, - sourcePack: Ea.BEET_PACKAGE, - ts: "bignum", - pack: Ea.BEET_PACKAGE, - }, - i512: { - beet: "i512", - isFixable: !1, - sourcePack: Ea.BEET_PACKAGE, - ts: "bignum", - pack: Ea.BEET_PACKAGE, - }, - }; - }); - var N9 = I((gf) => { - "use strict"; - m(); - g(); - var NMt = - (gf && gf.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(gf, "__esModule", { value: !0 }); - gf.bytes = - gf.beetBytes = - gf.logTrace = - gf.logDebug = - gf.logInfo = - gf.logError = - void 0; - var Hue = NMt(Nx()), - VKr = NMt(Mg()), - RMt = sm(), - { brightBlack: DMt } = VKr.default; - gf.logError = (0, Hue.default)("beet:error"); - gf.logInfo = (0, Hue.default)("beet:info"); - gf.logDebug = (0, Hue.default)("beet:debug"); - gf.logTrace = (0, Hue.default)("beet:trace"); - function WKr(t, e = !1) { - let r; - if ((0, RMt.isFixableBeet)(t)) r = "? B"; - else if ((0, RMt.isElementCollectionFixedSizeBeet)(t)) { - let n = e ? "length" : t.length, - i = t.lenPrefixByteSize; - r = - i > 0 - ? `${i} + (${t.elementByteSize} * ${n}) B (${t.byteSize} B)` - : `(${t.elementByteSize} * ${n}) B (${t.byteSize} B)`; - } else r = `${t.byteSize} B`; - return DMt(r); - } - gf.beetBytes = WKr; - function GKr(t) { - return DMt(`${t} B`); - } - gf.bytes = GKr; - }); - var hV = I((D9) => { - "use strict"; - m(); - g(); - Object.defineProperty(D9, "__esModule", { value: !0 }); - D9.fixBeetFromValue = D9.fixBeetFromData = void 0; - var Vue = sm(); - function JKr(t, e, r) { - if ((0, Vue.isFixedSizeBeet)(t)) return t; - if ((0, Vue.isFixableBeet)(t)) return t.toFixedFromData(e, r); - throw new Error(`${t.description} is neither fixed size nor fixable`); - } - D9.fixBeetFromData = JKr; - function $Kr(t, e) { - if ((0, Vue.isFixedSizeBeet)(t)) return t; - if ((0, Vue.isFixableBeet)(t)) return t.toFixedFromValue(e); - throw new Error(`${t.description} is neither fixed size nor fixable`); - } - D9.fixBeetFromValue = $Kr; - }); - var Wue = I((vf) => { - "use strict"; - m(); - g(); - Object.defineProperty(vf, "__esModule", { value: !0 }); - vf.collectionsTypeMap = - vf.uint8Array = - vf.fixedSizeUint8Array = - vf.fixedSizeBuffer = - vf.array = - vf.fixedSizeArray = - vf.uniformFixedSizeArray = - void 0; - var F9 = sm(), - w4 = Dr(), - ZE = R9(), - L9 = sm(), - LMt = N9(), - FMt = hV(); - function ZKr(t, e, r = !1) { - let n = t.byteSize * e, - i = r ? 4 + n : n; - return { - write: function (o, a, s) { - w4.strict.equal( - s.length, - e, - `array length ${s.length} should match len ${e}` - ), - r && (ZE.u32.write(o, a, e), (a += 4)); - for (let c = 0; c < e; c++) t.write(o, a + c * t.byteSize, s[c]); - }, - read: function (o, a) { - if (r) { - let c = ZE.u32.read(o, a); - w4.strict.equal(c, e, "invalid byte size"), (a += 4); - } - let s = new Array(e); - for (let c = 0; c < e; c++) s[c] = t.read(o, a + c * t.byteSize); - return s; - }, - byteSize: i, - length: e, - elementByteSize: t.byteSize, - lenPrefixByteSize: 4, - description: `Array<${t.description}>(${e})`, - }; - } - vf.uniformFixedSizeArray = ZKr; - function g4e(t, e) { - let r = t.length, - n = r === 0 ? "" : t[0].description; - return { - write: function (i, o, a) { - w4.strict.equal( - a.length, - r, - `array length ${a.length} should match len ${r}` - ), - ZE.u32.write(i, o, r); - let s = o + 4; - for (let c = 0; c < r; c++) { - let u = t[c]; - u.write(i, s, a[c]), (s += u.byteSize); - } - }, - read: function (i, o) { - let a = ZE.u32.read(i, o); - w4.strict.equal(a, r, "invalid byte size"); - let s = o + 4, - c = new Array(r); - for (let u = 0; u < r; u++) { - let h = t[u]; - (c[u] = h.read(i, s)), (s += h.byteSize); - } - return c; - }, - byteSize: 4 + e, - length: r, - description: `Array<${n}>(${r})[ 4 + ${e} ]`, - }; - } - vf.fixedSizeArray = g4e; - function XKr(t) { - return { - toFixedFromData(e, r) { - let n = ZE.u32.read(e, r); - (0, LMt.logTrace)(`${this.description}[${n}]`); - let i = r + 4, - o = i, - a = new Array(n); - for (let s = 0; s < n; s++) { - let c = (0, FMt.fixBeetFromData)(t, e, o); - (a[s] = c), (o += c.byteSize); - } - return g4e(a, o - i); - }, - toFixedFromValue(e) { - (0, w4.strict)(Array.isArray(e), `${e} should be an array`); - let r = 0, - n = new Array(e.length); - for (let i = 0; i < e.length; i++) { - let o = (0, FMt.fixBeetFromValue)(t, e[i]); - (n[i] = o), (r += o.byteSize); - } - return g4e(n, r); - }, - description: "array", - }; - } - vf.array = XKr; - function qMt(t) { - return { - write: function (e, r, n) { - n.copy(e, r, 0, t); - }, - read: function (e, r) { - return e.slice(r, r + t); - }, - byteSize: t, - description: `Buffer(${t})`, - }; - } - vf.fixedSizeBuffer = qMt; - function v4e(t, e = !1) { - let r = qMt(t), - n = e ? t + 4 : t; - return { - write: function (i, o, a) { - w4.strict.equal( - a.byteLength, - t, - `Uint8Array length ${a.byteLength} should match len ${t}` - ), - e && (ZE.u32.write(i, o, t), (o += 4)); - let s = Buffer.from(a); - r.write(i, o, s); - }, - read: function (i, o) { - if (e) { - let s = ZE.u32.read(i, o); - w4.strict.equal(s, t, "invalid byte size"), (o += 4); - } - let a = r.read(i, o); - return Uint8Array.from(a); - }, - byteSize: n, - description: `Uint8Array(${t})`, - }; - } - vf.fixedSizeUint8Array = v4e; - vf.uint8Array = { - toFixedFromData(t, e) { - let r = ZE.u32.read(t, e); - return (0, LMt.logTrace)(`${this.description}[${r}]`), v4e(r, !0); - }, - toFixedFromValue(t) { - let e = t.byteLength; - return v4e(e, !0); - }, - description: "Uint8Array", - }; - vf.collectionsTypeMap = { - Array: { - beet: "array", - isFixable: !0, - sourcePack: L9.BEET_PACKAGE, - ts: "Array", - arg: F9.BEET_TYPE_ARG_LEN, - }, - FixedSizeArray: { - beet: "fixedSizeArray", - isFixable: !1, - sourcePack: L9.BEET_PACKAGE, - ts: "Array", - arg: F9.BEET_TYPE_ARG_LEN, - }, - UniformFixedSizeArray: { - beet: "uniformFixedSizeArray", - isFixable: !1, - sourcePack: L9.BEET_PACKAGE, - ts: "Array", - arg: F9.BEET_TYPE_ARG_LEN, - }, - Buffer: { - beet: "fixedSizeBuffer", - isFixable: !1, - sourcePack: L9.BEET_PACKAGE, - ts: "Buffer", - arg: F9.BEET_TYPE_ARG_LEN, - }, - FixedSizeUint8Array: { - beet: "fixedSizeUint8Array", - isFixable: !1, - sourcePack: L9.BEET_PACKAGE, - ts: "Uint8Array", - arg: F9.BEET_TYPE_ARG_LEN, - }, - Uint8Array: { - beet: "uint8Array", - isFixable: !0, - sourcePack: L9.BEET_PACKAGE, - ts: "Uint8Array", - arg: F9.BEET_TYPE_ARG_LEN, - }, - }; - }); - var A4e = I((bp) => { - "use strict"; - m(); - g(); - Object.defineProperty(bp, "__esModule", { value: !0 }); - bp.compositesTypeMap = - bp.coption = - bp.coptionSome = - bp.coptionNone = - bp.isNoneBuffer = - bp.isSomeBuffer = - void 0; - var pV = Dr(), - b4e = sm(), - zMt = sm(), - UMt = N9(), - jMt = hV(), - KMt = 0, - HMt = 1; - function x4e(t, e) { - return t[e] === HMt; - } - bp.isSomeBuffer = x4e; - function S4e(t, e) { - return t[e] === KMt; - } - bp.isNoneBuffer = S4e; - function w4e(t) { - return ( - (0, UMt.logTrace)(`coptionNone(${t})`), - { - write: function (e, r, n) { - (0, pV.strict)( - n == null, - "coptionNone can only handle `null` values" - ), - (e[r] = KMt); - }, - read: function (e, r) { - return ( - (0, pV.strict)( - S4e(e, r), - "coptionNone can only handle `NONE` data" - ), - null - ); - }, - byteSize: 1, - description: `COption`, - } - ); - } - bp.coptionNone = w4e; - function _4e(t) { - let e = 1 + t.byteSize, - r = { - write: function (n, i, o) { - (0, b4e.assertFixedSizeBeet)( - t, - `coption inner type ${t.description} needs to be fixed before calling write` - ), - (0, pV.strict)( - o != null, - "coptionSome cannot handle `null` values" - ), - (n[i] = HMt), - t.write(n, i + 1, o); - }, - read: function (n, i) { - return ( - (0, b4e.assertFixedSizeBeet)( - t, - `coption inner type ${t.description} needs to be fixed before calling read` - ), - (0, pV.strict)( - x4e(n, i), - "coptionSome can only handle `SOME` data" - ), - t.read(n, i + 1) - ); - }, - description: `COption<${t.description}>[1 + ${t.byteSize}]`, - byteSize: e, - inner: t, - }; - return (0, UMt.logTrace)(r.description), r; - } - bp.coptionSome = _4e; - function YKr(t) { - return { - toFixedFromData(e, r) { - if (x4e(e, r)) { - let n = (0, jMt.fixBeetFromData)(t, e, r + 1); - return _4e(n); - } else - return ( - (0, pV.strict)(S4e(e, r), `Expected ${e} to hold a COption`), - w4e(t.description) - ); - }, - toFixedFromValue(e) { - return e == null - ? w4e(t.description) - : _4e((0, jMt.fixBeetFromValue)(t, e)); - }, - description: `COption<${t.description}>`, - }; - } - bp.coption = YKr; - bp.compositesTypeMap = { - option: { - beet: "coption", - isFixable: !0, - sourcePack: zMt.BEET_PACKAGE, - ts: "COption", - arg: b4e.BEET_TYPE_ARG_INNER, - pack: zMt.BEET_PACKAGE, - }, - }; - }); - var T4e = I((R1) => { - "use strict"; - m(); - g(); - Object.defineProperty(R1, "__esModule", { value: !0 }); - R1.stringTypeMap = R1.utf8String = R1.fixedSizeUtf8String = void 0; - var E4e = sm(), - VMt = Dr(), - M4e = R9(), - QKr = N9(), - eHr = (t) => ({ - write: function (e, r, n) { - let i = Buffer.from(n, "utf8"); - VMt.strict.equal(i.byteLength, t, `${n} has invalid byte size`), - M4e.u32.write(e, r, t), - i.copy(e, r + 4, 0, t); - }, - read: function (e, r) { - let n = M4e.u32.read(e, r); - return ( - VMt.strict.equal(n, t, "invalid byte size"), - e.slice(r + 4, r + 4 + t).toString("utf8") - ); - }, - elementByteSize: 1, - length: t, - lenPrefixByteSize: 4, - byteSize: 4 + t, - description: `Utf8String(4 + ${t})`, - }); - R1.fixedSizeUtf8String = eHr; - R1.utf8String = { - toFixedFromData(t, e) { - let r = M4e.u32.read(t, e); - return ( - (0, QKr.logTrace)(`${this.description}[${r}]`), - (0, R1.fixedSizeUtf8String)(r) - ); - }, - toFixedFromValue(t) { - let e = Buffer.from(t).byteLength; - return (0, R1.fixedSizeUtf8String)(e); - }, - description: "Utf8String", - }; - R1.stringTypeMap = { - fixedSizeString: { - beet: "fixedSizeUtf8String", - isFixable: !1, - sourcePack: E4e.BEET_PACKAGE, - ts: "string", - arg: E4e.BEET_TYPE_ARG_LEN, - }, - string: { - beet: "utf8String", - isFixable: !0, - sourcePack: E4e.BEET_PACKAGE, - ts: "string", - }, - }; - }); - var O4e = I((q9) => { - "use strict"; - m(); - g(); - Object.defineProperty(q9, "__esModule", { value: !0 }); - q9.BeetReader = q9.BeetWriter = void 0; - var tHr = Dr(), - k4e = class { - constructor(e) { - (this.buf = Buffer.alloc(e)), (this._offset = 0); - } - get buffer() { - return this.buf; - } - get offset() { - return this._offset; - } - maybeResize(e) { - this._offset + e > this.buf.length && - tHr.strict.fail( - `We shouldn't ever need to resize, but ${this._offset + e} > ${ - this.buf.length - }` - ); - } - write(e, r) { - this.maybeResize(e.byteSize), - e.write(this.buf, this._offset, r), - (this._offset += e.byteSize); - } - writeStruct(e, r) { - for (let [n, i] of r) { - let o = e[n]; - this.write(i, o); - } - } - }; - q9.BeetWriter = k4e; - var P4e = class { - constructor(e, r = 0) { - (this.buffer = e), (this._offset = r); - } - get offset() { - return this._offset; - } - read(e) { - let r = e.read(this.buffer, this._offset); - return (this._offset += e.byteSize), r; - } - readStruct(e) { - let r = {}; - for (let [n, i] of e) r[n] = this.read(i); - return r; - } - }; - q9.BeetReader = P4e; - }); - var Gue = I((XE) => { - "use strict"; - m(); - g(); - Object.defineProperty(XE, "__esModule", { value: !0 }); - XE.BeetArgsStruct = XE.isBeetStruct = XE.BeetStruct = void 0; - var WMt = O4e(), - Jx = N9(), - N1 = class { - constructor(e, r, n = N1.description) { - if ( - ((this.fields = e), - (this.construct = r), - (this.description = n), - (this.byteSize = this.getByteSize()), - Jx.logDebug.enabled) - ) { - let i = e.map( - ([o, a]) => - `${String(o)}: ${a.description} ${(0, Jx.beetBytes)(a)}` - ).join(` - `); - (0, Jx.logDebug)(`struct ${n} { - ${i} -} ${(0, Jx.beetBytes)(this)}`); - } - } - read(e, r) { - let [n] = this.deserialize(e, r); - return n; - } - write(e, r, n) { - let [i, o] = this.serialize(n); - i.copy(e, r, 0, o); - } - deserialize(e, r = 0) { - Jx.logTrace.enabled && - ((0, Jx.logTrace)( - "deserializing [%s] from %d bytes buffer", - this.description, - e.byteLength - ), - (0, Jx.logTrace)(e), - (0, Jx.logTrace)(e.toJSON().data)); - let n = new WMt.BeetReader(e, r), - i = n.readStruct(this.fields); - return [this.construct(i), n.offset]; - } - serialize(e, r = this.byteSize) { - (0, Jx.logTrace)( - "serializing [%s] %o to %d bytes buffer", - this.description, - e, - r - ); - let n = new WMt.BeetWriter(r); - return n.writeStruct(e, this.fields), [n.buffer, n.offset]; - } - getByteSize() { - return this.fields.reduce((e, [r, n]) => e + n.byteSize, 0); - } - get type() { - return N1.TYPE; - } - }; - XE.BeetStruct = N1; - N1.description = "BeetStruct"; - N1.TYPE = "BeetStruct"; - function rHr(t) { - return t.type === N1.TYPE; - } - XE.isBeetStruct = rHr; - var z9 = class extends N1 { - constructor(e, r = z9.description) { - super(e, (n) => n, r); - } - }; - XE.BeetArgsStruct = z9; - z9.description = "BeetArgsStruct"; - }); - var I4e = I((D1) => { - "use strict"; - m(); - g(); - var nHr = - (D1 && D1.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(D1, "__esModule", { value: !0 }); - D1.FixableBeetArgsStruct = - D1.isFixableBeetStruct = - D1.FixableBeetStruct = - void 0; - var GMt = hV(), - Jue = Gue(), - iHr = sm(), - oHr = Dr(), - B4e = N9(), - aHr = nHr(Mg()), - { brightBlack: sHr } = aHr.default, - um = class { - constructor(e, r, n = um.description) { - (this.fields = e), (this.construct = r), (this.description = n); - let i = 0; - if (B4e.logDebug.enabled) { - let o = e.map( - ([s, c]) => ( - (0, iHr.isFixedSizeBeet)(c) && (i += c.byteSize), - `${s}: ${c.description} ${(0, B4e.beetBytes)(c)}` - ) - ).join(` - `), - a = `> ${i} B`; - (0, B4e.logDebug)(`struct ${n} { - ${o} -} ${sHr(a)}`); - } - } - deserialize(e, r = 0) { - return this.toFixedFromData(e, r).deserialize(e, r); - } - serialize(e, r) { - return this.toFixedFromValue(e).serialize(e, r); - } - toFixedFromData(e, r) { - let n = r, - i = new Array(this.fields.length); - for (let o = 0; o < this.fields.length; o++) { - let [a, s] = this.fields[o], - c = (0, GMt.fixBeetFromData)(s, e, n); - (i[o] = [a, c]), (n += c.byteSize); - } - return this.description !== um.description - ? new Jue.BeetStruct(i, this.construct, this.description) - : new Jue.BeetStruct(i, this.construct); - } - toFixedFromValue(e) { - let r = Object.keys(e), - n = new Array(this.fields.length); - for (let i = 0; i < this.fields.length; i++) { - let [o, a] = this.fields[i]; - (0, oHr.strict)( - r.includes(o), - `Value with keys [ ${r} ] should include struct key '${o}' but doesn't.` - ); - let s = e[o], - c = (0, GMt.fixBeetFromValue)(a, s); - n[i] = [o, c]; - } - return this.description !== um.description - ? new Jue.BeetStruct(n, this.construct, this.description) - : new Jue.BeetStruct(n, this.construct); - } - get type() { - return um.TYPE; - } - }; - D1.FixableBeetStruct = um; - um.description = "FixableBeetStruct"; - um.TYPE = "FixableBeetStruct"; - function uHr(t) { - return t.type === um.TYPE; - } - D1.isFixableBeetStruct = uHr; - var j9 = class extends um { - constructor(e, r = j9.description) { - super(e, (n) => n, r); - } - }; - D1.FixableBeetArgsStruct = j9; - j9.description = "FixableBeetArgsStruct"; - }); - var C4e = I((F1) => { - "use strict"; - m(); - g(); - Object.defineProperty(F1, "__esModule", { value: !0 }); - F1.enumsTypeMap = - F1.dataEnum = - F1.uniformDataEnum = - F1.fixedScalarEnum = - void 0; - var YE = sm(), - Bg = R9(), - U9 = Dr(), - cHr = Gue(), - lHr = I4e(); - function JMt(t, e) { - return e ? `${t}` : t; - } - function fHr(t) { - let e = Object.keys(t); - return { - write(r, n, i) { - let o = typeof i == "number", - a = JMt(i, o); - if ( - (e.includes(a) || - U9.strict.fail( - `${i} should be a variant of the provided enum type, i.e. [ ${Object.values( - t - ).join(", ")} ], but isn't` - ), - o) - ) - Bg.u8.write(r, n, i); - else { - let s = t[a]; - Bg.u8.write(r, n, s); - } - }, - read(r, n) { - let i = Bg.u8.read(r, n), - o = typeof i == "number", - a = JMt(i, o); - return ( - e.includes(a) || - U9.strict.fail( - `${i} should be a of a variant of the provided enum type, i.e. [ ${Object.values( - t - ).join(", ")} ], but isn't` - ), - o ? i : t[a] - ); - }, - byteSize: Bg.u8.byteSize, - description: "Enum", - }; - } - F1.fixedScalarEnum = fHr; - function dHr(t) { - return { - write: function (e, r, n) { - Bg.u8.write(e, r, n.kind), t.write(e, r + 1, n.data); - }, - read: function (e, r) { - let n = Bg.u8.read(e, r), - i = t.read(e, r + 1); - return { kind: n, data: i }; - }, - byteSize: 1 + t.byteSize, - description: `UniformDataEnum<${t.description}>`, - }; - } - F1.uniformDataEnum = dHr; - function $Mt(t, e, r) { - return { - write(n, i, o) { - Bg.u8.write(n, i, e), t.write(n, i + Bg.u8.byteSize, o); - }, - read(n, i) { - let o = t.read(n, i + Bg.u8.byteSize); - return { __kind: r, ...o }; - }, - byteSize: t.byteSize + Bg.u8.byteSize, - description: `EnumData<${t.description}>`, - }; - } - function hHr(t) { - for (let [e, r] of t) - (0, U9.strict)( - (0, cHr.isBeetStruct)(r) || (0, lHr.isFixableBeetStruct)(r), - "dataEnum: data beet must be a struct" - ); - return { - toFixedFromData(e, r) { - let n = Bg.u8.read(e, r), - i = t[n]; - (0, U9.strict)( - i != null, - `Discriminant ${n} out of range for ${t.length} variants` - ); - let [o, a] = i, - s = (0, YE.isFixedSizeBeet)(a) ? a : a.toFixedFromData(e, r + 1); - return $Mt(s, n, o); - }, - toFixedFromValue(e) { - if (e.__kind == null) { - let u = Object.keys(e).join(", "), - h = t.map(([w]) => w).join(", "); - U9.strict.fail( - `Value with fields [ ${u} ] is missing __kind, which needs to be set to one of [ ${h} ]` - ); - } - let r = t.findIndex(([u]) => u === e.__kind); - if (r < 0) { - let u = t.map(([h]) => h).join(", "); - U9.strict.fail( - `${e.__kind} is not a valid kind, needs to be one of [ ${u} ]` - ); - } - let n = t[r], - { __kind: i, ...o } = e, - [a, s] = n, - c = (0, YE.isFixedSizeBeet)(s) ? s : s.toFixedFromValue(o); - return $Mt(c, r, a); - }, - description: `DataEnum<${t.length} variants>`, - }; - } - F1.dataEnum = hHr; - F1.enumsTypeMap = { - fixedScalarEnum: { - beet: "fixedScalarEnum", - isFixable: !1, - sourcePack: YE.BEET_PACKAGE, - ts: "", - arg: YE.BEET_TYPE_ARG_INNER, - pack: YE.BEET_PACKAGE, - }, - dataEnum: { - beet: "dataEnum", - isFixable: !1, - sourcePack: YE.BEET_PACKAGE, - ts: "DataEnum", - arg: YE.BEET_TYPE_ARG_INNER, - pack: YE.BEET_PACKAGE, - }, - }; - }); - var R4e = I((K9) => { - "use strict"; - m(); - g(); - Object.defineProperty(K9, "__esModule", { value: !0 }); - K9.aliasesTypeMap = K9.bytes = void 0; - var ZMt = Wue(); - K9.bytes = ZMt.uint8Array; - K9.aliasesTypeMap = { bytes: ZMt.collectionsTypeMap.Uint8Array }; - }); - var qo = I((iu) => { - "use strict"; - m(); - g(); - var pHr = - (iu && iu.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Ig = - (iu && iu.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - pHr(e, t, r); - }; - Object.defineProperty(iu, "__esModule", { value: !0 }); - iu.supportedTypeMap = void 0; - var yHr = Wue(), - mHr = A4e(), - gHr = R9(), - vHr = T4e(), - bHr = C4e(), - wHr = R4e(); - Ig(R4e(), iu); - Ig(Wue(), iu); - Ig(T4e(), iu); - Ig(A4e(), iu); - Ig(C4e(), iu); - Ig(R9(), iu); - Ig(hV(), iu); - Ig(O4e(), iu); - Ig(Gue(), iu); - Ig(I4e(), iu); - Ig(sm(), iu); - iu.supportedTypeMap = { - ...yHr.collectionsTypeMap, - ...vHr.stringTypeMap, - ...mHr.compositesTypeMap, - ...bHr.enumsTypeMap, - ...gHr.numbersTypeMap, - ...wHr.aliasesTypeMap, - }; - }); - var D4e = I((L1) => { - "use strict"; - m(); - g(); - var _Hr = - (L1 && L1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - xHr = - (L1 && L1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - SHr = - (L1 && L1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - _Hr(e, t, r); - return xHr(e, t), e; - }; - Object.defineProperty(L1, "__esModule", { value: !0 }); - L1.configLineBeet = void 0; - var N4e = SHr(qo()); - L1.configLineBeet = new N4e.FixableBeetArgsStruct( - [ - ["name", N4e.utf8String], - ["uri", N4e.utf8String], - ], - "ConfigLine" - ); - }); - var QMt = I((bf) => { - "use strict"; - m(); - g(); - var AHr = - (bf && bf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - EHr = - (bf && bf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - YMt = - (bf && bf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - AHr(e, t, r); - return EHr(e, t), e; - }; - Object.defineProperty(bf, "__esModule", { value: !0 }); - bf.createAddConfigLinesInstruction = - bf.addConfigLinesInstructionDiscriminator = - bf.addConfigLinesStruct = - void 0; - var yV = YMt(qo()), - XMt = YMt(Le()), - MHr = D4e(); - bf.addConfigLinesStruct = new yV.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", yV.uniformFixedSizeArray(yV.u8, 8)], - ["index", yV.u32], - ["configLines", yV.array(MHr.configLineBeet)], - ], - "AddConfigLinesInstructionArgs" - ); - bf.addConfigLinesInstructionDiscriminator = [ - 223, 50, 224, 227, 151, 8, 115, 106, - ]; - function THr( - t, - e, - r = new XMt.PublicKey("cndy3Z4yapfJBmL3ShUp5exZKqR3z33thTzeNMm2gRZ") - ) { - let [n] = bf.addConfigLinesStruct.serialize({ - instructionDiscriminator: bf.addConfigLinesInstructionDiscriminator, - ...e, - }), - i = [ - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !0 }, - ]; - return new XMt.TransactionInstruction({ programId: r, keys: i, data: n }); - } - bf.createAddConfigLinesInstruction = THr; - }); - var F4e = I((v0) => { - "use strict"; - m(); - g(); - var kHr = - (v0 && v0.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - PHr = - (v0 && v0.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - OHr = - (v0 && v0.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - kHr(e, t, r); - return PHr(e, t), e; - }; - Object.defineProperty(v0, "__esModule", { value: !0 }); - v0.endSettingTypeBeet = v0.EndSettingType = void 0; - var BHr = OHr(qo()), - eTt; - (function (t) { - (t[(t.Date = 0)] = "Date"), (t[(t.Amount = 1)] = "Amount"); - })((eTt = v0.EndSettingType || (v0.EndSettingType = {}))); - v0.endSettingTypeBeet = BHr.fixedScalarEnum(eTt); - }); - var L4e = I((q1) => { - "use strict"; - m(); - g(); - var IHr = - (q1 && q1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - CHr = - (q1 && q1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - RHr = - (q1 && q1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - IHr(e, t, r); - return CHr(e, t), e; - }; - Object.defineProperty(q1, "__esModule", { value: !0 }); - q1.endSettingsBeet = void 0; - var tTt = RHr(qo()), - NHr = F4e(); - q1.endSettingsBeet = new tTt.BeetArgsStruct( - [ - ["endSettingType", NHr.endSettingTypeBeet], - ["number", tTt.u64], - ], - "EndSettings" - ); - }); - var z4e = I((H9) => { - "use strict"; - m(); - g(); - Object.defineProperty(H9, "__esModule", { value: !0 }); - H9.keysTypeMap = H9.publicKey = void 0; - var DHr = Le(), - FHr = Wt(), - LHr = "@metaplex-foundation/beet-solana", - qHr = "@solana/web3.js", - q4e = (0, FHr.fixedSizeUint8Array)(32); - H9.publicKey = { - write: function (t, e, r) { - let n = r.toBytes(); - q4e.write(t, e, n); - }, - read: function (t, e) { - let r = q4e.read(t, e); - return new DHr.PublicKey(r); - }, - byteSize: q4e.byteSize, - description: "PublicKey", - }; - H9.keysTypeMap = { - publicKey: { - beet: "publicKey", - isFixable: !1, - sourcePack: LHr, - ts: "PublicKey", - pack: qHr, - }, - }; - }); - var rTt = I((cm) => { - "use strict"; - m(); - g(); - var zHr = - (cm && cm.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(cm, "__esModule", { value: !0 }); - cm.logTrace = cm.logDebug = cm.logInfo = cm.logError = void 0; - var $ue = zHr(Nx()); - cm.logError = (0, $ue.default)("beet:error"); - cm.logInfo = (0, $ue.default)("beet:info"); - cm.logDebug = (0, $ue.default)("beet:debug"); - cm.logTrace = (0, $ue.default)("beet:trace"); - }); - var iTt = I((sPn, nTt) => { - "use strict"; - m(); - g(); - function jHr(t) { - if (t.length >= 255) throw new TypeError("Alphabet too long"); - for (var e = new Uint8Array(256), r = 0; r < e.length; r++) e[r] = 255; - for (var n = 0; n < t.length; n++) { - var i = t.charAt(n), - o = i.charCodeAt(0); - if (e[o] !== 255) throw new TypeError(i + " is ambiguous"); - e[o] = n; - } - var a = t.length, - s = t.charAt(0), - c = Math.log(a) / Math.log(256), - u = Math.log(256) / Math.log(a); - function h(k) { - if ( - (k instanceof Uint8Array || - (ArrayBuffer.isView(k) - ? (k = new Uint8Array(k.buffer, k.byteOffset, k.byteLength)) - : Array.isArray(k) && (k = Uint8Array.from(k))), - !(k instanceof Uint8Array)) - ) - throw new TypeError("Expected Uint8Array"); - if (k.length === 0) return ""; - for (var O = 0, D = 0, F = 0, N = k.length; F !== N && k[F] === 0; ) - F++, O++; - for ( - var q = ((N - F) * u + 1) >>> 0, z = new Uint8Array(q); - F !== N; - - ) { - for ( - var H = k[F], Z = 0, $ = q - 1; - (H !== 0 || Z < D) && $ !== -1; - $--, Z++ - ) - (H += (256 * z[$]) >>> 0), - (z[$] = H % a >>> 0), - (H = (H / a) >>> 0); - if (H !== 0) throw new Error("Non-zero carry"); - (D = Z), F++; - } - for (var ue = q - D; ue !== q && z[ue] === 0; ) ue++; - for (var te = s.repeat(O); ue < q; ++ue) te += t.charAt(z[ue]); - return te; - } - function w(k) { - if (typeof k != "string") throw new TypeError("Expected String"); - if (k.length === 0) return new Uint8Array(); - for (var O = 0, D = 0, F = 0; k[O] === s; ) D++, O++; - for ( - var N = ((k.length - O) * c + 1) >>> 0, q = new Uint8Array(N); - k[O]; - - ) { - var z = e[k.charCodeAt(O)]; - if (z === 255) return; - for (var H = 0, Z = N - 1; (z !== 0 || H < F) && Z !== -1; Z--, H++) - (z += (a * q[Z]) >>> 0), - (q[Z] = z % 256 >>> 0), - (z = (z / 256) >>> 0); - if (z !== 0) throw new Error("Non-zero carry"); - (F = H), O++; - } - for (var $ = N - F; $ !== N && q[$] === 0; ) $++; - for (var ue = new Uint8Array(D + (N - $)), te = D; $ !== N; ) - ue[te++] = q[$++]; - return ue; - } - function M(k) { - var O = w(k); - if (O) return O; - throw new Error("Non-base" + a + " character"); - } - return { encode: h, decodeUnsafe: w, decode: M }; - } - nTt.exports = jHr; - }); - var aTt = I((uPn, oTt) => { - m(); - g(); - var UHr = iTt(), - KHr = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"; - oTt.exports = UHr(KHr); - }); - var sTt = I((V9) => { - "use strict"; - m(); - g(); - var HHr = - (V9 && V9.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(V9, "__esModule", { value: !0 }); - V9.encodeFixedBeet = void 0; - var VHr = HHr(aTt()); - function WHr(t, e) { - let r = Buffer.alloc(t.byteSize); - return t.write(r, 0, e), VHr.default.encode(r); - } - V9.encodeFixedBeet = WHr; - }); - var cTt = I((Zue) => { - "use strict"; - m(); - g(); - Object.defineProperty(Zue, "__esModule", { value: !0 }); - Zue.GpaBuilder = void 0; - var j4e = Wt(), - mV = Dr(), - GHr = rTt(), - uTt = sTt(), - W9 = class { - constructor(e, r, n) { - (this.programId = e), - (this.beets = r), - (this.accountSize = n), - (this.config = {}); - } - _addFilter(e) { - return ( - this.config.filters == null && (this.config.filters = []), - this.config.filters.push(e), - this - ); - } - _addInnerFilter(e, r, n) { - (0, GHr.logTrace)(`gpa.addInnerFilter: ${e}.${r}`); - let i = this.beets.get(e); - (0, mV.strict)( - i != null, - "Outer filter key needs to be an existing field name" - ); - let o = i.beet, - a = i.offset, - s = (0, j4e.isFixedSizeBeet)(o) ? o : o.toFixedFromValue(n), - c; - for (let [h, w] of s.fields) { - if (h === r) { - c = w; - break; - } - a += w.byteSize; - } - (0, mV.strict)(c != null, `${r} is not a field of the ${e} struct`); - let u = (0, uTt.encodeFixedBeet)(c, n); - return this._addFilter({ memcmp: { offset: a, bytes: u } }), this; - } - addInnerFilter(e, r) { - let n = e.split("."); - mV.strict.equal( - n.length, - 2, - "inner filters can go only one level deep, i.e. 'outer.inner' is ok, but 'outer.inner.deep' is not" - ); - let [i, o] = n; - return this._addInnerFilter(i, o, r); - } - addFilter(e, r) { - let n = this.beets.get(e); - (0, mV.strict)( - n != null, - "Filter key needs to be an existing field name" - ); - let i = (0, j4e.isFixedSizeBeet)(n.beet) - ? n.beet - : n.beet.toFixedFromValue(r), - o = (0, uTt.encodeFixedBeet)(i, r); - return ( - this._addFilter({ memcmp: { offset: n.offset, bytes: o } }), this - ); - } - dataSize(e) { - return ( - (e = e ?? this.accountSize), - (0, mV.strict)( - e != null, - "for accounts of dynamic size the dataSize arg needs to be provided" - ), - this._addFilter({ dataSize: e }) - ); - } - run(e) { - return e.getProgramAccounts(this.programId, this.config); - } - static fromBeetFields(e, r) { - let n = new Map(), - i = 0, - o = !1; - for (let [s, c] of r) { - if ( - (n.set(s, { beet: c, offset: i }), !(0, j4e.isFixedSizeBeet)(c)) - ) { - o = !0; - break; - } - i += c.byteSize; - } - let a = o ? void 0 : i; - return new W9(e, n, a); - } - static fromStruct(e, r) { - return W9.fromBeetFields(e, r.fields); - } - }; - Zue.GpaBuilder = W9; - }); - var Fi = I((z1) => { - "use strict"; - m(); - g(); - var JHr = - (z1 && z1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - lTt = - (z1 && z1.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - JHr(e, t, r); - }; - Object.defineProperty(z1, "__esModule", { value: !0 }); - z1.supportedTypeMap = void 0; - var $Hr = z4e(); - lTt(z4e(), z1); - lTt(cTt(), z1); - z1.supportedTypeMap = $Hr.keysTypeMap; - }); - var K4e = I((j1) => { - "use strict"; - m(); - g(); - var ZHr = - (j1 && j1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - XHr = - (j1 && j1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - fTt = - (j1 && j1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - ZHr(e, t, r); - return XHr(e, t), e; - }; - Object.defineProperty(j1, "__esModule", { value: !0 }); - j1.creatorBeet = void 0; - var YHr = fTt(Fi()), - U4e = fTt(qo()); - j1.creatorBeet = new U4e.BeetArgsStruct( - [ - ["address", YHr.publicKey], - ["verified", U4e.bool], - ["share", U4e.u8], - ], - "Creator" - ); - }); - var H4e = I((U1) => { - "use strict"; - m(); - g(); - var QHr = - (U1 && U1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - eVr = - (U1 && U1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - tVr = - (U1 && U1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - QHr(e, t, r); - return eVr(e, t), e; - }; - Object.defineProperty(U1, "__esModule", { value: !0 }); - U1.hiddenSettingsBeet = void 0; - var gV = tVr(qo()); - U1.hiddenSettingsBeet = new gV.FixableBeetArgsStruct( - [ - ["name", gV.utf8String], - ["uri", gV.utf8String], - ["hash", gV.uniformFixedSizeArray(gV.u8, 32)], - ], - "HiddenSettings" - ); - }); - var V4e = I((b0) => { - "use strict"; - m(); - g(); - var rVr = - (b0 && b0.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - nVr = - (b0 && b0.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - iVr = - (b0 && b0.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - rVr(e, t, r); - return nVr(e, t), e; - }; - Object.defineProperty(b0, "__esModule", { value: !0 }); - b0.whitelistMintModeBeet = b0.WhitelistMintMode = void 0; - var oVr = iVr(qo()), - dTt; - (function (t) { - (t[(t.BurnEveryTime = 0)] = "BurnEveryTime"), - (t[(t.NeverBurn = 1)] = "NeverBurn"); - })((dTt = b0.WhitelistMintMode || (b0.WhitelistMintMode = {}))); - b0.whitelistMintModeBeet = oVr.fixedScalarEnum(dTt); - }); - var W4e = I((K1) => { - "use strict"; - m(); - g(); - var aVr = - (K1 && K1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - sVr = - (K1 && K1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - hTt = - (K1 && K1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - aVr(e, t, r); - return sVr(e, t), e; - }; - Object.defineProperty(K1, "__esModule", { value: !0 }); - K1.whitelistMintSettingsBeet = void 0; - var Xue = hTt(qo()), - uVr = hTt(Fi()), - cVr = V4e(); - K1.whitelistMintSettingsBeet = new Xue.FixableBeetArgsStruct( - [ - ["mode", cVr.whitelistMintModeBeet], - ["mint", uVr.publicKey], - ["presale", Xue.bool], - ["discountPrice", Xue.coption(Xue.u64)], - ], - "WhitelistMintSettings" - ); - }); - var G4e = I((H1) => { - "use strict"; - m(); - g(); - var lVr = - (H1 && H1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - fVr = - (H1 && H1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - yTt = - (H1 && H1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - lVr(e, t, r); - return fVr(e, t), e; - }; - Object.defineProperty(H1, "__esModule", { value: !0 }); - H1.gatekeeperConfigBeet = void 0; - var dVr = yTt(Fi()), - pTt = yTt(qo()); - H1.gatekeeperConfigBeet = new pTt.BeetArgsStruct( - [ - ["gatekeeperNetwork", dVr.publicKey], - ["expireOnUse", pTt.bool], - ], - "GatekeeperConfig" - ); - }); - var vV = I((V1) => { - "use strict"; - m(); - g(); - var hVr = - (V1 && V1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - pVr = - (V1 && V1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - yVr = - (V1 && V1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - hVr(e, t, r); - return pVr(e, t), e; - }; - Object.defineProperty(V1, "__esModule", { value: !0 }); - V1.candyMachineDataBeet = void 0; - var wf = yVr(qo()), - mVr = L4e(), - gVr = K4e(), - vVr = H4e(), - bVr = W4e(), - wVr = G4e(); - V1.candyMachineDataBeet = new wf.FixableBeetArgsStruct( - [ - ["uuid", wf.utf8String], - ["price", wf.u64], - ["symbol", wf.utf8String], - ["sellerFeeBasisPoints", wf.u16], - ["maxSupply", wf.u64], - ["isMutable", wf.bool], - ["retainAuthority", wf.bool], - ["goLiveDate", wf.coption(wf.i64)], - ["endSettings", wf.coption(mVr.endSettingsBeet)], - ["creators", wf.array(gVr.creatorBeet)], - ["hiddenSettings", wf.coption(vVr.hiddenSettingsBeet)], - ["whitelistMintSettings", wf.coption(bVr.whitelistMintSettingsBeet)], - ["itemsAvailable", wf.u64], - ["gatekeeper", wf.coption(wVr.gatekeeperConfigBeet)], - ], - "CandyMachineData" - ); - }); - var gTt = I((_f) => { - "use strict"; - m(); - g(); - var _Vr = - (_f && _f.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - xVr = - (_f && _f.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - mTt = - (_f && _f.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - _Vr(e, t, r); - return xVr(e, t), e; - }; - Object.defineProperty(_f, "__esModule", { value: !0 }); - _f.createInitializeCandyMachineInstruction = - _f.initializeCandyMachineInstructionDiscriminator = - _f.initializeCandyMachineStruct = - void 0; - var J4e = mTt(qo()), - Yue = mTt(Le()), - SVr = vV(); - _f.initializeCandyMachineStruct = new J4e.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", J4e.uniformFixedSizeArray(J4e.u8, 8)], - ["data", SVr.candyMachineDataBeet], - ], - "InitializeCandyMachineInstructionArgs" - ); - _f.initializeCandyMachineInstructionDiscriminator = [ - 142, 137, 167, 107, 47, 39, 240, 124, - ]; - function AVr( - t, - e, - r = new Yue.PublicKey("cndy3Z4yapfJBmL3ShUp5exZKqR3z33thTzeNMm2gRZ") - ) { - var n, i; - let [o] = _f.initializeCandyMachineStruct.serialize({ - instructionDiscriminator: - _f.initializeCandyMachineInstructionDiscriminator, - ...e, - }), - a = [ - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.wallet, isWritable: !1, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !1 }, - { pubkey: t.payer, isWritable: !1, isSigner: !0 }, - { - pubkey: - (n = t.systemProgram) !== null && n !== void 0 - ? n - : Yue.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.rent) !== null && i !== void 0 - ? i - : Yue.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - return new Yue.TransactionInstruction({ programId: r, keys: a, data: o }); - } - _f.createInitializeCandyMachineInstruction = AVr; - }); - function _4(t, e, r) { - return ( - e in t - ? Object.defineProperty(t, e, { - value: r, - enumerable: !0, - configurable: !0, - writable: !0, - }) - : (t[e] = r), - t - ); - } - var vTt = vs(() => { - m(); - g(); - }); - var ha = {}; - y7e(ha, { - ASSOCIATED_TOKEN_PROGRAM_ID: () => ZTt, - AccountLayout: () => J9, - MintLayout: () => bV, - NATIVE_MINT: () => XTt, - TOKEN_PROGRAM_ID: () => YVr, - Token: () => io, - u64: () => Hu, - }); - function CTt(t) { - var e = t.length; - if (e % 4 > 0) - throw new Error("Invalid string. Length must be a multiple of 4"); - var r = t.indexOf("="); - r === -1 && (r = e); - var n = r === e ? 0 : 4 - (r % 4); - return [r, n]; - } - function MVr(t) { - var e = CTt(t), - r = e[0], - n = e[1]; - return ((r + n) * 3) / 4 - n; - } - function TVr(t, e, r) { - return ((e + r) * 3) / 4 - r; - } - function kVr(t) { - var e, - r = CTt(t), - n = r[0], - i = r[1], - o = new EVr(TVr(t, n, i)), - a = 0, - s = i > 0 ? n - 4 : n, - c; - for (c = 0; c < s; c += 4) - (e = - (lm[t.charCodeAt(c)] << 18) | - (lm[t.charCodeAt(c + 1)] << 12) | - (lm[t.charCodeAt(c + 2)] << 6) | - lm[t.charCodeAt(c + 3)]), - (o[a++] = (e >> 16) & 255), - (o[a++] = (e >> 8) & 255), - (o[a++] = e & 255); - return ( - i === 2 && - ((e = (lm[t.charCodeAt(c)] << 2) | (lm[t.charCodeAt(c + 1)] >> 4)), - (o[a++] = e & 255)), - i === 1 && - ((e = - (lm[t.charCodeAt(c)] << 10) | - (lm[t.charCodeAt(c + 1)] << 4) | - (lm[t.charCodeAt(c + 2)] >> 2)), - (o[a++] = (e >> 8) & 255), - (o[a++] = e & 255)), - o - ); - } - function PVr(t) { - return ( - W1[(t >> 18) & 63] + W1[(t >> 12) & 63] + W1[(t >> 6) & 63] + W1[t & 63] - ); - } - function OVr(t, e, r) { - for (var n, i = [], o = e; o < r; o += 3) - (n = - ((t[o] << 16) & 16711680) + - ((t[o + 1] << 8) & 65280) + - (t[o + 2] & 255)), - i.push(PVr(n)); - return i.join(""); - } - function BVr(t) { - for ( - var e, r = t.length, n = r % 3, i = [], o = 16383, a = 0, s = r - n; - a < s; - a += o - ) - i.push(OVr(t, a, a + o > s ? s : a + o)); - return ( - n === 1 - ? ((e = t[r - 1]), i.push(W1[e >> 2] + W1[(e << 4) & 63] + "==")) - : n === 2 && - ((e = (t[r - 2] << 8) + t[r - 1]), - i.push(W1[e >> 10] + W1[(e >> 4) & 63] + W1[(e << 2) & 63] + "=")), - i.join("") - ); - } - function S4(t, e) { - var r = { seen: [], stylize: NVr }; - return ( - arguments.length >= 3 && (r.depth = arguments[2]), - arguments.length >= 4 && (r.colors = arguments[3]), - RTt(e) ? (r.showHidden = e) : e && UVr(r, e), - $9(r.showHidden) && (r.showHidden = !1), - $9(r.depth) && (r.depth = 2), - $9(r.colors) && (r.colors = !1), - $9(r.customInspect) && (r.customInspect = !0), - r.colors && (r.stylize = RVr), - tce(r, t, r.depth) - ); - } - function RVr(t, e) { - var r = S4.styles[e]; - return r - ? "\x1B[" + S4.colors[r][0] + "m" + t + "\x1B[" + S4.colors[r][1] + "m" - : t; - } - function NVr(t, e) { - return t; - } - function DVr(t) { - var e = {}; - return ( - t.forEach(function (r, n) { - e[r] = !0; - }), - e - ); - } - function tce(t, e, r) { - if ( - t.customInspect && - e && - _V(e.inspect) && - e.inspect !== S4 && - !(e.constructor && e.constructor.prototype === e) - ) { - var n = e.inspect(r, t); - return DTt(n) || (n = tce(t, n, r)), n; - } - var i = FVr(t, e); - if (i) return i; - var o = Object.keys(e), - a = DVr(o); - if ( - (t.showHidden && (o = Object.getOwnPropertyNames(e)), - ece(e) && (o.indexOf("message") >= 0 || o.indexOf("description") >= 0)) - ) - return Z4e(e); - if (o.length === 0) { - if (_V(e)) { - var s = e.name ? ": " + e.name : ""; - return t.stylize("[Function" + s + "]", "special"); - } - if (wV(e)) return t.stylize(RegExp.prototype.toString.call(e), "regexp"); - if (rce(e)) return t.stylize(Date.prototype.toString.call(e), "date"); - if (ece(e)) return Z4e(e); - } - var c = "", - u = !1, - h = ["{", "}"]; - if ((zVr(e) && ((u = !0), (h = ["[", "]"])), _V(e))) { - var w = e.name ? ": " + e.name : ""; - c = " [Function" + w + "]"; - } - if ( - (wV(e) && (c = " " + RegExp.prototype.toString.call(e)), - rce(e) && (c = " " + Date.prototype.toUTCString.call(e)), - ece(e) && (c = " " + Z4e(e)), - o.length === 0 && (!u || e.length == 0)) - ) - return h[0] + c + h[1]; - if (r < 0) - return wV(e) - ? t.stylize(RegExp.prototype.toString.call(e), "regexp") - : t.stylize("[Object]", "special"); - t.seen.push(e); - var M; - return ( - u - ? (M = LVr(t, e, r, a, o)) - : (M = o.map(function (k) { - return eOe(t, e, r, a, k, u); - })), - t.seen.pop(), - qVr(M, c, h) - ); - } - function FVr(t, e) { - if ($9(e)) return t.stylize("undefined", "undefined"); - if (DTt(e)) { - var r = - "'" + - JSON.stringify(e) - .replace(/^"|"$/g, "") - .replace(/'/g, "\\'") - .replace(/\\"/g, '"') + - "'"; - return t.stylize(r, "string"); - } - if (jVr(e)) return t.stylize("" + e, "number"); - if (RTt(e)) return t.stylize("" + e, "boolean"); - if (NTt(e)) return t.stylize("null", "null"); - } - function Z4e(t) { - return "[" + Error.prototype.toString.call(t) + "]"; - } - function LVr(t, e, r, n, i) { - for (var o = [], a = 0, s = e.length; a < s; ++a) - FTt(e, String(a)) ? o.push(eOe(t, e, r, n, String(a), !0)) : o.push(""); - return ( - i.forEach(function (c) { - c.match(/^\d+$/) || o.push(eOe(t, e, r, n, c, !0)); - }), - o - ); - } - function eOe(t, e, r, n, i, o) { - var a, s, c; - if ( - ((c = Object.getOwnPropertyDescriptor(e, i) || { value: e[i] }), - c.get - ? c.set - ? (s = t.stylize("[Getter/Setter]", "special")) - : (s = t.stylize("[Getter]", "special")) - : c.set && (s = t.stylize("[Setter]", "special")), - FTt(n, i) || (a = "[" + i + "]"), - s || - (t.seen.indexOf(c.value) < 0 - ? (NTt(r) - ? (s = tce(t, c.value, null)) - : (s = tce(t, c.value, r - 1)), - s.indexOf(` -`) > -1 && - (o - ? (s = s - .split( - ` -` - ) - .map(function (u) { - return " " + u; - }) - .join( - ` -` - ) - .substr(2)) - : (s = - ` -` + - s - .split( - ` -` - ) - .map(function (u) { - return " " + u; - }).join(` -`)))) - : (s = t.stylize("[Circular]", "special"))), - $9(a)) - ) { - if (o && i.match(/^\d+$/)) return s; - (a = JSON.stringify("" + i)), - a.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/) - ? ((a = a.substr(1, a.length - 2)), (a = t.stylize(a, "name"))) - : ((a = a - .replace(/'/g, "\\'") - .replace(/\\"/g, '"') - .replace(/(^"|"$)/g, "'")), - (a = t.stylize(a, "string"))); - } - return a + ": " + s; - } - function qVr(t, e, r) { - var n = t.reduce(function (i, o) { - return ( - o.indexOf(` -`) >= 0, - i + o.replace(/\u001b\[\d\d?m/g, "").length + 1 - ); - }, 0); - return n > 60 - ? r[0] + - (e === "" - ? "" - : e + - ` - `) + - " " + - t.join(`, - `) + - " " + - r[1] - : r[0] + e + " " + t.join(", ") + " " + r[1]; - } - function zVr(t) { - return Array.isArray(t); - } - function RTt(t) { - return typeof t == "boolean"; - } - function NTt(t) { - return t === null; - } - function jVr(t) { - return typeof t == "number"; - } - function DTt(t) { - return typeof t == "string"; - } - function $9(t) { - return t === void 0; - } - function wV(t) { - return gce(t) && sOe(t) === "[object RegExp]"; - } - function gce(t) { - return typeof t == "object" && t !== null; - } - function rce(t) { - return gce(t) && sOe(t) === "[object Date]"; - } - function ece(t) { - return gce(t) && (sOe(t) === "[object Error]" || t instanceof Error); - } - function _V(t) { - return typeof t == "function"; - } - function wTt(t) { - return ( - t === null || - typeof t == "boolean" || - typeof t == "number" || - typeof t == "string" || - typeof t == "symbol" || - typeof t > "u" - ); - } - function sOe(t) { - return Object.prototype.toString.call(t); - } - function UVr(t, e) { - if (!e || !gce(e)) return t; - for (var r = Object.keys(e), n = r.length; n--; ) t[r[n]] = e[r[n]]; - return t; - } - function FTt(t, e) { - return Object.prototype.hasOwnProperty.call(t, e); - } - function _Tt(t, e) { - if (t === e) return 0; - for (var r = t.length, n = e.length, i = 0, o = Math.min(r, n); i < o; ++i) - if (t[i] !== e[i]) { - (r = t[i]), (n = e[i]); - break; - } - return r < n ? -1 : n < r ? 1 : 0; - } - function LTt() { - return typeof X4e < "u" - ? X4e - : (X4e = (function () { - return function () {}.name === "foo"; - })()); - } - function ATt(t) { - return Object.prototype.toString.call(t); - } - function ETt(t) { - return ni.isBuffer(t) || typeof IVr.ArrayBuffer != "function" - ? !1 - : typeof ArrayBuffer.isView == "function" - ? ArrayBuffer.isView(t) - : t - ? !!( - t instanceof DataView || - (t.buffer && t.buffer instanceof ArrayBuffer) - ) - : !1; - } - function Sf(t, e) { - t || wp(t, !0, e, "==", cOe); - } - function qTt(t) { - if (!!_V(t)) { - if (LTt()) return t.name; - var e = t.toString(), - r = e.match(HVr); - return r && r[1]; - } - } - function uOe(t) { - (this.name = "AssertionError"), - (this.actual = t.actual), - (this.expected = t.expected), - (this.operator = t.operator), - t.message - ? ((this.message = t.message), (this.generatedMessage = !1)) - : ((this.message = VVr(this)), (this.generatedMessage = !0)); - var e = t.stackStartFunction || wp; - if (Error.captureStackTrace) Error.captureStackTrace(this, e); - else { - var r = new Error(); - if (r.stack) { - var n = r.stack, - i = qTt(e), - o = n.indexOf( - ` -` + i - ); - if (o >= 0) { - var a = n.indexOf( - ` -`, - o + 1 - ); - n = n.substring(a + 1); - } - this.stack = n; - } - } - } - function MTt(t, e) { - return typeof t == "string" ? (t.length < e ? t : t.slice(0, e)) : t; - } - function TTt(t) { - if (LTt() || !_V(t)) return S4(t); - var e = qTt(t), - r = e ? ": " + e : ""; - return "[Function" + r + "]"; - } - function VVr(t) { - return ( - MTt(TTt(t.actual), 128) + - " " + - t.operator + - " " + - MTt(TTt(t.expected), 128) - ); - } - function wp(t, e, r, n, i) { - throw new uOe({ - message: r, - actual: t, - expected: e, - operator: n, - stackStartFunction: i, - }); - } - function cOe(t, e) { - t || wp(t, !0, e, "==", cOe); - } - function zTt(t, e, r) { - t != e && wp(t, e, r, "==", zTt); - } - function jTt(t, e, r) { - t == e && wp(t, e, r, "!=", jTt); - } - function UTt(t, e, r) { - Z9(t, e, !1) || wp(t, e, r, "deepEqual", UTt); - } - function KTt(t, e, r) { - Z9(t, e, !0) || wp(t, e, r, "deepStrictEqual", KTt); - } - function Z9(t, e, r, n) { - if (t === e) return !0; - if (ni.isBuffer(t) && ni.isBuffer(e)) return _Tt(t, e) === 0; - if (rce(t) && rce(e)) return t.getTime() === e.getTime(); - if (wV(t) && wV(e)) - return ( - t.source === e.source && - t.global === e.global && - t.multiline === e.multiline && - t.lastIndex === e.lastIndex && - t.ignoreCase === e.ignoreCase - ); - if ( - (t === null || typeof t != "object") && - (e === null || typeof e != "object") - ) - return r ? t === e : t == e; - if ( - ETt(t) && - ETt(e) && - ATt(t) === ATt(e) && - !(t instanceof Float32Array || t instanceof Float64Array) - ) - return _Tt(new Uint8Array(t.buffer), new Uint8Array(e.buffer)) === 0; - if (ni.isBuffer(t) !== ni.isBuffer(e)) return !1; - n = n || { actual: [], expected: [] }; - var i = n.actual.indexOf(t); - return i !== -1 && i === n.expected.indexOf(e) - ? !0 - : (n.actual.push(t), n.expected.push(e), WVr(t, e, r, n)); - } - function kTt(t) { - return Object.prototype.toString.call(t) == "[object Arguments]"; - } - function WVr(t, e, r, n) { - if (t == null || e === null || e === void 0) return !1; - if (wTt(t) || wTt(e)) return t === e; - if (r && Object.getPrototypeOf(t) !== Object.getPrototypeOf(e)) return !1; - var i = kTt(t), - o = kTt(e); - if ((i && !o) || (!i && o)) return !1; - if (i) return (t = STt.call(t)), (e = STt.call(e)), Z9(t, e, r); - var a = xTt(t), - s = xTt(e), - c, - u; - if (a.length !== s.length) return !1; - for (a.sort(), s.sort(), u = a.length - 1; u >= 0; u--) - if (a[u] !== s[u]) return !1; - for (u = a.length - 1; u >= 0; u--) - if (((c = a[u]), !Z9(t[c], e[c], r, n))) return !1; - return !0; - } - function HTt(t, e, r) { - Z9(t, e, !1) && wp(t, e, r, "notDeepEqual", HTt); - } - function VTt(t, e, r) { - Z9(t, e, !0) && wp(t, e, r, "notDeepStrictEqual", VTt); - } - function WTt(t, e, r) { - t !== e && wp(t, e, r, "===", WTt); - } - function GTt(t, e, r) { - t === e && wp(t, e, r, "!==", GTt); - } - function PTt(t, e) { - if (!t || !e) return !1; - if (Object.prototype.toString.call(e) == "[object RegExp]") - return e.test(t); - try { - if (t instanceof e) return !0; - } catch {} - return Error.isPrototypeOf(e) ? !1 : e.call({}, t) === !0; - } - function GVr(t) { - var e; - try { - t(); - } catch (r) { - e = r; - } - return e; - } - function JTt(t, e, r, n) { - var i; - if (typeof e != "function") - throw new TypeError('"block" argument must be a function'); - typeof r == "string" && ((n = r), (r = null)), - (i = GVr(e)), - (n = (r && r.name ? " (" + r.name + ")." : ".") + (n ? " " + n : ".")), - t && !i && wp(i, r, "Missing expected exception" + n); - var o = typeof n == "string", - a = !t && ece(i), - s = !t && i && !r; - if ( - (((a && o && PTt(i, r)) || s) && wp(i, r, "Got unwanted exception" + n), - (t && i && r && !PTt(i, r)) || (!t && i)) - ) - throw i; - } - function JVr(t, e, r) { - JTt(!0, t, e, r); - } - function $Vr(t, e, r) { - JTt(!1, t, e, r); - } - function ZVr(t) { - if (t) throw t; - } - function lOe(t, e) { - return e.property ? t + "[" + e.property + "]" : t; - } - function XVr(t, e) { - if (typeof t != "function") - throw new TypeError("Class must be constructor"); - if (t.hasOwnProperty("layout_")) - throw new Error("Class is already bound to a layout"); - if (!(e && e instanceof Wi)) throw new TypeError("layout must be a Layout"); - if (e.hasOwnProperty("boundConstructor_")) - throw new Error("layout is already bound to a constructor"); - (t.layout_ = e), - (e.boundConstructor_ = t), - (e.makeDestinationObject = () => new t()), - Object.defineProperty(t.prototype, "encode", { - value: function (r, n) { - return e.encode(this, r, n); - }, - writable: !0, - }), - Object.defineProperty(t, "decode", { - value: function (r, n) { - return e.decode(r, n); - }, - writable: !0, - }); - } - function vce(t) { - let e = Math.floor(t / tOe), - r = t - e * tOe; - return { hi32: e, lo32: r }; - } - function bce(t, e) { - return t * tOe + e; - } - function G9(t) { - return 0 > t && (t += 4294967296), t; - } - function ou(t, e, r, ...n) { - return (0, Xt.sendAndConfirmTransaction)(e, r, n, { skipPreflight: !1 }); - } - function Y4e(t) { - return ni.Buffer.from(t.toBuffer()); - } - function w0(t) { - return "publicKey" in t; - } - var ITt, - Xt, - ni, - mce, - W1, - lm, - EVr, - $4e, - x4, - bTt, - aOe, - IVr, - Q4e, - CVr, - KVr, - xTt, - STt, - X4e, - HVr, - sr, - Wi, - xf, - nce, - SV, - dm, - Cg, - $x, - QE, - tOe, - rOe, - nOe, - iOe, - oOe, - ice, - oce, - ace, - sce, - uce, - cce, - AV, - X9, - EV, - lce, - MV, - A4, - fce, - dce, - hce, - pce, - yce, - Li, - xV, - Cs, - $Tt, - Rs, - fm, - YVr, - ZTt, - OTt, - BTt, - Hu, - QVr, - XTt, - bV, - J9, - Que, - io, - pa = vs(() => { - m(); - g(); - vTt(); - (ITt = qe(Ho())), (Xt = qe(Le())), (ni = {}), (mce = {}); - mce.byteLength = MVr; - mce.toByteArray = kVr; - mce.fromByteArray = BVr; - (W1 = []), - (lm = []), - (EVr = typeof Uint8Array < "u" ? Uint8Array : Array), - ($4e = - "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"); - for (x4 = 0, bTt = $4e.length; x4 < bTt; ++x4) - (W1[x4] = $4e[x4]), (lm[$4e.charCodeAt(x4)] = x4); - lm["-".charCodeAt(0)] = 62; - lm["_".charCodeAt(0)] = 63; - aOe = {}; - aOe.read = function (t, e, r, n, i) { - var o, - a, - s = i * 8 - n - 1, - c = (1 << s) - 1, - u = c >> 1, - h = -7, - w = r ? i - 1 : 0, - M = r ? -1 : 1, - k = t[e + w]; - for ( - w += M, o = k & ((1 << -h) - 1), k >>= -h, h += s; - h > 0; - o = o * 256 + t[e + w], w += M, h -= 8 - ); - for ( - a = o & ((1 << -h) - 1), o >>= -h, h += n; - h > 0; - a = a * 256 + t[e + w], w += M, h -= 8 - ); - if (o === 0) o = 1 - u; - else { - if (o === c) return a ? NaN : (k ? -1 : 1) * (1 / 0); - (a = a + Math.pow(2, n)), (o = o - u); - } - return (k ? -1 : 1) * a * Math.pow(2, o - n); - }; - aOe.write = function (t, e, r, n, i, o) { - var a, - s, - c, - u = o * 8 - i - 1, - h = (1 << u) - 1, - w = h >> 1, - M = i === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, - k = n ? 0 : o - 1, - O = n ? 1 : -1, - D = e < 0 || (e === 0 && 1 / e < 0) ? 1 : 0; - for ( - e = Math.abs(e), - isNaN(e) || e === 1 / 0 - ? ((s = isNaN(e) ? 1 : 0), (a = h)) - : ((a = Math.floor(Math.log(e) / Math.LN2)), - e * (c = Math.pow(2, -a)) < 1 && (a--, (c *= 2)), - a + w >= 1 ? (e += M / c) : (e += M * Math.pow(2, 1 - w)), - e * c >= 2 && (a++, (c /= 2)), - a + w >= h - ? ((s = 0), (a = h)) - : a + w >= 1 - ? ((s = (e * c - 1) * Math.pow(2, i)), (a = a + w)) - : ((s = e * Math.pow(2, w - 1) * Math.pow(2, i)), (a = 0))); - i >= 8; - t[r + k] = s & 255, k += O, s /= 256, i -= 8 - ); - for ( - a = (a << i) | s, u += i; - u > 0; - t[r + k] = a & 255, k += O, a /= 256, u -= 8 - ); - t[r + k - O] |= D * 128; - }; - (function (t) { - let e = mce, - r = aOe, - n = - typeof Symbol == "function" && typeof Symbol.for == "function" - ? Symbol.for("nodejs.util.inspect.custom") - : null; - (t.Buffer = s), (t.SlowBuffer = q), (t.INSPECT_MAX_BYTES = 50); - let i = 2147483647; - (t.kMaxLength = i), - (s.TYPED_ARRAY_SUPPORT = o()), - !s.TYPED_ARRAY_SUPPORT && - typeof console < "u" && - 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 o() { - try { - let Y = new Uint8Array(1), - W = { - foo: function () { - return 42; - }, - }; - return ( - Object.setPrototypeOf(W, Uint8Array.prototype), - Object.setPrototypeOf(Y, W), - Y.foo() === 42 - ); - } catch { - return !1; - } - } - Object.defineProperty(s.prototype, "parent", { - enumerable: !0, - get: function () { - if (!!s.isBuffer(this)) return this.buffer; - }, - }), - Object.defineProperty(s.prototype, "offset", { - enumerable: !0, - get: function () { - if (!!s.isBuffer(this)) return this.byteOffset; - }, - }); - function a(Y) { - if (Y > i) - throw new RangeError( - 'The value "' + Y + '" is invalid for option "size"' - ); - let W = new Uint8Array(Y); - return Object.setPrototypeOf(W, s.prototype), W; - } - function s(Y, W, j) { - if (typeof Y == "number") { - if (typeof W == "string") - throw new TypeError( - 'The "string" argument must be of type string. Received type number' - ); - return w(Y); - } - return c(Y, W, j); - } - s.poolSize = 8192; - function c(Y, W, j) { - if (typeof Y == "string") return M(Y, W); - if (ArrayBuffer.isView(Y)) return O(Y); - if (Y == null) - throw new TypeError( - "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + - typeof Y - ); - if ( - kt(Y, ArrayBuffer) || - (Y && kt(Y.buffer, ArrayBuffer)) || - (typeof SharedArrayBuffer < "u" && - (kt(Y, SharedArrayBuffer) || - (Y && kt(Y.buffer, SharedArrayBuffer)))) - ) - return D(Y, W, j); - if (typeof Y == "number") - throw new TypeError( - 'The "value" argument must not be of type number. Received type number' - ); - let ce = Y.valueOf && Y.valueOf(); - if (ce != null && ce !== Y) return s.from(ce, W, j); - let ze = F(Y); - if (ze) return ze; - if ( - typeof Symbol < "u" && - Symbol.toPrimitive != null && - typeof Y[Symbol.toPrimitive] == "function" - ) - return s.from(Y[Symbol.toPrimitive]("string"), W, j); - throw new TypeError( - "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + - typeof Y - ); - } - (s.from = function (Y, W, j) { - return c(Y, W, j); - }), - Object.setPrototypeOf(s.prototype, Uint8Array.prototype), - Object.setPrototypeOf(s, Uint8Array); - function u(Y) { - if (typeof Y != "number") - throw new TypeError('"size" argument must be of type number'); - if (Y < 0) - throw new RangeError( - 'The value "' + Y + '" is invalid for option "size"' - ); - } - function h(Y, W, j) { - return ( - u(Y), - Y <= 0 - ? a(Y) - : W !== void 0 - ? typeof j == "string" - ? a(Y).fill(W, j) - : a(Y).fill(W) - : a(Y) - ); - } - s.alloc = function (Y, W, j) { - return h(Y, W, j); - }; - function w(Y) { - return u(Y), a(Y < 0 ? 0 : N(Y) | 0); - } - (s.allocUnsafe = function (Y) { - return w(Y); - }), - (s.allocUnsafeSlow = function (Y) { - return w(Y); - }); - function M(Y, W) { - if ( - ((typeof W != "string" || W === "") && (W = "utf8"), - !s.isEncoding(W)) - ) - throw new TypeError("Unknown encoding: " + W); - let j = z(Y, W) | 0, - ce = a(j), - ze = ce.write(Y, W); - return ze !== j && (ce = ce.slice(0, ze)), ce; - } - function k(Y) { - let W = Y.length < 0 ? 0 : N(Y.length) | 0, - j = a(W); - for (let ce = 0; ce < W; ce += 1) j[ce] = Y[ce] & 255; - return j; - } - function O(Y) { - if (kt(Y, Uint8Array)) { - let W = new Uint8Array(Y); - return D(W.buffer, W.byteOffset, W.byteLength); - } - return k(Y); - } - function D(Y, W, j) { - if (W < 0 || Y.byteLength < W) - throw new RangeError('"offset" is outside of buffer bounds'); - if (Y.byteLength < W + (j || 0)) - throw new RangeError('"length" is outside of buffer bounds'); - let ce; - return ( - W === void 0 && j === void 0 - ? (ce = new Uint8Array(Y)) - : j === void 0 - ? (ce = new Uint8Array(Y, W)) - : (ce = new Uint8Array(Y, W, j)), - Object.setPrototypeOf(ce, s.prototype), - ce - ); - } - function F(Y) { - if (s.isBuffer(Y)) { - let W = N(Y.length) | 0, - j = a(W); - return j.length === 0 || Y.copy(j, 0, 0, W), j; - } - if (Y.length !== void 0) - return typeof Y.length != "number" || Ve(Y.length) ? a(0) : k(Y); - if (Y.type === "Buffer" && Array.isArray(Y.data)) return k(Y.data); - } - function N(Y) { - if (Y >= i) - throw new RangeError( - "Attempt to allocate Buffer larger than maximum size: 0x" + - i.toString(16) + - " bytes" - ); - return Y | 0; - } - function q(Y) { - return +Y != Y && (Y = 0), s.alloc(+Y); - } - (s.isBuffer = function (W) { - return W != null && W._isBuffer === !0 && W !== s.prototype; - }), - (s.compare = function (W, j) { - if ( - (kt(W, Uint8Array) && (W = s.from(W, W.offset, W.byteLength)), - kt(j, Uint8Array) && (j = s.from(j, j.offset, j.byteLength)), - !s.isBuffer(W) || !s.isBuffer(j)) - ) - throw new TypeError( - 'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array' - ); - if (W === j) return 0; - let ce = W.length, - ze = j.length; - for (let we = 0, xe = Math.min(ce, ze); we < xe; ++we) - if (W[we] !== j[we]) { - (ce = W[we]), (ze = j[we]); - break; - } - return ce < ze ? -1 : ze < ce ? 1 : 0; - }), - (s.isEncoding = function (W) { - switch (String(W).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 !0; - default: - return !1; - } - }), - (s.concat = function (W, j) { - if (!Array.isArray(W)) - throw new TypeError( - '"list" argument must be an Array of Buffers' - ); - if (W.length === 0) return s.alloc(0); - let ce; - if (j === void 0) - for (j = 0, ce = 0; ce < W.length; ++ce) j += W[ce].length; - let ze = s.allocUnsafe(j), - we = 0; - for (ce = 0; ce < W.length; ++ce) { - let xe = W[ce]; - if (kt(xe, Uint8Array)) - we + xe.length > ze.length - ? (s.isBuffer(xe) || (xe = s.from(xe)), xe.copy(ze, we)) - : Uint8Array.prototype.set.call(ze, xe, we); - else if (s.isBuffer(xe)) xe.copy(ze, we); - else - throw new TypeError( - '"list" argument must be an Array of Buffers' - ); - we += xe.length; - } - return ze; - }); - function z(Y, W) { - if (s.isBuffer(Y)) return Y.length; - if (ArrayBuffer.isView(Y) || kt(Y, ArrayBuffer)) return Y.byteLength; - if (typeof Y != "string") - throw new TypeError( - 'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + - typeof Y - ); - let j = Y.length, - ce = arguments.length > 2 && arguments[2] === !0; - if (!ce && j === 0) return 0; - let ze = !1; - for (;;) - switch (W) { - case "ascii": - case "latin1": - case "binary": - return j; - case "utf8": - case "utf-8": - return me(Y).length; - case "ucs2": - case "ucs-2": - case "utf16le": - case "utf-16le": - return j * 2; - case "hex": - return j >>> 1; - case "base64": - return Ee(Y).length; - default: - if (ze) return ce ? -1 : me(Y).length; - (W = ("" + W).toLowerCase()), (ze = !0); - } - } - s.byteLength = z; - function H(Y, W, j) { - let ce = !1; - if ( - ((W === void 0 || W < 0) && (W = 0), - W > this.length || - ((j === void 0 || j > this.length) && (j = this.length), - j <= 0) || - ((j >>>= 0), (W >>>= 0), j <= W)) - ) - return ""; - for (Y || (Y = "utf8"); ; ) - switch (Y) { - case "hex": - return f(this, W, j); - case "utf8": - case "utf-8": - return d(this, W, j); - case "ascii": - return S(this, W, j); - case "latin1": - case "binary": - return b(this, W, j); - case "base64": - return y(this, W, j); - case "ucs2": - case "ucs-2": - case "utf16le": - case "utf-16le": - return x(this, W, j); - default: - if (ce) throw new TypeError("Unknown encoding: " + Y); - (Y = (Y + "").toLowerCase()), (ce = !0); - } - } - s.prototype._isBuffer = !0; - function Z(Y, W, j) { - let ce = Y[W]; - (Y[W] = Y[j]), (Y[j] = ce); - } - (s.prototype.swap16 = function () { - let W = this.length; - if (W % 2 !== 0) - throw new RangeError("Buffer size must be a multiple of 16-bits"); - for (let j = 0; j < W; j += 2) Z(this, j, j + 1); - return this; - }), - (s.prototype.swap32 = function () { - let W = this.length; - if (W % 4 !== 0) - throw new RangeError("Buffer size must be a multiple of 32-bits"); - for (let j = 0; j < W; j += 4) - Z(this, j, j + 3), Z(this, j + 1, j + 2); - return this; - }), - (s.prototype.swap64 = function () { - let W = this.length; - if (W % 8 !== 0) - throw new RangeError("Buffer size must be a multiple of 64-bits"); - for (let j = 0; j < W; j += 8) - Z(this, j, j + 7), - Z(this, j + 1, j + 6), - Z(this, j + 2, j + 5), - Z(this, j + 3, j + 4); - return this; - }), - (s.prototype.toString = function () { - let W = this.length; - return W === 0 - ? "" - : arguments.length === 0 - ? d(this, 0, W) - : H.apply(this, arguments); - }), - (s.prototype.toLocaleString = s.prototype.toString), - (s.prototype.equals = function (W) { - if (!s.isBuffer(W)) - throw new TypeError("Argument must be a Buffer"); - return this === W ? !0 : s.compare(this, W) === 0; - }), - (s.prototype.inspect = function () { - let W = "", - j = t.INSPECT_MAX_BYTES; - return ( - (W = this.toString("hex", 0, j) - .replace(/(.{2})/g, "$1 ") - .trim()), - this.length > j && (W += " ... "), - "" - ); - }), - n && (s.prototype[n] = s.prototype.inspect), - (s.prototype.compare = function (W, j, ce, ze, we) { - if ( - (kt(W, Uint8Array) && (W = s.from(W, W.offset, W.byteLength)), - !s.isBuffer(W)) - ) - throw new TypeError( - 'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + - typeof W - ); - if ( - (j === void 0 && (j = 0), - ce === void 0 && (ce = W ? W.length : 0), - ze === void 0 && (ze = 0), - we === void 0 && (we = this.length), - j < 0 || ce > W.length || ze < 0 || we > this.length) - ) - throw new RangeError("out of range index"); - if (ze >= we && j >= ce) return 0; - if (ze >= we) return -1; - if (j >= ce) return 1; - if (((j >>>= 0), (ce >>>= 0), (ze >>>= 0), (we >>>= 0), this === W)) - return 0; - let xe = we - ze, - Ft = ce - j, - Ke = Math.min(xe, Ft), - pe = this.slice(ze, we), - Re = W.slice(j, ce); - for (let Se = 0; Se < Ke; ++Se) - if (pe[Se] !== Re[Se]) { - (xe = pe[Se]), (Ft = Re[Se]); - break; - } - return xe < Ft ? -1 : Ft < xe ? 1 : 0; - }); - function $(Y, W, j, ce, ze) { - if (Y.length === 0) return -1; - if ( - (typeof j == "string" - ? ((ce = j), (j = 0)) - : j > 2147483647 - ? (j = 2147483647) - : j < -2147483648 && (j = -2147483648), - (j = +j), - Ve(j) && (j = ze ? 0 : Y.length - 1), - j < 0 && (j = Y.length + j), - j >= Y.length) - ) { - if (ze) return -1; - j = Y.length - 1; - } else if (j < 0) - if (ze) j = 0; - else return -1; - if ((typeof W == "string" && (W = s.from(W, ce)), s.isBuffer(W))) - return W.length === 0 ? -1 : ue(Y, W, j, ce, ze); - if (typeof W == "number") - return ( - (W = W & 255), - typeof Uint8Array.prototype.indexOf == "function" - ? ze - ? Uint8Array.prototype.indexOf.call(Y, W, j) - : Uint8Array.prototype.lastIndexOf.call(Y, W, j) - : ue(Y, [W], j, ce, ze) - ); - throw new TypeError("val must be string, number or Buffer"); - } - function ue(Y, W, j, ce, ze) { - let we = 1, - xe = Y.length, - Ft = W.length; - if ( - ce !== void 0 && - ((ce = String(ce).toLowerCase()), - ce === "ucs2" || - ce === "ucs-2" || - ce === "utf16le" || - ce === "utf-16le") - ) { - if (Y.length < 2 || W.length < 2) return -1; - (we = 2), (xe /= 2), (Ft /= 2), (j /= 2); - } - function Ke(Re, Se) { - return we === 1 ? Re[Se] : Re.readUInt16BE(Se * we); - } - let pe; - if (ze) { - let Re = -1; - for (pe = j; pe < xe; pe++) - if (Ke(Y, pe) === Ke(W, Re === -1 ? 0 : pe - Re)) { - if ((Re === -1 && (Re = pe), pe - Re + 1 === Ft)) - return Re * we; - } else Re !== -1 && (pe -= pe - Re), (Re = -1); - } else - for (j + Ft > xe && (j = xe - Ft), pe = j; pe >= 0; pe--) { - let Re = !0; - for (let Se = 0; Se < Ft; Se++) - if (Ke(Y, pe + Se) !== Ke(W, Se)) { - Re = !1; - break; - } - if (Re) return pe; - } - return -1; - } - (s.prototype.includes = function (W, j, ce) { - return this.indexOf(W, j, ce) !== -1; - }), - (s.prototype.indexOf = function (W, j, ce) { - return $(this, W, j, ce, !0); - }), - (s.prototype.lastIndexOf = function (W, j, ce) { - return $(this, W, j, ce, !1); - }); - function te(Y, W, j, ce) { - j = Number(j) || 0; - let ze = Y.length - j; - ce ? ((ce = Number(ce)), ce > ze && (ce = ze)) : (ce = ze); - let we = W.length; - ce > we / 2 && (ce = we / 2); - let xe; - for (xe = 0; xe < ce; ++xe) { - let Ft = parseInt(W.substr(xe * 2, 2), 16); - if (Ve(Ft)) return xe; - Y[j + xe] = Ft; - } - return xe; - } - function ne(Y, W, j, ce) { - return Be(me(W, Y.length - j), Y, j, ce); - } - function A(Y, W, j, ce) { - return Be(_e(W), Y, j, ce); - } - function l(Y, W, j, ce) { - return Be(Ee(W), Y, j, ce); - } - function p(Y, W, j, ce) { - return Be(Ye(W, Y.length - j), Y, j, ce); - } - (s.prototype.write = function (W, j, ce, ze) { - if (j === void 0) (ze = "utf8"), (ce = this.length), (j = 0); - else if (ce === void 0 && typeof j == "string") - (ze = j), (ce = this.length), (j = 0); - else if (isFinite(j)) - (j = j >>> 0), - isFinite(ce) - ? ((ce = ce >>> 0), ze === void 0 && (ze = "utf8")) - : ((ze = ce), (ce = void 0)); - else - throw new Error( - "Buffer.write(string, encoding, offset[, length]) is no longer supported" - ); - let we = this.length - j; - if ( - ((ce === void 0 || ce > we) && (ce = we), - (W.length > 0 && (ce < 0 || j < 0)) || j > this.length) - ) - throw new RangeError("Attempt to write outside buffer bounds"); - ze || (ze = "utf8"); - let xe = !1; - for (;;) - switch (ze) { - case "hex": - return te(this, W, j, ce); - case "utf8": - case "utf-8": - return ne(this, W, j, ce); - case "ascii": - case "latin1": - case "binary": - return A(this, W, j, ce); - case "base64": - return l(this, W, j, ce); - case "ucs2": - case "ucs-2": - case "utf16le": - case "utf-16le": - return p(this, W, j, ce); - default: - if (xe) throw new TypeError("Unknown encoding: " + ze); - (ze = ("" + ze).toLowerCase()), (xe = !0); - } - }), - (s.prototype.toJSON = function () { - return { - type: "Buffer", - data: Array.prototype.slice.call(this._arr || this, 0), - }; - }); - function y(Y, W, j) { - return W === 0 && j === Y.length - ? e.fromByteArray(Y) - : e.fromByteArray(Y.slice(W, j)); - } - function d(Y, W, j) { - j = Math.min(Y.length, j); - let ce = [], - ze = W; - for (; ze < j; ) { - let we = Y[ze], - xe = null, - Ft = we > 239 ? 4 : we > 223 ? 3 : we > 191 ? 2 : 1; - if (ze + Ft <= j) { - let Ke, pe, Re, Se; - switch (Ft) { - case 1: - we < 128 && (xe = we); - break; - case 2: - (Ke = Y[ze + 1]), - (Ke & 192) === 128 && - ((Se = ((we & 31) << 6) | (Ke & 63)), - Se > 127 && (xe = Se)); - break; - case 3: - (Ke = Y[ze + 1]), - (pe = Y[ze + 2]), - (Ke & 192) === 128 && - (pe & 192) === 128 && - ((Se = ((we & 15) << 12) | ((Ke & 63) << 6) | (pe & 63)), - Se > 2047 && (Se < 55296 || Se > 57343) && (xe = Se)); - break; - case 4: - (Ke = Y[ze + 1]), - (pe = Y[ze + 2]), - (Re = Y[ze + 3]), - (Ke & 192) === 128 && - (pe & 192) === 128 && - (Re & 192) === 128 && - ((Se = - ((we & 15) << 18) | - ((Ke & 63) << 12) | - ((pe & 63) << 6) | - (Re & 63)), - Se > 65535 && Se < 1114112 && (xe = Se)); - } - } - xe === null - ? ((xe = 65533), (Ft = 1)) - : xe > 65535 && - ((xe -= 65536), - ce.push(((xe >>> 10) & 1023) | 55296), - (xe = 56320 | (xe & 1023))), - ce.push(xe), - (ze += Ft); - } - return _(ce); - } - let v = 4096; - function _(Y) { - let W = Y.length; - if (W <= v) return String.fromCharCode.apply(String, Y); - let j = "", - ce = 0; - for (; ce < W; ) - j += String.fromCharCode.apply(String, Y.slice(ce, (ce += v))); - return j; - } - function S(Y, W, j) { - let ce = ""; - j = Math.min(Y.length, j); - for (let ze = W; ze < j; ++ze) ce += String.fromCharCode(Y[ze] & 127); - return ce; - } - function b(Y, W, j) { - let ce = ""; - j = Math.min(Y.length, j); - for (let ze = W; ze < j; ++ze) ce += String.fromCharCode(Y[ze]); - return ce; - } - function f(Y, W, j) { - let ce = Y.length; - (!W || W < 0) && (W = 0), (!j || j < 0 || j > ce) && (j = ce); - let ze = ""; - for (let we = W; we < j; ++we) ze += We[Y[we]]; - return ze; - } - function x(Y, W, j) { - let ce = Y.slice(W, j), - ze = ""; - for (let we = 0; we < ce.length - 1; we += 2) - ze += String.fromCharCode(ce[we] + ce[we + 1] * 256); - return ze; - } - s.prototype.slice = function (W, j) { - let ce = this.length; - (W = ~~W), - (j = j === void 0 ? ce : ~~j), - W < 0 ? ((W += ce), W < 0 && (W = 0)) : W > ce && (W = ce), - j < 0 ? ((j += ce), j < 0 && (j = 0)) : j > ce && (j = ce), - j < W && (j = W); - let ze = this.subarray(W, j); - return Object.setPrototypeOf(ze, s.prototype), ze; - }; - function C(Y, W, j) { - if (Y % 1 !== 0 || Y < 0) throw new RangeError("offset is not uint"); - if (Y + W > j) - throw new RangeError("Trying to access beyond buffer length"); - } - (s.prototype.readUintLE = s.prototype.readUIntLE = - function (W, j, ce) { - (W = W >>> 0), (j = j >>> 0), ce || C(W, j, this.length); - let ze = this[W], - we = 1, - xe = 0; - for (; ++xe < j && (we *= 256); ) ze += this[W + xe] * we; - return ze; - }), - (s.prototype.readUintBE = s.prototype.readUIntBE = - function (W, j, ce) { - (W = W >>> 0), (j = j >>> 0), ce || C(W, j, this.length); - let ze = this[W + --j], - we = 1; - for (; j > 0 && (we *= 256); ) ze += this[W + --j] * we; - return ze; - }), - (s.prototype.readUint8 = s.prototype.readUInt8 = - function (W, j) { - return (W = W >>> 0), j || C(W, 1, this.length), this[W]; - }), - (s.prototype.readUint16LE = s.prototype.readUInt16LE = - function (W, j) { - return ( - (W = W >>> 0), - j || C(W, 2, this.length), - this[W] | (this[W + 1] << 8) - ); - }), - (s.prototype.readUint16BE = s.prototype.readUInt16BE = - function (W, j) { - return ( - (W = W >>> 0), - j || C(W, 2, this.length), - (this[W] << 8) | this[W + 1] - ); - }), - (s.prototype.readUint32LE = s.prototype.readUInt32LE = - function (W, j) { - return ( - (W = W >>> 0), - j || C(W, 4, this.length), - (this[W] | (this[W + 1] << 8) | (this[W + 2] << 16)) + - this[W + 3] * 16777216 - ); - }), - (s.prototype.readUint32BE = s.prototype.readUInt32BE = - function (W, j) { - return ( - (W = W >>> 0), - j || C(W, 4, this.length), - this[W] * 16777216 + - ((this[W + 1] << 16) | (this[W + 2] << 8) | this[W + 3]) - ); - }), - (s.prototype.readBigUInt64LE = er(function (W) { - (W = W >>> 0), Me(W, "offset"); - let j = this[W], - ce = this[W + 7]; - (j === void 0 || ce === void 0) && de(W, this.length - 8); - let ze = - j + - this[++W] * 2 ** 8 + - this[++W] * 2 ** 16 + - this[++W] * 2 ** 24, - we = - this[++W] + - this[++W] * 2 ** 8 + - this[++W] * 2 ** 16 + - ce * 2 ** 24; - return BigInt(ze) + (BigInt(we) << BigInt(32)); - })), - (s.prototype.readBigUInt64BE = er(function (W) { - (W = W >>> 0), Me(W, "offset"); - let j = this[W], - ce = this[W + 7]; - (j === void 0 || ce === void 0) && de(W, this.length - 8); - let ze = - j * 2 ** 24 + - this[++W] * 2 ** 16 + - this[++W] * 2 ** 8 + - this[++W], - we = - this[++W] * 2 ** 24 + - this[++W] * 2 ** 16 + - this[++W] * 2 ** 8 + - ce; - return (BigInt(ze) << BigInt(32)) + BigInt(we); - })), - (s.prototype.readIntLE = function (W, j, ce) { - (W = W >>> 0), (j = j >>> 0), ce || C(W, j, this.length); - let ze = this[W], - we = 1, - xe = 0; - for (; ++xe < j && (we *= 256); ) ze += this[W + xe] * we; - return (we *= 128), ze >= we && (ze -= Math.pow(2, 8 * j)), ze; - }), - (s.prototype.readIntBE = function (W, j, ce) { - (W = W >>> 0), (j = j >>> 0), ce || C(W, j, this.length); - let ze = j, - we = 1, - xe = this[W + --ze]; - for (; ze > 0 && (we *= 256); ) xe += this[W + --ze] * we; - return (we *= 128), xe >= we && (xe -= Math.pow(2, 8 * j)), xe; - }), - (s.prototype.readInt8 = function (W, j) { - return ( - (W = W >>> 0), - j || C(W, 1, this.length), - this[W] & 128 ? (255 - this[W] + 1) * -1 : this[W] - ); - }), - (s.prototype.readInt16LE = function (W, j) { - (W = W >>> 0), j || C(W, 2, this.length); - let ce = this[W] | (this[W + 1] << 8); - return ce & 32768 ? ce | 4294901760 : ce; - }), - (s.prototype.readInt16BE = function (W, j) { - (W = W >>> 0), j || C(W, 2, this.length); - let ce = this[W + 1] | (this[W] << 8); - return ce & 32768 ? ce | 4294901760 : ce; - }), - (s.prototype.readInt32LE = function (W, j) { - return ( - (W = W >>> 0), - j || C(W, 4, this.length), - this[W] | - (this[W + 1] << 8) | - (this[W + 2] << 16) | - (this[W + 3] << 24) - ); - }), - (s.prototype.readInt32BE = function (W, j) { - return ( - (W = W >>> 0), - j || C(W, 4, this.length), - (this[W] << 24) | - (this[W + 1] << 16) | - (this[W + 2] << 8) | - this[W + 3] - ); - }), - (s.prototype.readBigInt64LE = er(function (W) { - (W = W >>> 0), Me(W, "offset"); - let j = this[W], - ce = this[W + 7]; - (j === void 0 || ce === void 0) && de(W, this.length - 8); - let ze = - this[W + 4] + - this[W + 5] * 2 ** 8 + - this[W + 6] * 2 ** 16 + - (ce << 24); - return ( - (BigInt(ze) << BigInt(32)) + - BigInt( - j + - this[++W] * 2 ** 8 + - this[++W] * 2 ** 16 + - this[++W] * 2 ** 24 - ) - ); - })), - (s.prototype.readBigInt64BE = er(function (W) { - (W = W >>> 0), Me(W, "offset"); - let j = this[W], - ce = this[W + 7]; - (j === void 0 || ce === void 0) && de(W, this.length - 8); - let ze = - (j << 24) + this[++W] * 2 ** 16 + this[++W] * 2 ** 8 + this[++W]; - return ( - (BigInt(ze) << BigInt(32)) + - BigInt( - this[++W] * 2 ** 24 + - this[++W] * 2 ** 16 + - this[++W] * 2 ** 8 + - ce - ) - ); - })), - (s.prototype.readFloatLE = function (W, j) { - return ( - (W = W >>> 0), - j || C(W, 4, this.length), - r.read(this, W, !0, 23, 4) - ); - }), - (s.prototype.readFloatBE = function (W, j) { - return ( - (W = W >>> 0), - j || C(W, 4, this.length), - r.read(this, W, !1, 23, 4) - ); - }), - (s.prototype.readDoubleLE = function (W, j) { - return ( - (W = W >>> 0), - j || C(W, 8, this.length), - r.read(this, W, !0, 52, 8) - ); - }), - (s.prototype.readDoubleBE = function (W, j) { - return ( - (W = W >>> 0), - j || C(W, 8, this.length), - r.read(this, W, !1, 52, 8) - ); - }); - function E(Y, W, j, ce, ze, we) { - if (!s.isBuffer(Y)) - throw new TypeError('"buffer" argument must be a Buffer instance'); - if (W > ze || W < we) - throw new RangeError('"value" argument is out of bounds'); - if (j + ce > Y.length) throw new RangeError("Index out of range"); - } - (s.prototype.writeUintLE = s.prototype.writeUIntLE = - function (W, j, ce, ze) { - if (((W = +W), (j = j >>> 0), (ce = ce >>> 0), !ze)) { - let Ft = Math.pow(2, 8 * ce) - 1; - E(this, W, j, ce, Ft, 0); - } - let we = 1, - xe = 0; - for (this[j] = W & 255; ++xe < ce && (we *= 256); ) - this[j + xe] = (W / we) & 255; - return j + ce; - }), - (s.prototype.writeUintBE = s.prototype.writeUIntBE = - function (W, j, ce, ze) { - if (((W = +W), (j = j >>> 0), (ce = ce >>> 0), !ze)) { - let Ft = Math.pow(2, 8 * ce) - 1; - E(this, W, j, ce, Ft, 0); - } - let we = ce - 1, - xe = 1; - for (this[j + we] = W & 255; --we >= 0 && (xe *= 256); ) - this[j + we] = (W / xe) & 255; - return j + ce; - }), - (s.prototype.writeUint8 = s.prototype.writeUInt8 = - function (W, j, ce) { - return ( - (W = +W), - (j = j >>> 0), - ce || E(this, W, j, 1, 255, 0), - (this[j] = W & 255), - j + 1 - ); - }), - (s.prototype.writeUint16LE = s.prototype.writeUInt16LE = - function (W, j, ce) { - return ( - (W = +W), - (j = j >>> 0), - ce || E(this, W, j, 2, 65535, 0), - (this[j] = W & 255), - (this[j + 1] = W >>> 8), - j + 2 - ); - }), - (s.prototype.writeUint16BE = s.prototype.writeUInt16BE = - function (W, j, ce) { - return ( - (W = +W), - (j = j >>> 0), - ce || E(this, W, j, 2, 65535, 0), - (this[j] = W >>> 8), - (this[j + 1] = W & 255), - j + 2 - ); - }), - (s.prototype.writeUint32LE = s.prototype.writeUInt32LE = - function (W, j, ce) { - return ( - (W = +W), - (j = j >>> 0), - ce || E(this, W, j, 4, 4294967295, 0), - (this[j + 3] = W >>> 24), - (this[j + 2] = W >>> 16), - (this[j + 1] = W >>> 8), - (this[j] = W & 255), - j + 4 - ); - }), - (s.prototype.writeUint32BE = s.prototype.writeUInt32BE = - function (W, j, ce) { - return ( - (W = +W), - (j = j >>> 0), - ce || E(this, W, j, 4, 4294967295, 0), - (this[j] = W >>> 24), - (this[j + 1] = W >>> 16), - (this[j + 2] = W >>> 8), - (this[j + 3] = W & 255), - j + 4 - ); - }); - function B(Y, W, j, ce, ze) { - le(W, ce, ze, Y, j, 7); - let we = Number(W & BigInt(4294967295)); - (Y[j++] = we), - (we = we >> 8), - (Y[j++] = we), - (we = we >> 8), - (Y[j++] = we), - (we = we >> 8), - (Y[j++] = we); - let xe = Number((W >> BigInt(32)) & BigInt(4294967295)); - return ( - (Y[j++] = xe), - (xe = xe >> 8), - (Y[j++] = xe), - (xe = xe >> 8), - (Y[j++] = xe), - (xe = xe >> 8), - (Y[j++] = xe), - j - ); - } - function G(Y, W, j, ce, ze) { - le(W, ce, ze, Y, j, 7); - let we = Number(W & BigInt(4294967295)); - (Y[j + 7] = we), - (we = we >> 8), - (Y[j + 6] = we), - (we = we >> 8), - (Y[j + 5] = we), - (we = we >> 8), - (Y[j + 4] = we); - let xe = Number((W >> BigInt(32)) & BigInt(4294967295)); - return ( - (Y[j + 3] = xe), - (xe = xe >> 8), - (Y[j + 2] = xe), - (xe = xe >> 8), - (Y[j + 1] = xe), - (xe = xe >> 8), - (Y[j] = xe), - j + 8 - ); - } - (s.prototype.writeBigUInt64LE = er(function (W, j = 0) { - return B(this, W, j, BigInt(0), BigInt("0xffffffffffffffff")); - })), - (s.prototype.writeBigUInt64BE = er(function (W, j = 0) { - return G(this, W, j, BigInt(0), BigInt("0xffffffffffffffff")); - })), - (s.prototype.writeIntLE = function (W, j, ce, ze) { - if (((W = +W), (j = j >>> 0), !ze)) { - let Ke = Math.pow(2, 8 * ce - 1); - E(this, W, j, ce, Ke - 1, -Ke); - } - let we = 0, - xe = 1, - Ft = 0; - for (this[j] = W & 255; ++we < ce && (xe *= 256); ) - W < 0 && Ft === 0 && this[j + we - 1] !== 0 && (Ft = 1), - (this[j + we] = (((W / xe) >> 0) - Ft) & 255); - return j + ce; - }), - (s.prototype.writeIntBE = function (W, j, ce, ze) { - if (((W = +W), (j = j >>> 0), !ze)) { - let Ke = Math.pow(2, 8 * ce - 1); - E(this, W, j, ce, Ke - 1, -Ke); - } - let we = ce - 1, - xe = 1, - Ft = 0; - for (this[j + we] = W & 255; --we >= 0 && (xe *= 256); ) - W < 0 && Ft === 0 && this[j + we + 1] !== 0 && (Ft = 1), - (this[j + we] = (((W / xe) >> 0) - Ft) & 255); - return j + ce; - }), - (s.prototype.writeInt8 = function (W, j, ce) { - return ( - (W = +W), - (j = j >>> 0), - ce || E(this, W, j, 1, 127, -128), - W < 0 && (W = 255 + W + 1), - (this[j] = W & 255), - j + 1 - ); - }), - (s.prototype.writeInt16LE = function (W, j, ce) { - return ( - (W = +W), - (j = j >>> 0), - ce || E(this, W, j, 2, 32767, -32768), - (this[j] = W & 255), - (this[j + 1] = W >>> 8), - j + 2 - ); - }), - (s.prototype.writeInt16BE = function (W, j, ce) { - return ( - (W = +W), - (j = j >>> 0), - ce || E(this, W, j, 2, 32767, -32768), - (this[j] = W >>> 8), - (this[j + 1] = W & 255), - j + 2 - ); - }), - (s.prototype.writeInt32LE = function (W, j, ce) { - return ( - (W = +W), - (j = j >>> 0), - ce || E(this, W, j, 4, 2147483647, -2147483648), - (this[j] = W & 255), - (this[j + 1] = W >>> 8), - (this[j + 2] = W >>> 16), - (this[j + 3] = W >>> 24), - j + 4 - ); - }), - (s.prototype.writeInt32BE = function (W, j, ce) { - return ( - (W = +W), - (j = j >>> 0), - ce || E(this, W, j, 4, 2147483647, -2147483648), - W < 0 && (W = 4294967295 + W + 1), - (this[j] = W >>> 24), - (this[j + 1] = W >>> 16), - (this[j + 2] = W >>> 8), - (this[j + 3] = W & 255), - j + 4 - ); - }), - (s.prototype.writeBigInt64LE = er(function (W, j = 0) { - return B( - this, - W, - j, - -BigInt("0x8000000000000000"), - BigInt("0x7fffffffffffffff") - ); - })), - (s.prototype.writeBigInt64BE = er(function (W, j = 0) { - return G( - this, - W, - j, - -BigInt("0x8000000000000000"), - BigInt("0x7fffffffffffffff") - ); - })); - function L(Y, W, j, ce, ze, we) { - if (j + ce > Y.length) throw new RangeError("Index out of range"); - if (j < 0) throw new RangeError("Index out of range"); - } - function ee(Y, W, j, ce, ze) { - return ( - (W = +W), - (j = j >>> 0), - ze || L(Y, W, j, 4), - r.write(Y, W, j, ce, 23, 4), - j + 4 - ); - } - (s.prototype.writeFloatLE = function (W, j, ce) { - return ee(this, W, j, !0, ce); - }), - (s.prototype.writeFloatBE = function (W, j, ce) { - return ee(this, W, j, !1, ce); - }); - function ge(Y, W, j, ce, ze) { - return ( - (W = +W), - (j = j >>> 0), - ze || L(Y, W, j, 8), - r.write(Y, W, j, ce, 52, 8), - j + 8 - ); - } - (s.prototype.writeDoubleLE = function (W, j, ce) { - return ge(this, W, j, !0, ce); - }), - (s.prototype.writeDoubleBE = function (W, j, ce) { - return ge(this, W, j, !1, ce); - }), - (s.prototype.copy = function (W, j, ce, ze) { - if (!s.isBuffer(W)) - throw new TypeError("argument should be a Buffer"); - if ( - (ce || (ce = 0), - !ze && ze !== 0 && (ze = this.length), - j >= W.length && (j = W.length), - j || (j = 0), - ze > 0 && ze < ce && (ze = ce), - ze === ce || W.length === 0 || this.length === 0) - ) - return 0; - if (j < 0) throw new RangeError("targetStart out of bounds"); - if (ce < 0 || ce >= this.length) - throw new RangeError("Index out of range"); - if (ze < 0) throw new RangeError("sourceEnd out of bounds"); - ze > this.length && (ze = this.length), - W.length - j < ze - ce && (ze = W.length - j + ce); - let we = ze - ce; - return ( - this === W && typeof Uint8Array.prototype.copyWithin == "function" - ? this.copyWithin(j, ce, ze) - : Uint8Array.prototype.set.call(W, this.subarray(ce, ze), j), - we - ); - }), - (s.prototype.fill = function (W, j, ce, ze) { - if (typeof W == "string") { - if ( - (typeof j == "string" - ? ((ze = j), (j = 0), (ce = this.length)) - : typeof ce == "string" && ((ze = ce), (ce = this.length)), - ze !== void 0 && typeof ze != "string") - ) - throw new TypeError("encoding must be a string"); - if (typeof ze == "string" && !s.isEncoding(ze)) - throw new TypeError("Unknown encoding: " + ze); - if (W.length === 1) { - let xe = W.charCodeAt(0); - ((ze === "utf8" && xe < 128) || ze === "latin1") && (W = xe); - } - } else - typeof W == "number" - ? (W = W & 255) - : typeof W == "boolean" && (W = Number(W)); - if (j < 0 || this.length < j || this.length < ce) - throw new RangeError("Out of range index"); - if (ce <= j) return this; - (j = j >>> 0), - (ce = ce === void 0 ? this.length : ce >>> 0), - W || (W = 0); - let we; - if (typeof W == "number") for (we = j; we < ce; ++we) this[we] = W; - else { - let xe = s.isBuffer(W) ? W : s.from(W, ze), - Ft = xe.length; - if (Ft === 0) - throw new TypeError( - 'The value "' + W + '" is invalid for argument "value"' - ); - for (we = 0; we < ce - j; ++we) this[we + j] = xe[we % Ft]; - } - return this; - }); - let fe = {}; - function V(Y, W, j) { - fe[Y] = class extends j { - constructor() { - super(), - Object.defineProperty(this, "message", { - value: W.apply(this, arguments), - writable: !0, - configurable: !0, - }), - (this.name = `${this.name} [${Y}]`), - this.stack, - delete this.name; - } - get code() { - return Y; - } - set code(ze) { - Object.defineProperty(this, "code", { - configurable: !0, - enumerable: !0, - value: ze, - writable: !0, - }); - } - toString() { - return `${this.name} [${Y}]: ${this.message}`; - } - }; - } - V( - "ERR_BUFFER_OUT_OF_BOUNDS", - function (Y) { - return Y - ? `${Y} is outside of buffer bounds` - : "Attempt to access memory outside buffer bounds"; - }, - RangeError - ), - V( - "ERR_INVALID_ARG_TYPE", - function (Y, W) { - return `The "${Y}" argument must be of type number. Received type ${typeof W}`; - }, - TypeError - ), - V( - "ERR_OUT_OF_RANGE", - function (Y, W, j) { - let ce = `The value of "${Y}" is out of range.`, - ze = j; - return ( - Number.isInteger(j) && Math.abs(j) > 2 ** 32 - ? (ze = ye(String(j))) - : typeof j == "bigint" && - ((ze = String(j)), - (j > BigInt(2) ** BigInt(32) || - j < -(BigInt(2) ** BigInt(32))) && - (ze = ye(ze)), - (ze += "n")), - (ce += ` It must be ${W}. Received ${ze}`), - ce - ); - }, - RangeError - ); - function ye(Y) { - let W = "", - j = Y.length, - ce = Y[0] === "-" ? 1 : 0; - for (; j >= ce + 4; j -= 3) W = `_${Y.slice(j - 3, j)}${W}`; - return `${Y.slice(0, j)}${W}`; - } - function ae(Y, W, j) { - Me(W, "offset"), - (Y[W] === void 0 || Y[W + j] === void 0) && - de(W, Y.length - (j + 1)); - } - function le(Y, W, j, ce, ze, we) { - if (Y > j || Y < W) { - let xe = typeof W == "bigint" ? "n" : "", - Ft; - throw ( - (we > 3 - ? W === 0 || W === BigInt(0) - ? (Ft = `>= 0${xe} and < 2${xe} ** ${(we + 1) * 8}${xe}`) - : (Ft = `>= -(2${xe} ** ${ - (we + 1) * 8 - 1 - }${xe}) and < 2 ** ${(we + 1) * 8 - 1}${xe}`) - : (Ft = `>= ${W}${xe} and <= ${j}${xe}`), - new fe.ERR_OUT_OF_RANGE("value", Ft, Y)) - ); - } - ae(ce, ze, we); - } - function Me(Y, W) { - if (typeof Y != "number") - throw new fe.ERR_INVALID_ARG_TYPE(W, "number", Y); - } - function de(Y, W, j) { - throw Math.floor(Y) !== Y - ? (Me(Y, j), - new fe.ERR_OUT_OF_RANGE(j || "offset", "an integer", Y)) - : W < 0 - ? new fe.ERR_BUFFER_OUT_OF_BOUNDS() - : new fe.ERR_OUT_OF_RANGE( - j || "offset", - `>= ${j ? 1 : 0} and <= ${W}`, - Y - ); - } - let ve = /[^+/0-9A-Za-z-_]/g; - function De(Y) { - if ( - ((Y = Y.split("=")[0]), - (Y = Y.trim().replace(ve, "")), - Y.length < 2) - ) - return ""; - for (; Y.length % 4 !== 0; ) Y = Y + "="; - return Y; - } - function me(Y, W) { - W = W || 1 / 0; - let j, - ce = Y.length, - ze = null, - we = []; - for (let xe = 0; xe < ce; ++xe) { - if (((j = Y.charCodeAt(xe)), j > 55295 && j < 57344)) { - if (!ze) { - if (j > 56319) { - (W -= 3) > -1 && we.push(239, 191, 189); - continue; - } else if (xe + 1 === ce) { - (W -= 3) > -1 && we.push(239, 191, 189); - continue; - } - ze = j; - continue; - } - if (j < 56320) { - (W -= 3) > -1 && we.push(239, 191, 189), (ze = j); - continue; - } - j = (((ze - 55296) << 10) | (j - 56320)) + 65536; - } else ze && (W -= 3) > -1 && we.push(239, 191, 189); - if (((ze = null), j < 128)) { - if ((W -= 1) < 0) break; - we.push(j); - } else if (j < 2048) { - if ((W -= 2) < 0) break; - we.push((j >> 6) | 192, (j & 63) | 128); - } else if (j < 65536) { - if ((W -= 3) < 0) break; - we.push((j >> 12) | 224, ((j >> 6) & 63) | 128, (j & 63) | 128); - } else if (j < 1114112) { - if ((W -= 4) < 0) break; - we.push( - (j >> 18) | 240, - ((j >> 12) & 63) | 128, - ((j >> 6) & 63) | 128, - (j & 63) | 128 - ); - } else throw new Error("Invalid code point"); - } - return we; - } - function _e(Y) { - let W = []; - for (let j = 0; j < Y.length; ++j) W.push(Y.charCodeAt(j) & 255); - return W; - } - function Ye(Y, W) { - let j, - ce, - ze, - we = []; - for (let xe = 0; xe < Y.length && !((W -= 2) < 0); ++xe) - (j = Y.charCodeAt(xe)), - (ce = j >> 8), - (ze = j % 256), - we.push(ze), - we.push(ce); - return we; - } - function Ee(Y) { - return e.toByteArray(De(Y)); - } - function Be(Y, W, j, ce) { - let ze; - for (ze = 0; ze < ce && !(ze + j >= W.length || ze >= Y.length); ++ze) - W[ze + j] = Y[ze]; - return ze; - } - function kt(Y, W) { - return ( - Y instanceof W || - (Y != null && - Y.constructor != null && - Y.constructor.name != null && - Y.constructor.name === W.name) - ); - } - function Ve(Y) { - return Y !== Y; - } - let We = (function () { - let Y = "0123456789abcdef", - W = new Array(256); - for (let j = 0; j < 16; ++j) { - let ce = j * 16; - for (let ze = 0; ze < 16; ++ze) W[ce + ze] = Y[j] + Y[ze]; - } - return W; - })(); - function er(Y) { - return typeof BigInt > "u" ? Ue : Y; - } - function Ue() { - throw new Error("BigInt not supported"); - } - })(ni); - IVr = - typeof window < "u" - ? window - : typeof self < "u" - ? self - : typeof window < "u" - ? window - : {}; - typeof Object.create == "function" - ? (Q4e = function (e, r) { - (e.super_ = r), - (e.prototype = Object.create(r.prototype, { - constructor: { - value: e, - enumerable: !1, - writable: !0, - configurable: !0, - }, - })); - }) - : (Q4e = function (e, r) { - e.super_ = r; - var n = function () {}; - (n.prototype = r.prototype), - (e.prototype = new n()), - (e.prototype.constructor = e); - }); - CVr = Q4e; - S4.colors = { - bold: [1, 22], - italic: [3, 23], - underline: [4, 24], - inverse: [7, 27], - white: [37, 39], - grey: [90, 39], - black: [30, 39], - blue: [34, 39], - cyan: [36, 39], - green: [32, 39], - magenta: [35, 39], - red: [31, 39], - yellow: [33, 39], - }; - S4.styles = { - special: "cyan", - number: "yellow", - boolean: "yellow", - undefined: "grey", - null: "bold", - string: "green", - date: "magenta", - regexp: "red", - }; - (KVr = Object.prototype.hasOwnProperty), - (xTt = - Object.keys || - function (t) { - var e = []; - for (var r in t) KVr.call(t, r) && e.push(r); - return e; - }), - (STt = Array.prototype.slice); - HVr = /\s*function\s+([^\(\s]*)\s*/; - Sf.AssertionError = uOe; - CVr(uOe, Error); - Sf.fail = wp; - Sf.ok = cOe; - Sf.equal = zTt; - Sf.notEqual = jTt; - Sf.deepEqual = UTt; - Sf.deepStrictEqual = KTt; - Sf.notDeepEqual = HTt; - Sf.notDeepStrictEqual = VTt; - Sf.strictEqual = WTt; - Sf.notStrictEqual = GTt; - Sf.throws = JVr; - Sf.doesNotThrow = $Vr; - Sf.ifError = ZVr; - (sr = {}), - (Wi = class { - constructor(e, r) { - if (!Number.isInteger(e)) - throw new TypeError("span must be an integer"); - (this.span = e), (this.property = r); - } - makeDestinationObject() { - return {}; - } - decode(e, r) { - throw new Error("Layout is abstract"); - } - encode(e, r, n) { - throw new Error("Layout is abstract"); - } - getSpan(e, r) { - if (0 > this.span) throw new RangeError("indeterminate span"); - return this.span; - } - replicate(e) { - let r = Object.create(this.constructor.prototype); - return Object.assign(r, this), (r.property = e), r; - } - fromArray(e) {} - }); - sr.Layout = Wi; - sr.nameWithProperty = lOe; - sr.bindConstructorLayout = XVr; - (xf = class extends Wi { - isCount() { - throw new Error("ExternalLayout is abstract"); - } - }), - (nce = class extends xf { - constructor(e, r) { - if ((e === void 0 && (e = 1), !Number.isInteger(e) || 0 >= e)) - throw new TypeError("elementSpan must be a (positive) integer"); - super(-1, r), (this.elementSpan = e); - } - isCount() { - return !0; - } - decode(e, r) { - r === void 0 && (r = 0); - let n = e.length - r; - return Math.floor(n / this.elementSpan); - } - encode(e, r, n) { - return 0; - } - }), - (SV = class extends xf { - constructor(e, r, n) { - if (!(e instanceof Wi)) - throw new TypeError("layout must be a Layout"); - if (r === void 0) r = 0; - else if (!Number.isInteger(r)) - throw new TypeError("offset must be integer or undefined"); - super(e.span, n || e.property), - (this.layout = e), - (this.offset = r); - } - isCount() { - return this.layout instanceof dm || this.layout instanceof Cg; - } - decode(e, r) { - return ( - r === void 0 && (r = 0), this.layout.decode(e, r + this.offset) - ); - } - encode(e, r, n) { - return ( - n === void 0 && (n = 0), this.layout.encode(e, r, n + this.offset) - ); - } - }), - (dm = class extends Wi { - constructor(e, r) { - if ((super(e, r), 6 < this.span)) - throw new RangeError("span must not exceed 6 bytes"); - } - decode(e, r) { - return r === void 0 && (r = 0), e.readUIntLE(r, this.span); - } - encode(e, r, n) { - return ( - n === void 0 && (n = 0), r.writeUIntLE(e, n, this.span), this.span - ); - } - }), - (Cg = class extends Wi { - constructor(e, r) { - if ((super(e, r), 6 < this.span)) - throw new RangeError("span must not exceed 6 bytes"); - } - decode(e, r) { - return r === void 0 && (r = 0), e.readUIntBE(r, this.span); - } - encode(e, r, n) { - return ( - n === void 0 && (n = 0), r.writeUIntBE(e, n, this.span), this.span - ); - } - }), - ($x = class extends Wi { - constructor(e, r) { - if ((super(e, r), 6 < this.span)) - throw new RangeError("span must not exceed 6 bytes"); - } - decode(e, r) { - return r === void 0 && (r = 0), e.readIntLE(r, this.span); - } - encode(e, r, n) { - return ( - n === void 0 && (n = 0), r.writeIntLE(e, n, this.span), this.span - ); - } - }), - (QE = class extends Wi { - constructor(e, r) { - if ((super(e, r), 6 < this.span)) - throw new RangeError("span must not exceed 6 bytes"); - } - decode(e, r) { - return r === void 0 && (r = 0), e.readIntBE(r, this.span); - } - encode(e, r, n) { - return ( - n === void 0 && (n = 0), r.writeIntBE(e, n, this.span), this.span - ); - } - }), - (tOe = Math.pow(2, 32)); - (rOe = class extends Wi { - constructor(e) { - super(8, e); - } - decode(e, r) { - r === void 0 && (r = 0); - let n = e.readUInt32LE(r), - i = e.readUInt32LE(r + 4); - return bce(i, n); - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = vce(e); - return r.writeUInt32LE(i.lo32, n), r.writeUInt32LE(i.hi32, n + 4), 8; - } - }), - (nOe = class extends Wi { - constructor(e) { - super(8, e); - } - decode(e, r) { - r === void 0 && (r = 0); - let n = e.readUInt32BE(r), - i = e.readUInt32BE(r + 4); - return bce(n, i); - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = vce(e); - return ( - r.writeUInt32BE(i.hi32, n), r.writeUInt32BE(i.lo32, n + 4), 8 - ); - } - }), - (iOe = class extends Wi { - constructor(e) { - super(8, e); - } - decode(e, r) { - r === void 0 && (r = 0); - let n = e.readUInt32LE(r), - i = e.readInt32LE(r + 4); - return bce(i, n); - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = vce(e); - return r.writeUInt32LE(i.lo32, n), r.writeInt32LE(i.hi32, n + 4), 8; - } - }), - (oOe = class extends Wi { - constructor(e) { - super(8, e); - } - decode(e, r) { - r === void 0 && (r = 0); - let n = e.readInt32BE(r), - i = e.readUInt32BE(r + 4); - return bce(n, i); - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = vce(e); - return r.writeInt32BE(i.hi32, n), r.writeUInt32BE(i.lo32, n + 4), 8; - } - }), - (ice = class extends Wi { - constructor(e) { - super(4, e); - } - decode(e, r) { - return r === void 0 && (r = 0), e.readFloatLE(r); - } - encode(e, r, n) { - return n === void 0 && (n = 0), r.writeFloatLE(e, n), 4; - } - }), - (oce = class extends Wi { - constructor(e) { - super(4, e); - } - decode(e, r) { - return r === void 0 && (r = 0), e.readFloatBE(r); - } - encode(e, r, n) { - return n === void 0 && (n = 0), r.writeFloatBE(e, n), 4; - } - }), - (ace = class extends Wi { - constructor(e) { - super(8, e); - } - decode(e, r) { - return r === void 0 && (r = 0), e.readDoubleLE(r); - } - encode(e, r, n) { - return n === void 0 && (n = 0), r.writeDoubleLE(e, n), 8; - } - }), - (sce = class extends Wi { - constructor(e) { - super(8, e); - } - decode(e, r) { - return r === void 0 && (r = 0), e.readDoubleBE(r); - } - encode(e, r, n) { - return n === void 0 && (n = 0), r.writeDoubleBE(e, n), 8; - } - }), - (uce = class extends Wi { - constructor(e, r, n) { - if (!(e instanceof Wi)) - throw new TypeError("elementLayout must be a Layout"); - if ( - !( - (r instanceof xf && r.isCount()) || - (Number.isInteger(r) && 0 <= r) - ) - ) - throw new TypeError( - "count must be non-negative integer or an unsigned integer ExternalLayout" - ); - let i = -1; - !(r instanceof xf) && 0 < e.span && (i = r * e.span), - super(i, n), - (this.elementLayout = e), - (this.count = r); - } - getSpan(e, r) { - if (0 <= this.span) return this.span; - r === void 0 && (r = 0); - let n = 0, - i = this.count; - if ( - (i instanceof xf && (i = i.decode(e, r)), - 0 < this.elementLayout.span) - ) - n = i * this.elementLayout.span; - else { - let o = 0; - for (; o < i; ) (n += this.elementLayout.getSpan(e, r + n)), ++o; - } - return n; - } - decode(e, r) { - r === void 0 && (r = 0); - let n = [], - i = 0, - o = this.count; - for (o instanceof xf && (o = o.decode(e, r)); i < o; ) - n.push(this.elementLayout.decode(e, r)), - (r += this.elementLayout.getSpan(e, r)), - (i += 1); - return n; - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = this.elementLayout, - o = e.reduce((a, s) => a + i.encode(s, r, n + a), 0); - return ( - this.count instanceof xf && this.count.encode(e.length, r, n), o - ); - } - }), - (cce = class extends Wi { - constructor(e, r, n) { - if ( - !( - Array.isArray(e) && e.reduce((o, a) => o && a instanceof Wi, !0) - ) - ) - throw new TypeError("fields must be array of Layout instances"); - typeof r == "boolean" && n === void 0 && ((n = r), (r = void 0)); - for (let o of e) - if (0 > o.span && o.property === void 0) - throw new Error( - "fields cannot contain unnamed variable-length layout" - ); - let i = -1; - try { - i = e.reduce((o, a) => o + a.getSpan(), 0); - } catch {} - super(i, r), (this.fields = e), (this.decodePrefixes = !!n); - } - getSpan(e, r) { - if (0 <= this.span) return this.span; - r === void 0 && (r = 0); - let n = 0; - try { - n = this.fields.reduce((i, o) => { - let a = o.getSpan(e, r); - return (r += a), i + a; - }, 0); - } catch { - throw new RangeError("indeterminate span"); - } - return n; - } - decode(e, r) { - r === void 0 && (r = 0); - let n = this.makeDestinationObject(); - for (let i of this.fields) - if ( - (i.property !== void 0 && (n[i.property] = i.decode(e, r)), - (r += i.getSpan(e, r)), - this.decodePrefixes && e.length === r) - ) - break; - return n; - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = n, - o = 0, - a = 0; - for (let s of this.fields) { - let c = s.span; - if (((a = 0 < c ? c : 0), s.property !== void 0)) { - let u = e[s.property]; - u !== void 0 && - ((a = s.encode(u, r, n)), 0 > c && (c = s.getSpan(r, n))); - } - (o = n), (n += c); - } - return o + a - i; - } - fromArray(e) { - let r = this.makeDestinationObject(); - for (let n of this.fields) - n.property !== void 0 && - 0 < e.length && - (r[n.property] = e.shift()); - return r; - } - layoutFor(e) { - if (typeof e != "string") - throw new TypeError("property must be string"); - for (let r of this.fields) if (r.property === e) return r; - } - offsetOf(e) { - if (typeof e != "string") - throw new TypeError("property must be string"); - let r = 0; - for (let n of this.fields) { - if (n.property === e) return r; - 0 > n.span ? (r = -1) : 0 <= r && (r += n.span); - } - } - }), - (AV = class { - constructor(e) { - this.property = e; - } - decode() { - throw new Error("UnionDiscriminator is abstract"); - } - encode() { - throw new Error("UnionDiscriminator is abstract"); - } - }), - (X9 = class extends AV { - constructor(e, r) { - if (!(e instanceof xf && e.isCount())) - throw new TypeError( - "layout must be an unsigned integer ExternalLayout" - ); - super(r || e.property || "variant"), (this.layout = e); - } - decode(e, r) { - return this.layout.decode(e, r); - } - encode(e, r, n) { - return this.layout.encode(e, r, n); - } - }), - (EV = class extends Wi { - constructor(e, r, n) { - let i = e instanceof dm || e instanceof Cg; - if (i) e = new X9(new SV(e)); - else if (e instanceof xf && e.isCount()) e = new X9(e); - else if (!(e instanceof AV)) - throw new TypeError( - "discr must be a UnionDiscriminator or an unsigned integer layout" - ); - if ((r === void 0 && (r = null), !(r === null || r instanceof Wi))) - throw new TypeError("defaultLayout must be null or a Layout"); - if (r !== null) { - if (0 > r.span) - throw new Error("defaultLayout must have constant span"); - r.property === void 0 && (r = r.replicate("content")); - } - let o = -1; - r && ((o = r.span), 0 <= o && i && (o += e.layout.span)), - super(o, n), - (this.discriminator = e), - (this.usesPrefixDiscriminator = i), - (this.defaultLayout = r), - (this.registry = {}); - let a = this.defaultGetSourceVariant.bind(this); - (this.getSourceVariant = function (s) { - return a(s); - }), - (this.configGetSourceVariant = function (s) { - a = s.bind(this); - }); - } - getSpan(e, r) { - if (0 <= this.span) return this.span; - r === void 0 && (r = 0); - let n = this.getVariant(e, r); - if (!n) - throw new Error( - "unable to determine span for unrecognized variant" - ); - return n.getSpan(e, r); - } - defaultGetSourceVariant(e) { - if (e.hasOwnProperty(this.discriminator.property)) { - if ( - this.defaultLayout && - e.hasOwnProperty(this.defaultLayout.property) - ) - return; - let r = this.registry[e[this.discriminator.property]]; - if (r && (!r.layout || e.hasOwnProperty(r.property))) return r; - } else - for (let r in this.registry) { - let n = this.registry[r]; - if (e.hasOwnProperty(n.property)) return n; - } - throw new Error("unable to infer src variant"); - } - decode(e, r) { - r === void 0 && (r = 0); - let n, - i = this.discriminator, - o = i.decode(e, r), - a = this.registry[o]; - if (a === void 0) { - let s = 0; - (a = this.defaultLayout), - this.usesPrefixDiscriminator && (s = i.layout.span), - (n = this.makeDestinationObject()), - (n[i.property] = o), - (n[a.property] = this.defaultLayout.decode(e, r + s)); - } else n = a.decode(e, r); - return n; - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = this.getSourceVariant(e); - if (i === void 0) { - let o = this.discriminator, - a = this.defaultLayout, - s = 0; - return ( - this.usesPrefixDiscriminator && (s = o.layout.span), - o.encode(e[o.property], r, n), - s + a.encode(e[a.property], r, n + s) - ); - } - return i.encode(e, r, n); - } - addVariant(e, r, n) { - let i = new lce(this, e, r, n); - return (this.registry[e] = i), i; - } - getVariant(e, r) { - let n = e; - return ( - ni.Buffer.isBuffer(e) && - (r === void 0 && (r = 0), - (n = this.discriminator.decode(e, r))), - this.registry[n] - ); - } - }), - (lce = class extends Wi { - constructor(e, r, n, i) { - if (!(e instanceof EV)) - throw new TypeError("union must be a Union"); - if (!Number.isInteger(r) || 0 > r) - throw new TypeError("variant must be a (non-negative) integer"); - if ( - (typeof n == "string" && i === void 0 && ((i = n), (n = null)), n) - ) { - if (!(n instanceof Wi)) - throw new TypeError("layout must be a Layout"); - if ( - e.defaultLayout !== null && - 0 <= n.span && - n.span > e.defaultLayout.span - ) - throw new Error( - "variant span exceeds span of containing union" - ); - if (typeof i != "string") - throw new TypeError("variant must have a String property"); - } - let o = e.span; - 0 > e.span && - ((o = n ? n.span : 0), - 0 <= o && - e.usesPrefixDiscriminator && - (o += e.discriminator.layout.span)), - super(o, i), - (this.union = e), - (this.variant = r), - (this.layout = n || null); - } - getSpan(e, r) { - if (0 <= this.span) return this.span; - r === void 0 && (r = 0); - let n = 0; - return ( - this.union.usesPrefixDiscriminator && - (n = this.union.discriminator.layout.span), - n + this.layout.getSpan(e, r + n) - ); - } - decode(e, r) { - let n = this.makeDestinationObject(); - if ((r === void 0 && (r = 0), this !== this.union.getVariant(e, r))) - throw new Error("variant mismatch"); - let i = 0; - return ( - this.union.usesPrefixDiscriminator && - (i = this.union.discriminator.layout.span), - this.layout - ? (n[this.property] = this.layout.decode(e, r + i)) - : this.property - ? (n[this.property] = !0) - : this.union.usesPrefixDiscriminator && - (n[this.union.discriminator.property] = this.variant), - n - ); - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = 0; - if ( - (this.union.usesPrefixDiscriminator && - (i = this.union.discriminator.layout.span), - this.layout && !e.hasOwnProperty(this.property)) - ) - throw new TypeError("variant lacks property " + this.property); - this.union.discriminator.encode(this.variant, r, n); - let o = i; - if ( - this.layout && - (this.layout.encode(e[this.property], r, n + i), - (o += this.layout.getSpan(r, n + i)), - 0 <= this.union.span && o > this.union.span) - ) - throw new Error("encoded variant overruns containing union"); - return o; - } - fromArray(e) { - if (this.layout) return this.layout.fromArray(e); - } - }); - (MV = class extends Wi { - constructor(e, r, n) { - if (!(e instanceof dm || e instanceof Cg)) - throw new TypeError("word must be a UInt or UIntBE layout"); - if ( - (typeof r == "string" && n === void 0 && ((n = r), (r = void 0)), - 4 < e.span) - ) - throw new RangeError("word cannot exceed 32 bits"); - super(e.span, n), - (this.word = e), - (this.msb = !!r), - (this.fields = []); - let i = 0; - (this._packedSetValue = function (o) { - return (i = G9(o)), this; - }), - (this._packedGetValue = function () { - return i; - }); - } - decode(e, r) { - let n = this.makeDestinationObject(); - r === void 0 && (r = 0); - let i = this.word.decode(e, r); - this._packedSetValue(i); - for (let o of this.fields) - o.property !== void 0 && (n[o.property] = o.decode(i)); - return n; - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = this.word.decode(r, n); - this._packedSetValue(i); - for (let o of this.fields) - if (o.property !== void 0) { - let a = e[o.property]; - a !== void 0 && o.encode(a); - } - return this.word.encode(this._packedGetValue(), r, n); - } - addField(e, r) { - let n = new A4(this, e, r); - return this.fields.push(n), n; - } - addBoolean(e) { - let r = new fce(this, e); - return this.fields.push(r), r; - } - fieldFor(e) { - if (typeof e != "string") - throw new TypeError("property must be string"); - for (let r of this.fields) if (r.property === e) return r; - } - }), - (A4 = class { - constructor(e, r, n) { - if (!(e instanceof MV)) - throw new TypeError("container must be a BitStructure"); - if (!Number.isInteger(r) || 0 >= r) - throw new TypeError("bits must be positive integer"); - let i = 8 * e.span, - o = e.fields.reduce((a, s) => a + s.bits, 0); - if (r + o > i) - throw new Error( - "bits too long for span remainder (" + - (i - o) + - " of " + - i + - " remain)" - ); - (this.container = e), - (this.bits = r), - (this.valueMask = (1 << r) - 1), - r === 32 && (this.valueMask = 4294967295), - (this.start = o), - this.container.msb && (this.start = i - o - r), - (this.wordMask = G9(this.valueMask << this.start)), - (this.property = n); - } - decode() { - let e = this.container._packedGetValue(); - return G9(e & this.wordMask) >>> this.start; - } - encode(e) { - if (!Number.isInteger(e) || e !== G9(e & this.valueMask)) - throw new TypeError( - lOe("BitField.encode", this) + - " value must be integer not exceeding " + - this.valueMask - ); - let r = this.container._packedGetValue(), - n = G9(e << this.start); - this.container._packedSetValue(G9(r & ~this.wordMask) | n); - } - }), - (fce = class extends A4 { - constructor(e, r) { - super(e, 1, r); - } - decode(e, r) { - return !!A4.prototype.decode.call(this, e, r); - } - encode(e) { - return ( - typeof e == "boolean" && (e = +e), - A4.prototype.encode.call(this, e) - ); - } - }), - (dce = class extends Wi { - constructor(e, r) { - if ( - !( - (e instanceof xf && e.isCount()) || - (Number.isInteger(e) && 0 <= e) - ) - ) - throw new TypeError( - "length must be positive integer or an unsigned integer ExternalLayout" - ); - let n = -1; - e instanceof xf || (n = e), super(n, r), (this.length = e); - } - getSpan(e, r) { - let n = this.span; - return 0 > n && (n = this.length.decode(e, r)), n; - } - decode(e, r) { - r === void 0 && (r = 0); - let n = this.span; - return 0 > n && (n = this.length.decode(e, r)), e.slice(r, r + n); - } - encode(e, r, n) { - let i = this.length; - if ( - (this.length instanceof xf && (i = e.length), - !(ni.Buffer.isBuffer(e) && i === e.length)) - ) - throw new TypeError( - lOe("Blob.encode", this) + - " requires (length " + - i + - ") Buffer as src" - ); - if (n + i > r.length) - throw new RangeError("encoding overruns Buffer"); - return ( - r.write(e.toString("hex"), n, i, "hex"), - this.length instanceof xf && this.length.encode(i, r, n), - i - ); - } - }), - (hce = class extends Wi { - constructor(e) { - super(-1, e); - } - getSpan(e, r) { - if (!ni.Buffer.isBuffer(e)) - throw new TypeError("b must be a Buffer"); - r === void 0 && (r = 0); - let n = r; - for (; n < e.length && e[n] !== 0; ) n += 1; - return 1 + n - r; - } - decode(e, r, n) { - r === void 0 && (r = 0); - let i = this.getSpan(e, r); - return e.slice(r, r + i - 1).toString("utf-8"); - } - encode(e, r, n) { - n === void 0 && (n = 0), typeof e != "string" && (e = e.toString()); - let i = new ni.Buffer(e, "utf8"), - o = i.length; - if (n + o > r.length) - throw new RangeError("encoding overruns Buffer"); - return i.copy(r, n), (r[n + o] = 0), o + 1; - } - }), - (pce = class extends Wi { - constructor(e, r) { - if ( - (typeof e == "string" && r === void 0 && ((r = e), (e = void 0)), - e === void 0) - ) - e = -1; - else if (!Number.isInteger(e)) - throw new TypeError("maxSpan must be an integer"); - super(-1, r), (this.maxSpan = e); - } - getSpan(e, r) { - if (!ni.Buffer.isBuffer(e)) - throw new TypeError("b must be a Buffer"); - return r === void 0 && (r = 0), e.length - r; - } - decode(e, r, n) { - r === void 0 && (r = 0); - let i = this.getSpan(e, r); - if (0 <= this.maxSpan && this.maxSpan < i) - throw new RangeError("text length exceeds maxSpan"); - return e.slice(r, r + i).toString("utf-8"); - } - encode(e, r, n) { - n === void 0 && (n = 0), typeof e != "string" && (e = e.toString()); - let i = new ni.Buffer(e, "utf8"), - o = i.length; - if (0 <= this.maxSpan && this.maxSpan < o) - throw new RangeError("text length exceeds maxSpan"); - if (n + o > r.length) - throw new RangeError("encoding overruns Buffer"); - return i.copy(r, n), o; - } - }), - (yce = class extends Wi { - constructor(e, r) { - super(0, r), (this.value = e); - } - decode(e, r, n) { - return this.value; - } - encode(e, r, n) { - return 0; - } - }); - sr.ExternalLayout = xf; - sr.GreedyCount = nce; - sr.OffsetLayout = SV; - sr.UInt = dm; - sr.UIntBE = Cg; - sr.Int = $x; - sr.IntBE = QE; - sr.Float = ice; - sr.FloatBE = oce; - sr.Double = ace; - sr.DoubleBE = sce; - sr.Sequence = uce; - sr.Structure = cce; - sr.UnionDiscriminator = AV; - sr.UnionLayoutDiscriminator = X9; - sr.Union = EV; - sr.VariantLayout = lce; - sr.BitStructure = MV; - sr.BitField = A4; - sr.Boolean = fce; - sr.Blob = dce; - sr.CString = hce; - sr.UTF8 = pce; - sr.Constant = yce; - sr.greedy = (t, e) => new nce(t, e); - sr.offset = (t, e, r) => new SV(t, e, r); - Li = sr.u8 = (t) => new dm(1, t); - sr.u16 = (t) => new dm(2, t); - sr.u24 = (t) => new dm(3, t); - xV = sr.u32 = (t) => new dm(4, t); - sr.u40 = (t) => new dm(5, t); - sr.u48 = (t) => new dm(6, t); - sr.nu64 = (t) => new rOe(t); - sr.u16be = (t) => new Cg(2, t); - sr.u24be = (t) => new Cg(3, t); - sr.u32be = (t) => new Cg(4, t); - sr.u40be = (t) => new Cg(5, t); - sr.u48be = (t) => new Cg(6, t); - sr.nu64be = (t) => new nOe(t); - sr.s8 = (t) => new $x(1, t); - sr.s16 = (t) => new $x(2, t); - sr.s24 = (t) => new $x(3, t); - sr.s32 = (t) => new $x(4, t); - sr.s40 = (t) => new $x(5, t); - sr.s48 = (t) => new $x(6, t); - sr.ns64 = (t) => new iOe(t); - sr.s16be = (t) => new QE(2, t); - sr.s24be = (t) => new QE(3, t); - sr.s32be = (t) => new QE(4, t); - sr.s40be = (t) => new QE(5, t); - sr.s48be = (t) => new QE(6, t); - sr.ns64be = (t) => new oOe(t); - sr.f32 = (t) => new ice(t); - sr.f32be = (t) => new oce(t); - sr.f64 = (t) => new ace(t); - sr.f64be = (t) => new sce(t); - Cs = sr.struct = (t, e, r) => new cce(t, e, r); - sr.bits = (t, e, r) => new MV(t, e, r); - sr.seq = (t, e, r) => new uce(t, e, r); - sr.union = (t, e, r) => new EV(t, e, r); - sr.unionLayoutDiscriminator = (t, e) => new X9(t, e); - $Tt = sr.blob = (t, e) => new dce(t, e); - sr.cstr = (t) => new hce(t); - sr.utf8 = (t, e) => new pce(t, e); - sr.const = (t, e) => new yce(t, e); - (Rs = (t = "publicKey") => $Tt(32, t)), - (fm = (t = "uint64") => $Tt(8, t)); - (YVr = new Xt.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA")), - (ZTt = new Xt.PublicKey( - "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL" - )), - (OTt = "Failed to find account"), - (BTt = "Invalid account owner"); - Hu = class extends ITt.default { - toBuffer() { - let e = super.toArray().reverse(), - r = ni.Buffer.from(e); - if (r.length === 8) return r; - Sf(r.length < 8, "u64 too large"); - let n = ni.Buffer.alloc(8); - return r.copy(n), n; - } - static fromBuffer(e) { - return ( - Sf(e.length === 8, `Invalid buffer length: ${e.length}`), - new Hu( - [...e] - .reverse() - .map((r) => `00${r.toString(16)}`.slice(-2)) - .join(""), - 16 - ) - ); - } - }; - (QVr = { - MintTokens: 0, - FreezeAccount: 1, - AccountOwner: 2, - CloseAccount: 3, - }), - (XTt = new Xt.PublicKey("So11111111111111111111111111111111111111112")), - (bV = Cs([ - xV("mintAuthorityOption"), - Rs("mintAuthority"), - fm("supply"), - Li("decimals"), - Li("isInitialized"), - xV("freezeAuthorityOption"), - Rs("freezeAuthority"), - ])), - (J9 = Cs([ - Rs("mint"), - Rs("owner"), - fm("amount"), - xV("delegateOption"), - Rs("delegate"), - Li("state"), - xV("isNativeOption"), - fm("isNative"), - fm("delegatedAmount"), - xV("closeAuthorityOption"), - Rs("closeAuthority"), - ])), - (Que = Cs([ - Li("m"), - Li("n"), - Li("is_initialized"), - Rs("signer1"), - Rs("signer2"), - Rs("signer3"), - Rs("signer4"), - Rs("signer5"), - Rs("signer6"), - Rs("signer7"), - Rs("signer8"), - Rs("signer9"), - Rs("signer10"), - Rs("signer11"), - ])), - (io = class { - constructor(e, r, n, i) { - _4(this, "connection", void 0), - _4(this, "publicKey", void 0), - _4(this, "programId", void 0), - _4(this, "associatedProgramId", void 0), - _4(this, "payer", void 0), - Object.assign(this, { - connection: e, - publicKey: r, - programId: n, - payer: i, - associatedProgramId: ZTt, - }); - } - static async getMinBalanceRentForExemptMint(e) { - return await e.getMinimumBalanceForRentExemption(bV.span); - } - static async getMinBalanceRentForExemptAccount(e) { - return await e.getMinimumBalanceForRentExemption(J9.span); - } - static async getMinBalanceRentForExemptMultisig(e) { - return await e.getMinimumBalanceForRentExemption(Que.span); - } - static async createMint(e, r, n, i, o, a) { - let s = Xt.Keypair.generate(), - c = new io(e, s.publicKey, a, r), - u = await io.getMinBalanceRentForExemptMint(e), - h = new Xt.Transaction(); - return ( - h.add( - Xt.SystemProgram.createAccount({ - fromPubkey: r.publicKey, - newAccountPubkey: s.publicKey, - lamports: u, - space: bV.span, - programId: a, - }) - ), - h.add(io.createInitMintInstruction(a, s.publicKey, o, n, i)), - await ou("createAccount and InitializeMint", e, h, r, s), - c - ); - } - async createAccount(e) { - let r = await io.getMinBalanceRentForExemptAccount(this.connection), - n = Xt.Keypair.generate(), - i = new Xt.Transaction(); - i.add( - Xt.SystemProgram.createAccount({ - fromPubkey: this.payer.publicKey, - newAccountPubkey: n.publicKey, - lamports: r, - space: J9.span, - programId: this.programId, - }) - ); - let o = this.publicKey; - return ( - i.add( - io.createInitAccountInstruction( - this.programId, - o, - n.publicKey, - e - ) - ), - await ou( - "createAccount and InitializeAccount", - this.connection, - i, - this.payer, - n - ), - n.publicKey - ); - } - async createAssociatedTokenAccount(e) { - let r = await io.getAssociatedTokenAddress( - this.associatedProgramId, - this.programId, - this.publicKey, - e - ); - return this.createAssociatedTokenAccountInternal(e, r); - } - async createAssociatedTokenAccountInternal(e, r) { - return ( - await ou( - "CreateAssociatedTokenAccount", - this.connection, - new Xt.Transaction().add( - io.createAssociatedTokenAccountInstruction( - this.associatedProgramId, - this.programId, - this.publicKey, - r, - e, - this.payer.publicKey - ) - ), - this.payer - ), - r - ); - } - async getOrCreateAssociatedAccountInfo(e) { - let r = await io.getAssociatedTokenAddress( - this.associatedProgramId, - this.programId, - this.publicKey, - e - ); - try { - return await this.getAccountInfo(r); - } catch (n) { - if (n.message === OTt || n.message === BTt) { - try { - await this.createAssociatedTokenAccountInternal(e, r); - } catch {} - return await this.getAccountInfo(r); - } else throw n; - } - } - static async createWrappedNativeAccount(e, r, n, i, o) { - let a = await io.getMinBalanceRentForExemptAccount(e), - s = Xt.Keypair.generate(), - c = new Xt.Transaction(); - return ( - c.add( - Xt.SystemProgram.createAccount({ - fromPubkey: i.publicKey, - newAccountPubkey: s.publicKey, - lamports: a, - space: J9.span, - programId: r, - }) - ), - c.add( - Xt.SystemProgram.transfer({ - fromPubkey: i.publicKey, - toPubkey: s.publicKey, - lamports: o, - }) - ), - c.add(io.createInitAccountInstruction(r, XTt, s.publicKey, n)), - await ou( - "createAccount, transfer, and initializeAccount", - e, - c, - i, - s - ), - s.publicKey - ); - } - async createMultisig(e, r) { - let n = Xt.Keypair.generate(), - i = await io.getMinBalanceRentForExemptMultisig(this.connection), - o = new Xt.Transaction(); - o.add( - Xt.SystemProgram.createAccount({ - fromPubkey: this.payer.publicKey, - newAccountPubkey: n.publicKey, - lamports: i, - space: Que.span, - programId: this.programId, - }) - ); - let a = [ - { pubkey: n.publicKey, isSigner: !1, isWritable: !0 }, - { pubkey: Xt.SYSVAR_RENT_PUBKEY, isSigner: !1, isWritable: !1 }, - ]; - r.forEach((u) => - a.push({ pubkey: u, isSigner: !1, isWritable: !1 }) - ); - let s = Cs([Li("instruction"), Li("m")]), - c = ni.Buffer.alloc(s.span); - return ( - s.encode({ instruction: 2, m: e }, c), - o.add({ keys: a, programId: this.programId, data: c }), - await ou( - "createAccount and InitializeMultisig", - this.connection, - o, - this.payer, - n - ), - n.publicKey - ); - } - async getMintInfo() { - let e = await this.connection.getAccountInfo(this.publicKey); - if (e === null) throw new Error("Failed to find mint account"); - if (!e.owner.equals(this.programId)) - throw new Error(`Invalid mint owner: ${JSON.stringify(e.owner)}`); - if (e.data.length != bV.span) throw new Error("Invalid mint size"); - let r = ni.Buffer.from(e.data), - n = bV.decode(r); - return ( - n.mintAuthorityOption === 0 - ? (n.mintAuthority = null) - : (n.mintAuthority = new Xt.PublicKey(n.mintAuthority)), - (n.supply = Hu.fromBuffer(n.supply)), - (n.isInitialized = n.isInitialized != 0), - n.freezeAuthorityOption === 0 - ? (n.freezeAuthority = null) - : (n.freezeAuthority = new Xt.PublicKey(n.freezeAuthority)), - n - ); - } - async getAccountInfo(e, r) { - let n = await this.connection.getAccountInfo(e, r); - if (n === null) throw new Error(OTt); - if (!n.owner.equals(this.programId)) throw new Error(BTt); - if (n.data.length != J9.span) - throw new Error("Invalid account size"); - let i = ni.Buffer.from(n.data), - o = J9.decode(i); - if ( - ((o.address = e), - (o.mint = new Xt.PublicKey(o.mint)), - (o.owner = new Xt.PublicKey(o.owner)), - (o.amount = Hu.fromBuffer(o.amount)), - o.delegateOption === 0 - ? ((o.delegate = null), (o.delegatedAmount = new Hu())) - : ((o.delegate = new Xt.PublicKey(o.delegate)), - (o.delegatedAmount = Hu.fromBuffer(o.delegatedAmount))), - (o.isInitialized = o.state !== 0), - (o.isFrozen = o.state === 2), - o.isNativeOption === 1 - ? ((o.rentExemptReserve = Hu.fromBuffer(o.isNative)), - (o.isNative = !0)) - : ((o.rentExemptReserve = null), (o.isNative = !1)), - o.closeAuthorityOption === 0 - ? (o.closeAuthority = null) - : (o.closeAuthority = new Xt.PublicKey(o.closeAuthority)), - !o.mint.equals(this.publicKey)) - ) - throw new Error( - `Invalid account mint: ${JSON.stringify( - o.mint - )} !== ${JSON.stringify(this.publicKey)}` - ); - return o; - } - async getMultisigInfo(e) { - let r = await this.connection.getAccountInfo(e); - if (r === null) throw new Error("Failed to find multisig"); - if (!r.owner.equals(this.programId)) - throw new Error("Invalid multisig owner"); - if (r.data.length != Que.span) - throw new Error("Invalid multisig size"); - let n = ni.Buffer.from(r.data), - i = Que.decode(n); - return ( - (i.signer1 = new Xt.PublicKey(i.signer1)), - (i.signer2 = new Xt.PublicKey(i.signer2)), - (i.signer3 = new Xt.PublicKey(i.signer3)), - (i.signer4 = new Xt.PublicKey(i.signer4)), - (i.signer5 = new Xt.PublicKey(i.signer5)), - (i.signer6 = new Xt.PublicKey(i.signer6)), - (i.signer7 = new Xt.PublicKey(i.signer7)), - (i.signer8 = new Xt.PublicKey(i.signer8)), - (i.signer9 = new Xt.PublicKey(i.signer9)), - (i.signer10 = new Xt.PublicKey(i.signer10)), - (i.signer11 = new Xt.PublicKey(i.signer11)), - i - ); - } - async transfer(e, r, n, i, o) { - let a, s; - return ( - w0(n) ? ((a = n.publicKey), (s = [n])) : ((a = n), (s = i)), - await ou( - "Transfer", - this.connection, - new Xt.Transaction().add( - io.createTransferInstruction(this.programId, e, r, a, i, o) - ), - this.payer, - ...s - ) - ); - } - async approve(e, r, n, i, o) { - let a, s; - w0(n) ? ((a = n.publicKey), (s = [n])) : ((a = n), (s = i)), - await ou( - "Approve", - this.connection, - new Xt.Transaction().add( - io.createApproveInstruction(this.programId, e, r, a, i, o) - ), - this.payer, - ...s - ); - } - async revoke(e, r, n) { - let i, o; - w0(r) ? ((i = r.publicKey), (o = [r])) : ((i = r), (o = n)), - await ou( - "Revoke", - this.connection, - new Xt.Transaction().add( - io.createRevokeInstruction(this.programId, e, i, n) - ), - this.payer, - ...o - ); - } - async setAuthority(e, r, n, i, o) { - let a, s; - w0(i) ? ((a = i.publicKey), (s = [i])) : ((a = i), (s = o)), - await ou( - "SetAuthority", - this.connection, - new Xt.Transaction().add( - io.createSetAuthorityInstruction( - this.programId, - e, - r, - n, - a, - o - ) - ), - this.payer, - ...s - ); - } - async mintTo(e, r, n, i) { - let o, a; - w0(r) ? ((o = r.publicKey), (a = [r])) : ((o = r), (a = n)), - await ou( - "MintTo", - this.connection, - new Xt.Transaction().add( - io.createMintToInstruction( - this.programId, - this.publicKey, - e, - o, - n, - i - ) - ), - this.payer, - ...a - ); - } - async burn(e, r, n, i) { - let o, a; - w0(r) ? ((o = r.publicKey), (a = [r])) : ((o = r), (a = n)), - await ou( - "Burn", - this.connection, - new Xt.Transaction().add( - io.createBurnInstruction( - this.programId, - this.publicKey, - e, - o, - n, - i - ) - ), - this.payer, - ...a - ); - } - async closeAccount(e, r, n, i) { - let o, a; - w0(n) ? ((o = n.publicKey), (a = [n])) : ((o = n), (a = i)), - await ou( - "CloseAccount", - this.connection, - new Xt.Transaction().add( - io.createCloseAccountInstruction(this.programId, e, r, o, i) - ), - this.payer, - ...a - ); - } - async freezeAccount(e, r, n) { - let i, o; - w0(r) ? ((i = r.publicKey), (o = [r])) : ((i = r), (o = n)), - await ou( - "FreezeAccount", - this.connection, - new Xt.Transaction().add( - io.createFreezeAccountInstruction( - this.programId, - e, - this.publicKey, - i, - n - ) - ), - this.payer, - ...o - ); - } - async thawAccount(e, r, n) { - let i, o; - w0(r) ? ((i = r.publicKey), (o = [r])) : ((i = r), (o = n)), - await ou( - "ThawAccount", - this.connection, - new Xt.Transaction().add( - io.createThawAccountInstruction( - this.programId, - e, - this.publicKey, - i, - n - ) - ), - this.payer, - ...o - ); - } - async transferChecked(e, r, n, i, o, a) { - let s, c; - return ( - w0(n) ? ((s = n.publicKey), (c = [n])) : ((s = n), (c = i)), - await ou( - "TransferChecked", - this.connection, - new Xt.Transaction().add( - io.createTransferCheckedInstruction( - this.programId, - e, - this.publicKey, - r, - s, - i, - o, - a - ) - ), - this.payer, - ...c - ) - ); - } - async approveChecked(e, r, n, i, o, a) { - let s, c; - w0(n) ? ((s = n.publicKey), (c = [n])) : ((s = n), (c = i)), - await ou( - "ApproveChecked", - this.connection, - new Xt.Transaction().add( - io.createApproveCheckedInstruction( - this.programId, - e, - this.publicKey, - r, - s, - i, - o, - a - ) - ), - this.payer, - ...c - ); - } - async mintToChecked(e, r, n, i, o) { - let a, s; - w0(r) ? ((a = r.publicKey), (s = [r])) : ((a = r), (s = n)), - await ou( - "MintToChecked", - this.connection, - new Xt.Transaction().add( - io.createMintToCheckedInstruction( - this.programId, - this.publicKey, - e, - a, - n, - i, - o - ) - ), - this.payer, - ...s - ); - } - async burnChecked(e, r, n, i, o) { - let a, s; - w0(r) ? ((a = r.publicKey), (s = [r])) : ((a = r), (s = n)), - await ou( - "BurnChecked", - this.connection, - new Xt.Transaction().add( - io.createBurnCheckedInstruction( - this.programId, - this.publicKey, - e, - a, - n, - i, - o - ) - ), - this.payer, - ...s - ); - } - async syncNative(e) { - await ou( - "SyncNative", - this.connection, - new Xt.Transaction().add( - io.createSyncNativeInstruction(this.programId, e) - ), - this.payer - ); - } - static createInitMintInstruction(e, r, n, i, o) { - let a = [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: Xt.SYSVAR_RENT_PUBKEY, isSigner: !1, isWritable: !1 }, - ], - s = Cs([ - Li("instruction"), - Li("decimals"), - Rs("mintAuthority"), - Li("option"), - Rs("freezeAuthority"), - ]), - c = ni.Buffer.alloc(1024); - { - let u = s.encode( - { - instruction: 0, - decimals: n, - mintAuthority: Y4e(i), - option: o === null ? 0 : 1, - freezeAuthority: Y4e(o || new Xt.PublicKey(0)), - }, - c - ); - c = c.slice(0, u); - } - return new Xt.TransactionInstruction({ - keys: a, - programId: e, - data: c, - }); - } - static createInitAccountInstruction(e, r, n, i) { - let o = [ - { pubkey: n, isSigner: !1, isWritable: !0 }, - { pubkey: r, isSigner: !1, isWritable: !1 }, - { pubkey: i, isSigner: !1, isWritable: !1 }, - { pubkey: Xt.SYSVAR_RENT_PUBKEY, isSigner: !1, isWritable: !1 }, - ], - a = Cs([Li("instruction")]), - s = ni.Buffer.alloc(a.span); - return ( - a.encode({ instruction: 1 }, s), - new Xt.TransactionInstruction({ keys: o, programId: e, data: s }) - ); - } - static createTransferInstruction(e, r, n, i, o, a) { - let s = Cs([Li("instruction"), fm("amount")]), - c = ni.Buffer.alloc(s.span); - s.encode({ instruction: 3, amount: new Hu(a).toBuffer() }, c); - let u = [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: n, isSigner: !1, isWritable: !0 }, - ]; - return ( - o.length === 0 - ? u.push({ pubkey: i, isSigner: !0, isWritable: !1 }) - : (u.push({ pubkey: i, isSigner: !1, isWritable: !1 }), - o.forEach((h) => - u.push({ - pubkey: h.publicKey, - isSigner: !0, - isWritable: !1, - }) - )), - new Xt.TransactionInstruction({ keys: u, programId: e, data: c }) - ); - } - static createApproveInstruction(e, r, n, i, o, a) { - let s = Cs([Li("instruction"), fm("amount")]), - c = ni.Buffer.alloc(s.span); - s.encode({ instruction: 4, amount: new Hu(a).toBuffer() }, c); - let u = [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: n, isSigner: !1, isWritable: !1 }, - ]; - return ( - o.length === 0 - ? u.push({ pubkey: i, isSigner: !0, isWritable: !1 }) - : (u.push({ pubkey: i, isSigner: !1, isWritable: !1 }), - o.forEach((h) => - u.push({ - pubkey: h.publicKey, - isSigner: !0, - isWritable: !1, - }) - )), - new Xt.TransactionInstruction({ keys: u, programId: e, data: c }) - ); - } - static createRevokeInstruction(e, r, n, i) { - let o = Cs([Li("instruction")]), - a = ni.Buffer.alloc(o.span); - o.encode({ instruction: 5 }, a); - let s = [{ pubkey: r, isSigner: !1, isWritable: !0 }]; - return ( - i.length === 0 - ? s.push({ pubkey: n, isSigner: !0, isWritable: !1 }) - : (s.push({ pubkey: n, isSigner: !1, isWritable: !1 }), - i.forEach((c) => - s.push({ - pubkey: c.publicKey, - isSigner: !0, - isWritable: !1, - }) - )), - new Xt.TransactionInstruction({ keys: s, programId: e, data: a }) - ); - } - static createSetAuthorityInstruction(e, r, n, i, o, a) { - let s = Cs([ - Li("instruction"), - Li("authorityType"), - Li("option"), - Rs("newAuthority"), - ]), - c = ni.Buffer.alloc(1024); - { - let h = s.encode( - { - instruction: 6, - authorityType: QVr[i], - option: n === null ? 0 : 1, - newAuthority: Y4e(n || new Xt.PublicKey(0)), - }, - c - ); - c = c.slice(0, h); - } - let u = [{ pubkey: r, isSigner: !1, isWritable: !0 }]; - return ( - a.length === 0 - ? u.push({ pubkey: o, isSigner: !0, isWritable: !1 }) - : (u.push({ pubkey: o, isSigner: !1, isWritable: !1 }), - a.forEach((h) => - u.push({ - pubkey: h.publicKey, - isSigner: !0, - isWritable: !1, - }) - )), - new Xt.TransactionInstruction({ keys: u, programId: e, data: c }) - ); - } - static createMintToInstruction(e, r, n, i, o, a) { - let s = Cs([Li("instruction"), fm("amount")]), - c = ni.Buffer.alloc(s.span); - s.encode({ instruction: 7, amount: new Hu(a).toBuffer() }, c); - let u = [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: n, isSigner: !1, isWritable: !0 }, - ]; - return ( - o.length === 0 - ? u.push({ pubkey: i, isSigner: !0, isWritable: !1 }) - : (u.push({ pubkey: i, isSigner: !1, isWritable: !1 }), - o.forEach((h) => - u.push({ - pubkey: h.publicKey, - isSigner: !0, - isWritable: !1, - }) - )), - new Xt.TransactionInstruction({ keys: u, programId: e, data: c }) - ); - } - static createBurnInstruction(e, r, n, i, o, a) { - let s = Cs([Li("instruction"), fm("amount")]), - c = ni.Buffer.alloc(s.span); - s.encode({ instruction: 8, amount: new Hu(a).toBuffer() }, c); - let u = [ - { pubkey: n, isSigner: !1, isWritable: !0 }, - { pubkey: r, isSigner: !1, isWritable: !0 }, - ]; - return ( - o.length === 0 - ? u.push({ pubkey: i, isSigner: !0, isWritable: !1 }) - : (u.push({ pubkey: i, isSigner: !1, isWritable: !1 }), - o.forEach((h) => - u.push({ - pubkey: h.publicKey, - isSigner: !0, - isWritable: !1, - }) - )), - new Xt.TransactionInstruction({ keys: u, programId: e, data: c }) - ); - } - static createCloseAccountInstruction(e, r, n, i, o) { - let a = Cs([Li("instruction")]), - s = ni.Buffer.alloc(a.span); - a.encode({ instruction: 9 }, s); - let c = [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: n, isSigner: !1, isWritable: !0 }, - ]; - return ( - o.length === 0 - ? c.push({ pubkey: i, isSigner: !0, isWritable: !1 }) - : (c.push({ pubkey: i, isSigner: !1, isWritable: !1 }), - o.forEach((u) => - c.push({ - pubkey: u.publicKey, - isSigner: !0, - isWritable: !1, - }) - )), - new Xt.TransactionInstruction({ keys: c, programId: e, data: s }) - ); - } - static createFreezeAccountInstruction(e, r, n, i, o) { - let a = Cs([Li("instruction")]), - s = ni.Buffer.alloc(a.span); - a.encode({ instruction: 10 }, s); - let c = [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: n, isSigner: !1, isWritable: !1 }, - ]; - return ( - o.length === 0 - ? c.push({ pubkey: i, isSigner: !0, isWritable: !1 }) - : (c.push({ pubkey: i, isSigner: !1, isWritable: !1 }), - o.forEach((u) => - c.push({ - pubkey: u.publicKey, - isSigner: !0, - isWritable: !1, - }) - )), - new Xt.TransactionInstruction({ keys: c, programId: e, data: s }) - ); - } - static createThawAccountInstruction(e, r, n, i, o) { - let a = Cs([Li("instruction")]), - s = ni.Buffer.alloc(a.span); - a.encode({ instruction: 11 }, s); - let c = [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: n, isSigner: !1, isWritable: !1 }, - ]; - return ( - o.length === 0 - ? c.push({ pubkey: i, isSigner: !0, isWritable: !1 }) - : (c.push({ pubkey: i, isSigner: !1, isWritable: !1 }), - o.forEach((u) => - c.push({ - pubkey: u.publicKey, - isSigner: !0, - isWritable: !1, - }) - )), - new Xt.TransactionInstruction({ keys: c, programId: e, data: s }) - ); - } - static createTransferCheckedInstruction(e, r, n, i, o, a, s, c) { - let u = Cs([Li("instruction"), fm("amount"), Li("decimals")]), - h = ni.Buffer.alloc(u.span); - u.encode( - { instruction: 12, amount: new Hu(s).toBuffer(), decimals: c }, - h - ); - let w = [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: n, isSigner: !1, isWritable: !1 }, - { pubkey: i, isSigner: !1, isWritable: !0 }, - ]; - return ( - a.length === 0 - ? w.push({ pubkey: o, isSigner: !0, isWritable: !1 }) - : (w.push({ pubkey: o, isSigner: !1, isWritable: !1 }), - a.forEach((M) => - w.push({ - pubkey: M.publicKey, - isSigner: !0, - isWritable: !1, - }) - )), - new Xt.TransactionInstruction({ keys: w, programId: e, data: h }) - ); - } - static createApproveCheckedInstruction(e, r, n, i, o, a, s, c) { - let u = Cs([Li("instruction"), fm("amount"), Li("decimals")]), - h = ni.Buffer.alloc(u.span); - u.encode( - { instruction: 13, amount: new Hu(s).toBuffer(), decimals: c }, - h - ); - let w = [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: n, isSigner: !1, isWritable: !1 }, - { pubkey: i, isSigner: !1, isWritable: !1 }, - ]; - return ( - a.length === 0 - ? w.push({ pubkey: o, isSigner: !0, isWritable: !1 }) - : (w.push({ pubkey: o, isSigner: !1, isWritable: !1 }), - a.forEach((M) => - w.push({ - pubkey: M.publicKey, - isSigner: !0, - isWritable: !1, - }) - )), - new Xt.TransactionInstruction({ keys: w, programId: e, data: h }) - ); - } - static createMintToCheckedInstruction(e, r, n, i, o, a, s) { - let c = Cs([Li("instruction"), fm("amount"), Li("decimals")]), - u = ni.Buffer.alloc(c.span); - c.encode( - { instruction: 14, amount: new Hu(a).toBuffer(), decimals: s }, - u - ); - let h = [ - { pubkey: r, isSigner: !1, isWritable: !0 }, - { pubkey: n, isSigner: !1, isWritable: !0 }, - ]; - return ( - o.length === 0 - ? h.push({ pubkey: i, isSigner: !0, isWritable: !1 }) - : (h.push({ pubkey: i, isSigner: !1, isWritable: !1 }), - o.forEach((w) => - h.push({ - pubkey: w.publicKey, - isSigner: !0, - isWritable: !1, - }) - )), - new Xt.TransactionInstruction({ keys: h, programId: e, data: u }) - ); - } - static createBurnCheckedInstruction(e, r, n, i, o, a, s) { - let c = Cs([Li("instruction"), fm("amount"), Li("decimals")]), - u = ni.Buffer.alloc(c.span); - c.encode( - { instruction: 15, amount: new Hu(a).toBuffer(), decimals: s }, - u - ); - let h = [ - { pubkey: n, isSigner: !1, isWritable: !0 }, - { pubkey: r, isSigner: !1, isWritable: !0 }, - ]; - return ( - o.length === 0 - ? h.push({ pubkey: i, isSigner: !0, isWritable: !1 }) - : (h.push({ pubkey: i, isSigner: !1, isWritable: !1 }), - o.forEach((w) => - h.push({ - pubkey: w.publicKey, - isSigner: !0, - isWritable: !1, - }) - )), - new Xt.TransactionInstruction({ keys: h, programId: e, data: u }) - ); - } - static createSyncNativeInstruction(e, r) { - let n = Cs([Li("instruction")]), - i = ni.Buffer.alloc(n.span); - n.encode({ instruction: 17 }, i); - let o = [{ pubkey: r, isSigner: !1, isWritable: !0 }]; - return new Xt.TransactionInstruction({ - keys: o, - programId: e, - data: i, - }); - } - static async getAssociatedTokenAddress(e, r, n, i, o = !1) { - if (!o && !Xt.PublicKey.isOnCurve(i.toBuffer())) - throw new Error(`Owner cannot sign: ${i.toString()}`); - return ( - await Xt.PublicKey.findProgramAddress( - [i.toBuffer(), r.toBuffer(), n.toBuffer()], - e - ) - )[0]; - } - static createAssociatedTokenAccountInstruction(e, r, n, i, o, a) { - let s = ni.Buffer.alloc(0), - c = [ - { pubkey: a, isSigner: !0, isWritable: !0 }, - { pubkey: i, isSigner: !1, isWritable: !0 }, - { pubkey: o, isSigner: !1, isWritable: !1 }, - { pubkey: n, isSigner: !1, isWritable: !1 }, - { - pubkey: Xt.SystemProgram.programId, - isSigner: !1, - isWritable: !1, - }, - { pubkey: r, isSigner: !1, isWritable: !1 }, - { pubkey: Xt.SYSVAR_RENT_PUBKEY, isSigner: !1, isWritable: !1 }, - ]; - return new Xt.TransactionInstruction({ - keys: c, - programId: e, - data: s, - }); - } - }); - }); - var YTt = I((Af) => { - "use strict"; - m(); - g(); - var eWr = - (Af && Af.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - tWr = - (Af && Af.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - fOe = - (Af && Af.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - eWr(e, t, r); - return tWr(e, t), e; - }; - Object.defineProperty(Af, "__esModule", { value: !0 }); - Af.createMintNftInstruction = - Af.mintNftInstructionDiscriminator = - Af.mintNftStruct = - void 0; - var rWr = fOe((pa(), jo(ha))), - wce = fOe(qo()), - _ce = fOe(Le()); - Af.mintNftStruct = new wce.BeetArgsStruct( - [ - ["instructionDiscriminator", wce.uniformFixedSizeArray(wce.u8, 8)], - ["creatorBump", wce.u8], - ], - "MintNftInstructionArgs" - ); - Af.mintNftInstructionDiscriminator = [211, 57, 6, 167, 15, 219, 35, 251]; - function nWr( - t, - e, - r = new _ce.PublicKey("cndy3Z4yapfJBmL3ShUp5exZKqR3z33thTzeNMm2gRZ") - ) { - var n, i, o; - let [a] = Af.mintNftStruct.serialize({ - instructionDiscriminator: Af.mintNftInstructionDiscriminator, - ...e, - }), - s = [ - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.candyMachineCreator, isWritable: !1, isSigner: !1 }, - { pubkey: t.payer, isWritable: !1, isSigner: !0 }, - { pubkey: t.wallet, isWritable: !0, isSigner: !1 }, - { pubkey: t.metadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.mint, isWritable: !0, isSigner: !1 }, - { pubkey: t.mintAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.updateAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.masterEdition, isWritable: !0, isSigner: !1 }, - { pubkey: t.tokenMetadataProgram, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : rWr.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : _ce.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (o = t.rent) !== null && o !== void 0 - ? o - : _ce.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.clock, isWritable: !1, isSigner: !1 }, - { pubkey: t.recentBlockhashes, isWritable: !1, isSigner: !1 }, - { pubkey: t.instructionSysvarAccount, isWritable: !1, isSigner: !1 }, - ]; - return new _ce.TransactionInstruction({ programId: r, keys: s, data: a }); - } - Af.createMintNftInstruction = nWr; - }); - var t6t = I((Ef) => { - "use strict"; - m(); - g(); - var iWr = - (Ef && Ef.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - oWr = - (Ef && Ef.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - e6t = - (Ef && Ef.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - iWr(e, t, r); - return oWr(e, t), e; - }; - Object.defineProperty(Ef, "__esModule", { value: !0 }); - Ef.createRemoveCollectionInstruction = - Ef.removeCollectionInstructionDiscriminator = - Ef.removeCollectionStruct = - void 0; - var dOe = e6t(qo()), - QTt = e6t(Le()); - Ef.removeCollectionStruct = new dOe.BeetArgsStruct( - [["instructionDiscriminator", dOe.uniformFixedSizeArray(dOe.u8, 8)]], - "RemoveCollectionInstructionArgs" - ); - Ef.removeCollectionInstructionDiscriminator = [ - 223, 52, 106, 217, 61, 220, 36, 160, - ]; - function aWr( - t, - e = new QTt.PublicKey("cndy3Z4yapfJBmL3ShUp5exZKqR3z33thTzeNMm2gRZ") - ) { - let [r] = Ef.removeCollectionStruct.serialize({ - instructionDiscriminator: Ef.removeCollectionInstructionDiscriminator, - }), - n = [ - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !0 }, - { pubkey: t.collectionPda, isWritable: !0, isSigner: !1 }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.mint, isWritable: !1, isSigner: !1 }, - { pubkey: t.collectionAuthorityRecord, isWritable: !0, isSigner: !1 }, - { pubkey: t.tokenMetadataProgram, isWritable: !1, isSigner: !1 }, - ]; - return new QTt.TransactionInstruction({ programId: e, keys: n, data: r }); - } - Ef.createRemoveCollectionInstruction = aWr; - }); - var i6t = I((Mf) => { - "use strict"; - m(); - g(); - var sWr = - (Mf && Mf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - uWr = - (Mf && Mf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - n6t = - (Mf && Mf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - sWr(e, t, r); - return uWr(e, t), e; - }; - Object.defineProperty(Mf, "__esModule", { value: !0 }); - Mf.createRemoveFreezeInstruction = - Mf.removeFreezeInstructionDiscriminator = - Mf.removeFreezeStruct = - void 0; - var hOe = n6t(qo()), - r6t = n6t(Le()); - Mf.removeFreezeStruct = new hOe.BeetArgsStruct( - [["instructionDiscriminator", hOe.uniformFixedSizeArray(hOe.u8, 8)]], - "RemoveFreezeInstructionArgs" - ); - Mf.removeFreezeInstructionDiscriminator = [ - 1, 212, 80, 168, 129, 60, 46, 251, - ]; - function cWr( - t, - e = new r6t.PublicKey("cndy3Z4yapfJBmL3ShUp5exZKqR3z33thTzeNMm2gRZ") - ) { - let [r] = Mf.removeFreezeStruct.serialize({ - instructionDiscriminator: Mf.removeFreezeInstructionDiscriminator, - }), - n = [ - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !0, isSigner: !0 }, - { pubkey: t.freezePda, isWritable: !0, isSigner: !1 }, - ]; - return new r6t.TransactionInstruction({ programId: e, keys: n, data: r }); - } - Mf.createRemoveFreezeInstruction = cWr; - }); - var a6t = I((Tf) => { - "use strict"; - m(); - g(); - var lWr = - (Tf && Tf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - fWr = - (Tf && Tf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - o6t = - (Tf && Tf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - lWr(e, t, r); - return fWr(e, t), e; - }; - Object.defineProperty(Tf, "__esModule", { value: !0 }); - Tf.createSetCollectionInstruction = - Tf.setCollectionInstructionDiscriminator = - Tf.setCollectionStruct = - void 0; - var pOe = o6t(qo()), - xce = o6t(Le()); - Tf.setCollectionStruct = new pOe.BeetArgsStruct( - [["instructionDiscriminator", pOe.uniformFixedSizeArray(pOe.u8, 8)]], - "SetCollectionInstructionArgs" - ); - Tf.setCollectionInstructionDiscriminator = [ - 192, 254, 206, 76, 168, 182, 59, 223, - ]; - function dWr( - t, - e = new xce.PublicKey("cndy3Z4yapfJBmL3ShUp5exZKqR3z33thTzeNMm2gRZ") - ) { - var r, n; - let [i] = Tf.setCollectionStruct.serialize({ - instructionDiscriminator: Tf.setCollectionInstructionDiscriminator, - }), - o = [ - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !0 }, - { pubkey: t.collectionPda, isWritable: !0, isSigner: !1 }, - { pubkey: t.payer, isWritable: !1, isSigner: !0 }, - { - pubkey: - (r = t.systemProgram) !== null && r !== void 0 - ? r - : xce.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (n = t.rent) !== null && n !== void 0 - ? n - : xce.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.mint, isWritable: !1, isSigner: !1 }, - { pubkey: t.edition, isWritable: !1, isSigner: !1 }, - { pubkey: t.collectionAuthorityRecord, isWritable: !0, isSigner: !1 }, - { pubkey: t.tokenMetadataProgram, isWritable: !1, isSigner: !1 }, - ]; - return new xce.TransactionInstruction({ programId: e, keys: o, data: i }); - } - Tf.createSetCollectionInstruction = dWr; - }); - var c6t = I((kf) => { - "use strict"; - m(); - g(); - var hWr = - (kf && kf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - pWr = - (kf && kf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - u6t = - (kf && kf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - hWr(e, t, r); - return pWr(e, t), e; - }; - Object.defineProperty(kf, "__esModule", { value: !0 }); - kf.createSetCollectionDuringMintInstruction = - kf.setCollectionDuringMintInstructionDiscriminator = - kf.setCollectionDuringMintStruct = - void 0; - var yOe = u6t(qo()), - s6t = u6t(Le()); - kf.setCollectionDuringMintStruct = new yOe.BeetArgsStruct( - [["instructionDiscriminator", yOe.uniformFixedSizeArray(yOe.u8, 8)]], - "SetCollectionDuringMintInstructionArgs" - ); - kf.setCollectionDuringMintInstructionDiscriminator = [ - 103, 17, 200, 25, 118, 95, 125, 61, - ]; - function yWr( - t, - e = new s6t.PublicKey("cndy3Z4yapfJBmL3ShUp5exZKqR3z33thTzeNMm2gRZ") - ) { - let [r] = kf.setCollectionDuringMintStruct.serialize({ - instructionDiscriminator: - kf.setCollectionDuringMintInstructionDiscriminator, - }), - n = [ - { pubkey: t.candyMachine, isWritable: !1, isSigner: !1 }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.payer, isWritable: !1, isSigner: !0 }, - { pubkey: t.collectionPda, isWritable: !0, isSigner: !1 }, - { pubkey: t.tokenMetadataProgram, isWritable: !1, isSigner: !1 }, - { pubkey: t.instructions, isWritable: !1, isSigner: !1 }, - { pubkey: t.collectionMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.collectionMetadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.collectionMasterEdition, isWritable: !1, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !1 }, - { pubkey: t.collectionAuthorityRecord, isWritable: !1, isSigner: !1 }, - ]; - return new s6t.TransactionInstruction({ programId: e, keys: n, data: r }); - } - kf.createSetCollectionDuringMintInstruction = yWr; - }); - var f6t = I((Pf) => { - "use strict"; - m(); - g(); - var mWr = - (Pf && Pf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - gWr = - (Pf && Pf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - l6t = - (Pf && Pf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - mWr(e, t, r); - return gWr(e, t), e; - }; - Object.defineProperty(Pf, "__esModule", { value: !0 }); - Pf.createSetFreezeInstruction = - Pf.setFreezeInstructionDiscriminator = - Pf.setFreezeStruct = - void 0; - var Sce = l6t(qo()), - mOe = l6t(Le()); - Pf.setFreezeStruct = new Sce.BeetArgsStruct( - [ - ["instructionDiscriminator", Sce.uniformFixedSizeArray(Sce.u8, 8)], - ["freezeTime", Sce.i64], - ], - "SetFreezeInstructionArgs" - ); - Pf.setFreezeInstructionDiscriminator = [ - 202, 80, 109, 208, 130, 144, 26, 233, - ]; - function vWr( - t, - e, - r = new mOe.PublicKey("cndy3Z4yapfJBmL3ShUp5exZKqR3z33thTzeNMm2gRZ") - ) { - var n; - let [i] = Pf.setFreezeStruct.serialize({ - instructionDiscriminator: Pf.setFreezeInstructionDiscriminator, - ...e, - }), - o = [ - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !0, isSigner: !0 }, - { pubkey: t.freezePda, isWritable: !0, isSigner: !1 }, - { - pubkey: - (n = t.systemProgram) !== null && n !== void 0 - ? n - : mOe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - ]; - return new mOe.TransactionInstruction({ programId: r, keys: o, data: i }); - } - Pf.createSetFreezeInstruction = vWr; - }); - var d6t = I((Of) => { - "use strict"; - m(); - g(); - var bWr = - (Of && Of.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - wWr = - (Of && Of.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - bOe = - (Of && Of.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - bWr(e, t, r); - return wWr(e, t), e; - }; - Object.defineProperty(Of, "__esModule", { value: !0 }); - Of.createThawNftInstruction = - Of.thawNftInstructionDiscriminator = - Of.thawNftStruct = - void 0; - var _Wr = bOe((pa(), jo(ha))), - gOe = bOe(qo()), - vOe = bOe(Le()); - Of.thawNftStruct = new gOe.BeetArgsStruct( - [["instructionDiscriminator", gOe.uniformFixedSizeArray(gOe.u8, 8)]], - "ThawNftInstructionArgs" - ); - Of.thawNftInstructionDiscriminator = [92, 44, 210, 187, 172, 6, 64, 183]; - function xWr( - t, - e = new vOe.PublicKey("cndy3Z4yapfJBmL3ShUp5exZKqR3z33thTzeNMm2gRZ") - ) { - var r, n; - let [i] = Of.thawNftStruct.serialize({ - instructionDiscriminator: Of.thawNftInstructionDiscriminator, - }), - o = [ - { pubkey: t.freezePda, isWritable: !0, isSigner: !1 }, - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.tokenAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.owner, isWritable: !1, isSigner: !1 }, - { pubkey: t.mint, isWritable: !1, isSigner: !1 }, - { pubkey: t.edition, isWritable: !1, isSigner: !1 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { - pubkey: - (r = t.tokenProgram) !== null && r !== void 0 - ? r - : _Wr.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.tokenMetadataProgram, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.systemProgram) !== null && n !== void 0 - ? n - : vOe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - ]; - return new vOe.TransactionInstruction({ programId: e, keys: o, data: i }); - } - Of.createThawNftInstruction = xWr; - }); - var p6t = I((Bf) => { - "use strict"; - m(); - g(); - var SWr = - (Bf && Bf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - AWr = - (Bf && Bf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - h6t = - (Bf && Bf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - SWr(e, t, r); - return AWr(e, t), e; - }; - Object.defineProperty(Bf, "__esModule", { value: !0 }); - Bf.createUnlockFundsInstruction = - Bf.unlockFundsInstructionDiscriminator = - Bf.unlockFundsStruct = - void 0; - var wOe = h6t(qo()), - _Oe = h6t(Le()); - Bf.unlockFundsStruct = new wOe.BeetArgsStruct( - [["instructionDiscriminator", wOe.uniformFixedSizeArray(wOe.u8, 8)]], - "UnlockFundsInstructionArgs" - ); - Bf.unlockFundsInstructionDiscriminator = [ - 175, 119, 16, 245, 141, 55, 255, 43, - ]; - function EWr( - t, - e = new _Oe.PublicKey("cndy3Z4yapfJBmL3ShUp5exZKqR3z33thTzeNMm2gRZ") - ) { - var r; - let [n] = Bf.unlockFundsStruct.serialize({ - instructionDiscriminator: Bf.unlockFundsInstructionDiscriminator, - }), - i = [ - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.wallet, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !0, isSigner: !0 }, - { pubkey: t.freezePda, isWritable: !0, isSigner: !1 }, - { - pubkey: - (r = t.systemProgram) !== null && r !== void 0 - ? r - : _Oe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - ]; - return new _Oe.TransactionInstruction({ programId: e, keys: i, data: n }); - } - Bf.createUnlockFundsInstruction = EWr; - }); - var m6t = I((If) => { - "use strict"; - m(); - g(); - var MWr = - (If && If.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - TWr = - (If && If.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - xOe = - (If && If.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - MWr(e, t, r); - return TWr(e, t), e; - }; - Object.defineProperty(If, "__esModule", { value: !0 }); - If.createUpdateAuthorityInstruction = - If.updateAuthorityInstructionDiscriminator = - If.updateAuthorityStruct = - void 0; - var y6t = xOe(Le()), - Ace = xOe(qo()), - kWr = xOe(Fi()); - If.updateAuthorityStruct = new Ace.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", Ace.uniformFixedSizeArray(Ace.u8, 8)], - ["newAuthority", Ace.coption(kWr.publicKey)], - ], - "UpdateAuthorityInstructionArgs" - ); - If.updateAuthorityInstructionDiscriminator = [ - 32, 46, 64, 28, 149, 75, 243, 88, - ]; - function PWr( - t, - e, - r = new y6t.PublicKey("cndy3Z4yapfJBmL3ShUp5exZKqR3z33thTzeNMm2gRZ") - ) { - let [n] = If.updateAuthorityStruct.serialize({ - instructionDiscriminator: If.updateAuthorityInstructionDiscriminator, - ...e, - }), - i = [ - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !0 }, - { pubkey: t.wallet, isWritable: !1, isSigner: !1 }, - ]; - return new y6t.TransactionInstruction({ programId: r, keys: i, data: n }); - } - If.createUpdateAuthorityInstruction = PWr; - }); - var b6t = I((Cf) => { - "use strict"; - m(); - g(); - var OWr = - (Cf && Cf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - BWr = - (Cf && Cf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - v6t = - (Cf && Cf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - OWr(e, t, r); - return BWr(e, t), e; - }; - Object.defineProperty(Cf, "__esModule", { value: !0 }); - Cf.createUpdateCandyMachineInstruction = - Cf.updateCandyMachineInstructionDiscriminator = - Cf.updateCandyMachineStruct = - void 0; - var SOe = v6t(qo()), - g6t = v6t(Le()), - IWr = vV(); - Cf.updateCandyMachineStruct = new SOe.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", SOe.uniformFixedSizeArray(SOe.u8, 8)], - ["data", IWr.candyMachineDataBeet], - ], - "UpdateCandyMachineInstructionArgs" - ); - Cf.updateCandyMachineInstructionDiscriminator = [ - 243, 251, 124, 156, 211, 211, 118, 239, - ]; - function CWr( - t, - e, - r = new g6t.PublicKey("cndy3Z4yapfJBmL3ShUp5exZKqR3z33thTzeNMm2gRZ") - ) { - let [n] = Cf.updateCandyMachineStruct.serialize({ - instructionDiscriminator: - Cf.updateCandyMachineInstructionDiscriminator, - ...e, - }), - i = [ - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !0 }, - { pubkey: t.wallet, isWritable: !1, isSigner: !1 }, - ]; - return new g6t.TransactionInstruction({ programId: r, keys: i, data: n }); - } - Cf.createUpdateCandyMachineInstruction = CWr; - }); - var x6t = I((Rf) => { - "use strict"; - m(); - g(); - var RWr = - (Rf && Rf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - NWr = - (Rf && Rf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - _6t = - (Rf && Rf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - RWr(e, t, r); - return NWr(e, t), e; - }; - Object.defineProperty(Rf, "__esModule", { value: !0 }); - Rf.createWithdrawFundsInstruction = - Rf.withdrawFundsInstructionDiscriminator = - Rf.withdrawFundsStruct = - void 0; - var AOe = _6t(qo()), - w6t = _6t(Le()); - Rf.withdrawFundsStruct = new AOe.BeetArgsStruct( - [["instructionDiscriminator", AOe.uniformFixedSizeArray(AOe.u8, 8)]], - "WithdrawFundsInstructionArgs" - ); - Rf.withdrawFundsInstructionDiscriminator = [ - 241, 36, 29, 111, 208, 31, 104, 217, - ]; - function DWr( - t, - e = new w6t.PublicKey("cndy3Z4yapfJBmL3ShUp5exZKqR3z33thTzeNMm2gRZ") - ) { - let [r] = Rf.withdrawFundsStruct.serialize({ - instructionDiscriminator: Rf.withdrawFundsInstructionDiscriminator, - }), - n = [ - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !0, isSigner: !0 }, - ]; - return new w6t.TransactionInstruction({ programId: e, keys: n, data: r }); - } - Rf.createWithdrawFundsInstruction = DWr; - }); - var EOe = I((au) => { - "use strict"; - m(); - g(); - var FWr = - (au && au.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - _0 = - (au && au.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - FWr(e, t, r); - }; - Object.defineProperty(au, "__esModule", { value: !0 }); - _0(QMt(), au); - _0(gTt(), au); - _0(YTt(), au); - _0(t6t(), au); - _0(i6t(), au); - _0(a6t(), au); - _0(c6t(), au); - _0(f6t(), au); - _0(d6t(), au); - _0(p6t(), au); - _0(m6t(), au); - _0(b6t(), au); - _0(x6t(), au); - }); - var TOe = I((Ns) => { - "use strict"; - m(); - g(); - var LWr = - (Ns && Ns.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - qWr = - (Ns && Ns.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - MOe = - (Ns && Ns.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - LWr(e, t, r); - return qWr(e, t), e; - }; - Object.defineProperty(Ns, "__esModule", { value: !0 }); - Ns.candyMachineBeet = - Ns.CandyMachine = - Ns.candyMachineDiscriminator = - void 0; - var zWr = MOe(Le()), - TV = MOe(qo()), - Ece = MOe(Fi()), - jWr = vV(); - Ns.candyMachineDiscriminator = [51, 173, 177, 113, 25, 241, 109, 189]; - var G1 = class { - constructor(e, r, n, i, o) { - (this.authority = e), - (this.wallet = r), - (this.tokenMint = n), - (this.itemsRedeemed = i), - (this.data = o); - } - static fromArgs(e) { - return new G1( - e.authority, - e.wallet, - e.tokenMint, - e.itemsRedeemed, - e.data - ); - } - static fromAccountInfo(e, r = 0) { - return G1.deserialize(e.data, r); - } - static async fromAccountAddress(e, r) { - let n = await e.getAccountInfo(r); - if (n == null) - throw new Error(`Unable to find CandyMachine account at ${r}`); - return G1.fromAccountInfo(n, 0)[0]; - } - static gpaBuilder( - e = new zWr.PublicKey("cndy3Z4yapfJBmL3ShUp5exZKqR3z33thTzeNMm2gRZ") - ) { - return Ece.GpaBuilder.fromStruct(e, Ns.candyMachineBeet); - } - static deserialize(e, r = 0) { - return Ns.candyMachineBeet.deserialize(e, r); - } - serialize() { - return Ns.candyMachineBeet.serialize({ - accountDiscriminator: Ns.candyMachineDiscriminator, - ...this, - }); - } - static byteSize(e) { - let r = G1.fromArgs(e); - return Ns.candyMachineBeet.toFixedFromValue({ - accountDiscriminator: Ns.candyMachineDiscriminator, - ...r, - }).byteSize; - } - static async getMinimumBalanceForRentExemption(e, r, n) { - return r.getMinimumBalanceForRentExemption(G1.byteSize(e), n); - } - pretty() { - return { - authority: this.authority.toBase58(), - wallet: this.wallet.toBase58(), - tokenMint: this.tokenMint, - itemsRedeemed: (() => { - let e = this.itemsRedeemed; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - data: this.data, - }; - } - }; - Ns.CandyMachine = G1; - Ns.candyMachineBeet = new TV.FixableBeetStruct( - [ - ["accountDiscriminator", TV.uniformFixedSizeArray(TV.u8, 8)], - ["authority", Ece.publicKey], - ["wallet", Ece.publicKey], - ["tokenMint", TV.coption(Ece.publicKey)], - ["itemsRedeemed", TV.u64], - ["data", jWr.candyMachineDataBeet], - ], - G1.fromArgs, - "CandyMachine" - ); - }); - var BOe = I((su) => { - "use strict"; - m(); - g(); - var UWr = - (su && su.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - KWr = - (su && su.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - OOe = - (su && su.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - UWr(e, t, r); - return KWr(e, t), e; - }; - Object.defineProperty(su, "__esModule", { value: !0 }); - su.collectionPDABeet = - su.CollectionPDA = - su.collectionPDADiscriminator = - void 0; - var HWr = OOe(Le()), - POe = OOe(Fi()), - kOe = OOe(qo()); - su.collectionPDADiscriminator = [203, 128, 119, 125, 234, 89, 232, 157]; - var J1 = class { - constructor(e, r) { - (this.mint = e), (this.candyMachine = r); - } - static fromArgs(e) { - return new J1(e.mint, e.candyMachine); - } - static fromAccountInfo(e, r = 0) { - return J1.deserialize(e.data, r); - } - static async fromAccountAddress(e, r) { - let n = await e.getAccountInfo(r); - if (n == null) - throw new Error(`Unable to find CollectionPDA account at ${r}`); - return J1.fromAccountInfo(n, 0)[0]; - } - static gpaBuilder( - e = new HWr.PublicKey("cndy3Z4yapfJBmL3ShUp5exZKqR3z33thTzeNMm2gRZ") - ) { - return POe.GpaBuilder.fromStruct(e, su.collectionPDABeet); - } - static deserialize(e, r = 0) { - return su.collectionPDABeet.deserialize(e, r); - } - serialize() { - return su.collectionPDABeet.serialize({ - accountDiscriminator: su.collectionPDADiscriminator, - ...this, - }); - } - static get byteSize() { - return su.collectionPDABeet.byteSize; - } - static async getMinimumBalanceForRentExemption(e, r) { - return e.getMinimumBalanceForRentExemption(J1.byteSize, r); - } - static hasCorrectByteSize(e, r = 0) { - return e.byteLength - r === J1.byteSize; - } - pretty() { - return { - mint: this.mint.toBase58(), - candyMachine: this.candyMachine.toBase58(), - }; - } - }; - su.CollectionPDA = J1; - su.collectionPDABeet = new kOe.BeetStruct( - [ - ["accountDiscriminator", kOe.uniformFixedSizeArray(kOe.u8, 8)], - ["mint", POe.publicKey], - ["candyMachine", POe.publicKey], - ], - J1.fromArgs, - "CollectionPDA" - ); - }); - var COe = I((Ds) => { - "use strict"; - m(); - g(); - var VWr = - (Ds && Ds.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - WWr = - (Ds && Ds.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - IOe = - (Ds && Ds.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - VWr(e, t, r); - return WWr(e, t), e; - }; - Object.defineProperty(Ds, "__esModule", { value: !0 }); - Ds.freezePDABeet = Ds.FreezePDA = Ds.freezePDADiscriminator = void 0; - var GWr = IOe(Le()), - Zx = IOe(qo()), - S6t = IOe(Fi()); - Ds.freezePDADiscriminator = [154, 58, 148, 24, 101, 200, 243, 127]; - var $1 = class { - constructor(e, r, n, i, o, a) { - (this.candyMachine = e), - (this.allowThaw = r), - (this.frozenCount = n), - (this.mintStart = i), - (this.freezeTime = o), - (this.freezeFee = a); - } - static fromArgs(e) { - return new $1( - e.candyMachine, - e.allowThaw, - e.frozenCount, - e.mintStart, - e.freezeTime, - e.freezeFee - ); - } - static fromAccountInfo(e, r = 0) { - return $1.deserialize(e.data, r); - } - static async fromAccountAddress(e, r) { - let n = await e.getAccountInfo(r); - if (n == null) - throw new Error(`Unable to find FreezePDA account at ${r}`); - return $1.fromAccountInfo(n, 0)[0]; - } - static gpaBuilder( - e = new GWr.PublicKey("cndy3Z4yapfJBmL3ShUp5exZKqR3z33thTzeNMm2gRZ") - ) { - return S6t.GpaBuilder.fromStruct(e, Ds.freezePDABeet); - } - static deserialize(e, r = 0) { - return Ds.freezePDABeet.deserialize(e, r); - } - serialize() { - return Ds.freezePDABeet.serialize({ - accountDiscriminator: Ds.freezePDADiscriminator, - ...this, - }); - } - static byteSize(e) { - let r = $1.fromArgs(e); - return Ds.freezePDABeet.toFixedFromValue({ - accountDiscriminator: Ds.freezePDADiscriminator, - ...r, - }).byteSize; - } - static async getMinimumBalanceForRentExemption(e, r, n) { - return r.getMinimumBalanceForRentExemption($1.byteSize(e), n); - } - pretty() { - return { - candyMachine: this.candyMachine.toBase58(), - allowThaw: this.allowThaw, - frozenCount: (() => { - let e = this.frozenCount; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - mintStart: this.mintStart, - freezeTime: (() => { - let e = this.freezeTime; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - freezeFee: (() => { - let e = this.freezeFee; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - }; - } - }; - Ds.FreezePDA = $1; - Ds.freezePDABeet = new Zx.FixableBeetStruct( - [ - ["accountDiscriminator", Zx.uniformFixedSizeArray(Zx.u8, 8)], - ["candyMachine", S6t.publicKey], - ["allowThaw", Zx.bool], - ["frozenCount", Zx.u64], - ["mintStart", Zx.coption(Zx.i64)], - ["freezeTime", Zx.i64], - ["freezeFee", Zx.u64], - ], - $1.fromArgs, - "FreezePDA" - ); - }); - var NOe = I((Rg) => { - "use strict"; - m(); - g(); - var JWr = - (Rg && Rg.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - ROe = - (Rg && Rg.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - JWr(e, t, r); - }; - Object.defineProperty(Rg, "__esModule", { value: !0 }); - Rg.accountProviders = void 0; - ROe(TOe(), Rg); - ROe(BOe(), Rg); - ROe(COe(), Rg); - var $Wr = TOe(), - ZWr = BOe(), - XWr = COe(); - Rg.accountProviders = { - CandyMachine: $Wr.CandyMachine, - CollectionPDA: ZWr.CollectionPDA, - FreezePDA: XWr.FreezePDA, - }; - }); - var A6t = I((nh) => { - "use strict"; - m(); - g(); - var YWr = - (nh && nh.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Xx = - (nh && nh.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - YWr(e, t, r); - }; - Object.defineProperty(nh, "__esModule", { value: !0 }); - Xx(vV(), nh); - Xx(D4e(), nh); - Xx(K4e(), nh); - Xx(F4e(), nh); - Xx(L4e(), nh); - Xx(G4e(), nh); - Xx(H4e(), nh); - Xx(V4e(), nh); - Xx(W4e(), nh); - }); - var Tce = I((ih) => { - "use strict"; - m(); - g(); - var QWr = - (ih && ih.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Mce = - (ih && ih.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - QWr(e, t, r); - }; - Object.defineProperty(ih, "__esModule", { value: !0 }); - ih.PROGRAM_ID = ih.PROGRAM_ADDRESS = void 0; - var eGr = Le(); - Mce(NOe(), ih); - Mce(m4e(), ih); - Mce(EOe(), ih); - Mce(A6t(), ih); - ih.PROGRAM_ADDRESS = "cndy3Z4yapfJBmL3ShUp5exZKqR3z33thTzeNMm2gRZ"; - ih.PROGRAM_ID = new eGr.PublicKey(ih.PROGRAM_ADDRESS); - }); - var E6t = I((X1) => { - "use strict"; - m(); - g(); - var tGr = - (X1 && X1.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - rGr = - (X1 && X1.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - DOe = - (X1 && X1.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - tGr(e, t, r); - return rGr(e, t), e; - }; - Object.defineProperty(X1, "__esModule", { value: !0 }); - X1.CandyMachineProgram = void 0; - var nGr = IMt(), - iGr = DOe(m4e()), - oGr = DOe(EOe()), - aGr = DOe(NOe()), - sGr = Tce(), - Z1 = class extends nGr.Program {}; - X1.CandyMachineProgram = Z1; - Z1.PREFIX = "metaplex"; - Z1.CONFIG = "config"; - Z1.TOTALS = "totals"; - Z1.PUBKEY = sGr.PROGRAM_ID; - Z1.instructions = oGr; - Z1.errors = iGr; - Z1.accounts = aGr; - }); - var M6t = I((kce) => { - "use strict"; - m(); - g(); - Object.defineProperty(kce, "__esModule", { value: !0 }); - kce.cusper = void 0; - var uGr = JN(), - cGr = Tce(); - kce.cusper = (0, uGr.initCusper)(cGr.errorFromCode); - }); - var hm = I((Yx) => { - "use strict"; - m(); - g(); - var lGr = - (Yx && Yx.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - FOe = - (Yx && Yx.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - lGr(e, t, r); - }; - Object.defineProperty(Yx, "__esModule", { value: !0 }); - FOe(E6t(), Yx); - FOe(M6t(), Yx); - FOe(Tce(), Yx); - }); - var pm = I((Nf) => { - "use strict"; - m(); - g(); - Object.defineProperty(Nf, "__esModule", { value: !0 }); - Nf.isElementCollectionFixedSizeBeet = - Nf.isFixableBeet = - Nf.assertFixedSizeBeet = - Nf.isFixedSizeBeet = - Nf.BEET_TYPE_ARG_INNER = - Nf.BEET_TYPE_ARG_LEN = - Nf.BEET_PACKAGE = - void 0; - var kGr = Dr(); - Nf.BEET_PACKAGE = "@metaplex-foundation/beet"; - Nf.BEET_TYPE_ARG_LEN = "len"; - Nf.BEET_TYPE_ARG_INNER = "Beet<{innner}>"; - function n8t(t) { - return Object.keys(t).includes("byteSize"); - } - Nf.isFixedSizeBeet = n8t; - function PGr(t, e = `${t} should have been a fixed beet`) { - (0, kGr.strict)(n8t(t), e); - } - Nf.assertFixedSizeBeet = PGr; - function OGr(t) { - return ( - typeof t.toFixedFromData == "function" && - typeof t.toFixedFromValue == "function" - ); - } - Nf.isFixableBeet = OGr; - function BGr(t) { - let e = Object.keys(t); - return ( - e.includes("length") && - e.includes("elementByteSize") && - e.includes("lenPrefixByteSize") - ); - } - Nf.isElementCollectionFixedSizeBeet = BGr; - }); - var rD = I((Hn) => { - "use strict"; - m(); - g(); - var IGr = - (Hn && Hn.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Hn, "__esModule", { value: !0 }); - Hn.numbersTypeMap = - Hn.bool = - Hn.i512 = - Hn.i256 = - Hn.i128 = - Hn.i64 = - Hn.i32 = - Hn.i16 = - Hn.i8 = - Hn.u512 = - Hn.u256 = - Hn.u128 = - Hn.u64 = - Hn.u32 = - Hn.u16 = - Hn.u8 = - void 0; - var tD = IGr(Ho()), - Ma = pm(); - Hn.u8 = { - write: function (t, e, r) { - t.writeUInt8(r, e); - }, - read: function (t, e) { - return t.readUInt8(e); - }, - byteSize: 1, - description: "u8", - }; - Hn.u16 = { - write: function (t, e, r) { - t.writeUInt16LE(r, e); - }, - read: function (t, e) { - return t.readUInt16LE(e); - }, - byteSize: 2, - description: "u16", - }; - Hn.u32 = { - write: function (t, e, r) { - t.writeUInt32LE(r, e); - }, - read: function (t, e) { - return t.readUInt32LE(e); - }, - byteSize: 4, - description: "u32", - }; - function Yce(t, e) { - return { - write: function (r, n, i) { - let a = (tD.default.isBN(i) ? i : new tD.default(i)).toArray( - "le", - this.byteSize - ); - Buffer.from(a).copy(r, n, 0, this.byteSize); - }, - read: function (r, n) { - let i = r.slice(n, n + this.byteSize); - return new tD.default(i, "le"); - }, - byteSize: t, - description: e, - }; - } - Hn.u64 = Yce(8, "u64"); - Hn.u128 = Yce(16, "u128"); - Hn.u256 = Yce(32, "u256"); - Hn.u512 = Yce(64, "u512"); - Hn.i8 = { - write: function (t, e, r) { - t.writeInt8(r, e); - }, - read: function (t, e) { - return t.readInt8(e); - }, - byteSize: 1, - description: "i8", - }; - Hn.i16 = { - write: function (t, e, r) { - t.writeInt16LE(r, e); - }, - read: function (t, e) { - return t.readInt16LE(e); - }, - byteSize: 2, - description: "i16", - }; - Hn.i32 = { - write: function (t, e, r) { - t.writeInt32LE(r, e); - }, - read: function (t, e) { - return t.readInt32LE(e); - }, - byteSize: 4, - description: "i32", - }; - function Qce(t, e) { - let r = t * 8; - return { - write: function (n, i, o) { - let s = (tD.default.isBN(o) ? o : new tD.default(o)) - .toTwos(r) - .toArray("le", this.byteSize); - Buffer.from(s).copy(n, i, 0, this.byteSize); - }, - read: function (n, i) { - let o = n.slice(i, i + this.byteSize); - return new tD.default(o, "le").fromTwos(r); - }, - byteSize: t, - description: e, - }; - } - Hn.i64 = Qce(8, "i64"); - Hn.i128 = Qce(16, "i128"); - Hn.i256 = Qce(32, "i256"); - Hn.i512 = Qce(64, "i512"); - Hn.bool = { - write: function (t, e, r) { - let n = r ? 1 : 0; - Hn.u8.write(t, e, n); - }, - read: function (t, e) { - return Hn.u8.read(t, e) === 1; - }, - byteSize: 1, - description: "bool", - }; - Hn.numbersTypeMap = { - u8: { - beet: "u8", - isFixable: !1, - sourcePack: Ma.BEET_PACKAGE, - ts: "number", - }, - u16: { - beet: "u16", - isFixable: !1, - sourcePack: Ma.BEET_PACKAGE, - ts: "number", - }, - u32: { - beet: "u32", - isFixable: !1, - sourcePack: Ma.BEET_PACKAGE, - ts: "number", - }, - i8: { - beet: "i8", - isFixable: !1, - sourcePack: Ma.BEET_PACKAGE, - ts: "number", - }, - i16: { - beet: "i16", - isFixable: !1, - sourcePack: Ma.BEET_PACKAGE, - ts: "number", - }, - i32: { - beet: "i32", - isFixable: !1, - sourcePack: Ma.BEET_PACKAGE, - ts: "number", - }, - bool: { - beet: "bool", - isFixable: !1, - sourcePack: Ma.BEET_PACKAGE, - ts: "boolean", - }, - u64: { - beet: "u64", - isFixable: !1, - sourcePack: Ma.BEET_PACKAGE, - ts: "bignum", - pack: Ma.BEET_PACKAGE, - }, - u128: { - beet: "u128", - isFixable: !1, - sourcePack: Ma.BEET_PACKAGE, - ts: "bignum", - pack: Ma.BEET_PACKAGE, - }, - u256: { - beet: "u256", - isFixable: !1, - sourcePack: Ma.BEET_PACKAGE, - ts: "bignum", - pack: Ma.BEET_PACKAGE, - }, - u512: { - beet: "u512", - isFixable: !1, - sourcePack: Ma.BEET_PACKAGE, - ts: "bignum", - pack: Ma.BEET_PACKAGE, - }, - i64: { - beet: "i64", - isFixable: !1, - sourcePack: Ma.BEET_PACKAGE, - ts: "bignum", - pack: Ma.BEET_PACKAGE, - }, - i128: { - beet: "i128", - isFixable: !1, - sourcePack: Ma.BEET_PACKAGE, - ts: "bignum", - pack: Ma.BEET_PACKAGE, - }, - i256: { - beet: "i256", - isFixable: !1, - sourcePack: Ma.BEET_PACKAGE, - ts: "bignum", - pack: Ma.BEET_PACKAGE, - }, - i512: { - beet: "i512", - isFixable: !1, - sourcePack: Ma.BEET_PACKAGE, - ts: "bignum", - pack: Ma.BEET_PACKAGE, - }, - }; - }); - var nD = I((Df) => { - "use strict"; - m(); - g(); - var o8t = - (Df && Df.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Df, "__esModule", { value: !0 }); - Df.bytes = - Df.beetBytes = - Df.logTrace = - Df.logDebug = - Df.logInfo = - Df.logError = - void 0; - var ele = o8t(Nx()), - CGr = o8t(Mg()), - i8t = pm(), - { brightBlack: a8t } = CGr.default; - Df.logError = (0, ele.default)("beet:error"); - Df.logInfo = (0, ele.default)("beet:info"); - Df.logDebug = (0, ele.default)("beet:debug"); - Df.logTrace = (0, ele.default)("beet:trace"); - function RGr(t, e = !1) { - let r; - if ((0, i8t.isFixableBeet)(t)) r = "? B"; - else if ((0, i8t.isElementCollectionFixedSizeBeet)(t)) { - let n = e ? "length" : t.length, - i = t.lenPrefixByteSize; - r = - i > 0 - ? `${i} + (${t.elementByteSize} * ${n}) B (${t.byteSize} B)` - : `(${t.elementByteSize} * ${n}) B (${t.byteSize} B)`; - } else r = `${t.byteSize} B`; - return a8t(r); - } - Df.beetBytes = RGr; - function NGr(t) { - return a8t(`${t} B`); - } - Df.bytes = NGr; - }); - var OV = I((iD) => { - "use strict"; - m(); - g(); - Object.defineProperty(iD, "__esModule", { value: !0 }); - iD.fixBeetFromValue = iD.fixBeetFromData = void 0; - var tle = pm(); - function DGr(t, e, r) { - if ((0, tle.isFixedSizeBeet)(t)) return t; - if ((0, tle.isFixableBeet)(t)) return t.toFixedFromData(e, r); - throw new Error(`${t.description} is neither fixed size nor fixable`); - } - iD.fixBeetFromData = DGr; - function FGr(t, e) { - if ((0, tle.isFixedSizeBeet)(t)) return t; - if ((0, tle.isFixableBeet)(t)) return t.toFixedFromValue(e); - throw new Error(`${t.description} is neither fixed size nor fixable`); - } - iD.fixBeetFromValue = FGr; - }); - var rle = I((Ff) => { - "use strict"; - m(); - g(); - Object.defineProperty(Ff, "__esModule", { value: !0 }); - Ff.collectionsTypeMap = - Ff.uint8Array = - Ff.fixedSizeUint8Array = - Ff.fixedSizeBuffer = - Ff.array = - Ff.fixedSizeArray = - Ff.uniformFixedSizeArray = - void 0; - var oD = pm(), - E4 = Dr(), - t3 = rD(), - aD = pm(), - u8t = nD(), - s8t = OV(); - function LGr(t, e, r = !1) { - let n = t.byteSize * e, - i = r ? 4 + n : n; - return { - write: function (o, a, s) { - E4.strict.equal( - s.length, - e, - `array length ${s.length} should match len ${e}` - ), - r && (t3.u32.write(o, a, e), (a += 4)); - for (let c = 0; c < e; c++) t.write(o, a + c * t.byteSize, s[c]); - }, - read: function (o, a) { - if (r) { - let c = t3.u32.read(o, a); - E4.strict.equal(c, e, "invalid byte size"), (a += 4); - } - let s = new Array(e); - for (let c = 0; c < e; c++) s[c] = t.read(o, a + c * t.byteSize); - return s; - }, - byteSize: i, - length: e, - elementByteSize: t.byteSize, - lenPrefixByteSize: 4, - description: `Array<${t.description}>(${e})`, - }; - } - Ff.uniformFixedSizeArray = LGr; - function $Oe(t, e) { - let r = t.length, - n = r === 0 ? "" : t[0].description; - return { - write: function (i, o, a) { - E4.strict.equal( - a.length, - r, - `array length ${a.length} should match len ${r}` - ), - t3.u32.write(i, o, r); - let s = o + 4; - for (let c = 0; c < r; c++) { - let u = t[c]; - u.write(i, s, a[c]), (s += u.byteSize); - } - }, - read: function (i, o) { - let a = t3.u32.read(i, o); - E4.strict.equal(a, r, "invalid byte size"); - let s = o + 4, - c = new Array(r); - for (let u = 0; u < r; u++) { - let h = t[u]; - (c[u] = h.read(i, s)), (s += h.byteSize); - } - return c; - }, - byteSize: 4 + e, - length: r, - description: `Array<${n}>(${r})[ 4 + ${e} ]`, - }; - } - Ff.fixedSizeArray = $Oe; - function qGr(t) { - return { - toFixedFromData(e, r) { - let n = t3.u32.read(e, r); - (0, u8t.logTrace)(`${this.description}[${n}]`); - let i = r + 4, - o = i, - a = new Array(n); - for (let s = 0; s < n; s++) { - let c = (0, s8t.fixBeetFromData)(t, e, o); - (a[s] = c), (o += c.byteSize); - } - return $Oe(a, o - i); - }, - toFixedFromValue(e) { - (0, E4.strict)(Array.isArray(e), `${e} should be an array`); - let r = 0, - n = new Array(e.length); - for (let i = 0; i < e.length; i++) { - let o = (0, s8t.fixBeetFromValue)(t, e[i]); - (n[i] = o), (r += o.byteSize); - } - return $Oe(n, r); - }, - description: "array", - }; - } - Ff.array = qGr; - function c8t(t) { - return { - write: function (e, r, n) { - n.copy(e, r, 0, t); - }, - read: function (e, r) { - return e.slice(r, r + t); - }, - byteSize: t, - description: `Buffer(${t})`, - }; - } - Ff.fixedSizeBuffer = c8t; - function ZOe(t, e = !1) { - let r = c8t(t), - n = e ? t + 4 : t; - return { - write: function (i, o, a) { - E4.strict.equal( - a.byteLength, - t, - `Uint8Array length ${a.byteLength} should match len ${t}` - ), - e && (t3.u32.write(i, o, t), (o += 4)); - let s = Buffer.from(a); - r.write(i, o, s); - }, - read: function (i, o) { - if (e) { - let s = t3.u32.read(i, o); - E4.strict.equal(s, t, "invalid byte size"), (o += 4); - } - let a = r.read(i, o); - return Uint8Array.from(a); - }, - byteSize: n, - description: `Uint8Array(${t})`, - }; - } - Ff.fixedSizeUint8Array = ZOe; - Ff.uint8Array = { - toFixedFromData(t, e) { - let r = t3.u32.read(t, e); - return (0, u8t.logTrace)(`${this.description}[${r}]`), ZOe(r, !0); - }, - toFixedFromValue(t) { - let e = t.byteLength; - return ZOe(e, !0); - }, - description: "Uint8Array", - }; - Ff.collectionsTypeMap = { - Array: { - beet: "array", - isFixable: !0, - sourcePack: aD.BEET_PACKAGE, - ts: "Array", - arg: oD.BEET_TYPE_ARG_LEN, - }, - FixedSizeArray: { - beet: "fixedSizeArray", - isFixable: !1, - sourcePack: aD.BEET_PACKAGE, - ts: "Array", - arg: oD.BEET_TYPE_ARG_LEN, - }, - UniformFixedSizeArray: { - beet: "uniformFixedSizeArray", - isFixable: !1, - sourcePack: aD.BEET_PACKAGE, - ts: "Array", - arg: oD.BEET_TYPE_ARG_LEN, - }, - Buffer: { - beet: "fixedSizeBuffer", - isFixable: !1, - sourcePack: aD.BEET_PACKAGE, - ts: "Buffer", - arg: oD.BEET_TYPE_ARG_LEN, - }, - FixedSizeUint8Array: { - beet: "fixedSizeUint8Array", - isFixable: !1, - sourcePack: aD.BEET_PACKAGE, - ts: "Uint8Array", - arg: oD.BEET_TYPE_ARG_LEN, - }, - Uint8Array: { - beet: "uint8Array", - isFixable: !0, - sourcePack: aD.BEET_PACKAGE, - ts: "Uint8Array", - arg: oD.BEET_TYPE_ARG_LEN, - }, - }; - }); - var rBe = I((xp) => { - "use strict"; - m(); - g(); - Object.defineProperty(xp, "__esModule", { value: !0 }); - xp.compositesTypeMap = - xp.coption = - xp.coptionSome = - xp.coptionNone = - xp.isNoneBuffer = - xp.isSomeBuffer = - void 0; - var BV = Dr(), - XOe = pm(), - l8t = pm(), - d8t = nD(), - f8t = OV(), - h8t = 0, - p8t = 1; - function eBe(t, e) { - return t[e] === p8t; - } - xp.isSomeBuffer = eBe; - function tBe(t, e) { - return t[e] === h8t; - } - xp.isNoneBuffer = tBe; - function YOe(t) { - return ( - (0, d8t.logTrace)(`coptionNone(${t})`), - { - write: function (e, r, n) { - (0, BV.strict)( - n == null, - "coptionNone can only handle `null` values" - ), - (e[r] = h8t); - }, - read: function (e, r) { - return ( - (0, BV.strict)( - tBe(e, r), - "coptionNone can only handle `NONE` data" - ), - null - ); - }, - byteSize: 1, - description: `COption`, - } - ); - } - xp.coptionNone = YOe; - function QOe(t) { - let e = 1 + t.byteSize, - r = { - write: function (n, i, o) { - (0, XOe.assertFixedSizeBeet)( - t, - `coption inner type ${t.description} needs to be fixed before calling write` - ), - (0, BV.strict)( - o != null, - "coptionSome cannot handle `null` values" - ), - (n[i] = p8t), - t.write(n, i + 1, o); - }, - read: function (n, i) { - return ( - (0, XOe.assertFixedSizeBeet)( - t, - `coption inner type ${t.description} needs to be fixed before calling read` - ), - (0, BV.strict)( - eBe(n, i), - "coptionSome can only handle `SOME` data" - ), - t.read(n, i + 1) - ); - }, - description: `COption<${t.description}>[1 + ${t.byteSize}]`, - byteSize: e, - inner: t, - }; - return (0, d8t.logTrace)(r.description), r; - } - xp.coptionSome = QOe; - function zGr(t) { - return { - toFixedFromData(e, r) { - if (eBe(e, r)) { - let n = (0, f8t.fixBeetFromData)(t, e, r + 1); - return QOe(n); - } else - return ( - (0, BV.strict)(tBe(e, r), `Expected ${e} to hold a COption`), - YOe(t.description) - ); - }, - toFixedFromValue(e) { - return e == null - ? YOe(t.description) - : QOe((0, f8t.fixBeetFromValue)(t, e)); - }, - description: `COption<${t.description}>`, - }; - } - xp.coption = zGr; - xp.compositesTypeMap = { - option: { - beet: "coption", - isFixable: !0, - sourcePack: l8t.BEET_PACKAGE, - ts: "COption", - arg: XOe.BEET_TYPE_ARG_INNER, - pack: l8t.BEET_PACKAGE, - }, - }; - }); - var oBe = I((Y1) => { - "use strict"; - m(); - g(); - Object.defineProperty(Y1, "__esModule", { value: !0 }); - Y1.stringTypeMap = Y1.utf8String = Y1.fixedSizeUtf8String = void 0; - var nBe = pm(), - y8t = Dr(), - iBe = rD(), - jGr = nD(), - UGr = (t) => ({ - write: function (e, r, n) { - let i = Buffer.from(n, "utf8"); - y8t.strict.equal(i.byteLength, t, `${n} has invalid byte size`), - iBe.u32.write(e, r, t), - i.copy(e, r + 4, 0, t); - }, - read: function (e, r) { - let n = iBe.u32.read(e, r); - return ( - y8t.strict.equal(n, t, "invalid byte size"), - e.slice(r + 4, r + 4 + t).toString("utf8") - ); - }, - elementByteSize: 1, - length: t, - lenPrefixByteSize: 4, - byteSize: 4 + t, - description: `Utf8String(4 + ${t})`, - }); - Y1.fixedSizeUtf8String = UGr; - Y1.utf8String = { - toFixedFromData(t, e) { - let r = iBe.u32.read(t, e); - return ( - (0, jGr.logTrace)(`${this.description}[${r}]`), - (0, Y1.fixedSizeUtf8String)(r) - ); - }, - toFixedFromValue(t) { - let e = Buffer.from(t).byteLength; - return (0, Y1.fixedSizeUtf8String)(e); - }, - description: "Utf8String", - }; - Y1.stringTypeMap = { - fixedSizeString: { - beet: "fixedSizeUtf8String", - isFixable: !1, - sourcePack: nBe.BEET_PACKAGE, - ts: "string", - arg: nBe.BEET_TYPE_ARG_LEN, - }, - string: { - beet: "utf8String", - isFixable: !0, - sourcePack: nBe.BEET_PACKAGE, - ts: "string", - }, - }; - }); - var uBe = I((sD) => { - "use strict"; - m(); - g(); - Object.defineProperty(sD, "__esModule", { value: !0 }); - sD.BeetReader = sD.BeetWriter = void 0; - var KGr = Dr(), - aBe = class { - constructor(e) { - (this.buf = Buffer.alloc(e)), (this._offset = 0); - } - get buffer() { - return this.buf; - } - get offset() { - return this._offset; - } - maybeResize(e) { - this._offset + e > this.buf.length && - KGr.strict.fail( - `We shouldn't ever need to resize, but ${this._offset + e} > ${ - this.buf.length - }` - ); - } - write(e, r) { - this.maybeResize(e.byteSize), - e.write(this.buf, this._offset, r), - (this._offset += e.byteSize); - } - writeStruct(e, r) { - for (let [n, i] of r) { - let o = e[n]; - this.write(i, o); - } - } - }; - sD.BeetWriter = aBe; - var sBe = class { - constructor(e, r = 0) { - (this.buffer = e), (this._offset = r); - } - get offset() { - return this._offset; - } - read(e) { - let r = e.read(this.buffer, this._offset); - return (this._offset += e.byteSize), r; - } - readStruct(e) { - let r = {}; - for (let [n, i] of e) r[n] = this.read(i); - return r; - } - }; - sD.BeetReader = sBe; - }); - var nle = I((r3) => { - "use strict"; - m(); - g(); - Object.defineProperty(r3, "__esModule", { value: !0 }); - r3.BeetArgsStruct = r3.isBeetStruct = r3.BeetStruct = void 0; - var m8t = uBe(), - rS = nD(), - Q1 = class { - constructor(e, r, n = Q1.description) { - if ( - ((this.fields = e), - (this.construct = r), - (this.description = n), - (this.byteSize = this.getByteSize()), - rS.logDebug.enabled) - ) { - let i = e.map( - ([o, a]) => - `${String(o)}: ${a.description} ${(0, rS.beetBytes)(a)}` - ).join(` - `); - (0, rS.logDebug)(`struct ${n} { - ${i} -} ${(0, rS.beetBytes)(this)}`); - } - } - read(e, r) { - let [n] = this.deserialize(e, r); - return n; - } - write(e, r, n) { - let [i, o] = this.serialize(n); - i.copy(e, r, 0, o); - } - deserialize(e, r = 0) { - rS.logTrace.enabled && - ((0, rS.logTrace)( - "deserializing [%s] from %d bytes buffer", - this.description, - e.byteLength - ), - (0, rS.logTrace)(e), - (0, rS.logTrace)(e.toJSON().data)); - let n = new m8t.BeetReader(e, r), - i = n.readStruct(this.fields); - return [this.construct(i), n.offset]; - } - serialize(e, r = this.byteSize) { - (0, rS.logTrace)( - "serializing [%s] %o to %d bytes buffer", - this.description, - e, - r - ); - let n = new m8t.BeetWriter(r); - return n.writeStruct(e, this.fields), [n.buffer, n.offset]; - } - getByteSize() { - return this.fields.reduce((e, [r, n]) => e + n.byteSize, 0); - } - get type() { - return Q1.TYPE; - } - }; - r3.BeetStruct = Q1; - Q1.description = "BeetStruct"; - Q1.TYPE = "BeetStruct"; - function HGr(t) { - return t.type === Q1.TYPE; - } - r3.isBeetStruct = HGr; - var uD = class extends Q1 { - constructor(e, r = uD.description) { - super(e, (n) => n, r); - } - }; - r3.BeetArgsStruct = uD; - uD.description = "BeetArgsStruct"; - }); - var lBe = I((ew) => { - "use strict"; - m(); - g(); - var VGr = - (ew && ew.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(ew, "__esModule", { value: !0 }); - ew.FixableBeetArgsStruct = - ew.isFixableBeetStruct = - ew.FixableBeetStruct = - void 0; - var g8t = OV(), - ile = nle(), - WGr = pm(), - GGr = Dr(), - cBe = nD(), - JGr = VGr(Mg()), - { brightBlack: $Gr } = JGr.default, - ym = class { - constructor(e, r, n = ym.description) { - (this.fields = e), (this.construct = r), (this.description = n); - let i = 0; - if (cBe.logDebug.enabled) { - let o = e.map( - ([s, c]) => ( - (0, WGr.isFixedSizeBeet)(c) && (i += c.byteSize), - `${s}: ${c.description} ${(0, cBe.beetBytes)(c)}` - ) - ).join(` - `), - a = `> ${i} B`; - (0, cBe.logDebug)(`struct ${n} { - ${o} -} ${$Gr(a)}`); - } - } - deserialize(e, r = 0) { - return this.toFixedFromData(e, r).deserialize(e, r); - } - serialize(e, r) { - return this.toFixedFromValue(e).serialize(e, r); - } - toFixedFromData(e, r) { - let n = r, - i = new Array(this.fields.length); - for (let o = 0; o < this.fields.length; o++) { - let [a, s] = this.fields[o], - c = (0, g8t.fixBeetFromData)(s, e, n); - (i[o] = [a, c]), (n += c.byteSize); - } - return this.description !== ym.description - ? new ile.BeetStruct(i, this.construct, this.description) - : new ile.BeetStruct(i, this.construct); - } - toFixedFromValue(e) { - let r = Object.keys(e), - n = new Array(this.fields.length); - for (let i = 0; i < this.fields.length; i++) { - let [o, a] = this.fields[i]; - (0, GGr.strict)( - r.includes(o), - `Value with keys [ ${r} ] should include struct key '${o}' but doesn't.` - ); - let s = e[o], - c = (0, g8t.fixBeetFromValue)(a, s); - n[i] = [o, c]; - } - return this.description !== ym.description - ? new ile.BeetStruct(n, this.construct, this.description) - : new ile.BeetStruct(n, this.construct); - } - get type() { - return ym.TYPE; - } - }; - ew.FixableBeetStruct = ym; - ym.description = "FixableBeetStruct"; - ym.TYPE = "FixableBeetStruct"; - function ZGr(t) { - return t.type === ym.TYPE; - } - ew.isFixableBeetStruct = ZGr; - var cD = class extends ym { - constructor(e, r = cD.description) { - super(e, (n) => n, r); - } - }; - ew.FixableBeetArgsStruct = cD; - cD.description = "FixableBeetArgsStruct"; - }); - var fBe = I((tw) => { - "use strict"; - m(); - g(); - Object.defineProperty(tw, "__esModule", { value: !0 }); - tw.enumsTypeMap = - tw.dataEnum = - tw.uniformDataEnum = - tw.fixedScalarEnum = - void 0; - var n3 = pm(), - Ng = rD(), - lD = Dr(), - XGr = nle(), - YGr = lBe(); - function v8t(t, e) { - return e ? `${t}` : t; - } - function QGr(t) { - let e = Object.keys(t); - return { - write(r, n, i) { - let o = typeof i == "number", - a = v8t(i, o); - if ( - (e.includes(a) || - lD.strict.fail( - `${i} should be a variant of the provided enum type, i.e. [ ${Object.values( - t - ).join(", ")} ], but isn't` - ), - o) - ) - Ng.u8.write(r, n, i); - else { - let s = t[a]; - Ng.u8.write(r, n, s); - } - }, - read(r, n) { - let i = Ng.u8.read(r, n), - o = typeof i == "number", - a = v8t(i, o); - return ( - e.includes(a) || - lD.strict.fail( - `${i} should be a of a variant of the provided enum type, i.e. [ ${Object.values( - t - ).join(", ")} ], but isn't` - ), - o ? i : t[a] - ); - }, - byteSize: Ng.u8.byteSize, - description: "Enum", - }; - } - tw.fixedScalarEnum = QGr; - function eJr(t) { - return { - write: function (e, r, n) { - Ng.u8.write(e, r, n.kind), t.write(e, r + 1, n.data); - }, - read: function (e, r) { - let n = Ng.u8.read(e, r), - i = t.read(e, r + 1); - return { kind: n, data: i }; - }, - byteSize: 1 + t.byteSize, - description: `UniformDataEnum<${t.description}>`, - }; - } - tw.uniformDataEnum = eJr; - function b8t(t, e, r) { - return { - write(n, i, o) { - Ng.u8.write(n, i, e), t.write(n, i + Ng.u8.byteSize, o); - }, - read(n, i) { - let o = t.read(n, i + Ng.u8.byteSize); - return { __kind: r, ...o }; - }, - byteSize: t.byteSize + Ng.u8.byteSize, - description: `EnumData<${t.description}>`, - }; - } - function tJr(t) { - for (let [e, r] of t) - (0, lD.strict)( - (0, XGr.isBeetStruct)(r) || (0, YGr.isFixableBeetStruct)(r), - "dataEnum: data beet must be a struct" - ); - return { - toFixedFromData(e, r) { - let n = Ng.u8.read(e, r), - i = t[n]; - (0, lD.strict)( - i != null, - `Discriminant ${n} out of range for ${t.length} variants` - ); - let [o, a] = i, - s = (0, n3.isFixedSizeBeet)(a) ? a : a.toFixedFromData(e, r + 1); - return b8t(s, n, o); - }, - toFixedFromValue(e) { - if (e.__kind == null) { - let u = Object.keys(e).join(", "), - h = t.map(([w]) => w).join(", "); - lD.strict.fail( - `Value with fields [ ${u} ] is missing __kind, which needs to be set to one of [ ${h} ]` - ); - } - let r = t.findIndex(([u]) => u === e.__kind); - if (r < 0) { - let u = t.map(([h]) => h).join(", "); - lD.strict.fail( - `${e.__kind} is not a valid kind, needs to be one of [ ${u} ]` - ); - } - let n = t[r], - { __kind: i, ...o } = e, - [a, s] = n, - c = (0, n3.isFixedSizeBeet)(s) ? s : s.toFixedFromValue(o); - return b8t(c, r, a); - }, - description: `DataEnum<${t.length} variants>`, - }; - } - tw.dataEnum = tJr; - tw.enumsTypeMap = { - fixedScalarEnum: { - beet: "fixedScalarEnum", - isFixable: !1, - sourcePack: n3.BEET_PACKAGE, - ts: "", - arg: n3.BEET_TYPE_ARG_INNER, - pack: n3.BEET_PACKAGE, - }, - dataEnum: { - beet: "dataEnum", - isFixable: !1, - sourcePack: n3.BEET_PACKAGE, - ts: "DataEnum", - arg: n3.BEET_TYPE_ARG_INNER, - pack: n3.BEET_PACKAGE, - }, - }; - }); - var dBe = I((fD) => { - "use strict"; - m(); - g(); - Object.defineProperty(fD, "__esModule", { value: !0 }); - fD.aliasesTypeMap = fD.bytes = void 0; - var w8t = rle(); - fD.bytes = w8t.uint8Array; - fD.aliasesTypeMap = { bytes: w8t.collectionsTypeMap.Uint8Array }; - }); - var En = I((uu) => { - "use strict"; - m(); - g(); - var rJr = - (uu && uu.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Dg = - (uu && uu.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - rJr(e, t, r); - }; - Object.defineProperty(uu, "__esModule", { value: !0 }); - uu.supportedTypeMap = void 0; - var nJr = rle(), - iJr = rBe(), - oJr = rD(), - aJr = oBe(), - sJr = fBe(), - uJr = dBe(); - Dg(dBe(), uu); - Dg(rle(), uu); - Dg(oBe(), uu); - Dg(rBe(), uu); - Dg(fBe(), uu); - Dg(rD(), uu); - Dg(OV(), uu); - Dg(uBe(), uu); - Dg(nle(), uu); - Dg(lBe(), uu); - Dg(pm(), uu); - uu.supportedTypeMap = { - ...nJr.collectionsTypeMap, - ...aJr.stringTypeMap, - ...iJr.compositesTypeMap, - ...sJr.enumsTypeMap, - ...oJr.numbersTypeMap, - ...uJr.aliasesTypeMap, - }; - }); - var yBe = I((cu) => { - "use strict"; - m(); - g(); - var cJr = - (cu && cu.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - lJr = - (cu && cu.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - pBe = - (cu && cu.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - cJr(e, t, r); - return lJr(e, t), e; - }; - Object.defineProperty(cu, "__esModule", { value: !0 }); - cu.candyGuardBeet = cu.CandyGuard = cu.candyGuardDiscriminator = void 0; - var fJr = pBe(Le()), - hBe = pBe(Fi()), - ole = pBe(En()); - cu.candyGuardDiscriminator = [44, 207, 199, 184, 112, 103, 34, 181]; - var rw = class { - constructor(e, r, n) { - (this.base = e), (this.bump = r), (this.authority = n); - } - static fromArgs(e) { - return new rw(e.base, e.bump, e.authority); - } - static fromAccountInfo(e, r = 0) { - return rw.deserialize(e.data, r); - } - static async fromAccountAddress(e, r) { - let n = await e.getAccountInfo(r); - if (n == null) - throw new Error(`Unable to find CandyGuard account at ${r}`); - return rw.fromAccountInfo(n, 0)[0]; - } - static gpaBuilder( - e = new fJr.PublicKey("Guard1JwRhJkVH6XZhzoYxeBVQe872VH6QggF4BWmS9g") - ) { - return hBe.GpaBuilder.fromStruct(e, cu.candyGuardBeet); - } - static deserialize(e, r = 0) { - return cu.candyGuardBeet.deserialize(e, r); - } - serialize() { - return cu.candyGuardBeet.serialize({ - accountDiscriminator: cu.candyGuardDiscriminator, - ...this, - }); - } - static get byteSize() { - return cu.candyGuardBeet.byteSize; - } - static async getMinimumBalanceForRentExemption(e, r) { - return e.getMinimumBalanceForRentExemption(rw.byteSize, r); - } - static hasCorrectByteSize(e, r = 0) { - return e.byteLength - r === rw.byteSize; - } - pretty() { - return { - base: this.base.toBase58(), - bump: this.bump, - authority: this.authority.toBase58(), - }; - } - }; - cu.CandyGuard = rw; - cu.candyGuardBeet = new ole.BeetStruct( - [ - ["accountDiscriminator", ole.uniformFixedSizeArray(ole.u8, 8)], - ["base", hBe.publicKey], - ["bump", ole.u8], - ["authority", hBe.publicKey], - ], - rw.fromArgs, - "CandyGuard" - ); - }); - var gBe = I((Fs) => { - "use strict"; - m(); - g(); - var dJr = - (Fs && Fs.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - hJr = - (Fs && Fs.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - mBe = - (Fs && Fs.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - dJr(e, t, r); - return hJr(e, t), e; - }; - Object.defineProperty(Fs, "__esModule", { value: !0 }); - Fs.freezeEscrowBeet = - Fs.FreezeEscrow = - Fs.freezeEscrowDiscriminator = - void 0; - var pJr = mBe(Le()), - M4 = mBe(En()), - IV = mBe(Fi()); - Fs.freezeEscrowDiscriminator = [227, 186, 40, 152, 7, 174, 131, 184]; - var nw = class { - constructor(e, r, n, i, o, a, s) { - (this.candyGuard = e), - (this.candyMachine = r), - (this.frozenCount = n), - (this.firstMintTime = i), - (this.freezePeriod = o), - (this.destination = a), - (this.authority = s); - } - static fromArgs(e) { - return new nw( - e.candyGuard, - e.candyMachine, - e.frozenCount, - e.firstMintTime, - e.freezePeriod, - e.destination, - e.authority - ); - } - static fromAccountInfo(e, r = 0) { - return nw.deserialize(e.data, r); - } - static async fromAccountAddress(e, r) { - let n = await e.getAccountInfo(r); - if (n == null) - throw new Error(`Unable to find FreezeEscrow account at ${r}`); - return nw.fromAccountInfo(n, 0)[0]; - } - static gpaBuilder( - e = new pJr.PublicKey("Guard1JwRhJkVH6XZhzoYxeBVQe872VH6QggF4BWmS9g") - ) { - return IV.GpaBuilder.fromStruct(e, Fs.freezeEscrowBeet); - } - static deserialize(e, r = 0) { - return Fs.freezeEscrowBeet.deserialize(e, r); - } - serialize() { - return Fs.freezeEscrowBeet.serialize({ - accountDiscriminator: Fs.freezeEscrowDiscriminator, - ...this, - }); - } - static byteSize(e) { - let r = nw.fromArgs(e); - return Fs.freezeEscrowBeet.toFixedFromValue({ - accountDiscriminator: Fs.freezeEscrowDiscriminator, - ...r, - }).byteSize; - } - static async getMinimumBalanceForRentExemption(e, r, n) { - return r.getMinimumBalanceForRentExemption(nw.byteSize(e), n); - } - pretty() { - return { - candyGuard: this.candyGuard.toBase58(), - candyMachine: this.candyMachine.toBase58(), - frozenCount: (() => { - let e = this.frozenCount; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - firstMintTime: this.firstMintTime, - freezePeriod: (() => { - let e = this.freezePeriod; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - destination: this.destination.toBase58(), - authority: this.authority.toBase58(), - }; - } - }; - Fs.FreezeEscrow = nw; - Fs.freezeEscrowBeet = new M4.FixableBeetStruct( - [ - ["accountDiscriminator", M4.uniformFixedSizeArray(M4.u8, 8)], - ["candyGuard", IV.publicKey], - ["candyMachine", IV.publicKey], - ["frozenCount", M4.u64], - ["firstMintTime", M4.coption(M4.i64)], - ["freezePeriod", M4.i64], - ["destination", IV.publicKey], - ["authority", IV.publicKey], - ], - nw.fromArgs, - "FreezeEscrow" - ); - }); - var x8t = I((iw) => { - "use strict"; - m(); - g(); - var yJr = - (iw && iw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - _8t = - (iw && iw.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - yJr(e, t, r); - }; - Object.defineProperty(iw, "__esModule", { value: !0 }); - iw.accountProviders = void 0; - _8t(yBe(), iw); - _8t(gBe(), iw); - var mJr = gBe(), - gJr = yBe(); - iw.accountProviders = { - FreezeEscrow: mJr.FreezeEscrow, - CandyGuard: gJr.CandyGuard, - }; - }); - var S8t = I((Dt) => { - "use strict"; - m(); - g(); - Object.defineProperty(Dt, "__esModule", { value: !0 }); - Dt.errorFromName = - Dt.errorFromCode = - Dt.ExceededProgramListSizeError = - Dt.UnauthorizedProgramFoundError = - Dt.DuplicatedMintLimitIdError = - Dt.DuplicatedGroupLabelError = - Dt.UnlockNotEnabledError = - Dt.ThawNotEnabledError = - Dt.ExceededMaximumFreezePeriodError = - Dt.FreezeEscrowAlreadyExistsError = - Dt.MissingFreezePeriodError = - Dt.FreezeNotInitializedError = - Dt.FreezeGuardNotEnabledError = - Dt.MissingFreezeInstructionError = - Dt.AddressNotAuthorizedError = - Dt.MaximumRedeemedAmountError = - Dt.MissingNftError = - Dt.InvalidNftCollectionError = - Dt.AllowedMintLimitReachedError = - Dt.AllowedListNotEnabledError = - Dt.MissingAllowedListProofError = - Dt.AddressNotFoundInAllowedListError = - Dt.InvalidMintTimeError = - Dt.AfterEndDateError = - Dt.GatewayTokenInvalidError = - Dt.MissingRequiredSignatureError = - Dt.TokenTransferFailedError = - Dt.NotEnoughTokensError = - Dt.TokenBurnFailedError = - Dt.NotEnoughSOLError = - Dt.MintNotLiveError = - Dt.MintNotLastTransactionError = - Dt.CollectionUpdateAuthorityKeyMismatchError = - Dt.MissingCollectionAccountsError = - Dt.CollectionKeyMismatchError = - Dt.InstructionNotFoundError = - Dt.CandyMachineEmptyError = - Dt.ExceededLengthError = - Dt.GroupNotFoundError = - Dt.RequiredGroupLabelNotFoundError = - Dt.NumericalOverflowErrorError = - Dt.MissingRemainingAccountError = - Dt.UninitializedError = - Dt.IncorrectOwnerError = - Dt.DataIncrementLimitExceededError = - Dt.PublicKeyMismatchError = - Dt.DeserializationErrorError = - Dt.InvalidAccountSizeError = - void 0; - var jr = new Map(), - Ur = new Map(), - T4 = class extends Error { - constructor() { - super("Could not save guard to account"), - (this.code = 6e3), - (this.name = "InvalidAccountSize"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, T4); - } - }; - Dt.InvalidAccountSizeError = T4; - jr.set(6e3, () => new T4()); - Ur.set("InvalidAccountSize", () => new T4()); - var k4 = class extends Error { - constructor() { - super("Could not deserialize guard"), - (this.code = 6001), - (this.name = "DeserializationError"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, k4); - } - }; - Dt.DeserializationErrorError = k4; - jr.set(6001, () => new k4()); - Ur.set("DeserializationError", () => new k4()); - var P4 = class extends Error { - constructor() { - super("Public key mismatch"), - (this.code = 6002), - (this.name = "PublicKeyMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, P4); - } - }; - Dt.PublicKeyMismatchError = P4; - jr.set(6002, () => new P4()); - Ur.set("PublicKeyMismatch", () => new P4()); - var O4 = class extends Error { - constructor() { - super("Exceeded account increase limit"), - (this.code = 6003), - (this.name = "DataIncrementLimitExceeded"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, O4); - } - }; - Dt.DataIncrementLimitExceededError = O4; - jr.set(6003, () => new O4()); - Ur.set("DataIncrementLimitExceeded", () => new O4()); - var B4 = class extends Error { - constructor() { - super("Account does not have correct owner"), - (this.code = 6004), - (this.name = "IncorrectOwner"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, B4); - } - }; - Dt.IncorrectOwnerError = B4; - jr.set(6004, () => new B4()); - Ur.set("IncorrectOwner", () => new B4()); - var I4 = class extends Error { - constructor() { - super("Account is not initialized"), - (this.code = 6005), - (this.name = "Uninitialized"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, I4); - } - }; - Dt.UninitializedError = I4; - jr.set(6005, () => new I4()); - Ur.set("Uninitialized", () => new I4()); - var C4 = class extends Error { - constructor() { - super("Missing expected remaining account"), - (this.code = 6006), - (this.name = "MissingRemainingAccount"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, C4); - } - }; - Dt.MissingRemainingAccountError = C4; - jr.set(6006, () => new C4()); - Ur.set("MissingRemainingAccount", () => new C4()); - var R4 = class extends Error { - constructor() { - super("Numerical overflow error"), - (this.code = 6007), - (this.name = "NumericalOverflowError"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, R4); - } - }; - Dt.NumericalOverflowErrorError = R4; - jr.set(6007, () => new R4()); - Ur.set("NumericalOverflowError", () => new R4()); - var N4 = class extends Error { - constructor() { - super("Missing required group label"), - (this.code = 6008), - (this.name = "RequiredGroupLabelNotFound"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, N4); - } - }; - Dt.RequiredGroupLabelNotFoundError = N4; - jr.set(6008, () => new N4()); - Ur.set("RequiredGroupLabelNotFound", () => new N4()); - var D4 = class extends Error { - constructor() { - super("Group not found"), - (this.code = 6009), - (this.name = "GroupNotFound"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, D4); - } - }; - Dt.GroupNotFoundError = D4; - jr.set(6009, () => new D4()); - Ur.set("GroupNotFound", () => new D4()); - var F4 = class extends Error { - constructor() { - super("Value exceeded maximum length"), - (this.code = 6010), - (this.name = "ExceededLength"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, F4); - } - }; - Dt.ExceededLengthError = F4; - jr.set(6010, () => new F4()); - Ur.set("ExceededLength", () => new F4()); - var L4 = class extends Error { - constructor() { - super("Candy machine is empty"), - (this.code = 6011), - (this.name = "CandyMachineEmpty"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, L4); - } - }; - Dt.CandyMachineEmptyError = L4; - jr.set(6011, () => new L4()); - Ur.set("CandyMachineEmpty", () => new L4()); - var q4 = class extends Error { - constructor() { - super("No instruction was found"), - (this.code = 6012), - (this.name = "InstructionNotFound"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, q4); - } - }; - Dt.InstructionNotFoundError = q4; - jr.set(6012, () => new q4()); - Ur.set("InstructionNotFound", () => new q4()); - var z4 = class extends Error { - constructor() { - super("Collection public key mismatch"), - (this.code = 6013), - (this.name = "CollectionKeyMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, z4); - } - }; - Dt.CollectionKeyMismatchError = z4; - jr.set(6013, () => new z4()); - Ur.set("CollectionKeyMismatch", () => new z4()); - var j4 = class extends Error { - constructor() { - super("Missing collection accounts"), - (this.code = 6014), - (this.name = "MissingCollectionAccounts"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, j4); - } - }; - Dt.MissingCollectionAccountsError = j4; - jr.set(6014, () => new j4()); - Ur.set("MissingCollectionAccounts", () => new j4()); - var U4 = class extends Error { - constructor() { - super("Collection update authority public key mismatch"), - (this.code = 6015), - (this.name = "CollectionUpdateAuthorityKeyMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, U4); - } - }; - Dt.CollectionUpdateAuthorityKeyMismatchError = U4; - jr.set(6015, () => new U4()); - Ur.set("CollectionUpdateAuthorityKeyMismatch", () => new U4()); - var K4 = class extends Error { - constructor() { - super("Mint must be the last instructions of the transaction"), - (this.code = 6016), - (this.name = "MintNotLastTransaction"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, K4); - } - }; - Dt.MintNotLastTransactionError = K4; - jr.set(6016, () => new K4()); - Ur.set("MintNotLastTransaction", () => new K4()); - var H4 = class extends Error { - constructor() { - super("Mint is not live"), - (this.code = 6017), - (this.name = "MintNotLive"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, H4); - } - }; - Dt.MintNotLiveError = H4; - jr.set(6017, () => new H4()); - Ur.set("MintNotLive", () => new H4()); - var V4 = class extends Error { - constructor() { - super("Not enough SOL to pay for the mint"), - (this.code = 6018), - (this.name = "NotEnoughSOL"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, V4); - } - }; - Dt.NotEnoughSOLError = V4; - jr.set(6018, () => new V4()); - Ur.set("NotEnoughSOL", () => new V4()); - var W4 = class extends Error { - constructor() { - super("Token burn failed"), - (this.code = 6019), - (this.name = "TokenBurnFailed"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, W4); - } - }; - Dt.TokenBurnFailedError = W4; - jr.set(6019, () => new W4()); - Ur.set("TokenBurnFailed", () => new W4()); - var G4 = class extends Error { - constructor() { - super("Not enough tokens on the account"), - (this.code = 6020), - (this.name = "NotEnoughTokens"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, G4); - } - }; - Dt.NotEnoughTokensError = G4; - jr.set(6020, () => new G4()); - Ur.set("NotEnoughTokens", () => new G4()); - var J4 = class extends Error { - constructor() { - super("Token transfer failed"), - (this.code = 6021), - (this.name = "TokenTransferFailed"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, J4); - } - }; - Dt.TokenTransferFailedError = J4; - jr.set(6021, () => new J4()); - Ur.set("TokenTransferFailed", () => new J4()); - var $4 = class extends Error { - constructor() { - super("A signature was required but not found"), - (this.code = 6022), - (this.name = "MissingRequiredSignature"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, $4); - } - }; - Dt.MissingRequiredSignatureError = $4; - jr.set(6022, () => new $4()); - Ur.set("MissingRequiredSignature", () => new $4()); - var Z4 = class extends Error { - constructor() { - super("Gateway token is not valid"), - (this.code = 6023), - (this.name = "GatewayTokenInvalid"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Z4); - } - }; - Dt.GatewayTokenInvalidError = Z4; - jr.set(6023, () => new Z4()); - Ur.set("GatewayTokenInvalid", () => new Z4()); - var X4 = class extends Error { - constructor() { - super("Current time is after the set end date"), - (this.code = 6024), - (this.name = "AfterEndDate"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, X4); - } - }; - Dt.AfterEndDateError = X4; - jr.set(6024, () => new X4()); - Ur.set("AfterEndDate", () => new X4()); - var Y4 = class extends Error { - constructor() { - super("Current time is not within the allowed mint time"), - (this.code = 6025), - (this.name = "InvalidMintTime"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Y4); - } - }; - Dt.InvalidMintTimeError = Y4; - jr.set(6025, () => new Y4()); - Ur.set("InvalidMintTime", () => new Y4()); - var Q4 = class extends Error { - constructor() { - super("Address not found on the allowed list"), - (this.code = 6026), - (this.name = "AddressNotFoundInAllowedList"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, Q4); - } - }; - Dt.AddressNotFoundInAllowedListError = Q4; - jr.set(6026, () => new Q4()); - Ur.set("AddressNotFoundInAllowedList", () => new Q4()); - var eO = class extends Error { - constructor() { - super("Missing allowed list proof"), - (this.code = 6027), - (this.name = "MissingAllowedListProof"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, eO); - } - }; - Dt.MissingAllowedListProofError = eO; - jr.set(6027, () => new eO()); - Ur.set("MissingAllowedListProof", () => new eO()); - var tO = class extends Error { - constructor() { - super("Allow list guard is not enabled"), - (this.code = 6028), - (this.name = "AllowedListNotEnabled"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, tO); - } - }; - Dt.AllowedListNotEnabledError = tO; - jr.set(6028, () => new tO()); - Ur.set("AllowedListNotEnabled", () => new tO()); - var rO = class extends Error { - constructor() { - super("The maximum number of allowed mints was reached"), - (this.code = 6029), - (this.name = "AllowedMintLimitReached"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, rO); - } - }; - Dt.AllowedMintLimitReachedError = rO; - jr.set(6029, () => new rO()); - Ur.set("AllowedMintLimitReached", () => new rO()); - var nO = class extends Error { - constructor() { - super("Invalid NFT collection"), - (this.code = 6030), - (this.name = "InvalidNftCollection"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, nO); - } - }; - Dt.InvalidNftCollectionError = nO; - jr.set(6030, () => new nO()); - Ur.set("InvalidNftCollection", () => new nO()); - var iO = class extends Error { - constructor() { - super("Missing NFT on the account"), - (this.code = 6031), - (this.name = "MissingNft"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, iO); - } - }; - Dt.MissingNftError = iO; - jr.set(6031, () => new iO()); - Ur.set("MissingNft", () => new iO()); - var oO = class extends Error { - constructor() { - super("Current redemeed items is at the set maximum amount"), - (this.code = 6032), - (this.name = "MaximumRedeemedAmount"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, oO); - } - }; - Dt.MaximumRedeemedAmountError = oO; - jr.set(6032, () => new oO()); - Ur.set("MaximumRedeemedAmount", () => new oO()); - var aO = class extends Error { - constructor() { - super("Address not authorized"), - (this.code = 6033), - (this.name = "AddressNotAuthorized"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, aO); - } - }; - Dt.AddressNotAuthorizedError = aO; - jr.set(6033, () => new aO()); - Ur.set("AddressNotAuthorized", () => new aO()); - var sO = class extends Error { - constructor() { - super("Missing freeze instruction data"), - (this.code = 6034), - (this.name = "MissingFreezeInstruction"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, sO); - } - }; - Dt.MissingFreezeInstructionError = sO; - jr.set(6034, () => new sO()); - Ur.set("MissingFreezeInstruction", () => new sO()); - var uO = class extends Error { - constructor() { - super("Freeze guard must be enabled"), - (this.code = 6035), - (this.name = "FreezeGuardNotEnabled"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, uO); - } - }; - Dt.FreezeGuardNotEnabledError = uO; - jr.set(6035, () => new uO()); - Ur.set("FreezeGuardNotEnabled", () => new uO()); - var cO = class extends Error { - constructor() { - super("Freeze must be initialized"), - (this.code = 6036), - (this.name = "FreezeNotInitialized"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, cO); - } - }; - Dt.FreezeNotInitializedError = cO; - jr.set(6036, () => new cO()); - Ur.set("FreezeNotInitialized", () => new cO()); - var lO = class extends Error { - constructor() { - super("Missing freeze period"), - (this.code = 6037), - (this.name = "MissingFreezePeriod"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, lO); - } - }; - Dt.MissingFreezePeriodError = lO; - jr.set(6037, () => new lO()); - Ur.set("MissingFreezePeriod", () => new lO()); - var fO = class extends Error { - constructor() { - super("The freeze escrow account already exists"), - (this.code = 6038), - (this.name = "FreezeEscrowAlreadyExists"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, fO); - } - }; - Dt.FreezeEscrowAlreadyExistsError = fO; - jr.set(6038, () => new fO()); - Ur.set("FreezeEscrowAlreadyExists", () => new fO()); - var dO = class extends Error { - constructor() { - super("Maximum freeze period exceeded"), - (this.code = 6039), - (this.name = "ExceededMaximumFreezePeriod"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, dO); - } - }; - Dt.ExceededMaximumFreezePeriodError = dO; - jr.set(6039, () => new dO()); - Ur.set("ExceededMaximumFreezePeriod", () => new dO()); - var hO = class extends Error { - constructor() { - super("Thaw is not enabled"), - (this.code = 6040), - (this.name = "ThawNotEnabled"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, hO); - } - }; - Dt.ThawNotEnabledError = hO; - jr.set(6040, () => new hO()); - Ur.set("ThawNotEnabled", () => new hO()); - var pO = class extends Error { - constructor() { - super("Unlock is not enabled (not all NFTs are thawed)"), - (this.code = 6041), - (this.name = "UnlockNotEnabled"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, pO); - } - }; - Dt.UnlockNotEnabledError = pO; - jr.set(6041, () => new pO()); - Ur.set("UnlockNotEnabled", () => new pO()); - var yO = class extends Error { - constructor() { - super("Duplicated group label"), - (this.code = 6042), - (this.name = "DuplicatedGroupLabel"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, yO); - } - }; - Dt.DuplicatedGroupLabelError = yO; - jr.set(6042, () => new yO()); - Ur.set("DuplicatedGroupLabel", () => new yO()); - var mO = class extends Error { - constructor() { - super("Duplicated mint limit id"), - (this.code = 6043), - (this.name = "DuplicatedMintLimitId"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, mO); - } - }; - Dt.DuplicatedMintLimitIdError = mO; - jr.set(6043, () => new mO()); - Ur.set("DuplicatedMintLimitId", () => new mO()); - var gO = class extends Error { - constructor() { - super("An unauthorized program was found in the transaction"), - (this.code = 6044), - (this.name = "UnauthorizedProgramFound"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, gO); - } - }; - Dt.UnauthorizedProgramFoundError = gO; - jr.set(6044, () => new gO()); - Ur.set("UnauthorizedProgramFound", () => new gO()); - var vO = class extends Error { - constructor() { - super("Exceeded the maximum number of programs in the additional list"), - (this.code = 6045), - (this.name = "ExceededProgramListSize"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, vO); - } - }; - Dt.ExceededProgramListSizeError = vO; - jr.set(6045, () => new vO()); - Ur.set("ExceededProgramListSize", () => new vO()); - function vJr(t) { - let e = jr.get(t); - return e != null ? e() : null; - } - Dt.errorFromCode = vJr; - function bJr(t) { - let e = Ur.get(t); - return e != null ? e() : null; - } - Dt.errorFromName = bJr; - }); - var E8t = I((Lf) => { - "use strict"; - m(); - g(); - var wJr = - (Lf && Lf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - _Jr = - (Lf && Lf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - A8t = - (Lf && Lf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - wJr(e, t, r); - return _Jr(e, t), e; - }; - Object.defineProperty(Lf, "__esModule", { value: !0 }); - Lf.createInitializeInstruction = - Lf.initializeInstructionDiscriminator = - Lf.initializeStruct = - void 0; - var ale = A8t(En()), - vBe = A8t(Le()); - Lf.initializeStruct = new ale.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", ale.uniformFixedSizeArray(ale.u8, 8)], - ["data", ale.bytes], - ], - "InitializeInstructionArgs" - ); - Lf.initializeInstructionDiscriminator = [ - 175, 175, 109, 31, 13, 152, 155, 237, - ]; - function xJr( - t, - e, - r = new vBe.PublicKey("Guard1JwRhJkVH6XZhzoYxeBVQe872VH6QggF4BWmS9g") - ) { - var n; - let [i] = Lf.initializeStruct.serialize({ - instructionDiscriminator: Lf.initializeInstructionDiscriminator, - ...e, - }), - o = [ - { pubkey: t.candyGuard, isWritable: !0, isSigner: !1 }, - { pubkey: t.base, isWritable: !1, isSigner: !0 }, - { pubkey: t.authority, isWritable: !1, isSigner: !1 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { - pubkey: - (n = t.systemProgram) !== null && n !== void 0 - ? n - : vBe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - ]; - return new vBe.TransactionInstruction({ programId: r, keys: o, data: i }); - } - Lf.createInitializeInstruction = xJr; - }); - var M8t = I((qf) => { - "use strict"; - m(); - g(); - var SJr = - (qf && qf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - AJr = - (qf && qf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - wBe = - (qf && qf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - SJr(e, t, r); - return AJr(e, t), e; - }; - Object.defineProperty(qf, "__esModule", { value: !0 }); - qf.createMintInstruction = - qf.mintInstructionDiscriminator = - qf.mintStruct = - void 0; - var EJr = wBe((pa(), jo(ha))), - dD = wBe(En()), - bBe = wBe(Le()); - qf.mintStruct = new dD.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", dD.uniformFixedSizeArray(dD.u8, 8)], - ["mintArgs", dD.bytes], - ["label", dD.coption(dD.utf8String)], - ], - "MintInstructionArgs" - ); - qf.mintInstructionDiscriminator = [51, 57, 225, 47, 182, 146, 137, 166]; - function MJr( - t, - e, - r = new bBe.PublicKey("Guard1JwRhJkVH6XZhzoYxeBVQe872VH6QggF4BWmS9g") - ) { - var n, i; - let [o] = qf.mintStruct.serialize({ - instructionDiscriminator: qf.mintInstructionDiscriminator, - ...e, - }), - a = [ - { pubkey: t.candyGuard, isWritable: !1, isSigner: !1 }, - { pubkey: t.candyMachineProgram, isWritable: !1, isSigner: !1 }, - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.candyMachineAuthorityPda, isWritable: !0, isSigner: !1 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { pubkey: t.nftMetadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.nftMint, isWritable: !0, isSigner: !1 }, - { pubkey: t.nftMintAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.nftMasterEdition, isWritable: !0, isSigner: !1 }, - { pubkey: t.collectionAuthorityRecord, isWritable: !1, isSigner: !1 }, - { pubkey: t.collectionMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.collectionMetadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.collectionMasterEdition, isWritable: !1, isSigner: !1 }, - { pubkey: t.collectionUpdateAuthority, isWritable: !1, isSigner: !1 }, - { pubkey: t.tokenMetadataProgram, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : EJr.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : bBe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.recentSlothashes, isWritable: !1, isSigner: !1 }, - { pubkey: t.instructionSysvarAccount, isWritable: !1, isSigner: !1 }, - ]; - return new bBe.TransactionInstruction({ programId: r, keys: a, data: o }); - } - qf.createMintInstruction = MJr; - }); - var _Be = I((S0) => { - "use strict"; - m(); - g(); - var TJr = - (S0 && S0.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - kJr = - (S0 && S0.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - PJr = - (S0 && S0.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - TJr(e, t, r); - return kJr(e, t), e; - }; - Object.defineProperty(S0, "__esModule", { value: !0 }); - S0.guardTypeBeet = S0.GuardType = void 0; - var OJr = PJr(En()), - T8t; - (function (t) { - (t[(t.BotTax = 0)] = "BotTax"), - (t[(t.SolPayment = 1)] = "SolPayment"), - (t[(t.TokenPayment = 2)] = "TokenPayment"), - (t[(t.StartDate = 3)] = "StartDate"), - (t[(t.ThirdPartySigner = 4)] = "ThirdPartySigner"), - (t[(t.TokenGate = 5)] = "TokenGate"), - (t[(t.Gatekeeper = 6)] = "Gatekeeper"), - (t[(t.EndDate = 7)] = "EndDate"), - (t[(t.AllowList = 8)] = "AllowList"), - (t[(t.MintLimit = 9)] = "MintLimit"), - (t[(t.NftPayment = 10)] = "NftPayment"), - (t[(t.RedeemedAmount = 11)] = "RedeemedAmount"), - (t[(t.AddressGate = 12)] = "AddressGate"), - (t[(t.NftGate = 13)] = "NftGate"), - (t[(t.NftBurn = 14)] = "NftBurn"), - (t[(t.TokenBurn = 15)] = "TokenBurn"), - (t[(t.FreezeSolPayment = 16)] = "FreezeSolPayment"), - (t[(t.FreezeTokenPayment = 17)] = "FreezeTokenPayment"), - (t[(t.ProgramGate = 18)] = "ProgramGate"); - })((T8t = S0.GuardType || (S0.GuardType = {}))); - S0.guardTypeBeet = OJr.fixedScalarEnum(T8t); - }); - var xBe = I((ow) => { - "use strict"; - m(); - g(); - var BJr = - (ow && ow.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - IJr = - (ow && ow.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - CJr = - (ow && ow.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - BJr(e, t, r); - return IJr(e, t), e; - }; - Object.defineProperty(ow, "__esModule", { value: !0 }); - ow.routeArgsBeet = void 0; - var k8t = CJr(En()), - RJr = _Be(); - ow.routeArgsBeet = new k8t.FixableBeetArgsStruct( - [ - ["guard", RJr.guardTypeBeet], - ["data", k8t.bytes], - ], - "RouteArgs" - ); - }); - var B8t = I((zf) => { - "use strict"; - m(); - g(); - var NJr = - (zf && zf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - DJr = - (zf && zf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - O8t = - (zf && zf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - NJr(e, t, r); - return DJr(e, t), e; - }; - Object.defineProperty(zf, "__esModule", { value: !0 }); - zf.createRouteInstruction = - zf.routeInstructionDiscriminator = - zf.routeStruct = - void 0; - var CV = O8t(En()), - P8t = O8t(Le()), - FJr = xBe(); - zf.routeStruct = new CV.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", CV.uniformFixedSizeArray(CV.u8, 8)], - ["args", FJr.routeArgsBeet], - ["label", CV.coption(CV.utf8String)], - ], - "RouteInstructionArgs" - ); - zf.routeInstructionDiscriminator = [229, 23, 203, 151, 122, 227, 173, 42]; - function LJr( - t, - e, - r = new P8t.PublicKey("Guard1JwRhJkVH6XZhzoYxeBVQe872VH6QggF4BWmS9g") - ) { - let [n] = zf.routeStruct.serialize({ - instructionDiscriminator: zf.routeInstructionDiscriminator, - ...e, - }), - i = [ - { pubkey: t.candyGuard, isWritable: !1, isSigner: !1 }, - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - ]; - return new P8t.TransactionInstruction({ programId: r, keys: i, data: n }); - } - zf.createRouteInstruction = LJr; - }); - var C8t = I((jf) => { - "use strict"; - m(); - g(); - var qJr = - (jf && jf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - zJr = - (jf && jf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - ABe = - (jf && jf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - qJr(e, t, r); - return zJr(e, t), e; - }; - Object.defineProperty(jf, "__esModule", { value: !0 }); - jf.createSetAuthorityInstruction = - jf.setAuthorityInstructionDiscriminator = - jf.setAuthorityStruct = - void 0; - var I8t = ABe(Le()), - jJr = ABe(Fi()), - SBe = ABe(En()); - jf.setAuthorityStruct = new SBe.BeetArgsStruct( - [ - ["instructionDiscriminator", SBe.uniformFixedSizeArray(SBe.u8, 8)], - ["newAuthority", jJr.publicKey], - ], - "SetAuthorityInstructionArgs" - ); - jf.setAuthorityInstructionDiscriminator = [ - 133, 250, 37, 21, 110, 163, 26, 121, - ]; - function UJr( - t, - e, - r = new I8t.PublicKey("Guard1JwRhJkVH6XZhzoYxeBVQe872VH6QggF4BWmS9g") - ) { - let [n] = jf.setAuthorityStruct.serialize({ - instructionDiscriminator: jf.setAuthorityInstructionDiscriminator, - ...e, - }), - i = [ - { pubkey: t.candyGuard, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !0 }, - ]; - return new I8t.TransactionInstruction({ programId: r, keys: i, data: n }); - } - jf.createSetAuthorityInstruction = UJr; - }); - var D8t = I((Uf) => { - "use strict"; - m(); - g(); - var KJr = - (Uf && Uf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - HJr = - (Uf && Uf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - N8t = - (Uf && Uf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - KJr(e, t, r); - return HJr(e, t), e; - }; - Object.defineProperty(Uf, "__esModule", { value: !0 }); - Uf.createUnwrapInstruction = - Uf.unwrapInstructionDiscriminator = - Uf.unwrapStruct = - void 0; - var EBe = N8t(En()), - R8t = N8t(Le()); - Uf.unwrapStruct = new EBe.BeetArgsStruct( - [["instructionDiscriminator", EBe.uniformFixedSizeArray(EBe.u8, 8)]], - "UnwrapInstructionArgs" - ); - Uf.unwrapInstructionDiscriminator = [126, 175, 198, 14, 212, 69, 50, 44]; - function VJr( - t, - e = new R8t.PublicKey("Guard1JwRhJkVH6XZhzoYxeBVQe872VH6QggF4BWmS9g") - ) { - let [r] = Uf.unwrapStruct.serialize({ - instructionDiscriminator: Uf.unwrapInstructionDiscriminator, - }), - n = [ - { pubkey: t.candyGuard, isWritable: !1, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !0 }, - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.candyMachineAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.candyMachineProgram, isWritable: !1, isSigner: !1 }, - ]; - return new R8t.TransactionInstruction({ programId: e, keys: n, data: r }); - } - Uf.createUnwrapInstruction = VJr; - }); - var L8t = I((Kf) => { - "use strict"; - m(); - g(); - var WJr = - (Kf && Kf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - GJr = - (Kf && Kf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - F8t = - (Kf && Kf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - WJr(e, t, r); - return GJr(e, t), e; - }; - Object.defineProperty(Kf, "__esModule", { value: !0 }); - Kf.createUpdateInstruction = - Kf.updateInstructionDiscriminator = - Kf.updateStruct = - void 0; - var sle = F8t(En()), - MBe = F8t(Le()); - Kf.updateStruct = new sle.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", sle.uniformFixedSizeArray(sle.u8, 8)], - ["data", sle.bytes], - ], - "UpdateInstructionArgs" - ); - Kf.updateInstructionDiscriminator = [219, 200, 88, 176, 158, 63, 253, 127]; - function JJr( - t, - e, - r = new MBe.PublicKey("Guard1JwRhJkVH6XZhzoYxeBVQe872VH6QggF4BWmS9g") - ) { - var n; - let [i] = Kf.updateStruct.serialize({ - instructionDiscriminator: Kf.updateInstructionDiscriminator, - ...e, - }), - o = [ - { pubkey: t.candyGuard, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !0 }, - { pubkey: t.payer, isWritable: !1, isSigner: !0 }, - { - pubkey: - (n = t.systemProgram) !== null && n !== void 0 - ? n - : MBe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - ]; - return new MBe.TransactionInstruction({ programId: r, keys: o, data: i }); - } - Kf.createUpdateInstruction = JJr; - }); - var j8t = I((Hf) => { - "use strict"; - m(); - g(); - var $Jr = - (Hf && Hf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - ZJr = - (Hf && Hf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - z8t = - (Hf && Hf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - $Jr(e, t, r); - return ZJr(e, t), e; - }; - Object.defineProperty(Hf, "__esModule", { value: !0 }); - Hf.createWithdrawInstruction = - Hf.withdrawInstructionDiscriminator = - Hf.withdrawStruct = - void 0; - var TBe = z8t(En()), - q8t = z8t(Le()); - Hf.withdrawStruct = new TBe.BeetArgsStruct( - [["instructionDiscriminator", TBe.uniformFixedSizeArray(TBe.u8, 8)]], - "WithdrawInstructionArgs" - ); - Hf.withdrawInstructionDiscriminator = [183, 18, 70, 156, 148, 109, 161, 34]; - function XJr( - t, - e = new q8t.PublicKey("Guard1JwRhJkVH6XZhzoYxeBVQe872VH6QggF4BWmS9g") - ) { - let [r] = Hf.withdrawStruct.serialize({ - instructionDiscriminator: Hf.withdrawInstructionDiscriminator, - }), - n = [ - { pubkey: t.candyGuard, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !0, isSigner: !0 }, - ]; - return new q8t.TransactionInstruction({ programId: e, keys: n, data: r }); - } - Hf.createWithdrawInstruction = XJr; - }); - var H8t = I((Vf) => { - "use strict"; - m(); - g(); - var YJr = - (Vf && Vf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - QJr = - (Vf && Vf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - K8t = - (Vf && Vf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - YJr(e, t, r); - return QJr(e, t), e; - }; - Object.defineProperty(Vf, "__esModule", { value: !0 }); - Vf.createWrapInstruction = - Vf.wrapInstructionDiscriminator = - Vf.wrapStruct = - void 0; - var kBe = K8t(En()), - U8t = K8t(Le()); - Vf.wrapStruct = new kBe.BeetArgsStruct( - [["instructionDiscriminator", kBe.uniformFixedSizeArray(kBe.u8, 8)]], - "WrapInstructionArgs" - ); - Vf.wrapInstructionDiscriminator = [178, 40, 10, 189, 228, 129, 186, 140]; - function e$r( - t, - e = new U8t.PublicKey("Guard1JwRhJkVH6XZhzoYxeBVQe872VH6QggF4BWmS9g") - ) { - let [r] = Vf.wrapStruct.serialize({ - instructionDiscriminator: Vf.wrapInstructionDiscriminator, - }), - n = [ - { pubkey: t.candyGuard, isWritable: !1, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !0 }, - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.candyMachineProgram, isWritable: !1, isSigner: !1 }, - { pubkey: t.candyMachineAuthority, isWritable: !1, isSigner: !0 }, - ]; - return new U8t.TransactionInstruction({ programId: e, keys: n, data: r }); - } - Vf.createWrapInstruction = e$r; - }); - var V8t = I((Sp) => { - "use strict"; - m(); - g(); - var t$r = - (Sp && Sp.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - i3 = - (Sp && Sp.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - t$r(e, t, r); - }; - Object.defineProperty(Sp, "__esModule", { value: !0 }); - i3(E8t(), Sp); - i3(M8t(), Sp); - i3(B8t(), Sp); - i3(C8t(), Sp); - i3(D8t(), Sp); - i3(L8t(), Sp); - i3(j8t(), Sp); - i3(H8t(), Sp); - }); - var ule = I((aw) => { - "use strict"; - m(); - g(); - var r$r = - (aw && aw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - n$r = - (aw && aw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - W8t = - (aw && aw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - r$r(e, t, r); - return n$r(e, t), e; - }; - Object.defineProperty(aw, "__esModule", { value: !0 }); - aw.addressGateBeet = void 0; - var i$r = W8t(Fi()), - o$r = W8t(En()); - aw.addressGateBeet = new o$r.BeetArgsStruct( - [["address", i$r.publicKey]], - "AddressGate" - ); - }); - var OBe = I((sw) => { - "use strict"; - m(); - g(); - var a$r = - (sw && sw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - s$r = - (sw && sw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - u$r = - (sw && sw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - a$r(e, t, r); - return s$r(e, t), e; - }; - Object.defineProperty(sw, "__esModule", { value: !0 }); - sw.allowListBeet = void 0; - var PBe = u$r(En()); - sw.allowListBeet = new PBe.BeetArgsStruct( - [["merkleRoot", PBe.uniformFixedSizeArray(PBe.u8, 32)]], - "AllowList" - ); - }); - var J8t = I((uw) => { - "use strict"; - m(); - g(); - var c$r = - (uw && uw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - l$r = - (uw && uw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - f$r = - (uw && uw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - c$r(e, t, r); - return l$r(e, t), e; - }; - Object.defineProperty(uw, "__esModule", { value: !0 }); - uw.allowListProofBeet = void 0; - var G8t = f$r(En()); - uw.allowListProofBeet = new G8t.BeetArgsStruct( - [["timestamp", G8t.i64]], - "AllowListProof" - ); - }); - var IBe = I((cw) => { - "use strict"; - m(); - g(); - var d$r = - (cw && cw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - h$r = - (cw && cw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - p$r = - (cw && cw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - d$r(e, t, r); - return h$r(e, t), e; - }; - Object.defineProperty(cw, "__esModule", { value: !0 }); - cw.botTaxBeet = void 0; - var BBe = p$r(En()); - cw.botTaxBeet = new BBe.BeetArgsStruct( - [ - ["lamports", BBe.u64], - ["lastInstruction", BBe.bool], - ], - "BotTax" - ); - }); - var cle = I((lw) => { - "use strict"; - m(); - g(); - var y$r = - (lw && lw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - m$r = - (lw && lw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Z8t = - (lw && lw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - y$r(e, t, r); - return m$r(e, t), e; - }; - Object.defineProperty(lw, "__esModule", { value: !0 }); - lw.solPaymentBeet = void 0; - var $8t = Z8t(En()), - g$r = Z8t(Fi()); - lw.solPaymentBeet = new $8t.BeetArgsStruct( - [ - ["lamports", $8t.u64], - ["destination", g$r.publicKey], - ], - "SolPayment" - ); - }); - var lle = I((fw) => { - "use strict"; - m(); - g(); - var v$r = - (fw && fw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - b$r = - (fw && fw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Q8t = - (fw && fw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - v$r(e, t, r); - return b$r(e, t), e; - }; - Object.defineProperty(fw, "__esModule", { value: !0 }); - fw.tokenPaymentBeet = void 0; - var X8t = Q8t(En()), - Y8t = Q8t(Fi()); - fw.tokenPaymentBeet = new X8t.BeetArgsStruct( - [ - ["amount", X8t.u64], - ["mint", Y8t.publicKey], - ["destinationAta", Y8t.publicKey], - ], - "TokenPayment" - ); - }); - var CBe = I((dw) => { - "use strict"; - m(); - g(); - var w$r = - (dw && dw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - _$r = - (dw && dw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - x$r = - (dw && dw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - w$r(e, t, r); - return _$r(e, t), e; - }; - Object.defineProperty(dw, "__esModule", { value: !0 }); - dw.startDateBeet = void 0; - var ekt = x$r(En()); - dw.startDateBeet = new ekt.BeetArgsStruct([["date", ekt.i64]], "StartDate"); - }); - var RBe = I((hw) => { - "use strict"; - m(); - g(); - var S$r = - (hw && hw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - A$r = - (hw && hw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - tkt = - (hw && hw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - S$r(e, t, r); - return A$r(e, t), e; - }; - Object.defineProperty(hw, "__esModule", { value: !0 }); - hw.thirdPartySignerBeet = void 0; - var E$r = tkt(Fi()), - M$r = tkt(En()); - hw.thirdPartySignerBeet = new M$r.BeetArgsStruct( - [["signerKey", E$r.publicKey]], - "ThirdPartySigner" - ); - }); - var NBe = I((pw) => { - "use strict"; - m(); - g(); - var T$r = - (pw && pw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - k$r = - (pw && pw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - nkt = - (pw && pw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - T$r(e, t, r); - return k$r(e, t), e; - }; - Object.defineProperty(pw, "__esModule", { value: !0 }); - pw.tokenGateBeet = void 0; - var rkt = nkt(En()), - P$r = nkt(Fi()); - pw.tokenGateBeet = new rkt.BeetArgsStruct( - [ - ["amount", rkt.u64], - ["mint", P$r.publicKey], - ], - "TokenGate" - ); - }); - var DBe = I((yw) => { - "use strict"; - m(); - g(); - var O$r = - (yw && yw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - B$r = - (yw && yw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - okt = - (yw && yw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - O$r(e, t, r); - return B$r(e, t), e; - }; - Object.defineProperty(yw, "__esModule", { value: !0 }); - yw.gatekeeperBeet = void 0; - var I$r = okt(Fi()), - ikt = okt(En()); - yw.gatekeeperBeet = new ikt.BeetArgsStruct( - [ - ["gatekeeperNetwork", I$r.publicKey], - ["expireOnUse", ikt.bool], - ], - "Gatekeeper" - ); - }); - var fle = I((mw) => { - "use strict"; - m(); - g(); - var C$r = - (mw && mw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - R$r = - (mw && mw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - N$r = - (mw && mw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - C$r(e, t, r); - return R$r(e, t), e; - }; - Object.defineProperty(mw, "__esModule", { value: !0 }); - mw.endDateBeet = void 0; - var akt = N$r(En()); - mw.endDateBeet = new akt.BeetArgsStruct([["date", akt.i64]], "EndDate"); - }); - var LBe = I((gw) => { - "use strict"; - m(); - g(); - var D$r = - (gw && gw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - F$r = - (gw && gw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - L$r = - (gw && gw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - D$r(e, t, r); - return F$r(e, t), e; - }; - Object.defineProperty(gw, "__esModule", { value: !0 }); - gw.mintLimitBeet = void 0; - var FBe = L$r(En()); - gw.mintLimitBeet = new FBe.BeetArgsStruct( - [ - ["id", FBe.u8], - ["limit", FBe.u16], - ], - "MintLimit" - ); - }); - var qBe = I((vw) => { - "use strict"; - m(); - g(); - var q$r = - (vw && vw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - z$r = - (vw && vw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - ukt = - (vw && vw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - q$r(e, t, r); - return z$r(e, t), e; - }; - Object.defineProperty(vw, "__esModule", { value: !0 }); - vw.nftPaymentBeet = void 0; - var skt = ukt(Fi()), - j$r = ukt(En()); - vw.nftPaymentBeet = new j$r.BeetArgsStruct( - [ - ["requiredCollection", skt.publicKey], - ["destination", skt.publicKey], - ], - "NftPayment" - ); - }); - var dle = I((bw) => { - "use strict"; - m(); - g(); - var U$r = - (bw && bw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - K$r = - (bw && bw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - H$r = - (bw && bw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - U$r(e, t, r); - return K$r(e, t), e; - }; - Object.defineProperty(bw, "__esModule", { value: !0 }); - bw.redeemedAmountBeet = void 0; - var ckt = H$r(En()); - bw.redeemedAmountBeet = new ckt.BeetArgsStruct( - [["maximum", ckt.u64]], - "RedeemedAmount" - ); - }); - var hle = I((ww) => { - "use strict"; - m(); - g(); - var V$r = - (ww && ww.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - W$r = - (ww && ww.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - lkt = - (ww && ww.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - V$r(e, t, r); - return W$r(e, t), e; - }; - Object.defineProperty(ww, "__esModule", { value: !0 }); - ww.nftGateBeet = void 0; - var G$r = lkt(Fi()), - J$r = lkt(En()); - ww.nftGateBeet = new J$r.BeetArgsStruct( - [["requiredCollection", G$r.publicKey]], - "NftGate" - ); - }); - var ple = I((_w) => { - "use strict"; - m(); - g(); - var $$r = - (_w && _w.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Z$r = - (_w && _w.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - fkt = - (_w && _w.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - $$r(e, t, r); - return Z$r(e, t), e; - }; - Object.defineProperty(_w, "__esModule", { value: !0 }); - _w.nftBurnBeet = void 0; - var X$r = fkt(Fi()), - Y$r = fkt(En()); - _w.nftBurnBeet = new Y$r.BeetArgsStruct( - [["requiredCollection", X$r.publicKey]], - "NftBurn" - ); - }); - var yle = I((xw) => { - "use strict"; - m(); - g(); - var Q$r = - (xw && xw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - eZr = - (xw && xw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - hkt = - (xw && xw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - Q$r(e, t, r); - return eZr(e, t), e; - }; - Object.defineProperty(xw, "__esModule", { value: !0 }); - xw.tokenBurnBeet = void 0; - var dkt = hkt(En()), - tZr = hkt(Fi()); - xw.tokenBurnBeet = new dkt.BeetArgsStruct( - [ - ["amount", dkt.u64], - ["mint", tZr.publicKey], - ], - "TokenBurn" - ); - }); - var zBe = I((Sw) => { - "use strict"; - m(); - g(); - var rZr = - (Sw && Sw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - nZr = - (Sw && Sw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - ykt = - (Sw && Sw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - rZr(e, t, r); - return nZr(e, t), e; - }; - Object.defineProperty(Sw, "__esModule", { value: !0 }); - Sw.freezeSolPaymentBeet = void 0; - var pkt = ykt(En()), - iZr = ykt(Fi()); - Sw.freezeSolPaymentBeet = new pkt.BeetArgsStruct( - [ - ["lamports", pkt.u64], - ["destination", iZr.publicKey], - ], - "FreezeSolPayment" - ); - }); - var jBe = I((Aw) => { - "use strict"; - m(); - g(); - var oZr = - (Aw && Aw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - aZr = - (Aw && Aw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - vkt = - (Aw && Aw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - oZr(e, t, r); - return aZr(e, t), e; - }; - Object.defineProperty(Aw, "__esModule", { value: !0 }); - Aw.freezeTokenPaymentBeet = void 0; - var mkt = vkt(En()), - gkt = vkt(Fi()); - Aw.freezeTokenPaymentBeet = new mkt.BeetArgsStruct( - [ - ["amount", mkt.u64], - ["mint", gkt.publicKey], - ["destinationAta", gkt.publicKey], - ], - "FreezeTokenPayment" - ); - }); - var UBe = I((Ew) => { - "use strict"; - m(); - g(); - var sZr = - (Ew && Ew.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - uZr = - (Ew && Ew.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - wkt = - (Ew && Ew.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - sZr(e, t, r); - return uZr(e, t), e; - }; - Object.defineProperty(Ew, "__esModule", { value: !0 }); - Ew.programGateBeet = void 0; - var cZr = wkt(Fi()), - bkt = wkt(En()); - Ew.programGateBeet = new bkt.FixableBeetArgsStruct( - [["additional", bkt.array(cZr.publicKey)]], - "ProgramGate" - ); - }); - var mle = I((Mw) => { - "use strict"; - m(); - g(); - var lZr = - (Mw && Mw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - fZr = - (Mw && Mw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - dZr = - (Mw && Mw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - lZr(e, t, r); - return fZr(e, t), e; - }; - Object.defineProperty(Mw, "__esModule", { value: !0 }); - Mw.guardSetBeet = void 0; - var Ls = dZr(En()), - hZr = IBe(), - pZr = cle(), - yZr = lle(), - mZr = CBe(), - gZr = RBe(), - vZr = NBe(), - bZr = DBe(), - wZr = fle(), - _Zr = OBe(), - xZr = LBe(), - SZr = qBe(), - AZr = dle(), - EZr = ule(), - MZr = hle(), - TZr = ple(), - kZr = yle(), - PZr = zBe(), - OZr = jBe(), - BZr = UBe(); - Mw.guardSetBeet = new Ls.FixableBeetArgsStruct( - [ - ["botTax", Ls.coption(hZr.botTaxBeet)], - ["solPayment", Ls.coption(pZr.solPaymentBeet)], - ["tokenPayment", Ls.coption(yZr.tokenPaymentBeet)], - ["startDate", Ls.coption(mZr.startDateBeet)], - ["thirdPartySigner", Ls.coption(gZr.thirdPartySignerBeet)], - ["tokenGate", Ls.coption(vZr.tokenGateBeet)], - ["gatekeeper", Ls.coption(bZr.gatekeeperBeet)], - ["endDate", Ls.coption(wZr.endDateBeet)], - ["allowList", Ls.coption(_Zr.allowListBeet)], - ["mintLimit", Ls.coption(xZr.mintLimitBeet)], - ["nftPayment", Ls.coption(SZr.nftPaymentBeet)], - ["redeemedAmount", Ls.coption(AZr.redeemedAmountBeet)], - ["addressGate", Ls.coption(EZr.addressGateBeet)], - ["nftGate", Ls.coption(MZr.nftGateBeet)], - ["nftBurn", Ls.coption(TZr.nftBurnBeet)], - ["tokenBurn", Ls.coption(kZr.tokenBurnBeet)], - ["freezeSolPayment", Ls.coption(PZr.freezeSolPaymentBeet)], - ["freezeTokenPayment", Ls.coption(OZr.freezeTokenPaymentBeet)], - ["programGate", Ls.coption(BZr.programGateBeet)], - ], - "GuardSet" - ); - }); - var KBe = I((Tw) => { - "use strict"; - m(); - g(); - var IZr = - (Tw && Tw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - CZr = - (Tw && Tw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - RZr = - (Tw && Tw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - IZr(e, t, r); - return CZr(e, t), e; - }; - Object.defineProperty(Tw, "__esModule", { value: !0 }); - Tw.groupBeet = void 0; - var _kt = RZr(En()), - NZr = mle(); - Tw.groupBeet = new _kt.FixableBeetArgsStruct( - [ - ["label", _kt.utf8String], - ["guards", NZr.guardSetBeet], - ], - "Group" - ); - }); - var xkt = I((kw) => { - "use strict"; - m(); - g(); - var DZr = - (kw && kw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - FZr = - (kw && kw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - LZr = - (kw && kw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - DZr(e, t, r); - return FZr(e, t), e; - }; - Object.defineProperty(kw, "__esModule", { value: !0 }); - kw.candyGuardDataBeet = void 0; - var HBe = LZr(En()), - qZr = mle(), - zZr = KBe(); - kw.candyGuardDataBeet = new HBe.FixableBeetArgsStruct( - [ - ["default", qZr.guardSetBeet], - ["groups", HBe.coption(HBe.array(zZr.groupBeet))], - ], - "CandyGuardData" - ); - }); - var Akt = I((A0) => { - "use strict"; - m(); - g(); - var jZr = - (A0 && A0.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - UZr = - (A0 && A0.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - KZr = - (A0 && A0.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - jZr(e, t, r); - return UZr(e, t), e; - }; - Object.defineProperty(A0, "__esModule", { value: !0 }); - A0.freezeInstructionBeet = A0.FreezeInstruction = void 0; - var HZr = KZr(En()), - Skt; - (function (t) { - (t[(t.Initialize = 0)] = "Initialize"), - (t[(t.Thaw = 1)] = "Thaw"), - (t[(t.UnlockFunds = 2)] = "UnlockFunds"); - })((Skt = A0.FreezeInstruction || (A0.FreezeInstruction = {}))); - A0.freezeInstructionBeet = HZr.fixedScalarEnum(Skt); - }); - var Mkt = I((Pw) => { - "use strict"; - m(); - g(); - var VZr = - (Pw && Pw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - WZr = - (Pw && Pw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - GZr = - (Pw && Pw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - VZr(e, t, r); - return WZr(e, t), e; - }; - Object.defineProperty(Pw, "__esModule", { value: !0 }); - Pw.mintCounterBeet = void 0; - var Ekt = GZr(En()); - Pw.mintCounterBeet = new Ekt.BeetArgsStruct( - [["count", Ekt.u16]], - "MintCounter" - ); - }); - var Tkt = I((ki) => { - "use strict"; - m(); - g(); - var JZr = - (ki && ki.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Mo = - (ki && ki.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - JZr(e, t, r); - }; - Object.defineProperty(ki, "__esModule", { value: !0 }); - Mo(ule(), ki); - Mo(OBe(), ki); - Mo(J8t(), ki); - Mo(IBe(), ki); - Mo(xkt(), ki); - Mo(fle(), ki); - Mo(Akt(), ki); - Mo(zBe(), ki); - Mo(jBe(), ki); - Mo(DBe(), ki); - Mo(KBe(), ki); - Mo(mle(), ki); - Mo(_Be(), ki); - Mo(Mkt(), ki); - Mo(LBe(), ki); - Mo(ple(), ki); - Mo(hle(), ki); - Mo(qBe(), ki); - Mo(UBe(), ki); - Mo(dle(), ki); - Mo(xBe(), ki); - Mo(cle(), ki); - Mo(CBe(), ki); - Mo(RBe(), ki); - Mo(yle(), ki); - Mo(NBe(), ki); - Mo(lle(), ki); - }); - var vle = I((ah) => { - "use strict"; - m(); - g(); - var $Zr = - (ah && ah.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - gle = - (ah && ah.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - $Zr(e, t, r); - }; - Object.defineProperty(ah, "__esModule", { value: !0 }); - ah.PROGRAM_ID = ah.PROGRAM_ADDRESS = void 0; - var ZZr = Le(); - gle(x8t(), ah); - gle(S8t(), ah); - gle(V8t(), ah); - gle(Tkt(), ah); - ah.PROGRAM_ADDRESS = "Guard1JwRhJkVH6XZhzoYxeBVQe872VH6QggF4BWmS9g"; - ah.PROGRAM_ID = new ZZr.PublicKey(ah.PROGRAM_ADDRESS); - }); - var kkt = I((ble) => { - "use strict"; - m(); - g(); - Object.defineProperty(ble, "__esModule", { value: !0 }); - ble.cusper = void 0; - var XZr = JN(), - YZr = vle(); - ble.cusper = (0, XZr.initCusper)(YZr.errorFromCode); - }); - var VBe = I((mm) => { - "use strict"; - m(); - g(); - var QZr = - (mm && mm.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(mm, "__esModule", { value: !0 }); - mm.logTrace = mm.logDebug = mm.logInfo = mm.logError = void 0; - var wle = QZr(Nx()); - mm.logError = (0, wle.default)("candy-guard:error"); - mm.logInfo = (0, wle.default)("candy-guard:info"); - mm.logDebug = (0, wle.default)("candy-guard:debug"); - mm.logTrace = (0, wle.default)("candy-guard:trace"); - }); - var Hkt = I((gm) => { - "use strict"; - m(); - g(); - var eXr = - (gm && gm.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - tXr = - (gm && gm.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - rXr = - (gm && gm.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - eXr(e, t, r); - return tXr(e, t), e; - }; - Object.defineProperty(gm, "__esModule", { value: !0 }); - gm.serialize = gm.deserialize = void 0; - var Ckt = Ho(), - _le = rXr(En()), - nXr = VBe(), - Wa = vle(), - Rkt = cle(), - Nkt = lle(), - Dkt = fle(), - Fkt = dle(), - Lkt = ule(), - qkt = hle(), - zkt = ple(), - jkt = yle(), - hD = En(), - Mn = { - botTax: 9, - solPayment: 40, - tokenPayment: 72, - startDate: 8, - thirdPartySigner: 32, - tokenGate: 40, - gatekeeper: 33, - endDate: 8, - allowList: 32, - mintLimit: 3, - nftPayment: 64, - redeemedAmount: 8, - addressGate: 32, - nftGate: 32, - nftBurn: 32, - tokenBurn: 40, - freezeSolPayment: 40, - freezeTokenPayment: 72, - programGate: 164, - }, - Ukt = [ - "botTax", - "solPayment", - "tokenPayment", - "startDate", - "thirdPartySigner", - "tokenGate", - "gatekeeper", - "endDate", - "allowList", - "mintLimit", - "nftPayment", - "redeemedAmount", - "addressGate", - "nftGate", - "nftBurn", - "tokenBurn", - "freezeSolPayment", - "freezeTokenPayment", - "programGate", - ], - Kkt = Ukt.length, - bO = 6, - Pkt = 5; - function iXr(t) { - let e = new Ckt.BN(_le.u64.read(t, 0)).toNumber(), - r = []; - for (let $ = 0; $ < Kkt; $++) r.push(!!((1 << $) & e)); - let [n, i, o, a, s, c, u, h, w, M, k, O, D, F, N, q, z, H, Z] = r; - return { - botTaxEnabled: n, - solPaymentEnabled: i, - tokenPaymentEnabled: o, - startDateEnabled: a, - thirdPartySignerEnabled: s, - tokenGateEnabled: c, - gatekeeperEnabled: u, - endDateEnabled: h, - allowListEnabled: w, - mintLimitEnabled: M, - nftPaymentEnabled: k, - redeemedAmountEnabled: O, - addressGateEnabled: D, - nftGateEnabled: F, - nftBurnEnabled: N, - tokenBurnEnabled: q, - freezeSolPaymentEnabled: z, - freezeTokenPaymentEnabled: H, - programGateEnabled: Z, - }; - } - function oXr(t) { - let { guardSet: e, offset: r } = Bkt(t), - n = new Ckt.BN(_le.u32.read(t, r)).toNumber(), - i = [], - o = _le.u32.byteSize + r; - for (let a = 0; a < n; a++) { - let s = t.subarray(o, o + bO).toString(); - o += bO; - let { guardSet: c, offset: u } = Bkt(t.subarray(o)); - i.push({ label: s, guards: c }), (o += u); - } - return { default: e, groups: i.length === 0 ? null : i }; - } - gm.deserialize = oXr; - function aXr(t) { - let e = Buffer.alloc(sXr(t)), - r = Ikt(e, 0, t.default), - n = t.groups ? t.groups.length : 0; - hD.u32.write(e, r, n), (r += hD.u32.byteSize); - for (let i = 0; i < n; i++) { - let o = t.groups.at(i); - if (o.label.length > bO) - throw `Exceeded maximum label length: ${o.label.length} > ${bO}`; - e.write(o.label, r, bO, "utf8"), (r += bO), (r = Ikt(e, r, o.guards)); - } - return e; - } - gm.serialize = aXr; - function sXr(t) { - let e = Okt(t.default); - if (((e += hD.u32.byteSize), t.groups)) - for (let r = 0; r < t.groups.length; r++) - (e += bO), (e += Okt(t.groups.at(r).guards)); - return e; - } - function Okt(t) { - let e = []; - for (let r = 0; r < Kkt; r++) { - let n = Ukt[r]; - t[n] && e.push(Mn[n]); - } - return hD.u64.byteSize + e.reduce((r, n) => r + n, 0); - } - function Bkt(t) { - var e, r, n, i, o, a, s, c, u, h, w, M, k, O, D, F, N, q, z; - let H = iXr(t), - { - botTaxEnabled: Z, - startDateEnabled: $, - solPaymentEnabled: ue, - tokenPaymentEnabled: te, - thirdPartySignerEnabled: ne, - tokenGateEnabled: A, - gatekeeperEnabled: l, - endDateEnabled: p, - allowListEnabled: y, - mintLimitEnabled: d, - nftPaymentEnabled: v, - redeemedAmountEnabled: _, - addressGateEnabled: S, - nftGateEnabled: b, - nftBurnEnabled: f, - tokenBurnEnabled: x, - freezeSolPaymentEnabled: C, - freezeTokenPaymentEnabled: E, - programGateEnabled: B, - } = H; - (0, nXr.logDebug)("Guards: %O", H); - let G = _le.u64.byteSize, - L = {}; - if (Z) { - let [ee] = Wa.botTaxBeet.deserialize(t, G); - (L.botTax = ee), (G += Mn.botTax); - } - if (ue) { - let [ee] = Rkt.solPaymentBeet.deserialize(t, G); - (L.solPayment = ee), (G += Mn.solPayment); - } - if (te) { - let [ee] = Nkt.tokenPaymentBeet.deserialize(t, G); - (L.tokenPayment = ee), (G += Mn.tokenPayment); - } - if ($) { - let [ee] = Wa.startDateBeet.deserialize(t, G); - (L.startDate = ee), (G += Mn.startDate); - } - if (ne) { - let [ee] = Wa.thirdPartySignerBeet.deserialize(t, G); - (L.thirdPartySigner = ee), (G += Mn.thirdPartySigner); - } - if (A) { - let [ee] = Wa.tokenGateBeet.deserialize(t, G); - (L.tokenGate = ee), (G += Mn.tokenGate); - } - if (l) { - let [ee] = Wa.gatekeeperBeet.deserialize(t, G); - (L.gatekeeper = ee), (G += Mn.gatekeeper); - } - if (p) { - let [ee] = Dkt.endDateBeet.deserialize(t, G); - (L.endDate = ee), (G += Mn.endDate); - } - if (y) { - let [ee] = Wa.allowListBeet.deserialize(t, G); - (L.allowList = ee), (G += Mn.allowList); - } - if (d) { - let [ee] = Wa.mintLimitBeet.deserialize(t, G); - (L.mintLimit = ee), (G += Mn.mintLimit); - } - if (v) { - let [ee] = Wa.nftPaymentBeet.deserialize(t, G); - (L.nftPayment = ee), (G += Mn.nftPayment); - } - if (_) { - let [ee] = Fkt.redeemedAmountBeet.deserialize(t, G); - (L.redeemedAmount = ee), (G += Mn.redeemedAmount); - } - if (S) { - let [ee] = Lkt.addressGateBeet.deserialize(t, G); - (L.addressGate = ee), (G += Mn.addressGate); - } - if (b) { - let [ee] = qkt.nftGateBeet.deserialize(t, G); - (L.nftGate = ee), (G += Mn.nftGate); - } - if (f) { - let [ee] = zkt.nftBurnBeet.deserialize(t, G); - (L.nftBurn = ee), (G += Mn.nftBurn); - } - if (x) { - let [ee] = jkt.tokenBurnBeet.deserialize(t, G); - (L.tokenBurn = ee), (G += Mn.tokenBurn); - } - if (C) { - let [ee] = Wa.freezeSolPaymentBeet.deserialize(t, G); - (L.freezeSolPayment = ee), (G += Mn.freezeSolPayment); - } - if (E) { - let [ee] = Wa.freezeTokenPaymentBeet.deserialize(t, G); - (L.freezeTokenPayment = ee), (G += Mn.freezeTokenPayment); - } - if (B) { - let [ee] = Wa.programGateBeet.deserialize(t, G); - (L.programGate = ee), (G += Mn.programGate); - } - return { - guardSet: { - botTax: (e = L.botTax) !== null && e !== void 0 ? e : null, - solPayment: (r = L.solPayment) !== null && r !== void 0 ? r : null, - tokenPayment: - (n = L.tokenPayment) !== null && n !== void 0 ? n : null, - startDate: (i = L.startDate) !== null && i !== void 0 ? i : null, - thirdPartySigner: - (o = L.thirdPartySigner) !== null && o !== void 0 ? o : null, - tokenGate: (a = L.tokenGate) !== null && a !== void 0 ? a : null, - gatekeeper: (s = L.gateKeeper) !== null && s !== void 0 ? s : null, - endDate: (c = L.endDate) !== null && c !== void 0 ? c : null, - allowList: (u = L.allowList) !== null && u !== void 0 ? u : null, - mintLimit: (h = L.mintLimit) !== null && h !== void 0 ? h : null, - nftPayment: (w = L.nftPayment) !== null && w !== void 0 ? w : null, - redeemedAmount: - (M = L.redeemedAmount) !== null && M !== void 0 ? M : null, - addressGate: (k = L.addressGate) !== null && k !== void 0 ? k : null, - nftGate: (O = L.nftGate) !== null && O !== void 0 ? O : null, - nftBurn: (D = L.nftBurn) !== null && D !== void 0 ? D : null, - tokenBurn: (F = L.tokenBurn) !== null && F !== void 0 ? F : null, - freezeSolPayment: - (N = L.freezeSolPayment) !== null && N !== void 0 ? N : null, - freezeTokenPayment: - (q = L.freezeTokenPayment) !== null && q !== void 0 ? q : null, - programGate: (z = L.programGate) !== null && z !== void 0 ? z : null, - }, - offset: G, - }; - } - function Ikt(t, e, r) { - let n = e; - e += hD.u64.byteSize; - let i = 0, - o = 0; - if ( - (r.botTax && - (Wa.botTaxBeet.write(t, e, r.botTax), - (e += Mn.botTax), - (i |= 1 << o)), - o++, - r.solPayment && - (Rkt.solPaymentBeet.write(t, e, r.solPayment), - (e += Mn.solPayment), - (i |= 1 << o)), - o++, - r.tokenPayment && - (Nkt.tokenPaymentBeet.write(t, e, r.tokenPayment), - (e += Mn.tokenPayment), - (i |= 1 << o)), - o++, - r.startDate && - (Wa.startDateBeet.write(t, e, r.startDate), - (e += Mn.startDate), - (i |= 1 << o)), - o++, - r.thirdPartySigner && - (Wa.thirdPartySignerBeet.write(t, e, r.thirdPartySigner), - (e += Mn.thirdPartySigner), - (i |= 1 << o)), - o++, - r.tokenGate && - (Wa.tokenGateBeet.write(t, e, r.tokenGate), - (e += Mn.tokenGate), - (i |= 1 << o)), - o++, - r.gatekeeper && - (Wa.gatekeeperBeet.write(t, e, r.gatekeeper), - (e += Mn.gatekeeper), - (i |= 1 << o)), - o++, - r.endDate && - (Dkt.endDateBeet.write(t, e, r.endDate), - (e += Mn.endDate), - (i |= 1 << o)), - o++, - r.allowList && - (Wa.allowListBeet.write(t, e, r.allowList), - (e += Mn.allowList), - (i |= 1 << o)), - o++, - r.mintLimit && - (Wa.mintLimitBeet.write(t, e, r.mintLimit), - (e += Mn.mintLimit), - (i |= 1 << o)), - o++, - r.nftPayment && - (Wa.nftPaymentBeet.write(t, e, r.nftPayment), - (e += Mn.nftPayment), - (i |= 1 << o)), - o++, - r.redeemedAmount && - (Fkt.redeemedAmountBeet.write(t, e, r.redeemedAmount), - (e += Mn.redeemedAmount), - (i |= 1 << o)), - o++, - r.addressGate && - (Lkt.addressGateBeet.write(t, e, r.addressGate), - (e += Mn.addressGate), - (i |= 1 << o)), - o++, - r.nftGate && - (qkt.nftGateBeet.write(t, e, r.nftGate), - (e += Mn.nftGate), - (i |= 1 << o)), - o++, - r.nftBurn && - (zkt.nftBurnBeet.write(t, e, r.nftBurn), - (e += Mn.nftBurn), - (i |= 1 << o)), - o++, - r.tokenBurn && - (jkt.tokenBurnBeet.write(t, e, r.tokenBurn), - (e += Mn.tokenBurn), - (i |= 1 << o)), - o++, - r.freezeSolPayment && - (Wa.freezeSolPaymentBeet.write(t, e, r.freezeSolPayment), - (e += Mn.freezeSolPayment), - (i |= 1 << o)), - o++, - r.freezeTokenPayment && - (Wa.freezeTokenPaymentBeet.write(t, e, r.freezeTokenPayment), - (e += Mn.freezeTokenPayment), - (i |= 1 << o)), - o++, - r.programGate) - ) { - if (r.programGate.additional && r.programGate.additional.length > Pkt) - throw `Exceeded maximum number of programs on additional list: ${r.programGate.additional.length} > ${Pkt}`; - let [a] = Wa.programGateBeet.serialize(r.programGate, Mn.programGate); - a.copy(t, e), (e += Mn.programGate), (i |= 1 << o); - } - return o++, hD.u64.write(t, n, i), e; - } - }); - var vo = I((Ow) => { - "use strict"; - m(); - g(); - var uXr = - (Ow && Ow.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - xle = - (Ow && Ow.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - uXr(e, t, r); - }; - Object.defineProperty(Ow, "__esModule", { value: !0 }); - xle(vle(), Ow); - xle(kkt(), Ow); - xle(Hkt(), Ow); - xle(VBe(), Ow); - }); - var vm = I((Wf) => { - "use strict"; - m(); - g(); - Object.defineProperty(Wf, "__esModule", { value: !0 }); - Wf.isElementCollectionFixedSizeBeet = - Wf.isFixableBeet = - Wf.assertFixedSizeBeet = - Wf.isFixedSizeBeet = - Wf.BEET_TYPE_ARG_INNER = - Wf.BEET_TYPE_ARG_LEN = - Wf.BEET_PACKAGE = - void 0; - var lXr = Dr(); - Wf.BEET_PACKAGE = "@metaplex-foundation/beet"; - Wf.BEET_TYPE_ARG_LEN = "len"; - Wf.BEET_TYPE_ARG_INNER = "Beet<{innner}>"; - function Ykt(t) { - return Object.keys(t).includes("byteSize"); - } - Wf.isFixedSizeBeet = Ykt; - function fXr(t, e = `${t} should have been a fixed beet`) { - (0, lXr.strict)(Ykt(t), e); - } - Wf.assertFixedSizeBeet = fXr; - function dXr(t) { - return ( - typeof t.toFixedFromData == "function" && - typeof t.toFixedFromValue == "function" - ); - } - Wf.isFixableBeet = dXr; - function hXr(t) { - let e = Object.keys(t); - return ( - e.includes("length") && - e.includes("elementByteSize") && - e.includes("lenPrefixByteSize") - ); - } - Wf.isElementCollectionFixedSizeBeet = hXr; - }); - var yD = I((Vn) => { - "use strict"; - m(); - g(); - var pXr = - (Vn && Vn.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Vn, "__esModule", { value: !0 }); - Vn.numbersTypeMap = - Vn.bool = - Vn.i512 = - Vn.i256 = - Vn.i128 = - Vn.i64 = - Vn.i32 = - Vn.i16 = - Vn.i8 = - Vn.u512 = - Vn.u256 = - Vn.u128 = - Vn.u64 = - Vn.u32 = - Vn.u16 = - Vn.u8 = - void 0; - var pD = pXr(Ho()), - Ta = vm(); - Vn.u8 = { - write: function (t, e, r) { - t.writeUInt8(r, e); - }, - read: function (t, e) { - return t.readUInt8(e); - }, - byteSize: 1, - description: "u8", - }; - Vn.u16 = { - write: function (t, e, r) { - t.writeUInt16LE(r, e); - }, - read: function (t, e) { - return t.readUInt16LE(e); - }, - byteSize: 2, - description: "u16", - }; - Vn.u32 = { - write: function (t, e, r) { - t.writeUInt32LE(r, e); - }, - read: function (t, e) { - return t.readUInt32LE(e); - }, - byteSize: 4, - description: "u32", - }; - function Nle(t, e) { - return { - write: function (r, n, i) { - let a = (pD.default.isBN(i) ? i : new pD.default(i)).toArray( - "le", - this.byteSize - ); - Buffer.from(a).copy(r, n, 0, this.byteSize); - }, - read: function (r, n) { - let i = r.slice(n, n + this.byteSize); - return new pD.default(i, "le"); - }, - byteSize: t, - description: e, - }; - } - Vn.u64 = Nle(8, "u64"); - Vn.u128 = Nle(16, "u128"); - Vn.u256 = Nle(32, "u256"); - Vn.u512 = Nle(64, "u512"); - Vn.i8 = { - write: function (t, e, r) { - t.writeInt8(r, e); - }, - read: function (t, e) { - return t.readInt8(e); - }, - byteSize: 1, - description: "i8", - }; - Vn.i16 = { - write: function (t, e, r) { - t.writeInt16LE(r, e); - }, - read: function (t, e) { - return t.readInt16LE(e); - }, - byteSize: 2, - description: "i16", - }; - Vn.i32 = { - write: function (t, e, r) { - t.writeInt32LE(r, e); - }, - read: function (t, e) { - return t.readInt32LE(e); - }, - byteSize: 4, - description: "i32", - }; - function Dle(t, e) { - let r = t * 8; - return { - write: function (n, i, o) { - let s = (pD.default.isBN(o) ? o : new pD.default(o)) - .toTwos(r) - .toArray("le", this.byteSize); - Buffer.from(s).copy(n, i, 0, this.byteSize); - }, - read: function (n, i) { - let o = n.slice(i, i + this.byteSize); - return new pD.default(o, "le").fromTwos(r); - }, - byteSize: t, - description: e, - }; - } - Vn.i64 = Dle(8, "i64"); - Vn.i128 = Dle(16, "i128"); - Vn.i256 = Dle(32, "i256"); - Vn.i512 = Dle(64, "i512"); - Vn.bool = { - write: function (t, e, r) { - let n = r ? 1 : 0; - Vn.u8.write(t, e, n); - }, - read: function (t, e) { - return Vn.u8.read(t, e) === 1; - }, - byteSize: 1, - description: "bool", - }; - Vn.numbersTypeMap = { - u8: { - beet: "u8", - isFixable: !1, - sourcePack: Ta.BEET_PACKAGE, - ts: "number", - }, - u16: { - beet: "u16", - isFixable: !1, - sourcePack: Ta.BEET_PACKAGE, - ts: "number", - }, - u32: { - beet: "u32", - isFixable: !1, - sourcePack: Ta.BEET_PACKAGE, - ts: "number", - }, - i8: { - beet: "i8", - isFixable: !1, - sourcePack: Ta.BEET_PACKAGE, - ts: "number", - }, - i16: { - beet: "i16", - isFixable: !1, - sourcePack: Ta.BEET_PACKAGE, - ts: "number", - }, - i32: { - beet: "i32", - isFixable: !1, - sourcePack: Ta.BEET_PACKAGE, - ts: "number", - }, - bool: { - beet: "bool", - isFixable: !1, - sourcePack: Ta.BEET_PACKAGE, - ts: "boolean", - }, - u64: { - beet: "u64", - isFixable: !1, - sourcePack: Ta.BEET_PACKAGE, - ts: "bignum", - pack: Ta.BEET_PACKAGE, - }, - u128: { - beet: "u128", - isFixable: !1, - sourcePack: Ta.BEET_PACKAGE, - ts: "bignum", - pack: Ta.BEET_PACKAGE, - }, - u256: { - beet: "u256", - isFixable: !1, - sourcePack: Ta.BEET_PACKAGE, - ts: "bignum", - pack: Ta.BEET_PACKAGE, - }, - u512: { - beet: "u512", - isFixable: !1, - sourcePack: Ta.BEET_PACKAGE, - ts: "bignum", - pack: Ta.BEET_PACKAGE, - }, - i64: { - beet: "i64", - isFixable: !1, - sourcePack: Ta.BEET_PACKAGE, - ts: "bignum", - pack: Ta.BEET_PACKAGE, - }, - i128: { - beet: "i128", - isFixable: !1, - sourcePack: Ta.BEET_PACKAGE, - ts: "bignum", - pack: Ta.BEET_PACKAGE, - }, - i256: { - beet: "i256", - isFixable: !1, - sourcePack: Ta.BEET_PACKAGE, - ts: "bignum", - pack: Ta.BEET_PACKAGE, - }, - i512: { - beet: "i512", - isFixable: !1, - sourcePack: Ta.BEET_PACKAGE, - ts: "bignum", - pack: Ta.BEET_PACKAGE, - }, - }; - }); - var mD = I((Gf) => { - "use strict"; - m(); - g(); - var ePt = - (Gf && Gf.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Gf, "__esModule", { value: !0 }); - Gf.bytes = - Gf.beetBytes = - Gf.logTrace = - Gf.logDebug = - Gf.logInfo = - Gf.logError = - void 0; - var Fle = ePt(Nx()), - yXr = ePt(Mg()), - Qkt = vm(), - { brightBlack: tPt } = yXr.default; - Gf.logError = (0, Fle.default)("beet:error"); - Gf.logInfo = (0, Fle.default)("beet:info"); - Gf.logDebug = (0, Fle.default)("beet:debug"); - Gf.logTrace = (0, Fle.default)("beet:trace"); - function mXr(t, e = !1) { - let r; - if ((0, Qkt.isFixableBeet)(t)) r = "? B"; - else if ((0, Qkt.isElementCollectionFixedSizeBeet)(t)) { - let n = e ? "length" : t.length, - i = t.lenPrefixByteSize; - r = - i > 0 - ? `${i} + (${t.elementByteSize} * ${n}) B (${t.byteSize} B)` - : `(${t.elementByteSize} * ${n}) B (${t.byteSize} B)`; - } else r = `${t.byteSize} B`; - return tPt(r); - } - Gf.beetBytes = mXr; - function gXr(t) { - return tPt(`${t} B`); - } - Gf.bytes = gXr; - }); - var NV = I((gD) => { - "use strict"; - m(); - g(); - Object.defineProperty(gD, "__esModule", { value: !0 }); - gD.fixBeetFromValue = gD.fixBeetFromData = void 0; - var Lle = vm(); - function vXr(t, e, r) { - if ((0, Lle.isFixedSizeBeet)(t)) return t; - if ((0, Lle.isFixableBeet)(t)) return t.toFixedFromData(e, r); - throw new Error(`${t.description} is neither fixed size nor fixable`); - } - gD.fixBeetFromData = vXr; - function bXr(t, e) { - if ((0, Lle.isFixedSizeBeet)(t)) return t; - if ((0, Lle.isFixableBeet)(t)) return t.toFixedFromValue(e); - throw new Error(`${t.description} is neither fixed size nor fixable`); - } - gD.fixBeetFromValue = bXr; - }); - var qle = I((Jf) => { - "use strict"; - m(); - g(); - Object.defineProperty(Jf, "__esModule", { value: !0 }); - Jf.collectionsTypeMap = - Jf.uint8Array = - Jf.fixedSizeUint8Array = - Jf.fixedSizeBuffer = - Jf.array = - Jf.fixedSizeArray = - Jf.uniformFixedSizeArray = - void 0; - var vD = vm(), - wO = Dr(), - o3 = yD(), - bD = vm(), - nPt = mD(), - rPt = NV(); - function wXr(t, e, r = !1) { - let n = t.byteSize * e, - i = r ? 4 + n : n; - return { - write: function (o, a, s) { - wO.strict.equal( - s.length, - e, - `array length ${s.length} should match len ${e}` - ), - r && (o3.u32.write(o, a, e), (a += 4)); - for (let c = 0; c < e; c++) t.write(o, a + c * t.byteSize, s[c]); - }, - read: function (o, a) { - if (r) { - let c = o3.u32.read(o, a); - wO.strict.equal(c, e, "invalid byte size"), (a += 4); - } - let s = new Array(e); - for (let c = 0; c < e; c++) s[c] = t.read(o, a + c * t.byteSize); - return s; - }, - byteSize: i, - length: e, - elementByteSize: t.byteSize, - lenPrefixByteSize: 4, - description: `Array<${t.description}>(${e})`, - }; - } - Jf.uniformFixedSizeArray = wXr; - function JBe(t, e) { - let r = t.length, - n = r === 0 ? "" : t[0].description; - return { - write: function (i, o, a) { - wO.strict.equal( - a.length, - r, - `array length ${a.length} should match len ${r}` - ), - o3.u32.write(i, o, r); - let s = o + 4; - for (let c = 0; c < r; c++) { - let u = t[c]; - u.write(i, s, a[c]), (s += u.byteSize); - } - }, - read: function (i, o) { - let a = o3.u32.read(i, o); - wO.strict.equal(a, r, "invalid byte size"); - let s = o + 4, - c = new Array(r); - for (let u = 0; u < r; u++) { - let h = t[u]; - (c[u] = h.read(i, s)), (s += h.byteSize); - } - return c; - }, - byteSize: 4 + e, - length: r, - description: `Array<${n}>(${r})[ 4 + ${e} ]`, - }; - } - Jf.fixedSizeArray = JBe; - function _Xr(t) { - return { - toFixedFromData(e, r) { - let n = o3.u32.read(e, r); - (0, nPt.logTrace)(`${this.description}[${n}]`); - let i = r + 4, - o = i, - a = new Array(n); - for (let s = 0; s < n; s++) { - let c = (0, rPt.fixBeetFromData)(t, e, o); - (a[s] = c), (o += c.byteSize); - } - return JBe(a, o - i); - }, - toFixedFromValue(e) { - (0, wO.strict)(Array.isArray(e), `${e} should be an array`); - let r = 0, - n = new Array(e.length); - for (let i = 0; i < e.length; i++) { - let o = (0, rPt.fixBeetFromValue)(t, e[i]); - (n[i] = o), (r += o.byteSize); - } - return JBe(n, r); - }, - description: "array", - }; - } - Jf.array = _Xr; - function iPt(t) { - return { - write: function (e, r, n) { - n.copy(e, r, 0, t); - }, - read: function (e, r) { - return e.slice(r, r + t); - }, - byteSize: t, - description: `Buffer(${t})`, - }; - } - Jf.fixedSizeBuffer = iPt; - function $Be(t, e = !1) { - let r = iPt(t), - n = e ? t + 4 : t; - return { - write: function (i, o, a) { - wO.strict.equal( - a.byteLength, - t, - `Uint8Array length ${a.byteLength} should match len ${t}` - ), - e && (o3.u32.write(i, o, t), (o += 4)); - let s = Buffer.from(a); - r.write(i, o, s); - }, - read: function (i, o) { - if (e) { - let s = o3.u32.read(i, o); - wO.strict.equal(s, t, "invalid byte size"), (o += 4); - } - let a = r.read(i, o); - return Uint8Array.from(a); - }, - byteSize: n, - description: `Uint8Array(${t})`, - }; - } - Jf.fixedSizeUint8Array = $Be; - Jf.uint8Array = { - toFixedFromData(t, e) { - let r = o3.u32.read(t, e); - return (0, nPt.logTrace)(`${this.description}[${r}]`), $Be(r, !0); - }, - toFixedFromValue(t) { - let e = t.byteLength; - return $Be(e, !0); - }, - description: "Uint8Array", - }; - Jf.collectionsTypeMap = { - Array: { - beet: "array", - isFixable: !0, - sourcePack: bD.BEET_PACKAGE, - ts: "Array", - arg: vD.BEET_TYPE_ARG_LEN, - }, - FixedSizeArray: { - beet: "fixedSizeArray", - isFixable: !1, - sourcePack: bD.BEET_PACKAGE, - ts: "Array", - arg: vD.BEET_TYPE_ARG_LEN, - }, - UniformFixedSizeArray: { - beet: "uniformFixedSizeArray", - isFixable: !1, - sourcePack: bD.BEET_PACKAGE, - ts: "Array", - arg: vD.BEET_TYPE_ARG_LEN, - }, - Buffer: { - beet: "fixedSizeBuffer", - isFixable: !1, - sourcePack: bD.BEET_PACKAGE, - ts: "Buffer", - arg: vD.BEET_TYPE_ARG_LEN, - }, - FixedSizeUint8Array: { - beet: "fixedSizeUint8Array", - isFixable: !1, - sourcePack: bD.BEET_PACKAGE, - ts: "Uint8Array", - arg: vD.BEET_TYPE_ARG_LEN, - }, - Uint8Array: { - beet: "uint8Array", - isFixable: !0, - sourcePack: bD.BEET_PACKAGE, - ts: "Uint8Array", - arg: vD.BEET_TYPE_ARG_LEN, - }, - }; - }); - var tIe = I((Ep) => { - "use strict"; - m(); - g(); - Object.defineProperty(Ep, "__esModule", { value: !0 }); - Ep.compositesTypeMap = - Ep.coption = - Ep.coptionSome = - Ep.coptionNone = - Ep.isNoneBuffer = - Ep.isSomeBuffer = - void 0; - var DV = Dr(), - ZBe = vm(), - oPt = vm(), - sPt = mD(), - aPt = NV(), - uPt = 0, - cPt = 1; - function QBe(t, e) { - return t[e] === cPt; - } - Ep.isSomeBuffer = QBe; - function eIe(t, e) { - return t[e] === uPt; - } - Ep.isNoneBuffer = eIe; - function XBe(t) { - return ( - (0, sPt.logTrace)(`coptionNone(${t})`), - { - write: function (e, r, n) { - (0, DV.strict)( - n == null, - "coptionNone can only handle `null` values" - ), - (e[r] = uPt); - }, - read: function (e, r) { - return ( - (0, DV.strict)( - eIe(e, r), - "coptionNone can only handle `NONE` data" - ), - null - ); - }, - byteSize: 1, - description: `COption`, - } - ); - } - Ep.coptionNone = XBe; - function YBe(t) { - let e = 1 + t.byteSize, - r = { - write: function (n, i, o) { - (0, ZBe.assertFixedSizeBeet)( - t, - `coption inner type ${t.description} needs to be fixed before calling write` - ), - (0, DV.strict)( - o != null, - "coptionSome cannot handle `null` values" - ), - (n[i] = cPt), - t.write(n, i + 1, o); - }, - read: function (n, i) { - return ( - (0, ZBe.assertFixedSizeBeet)( - t, - `coption inner type ${t.description} needs to be fixed before calling read` - ), - (0, DV.strict)( - QBe(n, i), - "coptionSome can only handle `SOME` data" - ), - t.read(n, i + 1) - ); - }, - description: `COption<${t.description}>[1 + ${t.byteSize}]`, - byteSize: e, - inner: t, - }; - return (0, sPt.logTrace)(r.description), r; - } - Ep.coptionSome = YBe; - function xXr(t) { - return { - toFixedFromData(e, r) { - if (QBe(e, r)) { - let n = (0, aPt.fixBeetFromData)(t, e, r + 1); - return YBe(n); - } else - return ( - (0, DV.strict)(eIe(e, r), `Expected ${e} to hold a COption`), - XBe(t.description) - ); - }, - toFixedFromValue(e) { - return e == null - ? XBe(t.description) - : YBe((0, aPt.fixBeetFromValue)(t, e)); - }, - description: `COption<${t.description}>`, - }; - } - Ep.coption = xXr; - Ep.compositesTypeMap = { - option: { - beet: "coption", - isFixable: !0, - sourcePack: oPt.BEET_PACKAGE, - ts: "COption", - arg: ZBe.BEET_TYPE_ARG_INNER, - pack: oPt.BEET_PACKAGE, - }, - }; - }); - var iIe = I((Iw) => { - "use strict"; - m(); - g(); - Object.defineProperty(Iw, "__esModule", { value: !0 }); - Iw.stringTypeMap = Iw.utf8String = Iw.fixedSizeUtf8String = void 0; - var rIe = vm(), - lPt = Dr(), - nIe = yD(), - SXr = mD(), - AXr = (t) => ({ - write: function (e, r, n) { - let i = Buffer.from(n, "utf8"); - lPt.strict.equal(i.byteLength, t, `${n} has invalid byte size`), - nIe.u32.write(e, r, t), - i.copy(e, r + 4, 0, t); - }, - read: function (e, r) { - let n = nIe.u32.read(e, r); - return ( - lPt.strict.equal(n, t, "invalid byte size"), - e.slice(r + 4, r + 4 + t).toString("utf8") - ); - }, - elementByteSize: 1, - length: t, - lenPrefixByteSize: 4, - byteSize: 4 + t, - description: `Utf8String(4 + ${t})`, - }); - Iw.fixedSizeUtf8String = AXr; - Iw.utf8String = { - toFixedFromData(t, e) { - let r = nIe.u32.read(t, e); - return ( - (0, SXr.logTrace)(`${this.description}[${r}]`), - (0, Iw.fixedSizeUtf8String)(r) - ); - }, - toFixedFromValue(t) { - let e = Buffer.from(t).byteLength; - return (0, Iw.fixedSizeUtf8String)(e); - }, - description: "Utf8String", - }; - Iw.stringTypeMap = { - fixedSizeString: { - beet: "fixedSizeUtf8String", - isFixable: !1, - sourcePack: rIe.BEET_PACKAGE, - ts: "string", - arg: rIe.BEET_TYPE_ARG_LEN, - }, - string: { - beet: "utf8String", - isFixable: !0, - sourcePack: rIe.BEET_PACKAGE, - ts: "string", - }, - }; - }); - var sIe = I((wD) => { - "use strict"; - m(); - g(); - Object.defineProperty(wD, "__esModule", { value: !0 }); - wD.BeetReader = wD.BeetWriter = void 0; - var EXr = Dr(), - oIe = class { - constructor(e) { - (this.buf = Buffer.alloc(e)), (this._offset = 0); - } - get buffer() { - return this.buf; - } - get offset() { - return this._offset; - } - maybeResize(e) { - this._offset + e > this.buf.length && - EXr.strict.fail( - `We shouldn't ever need to resize, but ${this._offset + e} > ${ - this.buf.length - }` - ); - } - write(e, r) { - this.maybeResize(e.byteSize), - e.write(this.buf, this._offset, r), - (this._offset += e.byteSize); - } - writeStruct(e, r) { - for (let [n, i] of r) { - let o = e[n]; - this.write(i, o); - } - } - }; - wD.BeetWriter = oIe; - var aIe = class { - constructor(e, r = 0) { - (this.buffer = e), (this._offset = r); - } - get offset() { - return this._offset; - } - read(e) { - let r = e.read(this.buffer, this._offset); - return (this._offset += e.byteSize), r; - } - readStruct(e) { - let r = {}; - for (let [n, i] of e) r[n] = this.read(i); - return r; - } - }; - wD.BeetReader = aIe; - }); - var zle = I((a3) => { - "use strict"; - m(); - g(); - Object.defineProperty(a3, "__esModule", { value: !0 }); - a3.BeetArgsStruct = a3.isBeetStruct = a3.BeetStruct = void 0; - var fPt = sIe(), - nS = mD(), - Cw = class { - constructor(e, r, n = Cw.description) { - if ( - ((this.fields = e), - (this.construct = r), - (this.description = n), - (this.byteSize = this.getByteSize()), - nS.logDebug.enabled) - ) { - let i = e.map( - ([o, a]) => - `${String(o)}: ${a.description} ${(0, nS.beetBytes)(a)}` - ).join(` - `); - (0, nS.logDebug)(`struct ${n} { - ${i} -} ${(0, nS.beetBytes)(this)}`); - } - } - read(e, r) { - let [n] = this.deserialize(e, r); - return n; - } - write(e, r, n) { - let [i, o] = this.serialize(n); - i.copy(e, r, 0, o); - } - deserialize(e, r = 0) { - nS.logTrace.enabled && - ((0, nS.logTrace)( - "deserializing [%s] from %d bytes buffer", - this.description, - e.byteLength - ), - (0, nS.logTrace)(e), - (0, nS.logTrace)(e.toJSON().data)); - let n = new fPt.BeetReader(e, r), - i = n.readStruct(this.fields); - return [this.construct(i), n.offset]; - } - serialize(e, r = this.byteSize) { - (0, nS.logTrace)( - "serializing [%s] %o to %d bytes buffer", - this.description, - e, - r - ); - let n = new fPt.BeetWriter(r); - return n.writeStruct(e, this.fields), [n.buffer, n.offset]; - } - getByteSize() { - return this.fields.reduce((e, [r, n]) => e + n.byteSize, 0); - } - get type() { - return Cw.TYPE; - } - }; - a3.BeetStruct = Cw; - Cw.description = "BeetStruct"; - Cw.TYPE = "BeetStruct"; - function MXr(t) { - return t.type === Cw.TYPE; - } - a3.isBeetStruct = MXr; - var _D = class extends Cw { - constructor(e, r = _D.description) { - super(e, (n) => n, r); - } - }; - a3.BeetArgsStruct = _D; - _D.description = "BeetArgsStruct"; - }); - var cIe = I((Rw) => { - "use strict"; - m(); - g(); - var TXr = - (Rw && Rw.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Rw, "__esModule", { value: !0 }); - Rw.FixableBeetArgsStruct = - Rw.isFixableBeetStruct = - Rw.FixableBeetStruct = - void 0; - var dPt = NV(), - jle = zle(), - kXr = vm(), - PXr = Dr(), - uIe = mD(), - OXr = TXr(Mg()), - { brightBlack: BXr } = OXr.default, - bm = class { - constructor(e, r, n = bm.description) { - (this.fields = e), (this.construct = r), (this.description = n); - let i = 0; - if (uIe.logDebug.enabled) { - let o = e.map( - ([s, c]) => ( - (0, kXr.isFixedSizeBeet)(c) && (i += c.byteSize), - `${s}: ${c.description} ${(0, uIe.beetBytes)(c)}` - ) - ).join(` - `), - a = `> ${i} B`; - (0, uIe.logDebug)(`struct ${n} { - ${o} -} ${BXr(a)}`); - } - } - deserialize(e, r = 0) { - return this.toFixedFromData(e, r).deserialize(e, r); - } - serialize(e, r) { - return this.toFixedFromValue(e).serialize(e, r); - } - toFixedFromData(e, r) { - let n = r, - i = new Array(this.fields.length); - for (let o = 0; o < this.fields.length; o++) { - let [a, s] = this.fields[o], - c = (0, dPt.fixBeetFromData)(s, e, n); - (i[o] = [a, c]), (n += c.byteSize); - } - return this.description !== bm.description - ? new jle.BeetStruct(i, this.construct, this.description) - : new jle.BeetStruct(i, this.construct); - } - toFixedFromValue(e) { - let r = Object.keys(e), - n = new Array(this.fields.length); - for (let i = 0; i < this.fields.length; i++) { - let [o, a] = this.fields[i]; - (0, PXr.strict)( - r.includes(o), - `Value with keys [ ${r} ] should include struct key '${o}' but doesn't.` - ); - let s = e[o], - c = (0, dPt.fixBeetFromValue)(a, s); - n[i] = [o, c]; - } - return this.description !== bm.description - ? new jle.BeetStruct(n, this.construct, this.description) - : new jle.BeetStruct(n, this.construct); - } - get type() { - return bm.TYPE; - } - }; - Rw.FixableBeetStruct = bm; - bm.description = "FixableBeetStruct"; - bm.TYPE = "FixableBeetStruct"; - function IXr(t) { - return t.type === bm.TYPE; - } - Rw.isFixableBeetStruct = IXr; - var xD = class extends bm { - constructor(e, r = xD.description) { - super(e, (n) => n, r); - } - }; - Rw.FixableBeetArgsStruct = xD; - xD.description = "FixableBeetArgsStruct"; - }); - var lIe = I((Nw) => { - "use strict"; - m(); - g(); - Object.defineProperty(Nw, "__esModule", { value: !0 }); - Nw.enumsTypeMap = - Nw.dataEnum = - Nw.uniformDataEnum = - Nw.fixedScalarEnum = - void 0; - var s3 = vm(), - Fg = yD(), - SD = Dr(), - CXr = zle(), - RXr = cIe(); - function hPt(t, e) { - return e ? `${t}` : t; - } - function NXr(t) { - let e = Object.keys(t); - return { - write(r, n, i) { - let o = typeof i == "number", - a = hPt(i, o); - if ( - (e.includes(a) || - SD.strict.fail( - `${i} should be a variant of the provided enum type, i.e. [ ${Object.values( - t - ).join(", ")} ], but isn't` - ), - o) - ) - Fg.u8.write(r, n, i); - else { - let s = t[a]; - Fg.u8.write(r, n, s); - } - }, - read(r, n) { - let i = Fg.u8.read(r, n), - o = typeof i == "number", - a = hPt(i, o); - return ( - e.includes(a) || - SD.strict.fail( - `${i} should be a of a variant of the provided enum type, i.e. [ ${Object.values( - t - ).join(", ")} ], but isn't` - ), - o ? i : t[a] - ); - }, - byteSize: Fg.u8.byteSize, - description: "Enum", - }; - } - Nw.fixedScalarEnum = NXr; - function DXr(t) { - return { - write: function (e, r, n) { - Fg.u8.write(e, r, n.kind), t.write(e, r + 1, n.data); - }, - read: function (e, r) { - let n = Fg.u8.read(e, r), - i = t.read(e, r + 1); - return { kind: n, data: i }; - }, - byteSize: 1 + t.byteSize, - description: `UniformDataEnum<${t.description}>`, - }; - } - Nw.uniformDataEnum = DXr; - function pPt(t, e, r) { - return { - write(n, i, o) { - Fg.u8.write(n, i, e), t.write(n, i + Fg.u8.byteSize, o); - }, - read(n, i) { - let o = t.read(n, i + Fg.u8.byteSize); - return { __kind: r, ...o }; - }, - byteSize: t.byteSize + Fg.u8.byteSize, - description: `EnumData<${t.description}>`, - }; - } - function FXr(t) { - for (let [e, r] of t) - (0, SD.strict)( - (0, CXr.isBeetStruct)(r) || (0, RXr.isFixableBeetStruct)(r), - "dataEnum: data beet must be a struct" - ); - return { - toFixedFromData(e, r) { - let n = Fg.u8.read(e, r), - i = t[n]; - (0, SD.strict)( - i != null, - `Discriminant ${n} out of range for ${t.length} variants` - ); - let [o, a] = i, - s = (0, s3.isFixedSizeBeet)(a) ? a : a.toFixedFromData(e, r + 1); - return pPt(s, n, o); - }, - toFixedFromValue(e) { - if (e.__kind == null) { - let u = Object.keys(e).join(", "), - h = t.map(([w]) => w).join(", "); - SD.strict.fail( - `Value with fields [ ${u} ] is missing __kind, which needs to be set to one of [ ${h} ]` - ); - } - let r = t.findIndex(([u]) => u === e.__kind); - if (r < 0) { - let u = t.map(([h]) => h).join(", "); - SD.strict.fail( - `${e.__kind} is not a valid kind, needs to be one of [ ${u} ]` - ); - } - let n = t[r], - { __kind: i, ...o } = e, - [a, s] = n, - c = (0, s3.isFixedSizeBeet)(s) ? s : s.toFixedFromValue(o); - return pPt(c, r, a); - }, - description: `DataEnum<${t.length} variants>`, - }; - } - Nw.dataEnum = FXr; - Nw.enumsTypeMap = { - fixedScalarEnum: { - beet: "fixedScalarEnum", - isFixable: !1, - sourcePack: s3.BEET_PACKAGE, - ts: "", - arg: s3.BEET_TYPE_ARG_INNER, - pack: s3.BEET_PACKAGE, - }, - dataEnum: { - beet: "dataEnum", - isFixable: !1, - sourcePack: s3.BEET_PACKAGE, - ts: "DataEnum", - arg: s3.BEET_TYPE_ARG_INNER, - pack: s3.BEET_PACKAGE, - }, - }; - }); - var fIe = I((AD) => { - "use strict"; - m(); - g(); - Object.defineProperty(AD, "__esModule", { value: !0 }); - AD.aliasesTypeMap = AD.bytes = void 0; - var yPt = qle(); - AD.bytes = yPt.uint8Array; - AD.aliasesTypeMap = { bytes: yPt.collectionsTypeMap.Uint8Array }; - }); - var sh = I((lu) => { - "use strict"; - m(); - g(); - var LXr = - (lu && lu.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Lg = - (lu && lu.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - LXr(e, t, r); - }; - Object.defineProperty(lu, "__esModule", { value: !0 }); - lu.supportedTypeMap = void 0; - var qXr = qle(), - zXr = tIe(), - jXr = yD(), - UXr = iIe(), - KXr = lIe(), - HXr = fIe(); - Lg(fIe(), lu); - Lg(qle(), lu); - Lg(iIe(), lu); - Lg(tIe(), lu); - Lg(lIe(), lu); - Lg(yD(), lu); - Lg(NV(), lu); - Lg(sIe(), lu); - Lg(zle(), lu); - Lg(cIe(), lu); - Lg(vm(), lu); - lu.supportedTypeMap = { - ...qXr.collectionsTypeMap, - ...UXr.stringTypeMap, - ...zXr.compositesTypeMap, - ...KXr.enumsTypeMap, - ...jXr.numbersTypeMap, - ...HXr.aliasesTypeMap, - }; - }); - var hIe = I((Dw) => { - "use strict"; - m(); - g(); - var VXr = - (Dw && Dw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - WXr = - (Dw && Dw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - mPt = - (Dw && Dw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - VXr(e, t, r); - return WXr(e, t), e; - }; - Object.defineProperty(Dw, "__esModule", { value: !0 }); - Dw.creatorBeet = void 0; - var GXr = mPt(Fi()), - dIe = mPt(sh()); - Dw.creatorBeet = new dIe.BeetArgsStruct( - [ - ["address", GXr.publicKey], - ["verified", dIe.bool], - ["percentageShare", dIe.u8], - ], - "Creator" - ); - }); - var pIe = I((Fw) => { - "use strict"; - m(); - g(); - var JXr = - (Fw && Fw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - $Xr = - (Fw && Fw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - ZXr = - (Fw && Fw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - JXr(e, t, r); - return $Xr(e, t), e; - }; - Object.defineProperty(Fw, "__esModule", { value: !0 }); - Fw.configLineSettingsBeet = void 0; - var ED = ZXr(sh()); - Fw.configLineSettingsBeet = new ED.FixableBeetArgsStruct( - [ - ["prefixName", ED.utf8String], - ["nameLength", ED.u32], - ["prefixUri", ED.utf8String], - ["uriLength", ED.u32], - ["isSequential", ED.bool], - ], - "ConfigLineSettings" - ); - }); - var yIe = I((Lw) => { - "use strict"; - m(); - g(); - var XXr = - (Lw && Lw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - YXr = - (Lw && Lw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - QXr = - (Lw && Lw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - XXr(e, t, r); - return YXr(e, t), e; - }; - Object.defineProperty(Lw, "__esModule", { value: !0 }); - Lw.hiddenSettingsBeet = void 0; - var FV = QXr(sh()); - Lw.hiddenSettingsBeet = new FV.FixableBeetArgsStruct( - [ - ["name", FV.utf8String], - ["uri", FV.utf8String], - ["hash", FV.uniformFixedSizeArray(FV.u8, 32)], - ], - "HiddenSettings" - ); - }); - var LV = I((qw) => { - "use strict"; - m(); - g(); - var eYr = - (qw && qw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - tYr = - (qw && qw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - rYr = - (qw && qw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - eYr(e, t, r); - return tYr(e, t), e; - }; - Object.defineProperty(qw, "__esModule", { value: !0 }); - qw.candyMachineDataBeet = void 0; - var iS = rYr(sh()), - nYr = hIe(), - iYr = pIe(), - oYr = yIe(); - qw.candyMachineDataBeet = new iS.FixableBeetArgsStruct( - [ - ["itemsAvailable", iS.u64], - ["symbol", iS.utf8String], - ["sellerFeeBasisPoints", iS.u16], - ["maxSupply", iS.u64], - ["isMutable", iS.bool], - ["creators", iS.array(nYr.creatorBeet)], - ["configLineSettings", iS.coption(iYr.configLineSettingsBeet)], - ["hiddenSettings", iS.coption(oYr.hiddenSettingsBeet)], - ], - "CandyMachineData" - ); - }); - var gIe = I((qs) => { - "use strict"; - m(); - g(); - var aYr = - (qs && qs.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - sYr = - (qs && qs.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - mIe = - (qs && qs.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - aYr(e, t, r); - return sYr(e, t), e; - }; - Object.defineProperty(qs, "__esModule", { value: !0 }); - qs.candyMachineBeet = - qs.CandyMachine = - qs.candyMachineDiscriminator = - void 0; - var qV = mIe(sh()), - uYr = mIe(Le()), - Ule = mIe(Fi()), - cYr = LV(); - qs.candyMachineDiscriminator = [51, 173, 177, 113, 25, 241, 109, 189]; - var zw = class { - constructor(e, r, n, i, o, a) { - (this.features = e), - (this.authority = r), - (this.mintAuthority = n), - (this.collectionMint = i), - (this.itemsRedeemed = o), - (this.data = a); - } - static fromArgs(e) { - return new zw( - e.features, - e.authority, - e.mintAuthority, - e.collectionMint, - e.itemsRedeemed, - e.data - ); - } - static fromAccountInfo(e, r = 0) { - return zw.deserialize(e.data, r); - } - static async fromAccountAddress(e, r) { - let n = await e.getAccountInfo(r); - if (n == null) - throw new Error(`Unable to find CandyMachine account at ${r}`); - return zw.fromAccountInfo(n, 0)[0]; - } - static gpaBuilder( - e = new uYr.PublicKey("CndyV3LdqHUfDLmE5naZjVN8rBZz4tqhdefbAnjHG3JR") - ) { - return Ule.GpaBuilder.fromStruct(e, qs.candyMachineBeet); - } - static deserialize(e, r = 0) { - return qs.candyMachineBeet.deserialize(e, r); - } - serialize() { - return qs.candyMachineBeet.serialize({ - accountDiscriminator: qs.candyMachineDiscriminator, - ...this, - }); - } - static byteSize(e) { - let r = zw.fromArgs(e); - return qs.candyMachineBeet.toFixedFromValue({ - accountDiscriminator: qs.candyMachineDiscriminator, - ...r, - }).byteSize; - } - static async getMinimumBalanceForRentExemption(e, r, n) { - return r.getMinimumBalanceForRentExemption(zw.byteSize(e), n); - } - pretty() { - return { - features: (() => { - let e = this.features; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - authority: this.authority.toBase58(), - mintAuthority: this.mintAuthority.toBase58(), - collectionMint: this.collectionMint.toBase58(), - itemsRedeemed: (() => { - let e = this.itemsRedeemed; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - data: this.data, - }; - } - }; - qs.CandyMachine = zw; - qs.candyMachineBeet = new qV.FixableBeetStruct( - [ - ["accountDiscriminator", qV.uniformFixedSizeArray(qV.u8, 8)], - ["features", qV.u64], - ["authority", Ule.publicKey], - ["mintAuthority", Ule.publicKey], - ["collectionMint", Ule.publicKey], - ["itemsRedeemed", qV.u64], - ["data", cYr.candyMachineDataBeet], - ], - zw.fromArgs, - "CandyMachine" - ); - }); - var gPt = I((oS) => { - "use strict"; - m(); - g(); - var lYr = - (oS && oS.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - fYr = - (oS && oS.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - lYr(e, t, r); - }; - Object.defineProperty(oS, "__esModule", { value: !0 }); - oS.accountProviders = void 0; - fYr(gIe(), oS); - var dYr = gIe(); - oS.accountProviders = { CandyMachine: dYr.CandyMachine }; - }); - var vPt = I((Lr) => { - "use strict"; - m(); - g(); - Object.defineProperty(Lr, "__esModule", { value: !0 }); - Lr.errorFromName = - Lr.errorFromCode = - Lr.NotFullyLoadedError = - Lr.CouldNotRetrieveConfigLineDataError = - Lr.CollectionKeyMismatchError = - Lr.CannotChangeSequentialIndexGenerationError = - Lr.CannotSwitchFromHiddenSettingsError = - Lr.CannotIncreaseLengthError = - Lr.MissingConfigLinesSettingsError = - Lr.ExceededLengthErrorError = - Lr.NoChangingCollectionDuringMintError = - Lr.MetadataAccountMustBeEmptyError = - Lr.IncorrectCollectionAuthorityError = - Lr.CannotSwitchToHiddenSettingsError = - Lr.CannotChangeNumberOfLinesError = - Lr.HiddenSettingsDoNotHaveConfigLinesError = - Lr.CandyMachineEmptyError = - Lr.TooManyCreatorsError = - Lr.NumericalOverflowErrorError = - Lr.IndexGreaterThanLengthError = - Lr.MintMismatchError = - Lr.UninitializedError = - Lr.IncorrectOwnerError = - void 0; - var Ga = new Map(), - Ja = new Map(), - _O = class extends Error { - constructor() { - super("Account does not have correct owner"), - (this.code = 6e3), - (this.name = "IncorrectOwner"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, _O); - } - }; - Lr.IncorrectOwnerError = _O; - Ga.set(6e3, () => new _O()); - Ja.set("IncorrectOwner", () => new _O()); - var xO = class extends Error { - constructor() { - super("Account is not initialized"), - (this.code = 6001), - (this.name = "Uninitialized"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, xO); - } - }; - Lr.UninitializedError = xO; - Ga.set(6001, () => new xO()); - Ja.set("Uninitialized", () => new xO()); - var SO = class extends Error { - constructor() { - super("Mint Mismatch"), - (this.code = 6002), - (this.name = "MintMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, SO); - } - }; - Lr.MintMismatchError = SO; - Ga.set(6002, () => new SO()); - Ja.set("MintMismatch", () => new SO()); - var AO = class extends Error { - constructor() { - super("Index greater than length"), - (this.code = 6003), - (this.name = "IndexGreaterThanLength"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, AO); - } - }; - Lr.IndexGreaterThanLengthError = AO; - Ga.set(6003, () => new AO()); - Ja.set("IndexGreaterThanLength", () => new AO()); - var EO = class extends Error { - constructor() { - super("Numerical overflow error"), - (this.code = 6004), - (this.name = "NumericalOverflowError"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, EO); - } - }; - Lr.NumericalOverflowErrorError = EO; - Ga.set(6004, () => new EO()); - Ja.set("NumericalOverflowError", () => new EO()); - var MO = class extends Error { - constructor() { - super( - "Can only provide up to 4 creators to candy machine (because candy machine is one)" - ), - (this.code = 6005), - (this.name = "TooManyCreators"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, MO); - } - }; - Lr.TooManyCreatorsError = MO; - Ga.set(6005, () => new MO()); - Ja.set("TooManyCreators", () => new MO()); - var TO = class extends Error { - constructor() { - super("Candy machine is empty"), - (this.code = 6006), - (this.name = "CandyMachineEmpty"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, TO); - } - }; - Lr.CandyMachineEmptyError = TO; - Ga.set(6006, () => new TO()); - Ja.set("CandyMachineEmpty", () => new TO()); - var kO = class extends Error { - constructor() { - super( - "Candy machines using hidden uris do not have config lines, they have a single hash representing hashed order" - ), - (this.code = 6007), - (this.name = "HiddenSettingsDoNotHaveConfigLines"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, kO); - } - }; - Lr.HiddenSettingsDoNotHaveConfigLinesError = kO; - Ga.set(6007, () => new kO()); - Ja.set("HiddenSettingsDoNotHaveConfigLines", () => new kO()); - var PO = class extends Error { - constructor() { - super("Cannot change number of lines unless is a hidden config"), - (this.code = 6008), - (this.name = "CannotChangeNumberOfLines"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, PO); - } - }; - Lr.CannotChangeNumberOfLinesError = PO; - Ga.set(6008, () => new PO()); - Ja.set("CannotChangeNumberOfLines", () => new PO()); - var OO = class extends Error { - constructor() { - super( - "Cannot switch to hidden settings after items available is greater than 0" - ), - (this.code = 6009), - (this.name = "CannotSwitchToHiddenSettings"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, OO); - } - }; - Lr.CannotSwitchToHiddenSettingsError = OO; - Ga.set(6009, () => new OO()); - Ja.set("CannotSwitchToHiddenSettings", () => new OO()); - var BO = class extends Error { - constructor() { - super("Incorrect collection NFT authority"), - (this.code = 6010), - (this.name = "IncorrectCollectionAuthority"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, BO); - } - }; - Lr.IncorrectCollectionAuthorityError = BO; - Ga.set(6010, () => new BO()); - Ja.set("IncorrectCollectionAuthority", () => new BO()); - var IO = class extends Error { - constructor() { - super( - "The metadata account has data in it, and this must be empty to mint a new NFT" - ), - (this.code = 6011), - (this.name = "MetadataAccountMustBeEmpty"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, IO); - } - }; - Lr.MetadataAccountMustBeEmptyError = IO; - Ga.set(6011, () => new IO()); - Ja.set("MetadataAccountMustBeEmpty", () => new IO()); - var CO = class extends Error { - constructor() { - super( - "Can't change collection settings after items have begun to be minted" - ), - (this.code = 6012), - (this.name = "NoChangingCollectionDuringMint"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, CO); - } - }; - Lr.NoChangingCollectionDuringMintError = CO; - Ga.set(6012, () => new CO()); - Ja.set("NoChangingCollectionDuringMint", () => new CO()); - var RO = class extends Error { - constructor() { - super("Value longer than expected maximum value"), - (this.code = 6013), - (this.name = "ExceededLengthError"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, RO); - } - }; - Lr.ExceededLengthErrorError = RO; - Ga.set(6013, () => new RO()); - Ja.set("ExceededLengthError", () => new RO()); - var NO = class extends Error { - constructor() { - super("Missing config lines settings"), - (this.code = 6014), - (this.name = "MissingConfigLinesSettings"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, NO); - } - }; - Lr.MissingConfigLinesSettingsError = NO; - Ga.set(6014, () => new NO()); - Ja.set("MissingConfigLinesSettings", () => new NO()); - var DO = class extends Error { - constructor() { - super("Cannot increase the length in config lines settings"), - (this.code = 6015), - (this.name = "CannotIncreaseLength"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, DO); - } - }; - Lr.CannotIncreaseLengthError = DO; - Ga.set(6015, () => new DO()); - Ja.set("CannotIncreaseLength", () => new DO()); - var FO = class extends Error { - constructor() { - super("Cannot switch from hidden settings"), - (this.code = 6016), - (this.name = "CannotSwitchFromHiddenSettings"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, FO); - } - }; - Lr.CannotSwitchFromHiddenSettingsError = FO; - Ga.set(6016, () => new FO()); - Ja.set("CannotSwitchFromHiddenSettings", () => new FO()); - var LO = class extends Error { - constructor() { - super( - "Cannot change sequential index generation after items have begun to be minted" - ), - (this.code = 6017), - (this.name = "CannotChangeSequentialIndexGeneration"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, LO); - } - }; - Lr.CannotChangeSequentialIndexGenerationError = LO; - Ga.set(6017, () => new LO()); - Ja.set("CannotChangeSequentialIndexGeneration", () => new LO()); - var qO = class extends Error { - constructor() { - super("Collection public key mismatch"), - (this.code = 6018), - (this.name = "CollectionKeyMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, qO); - } - }; - Lr.CollectionKeyMismatchError = qO; - Ga.set(6018, () => new qO()); - Ja.set("CollectionKeyMismatch", () => new qO()); - var zO = class extends Error { - constructor() { - super("Could not retrive config line data"), - (this.code = 6019), - (this.name = "CouldNotRetrieveConfigLineData"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, zO); - } - }; - Lr.CouldNotRetrieveConfigLineDataError = zO; - Ga.set(6019, () => new zO()); - Ja.set("CouldNotRetrieveConfigLineData", () => new zO()); - var jO = class extends Error { - constructor() { - super("Not all config lines were added to the candy machine"), - (this.code = 6020), - (this.name = "NotFullyLoaded"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, jO); - } - }; - Lr.NotFullyLoadedError = jO; - Ga.set(6020, () => new jO()); - Ja.set("NotFullyLoaded", () => new jO()); - function hYr(t) { - let e = Ga.get(t); - return e != null ? e() : null; - } - Lr.errorFromCode = hYr; - function pYr(t) { - let e = Ja.get(t); - return e != null ? e() : null; - } - Lr.errorFromName = pYr; - }); - var bIe = I((jw) => { - "use strict"; - m(); - g(); - var yYr = - (jw && jw.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - mYr = - (jw && jw.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - gYr = - (jw && jw.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - yYr(e, t, r); - return mYr(e, t), e; - }; - Object.defineProperty(jw, "__esModule", { value: !0 }); - jw.configLineBeet = void 0; - var vIe = gYr(sh()); - jw.configLineBeet = new vIe.FixableBeetArgsStruct( - [ - ["name", vIe.utf8String], - ["uri", vIe.utf8String], - ], - "ConfigLine" - ); - }); - var _Pt = I(($f) => { - "use strict"; - m(); - g(); - var vYr = - ($f && $f.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - bYr = - ($f && $f.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - wPt = - ($f && $f.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - vYr(e, t, r); - return bYr(e, t), e; - }; - Object.defineProperty($f, "__esModule", { value: !0 }); - $f.createAddConfigLinesInstruction = - $f.addConfigLinesInstructionDiscriminator = - $f.addConfigLinesStruct = - void 0; - var zV = wPt(sh()), - bPt = wPt(Le()), - wYr = bIe(); - $f.addConfigLinesStruct = new zV.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", zV.uniformFixedSizeArray(zV.u8, 8)], - ["index", zV.u32], - ["configLines", zV.array(wYr.configLineBeet)], - ], - "AddConfigLinesInstructionArgs" - ); - $f.addConfigLinesInstructionDiscriminator = [ - 223, 50, 224, 227, 151, 8, 115, 106, - ]; - function _Yr( - t, - e, - r = new bPt.PublicKey("CndyV3LdqHUfDLmE5naZjVN8rBZz4tqhdefbAnjHG3JR") - ) { - let [n] = $f.addConfigLinesStruct.serialize({ - instructionDiscriminator: $f.addConfigLinesInstructionDiscriminator, - ...e, - }), - i = [ - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !0 }, - ]; - return new bPt.TransactionInstruction({ programId: r, keys: i, data: n }); - } - $f.createAddConfigLinesInstruction = _Yr; - }); - var SPt = I((Zf) => { - "use strict"; - m(); - g(); - var xYr = - (Zf && Zf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - SYr = - (Zf && Zf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - xPt = - (Zf && Zf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - xYr(e, t, r); - return SYr(e, t), e; - }; - Object.defineProperty(Zf, "__esModule", { value: !0 }); - Zf.createInitializeInstruction = - Zf.initializeInstructionDiscriminator = - Zf.initializeStruct = - void 0; - var wIe = xPt(sh()), - _Ie = xPt(Le()), - AYr = LV(); - Zf.initializeStruct = new wIe.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", wIe.uniformFixedSizeArray(wIe.u8, 8)], - ["data", AYr.candyMachineDataBeet], - ], - "InitializeInstructionArgs" - ); - Zf.initializeInstructionDiscriminator = [ - 175, 175, 109, 31, 13, 152, 155, 237, - ]; - function EYr( - t, - e, - r = new _Ie.PublicKey("CndyV3LdqHUfDLmE5naZjVN8rBZz4tqhdefbAnjHG3JR") - ) { - var n; - let [i] = Zf.initializeStruct.serialize({ - instructionDiscriminator: Zf.initializeInstructionDiscriminator, - ...e, - }), - o = [ - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.authorityPda, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !1 }, - { pubkey: t.payer, isWritable: !1, isSigner: !0 }, - { pubkey: t.collectionMetadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.collectionMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.collectionMasterEdition, isWritable: !1, isSigner: !1 }, - { pubkey: t.collectionUpdateAuthority, isWritable: !0, isSigner: !0 }, - { pubkey: t.collectionAuthorityRecord, isWritable: !0, isSigner: !1 }, - { pubkey: t.tokenMetadataProgram, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.systemProgram) !== null && n !== void 0 - ? n - : _Ie.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - ]; - return new _Ie.TransactionInstruction({ programId: r, keys: o, data: i }); - } - Zf.createInitializeInstruction = EYr; - }); - var APt = I((Xf) => { - "use strict"; - m(); - g(); - var MYr = - (Xf && Xf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - TYr = - (Xf && Xf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - AIe = - (Xf && Xf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - MYr(e, t, r); - return TYr(e, t), e; - }; - Object.defineProperty(Xf, "__esModule", { value: !0 }); - Xf.createMintInstruction = - Xf.mintInstructionDiscriminator = - Xf.mintStruct = - void 0; - var kYr = AIe((pa(), jo(ha))), - xIe = AIe(sh()), - SIe = AIe(Le()); - Xf.mintStruct = new xIe.BeetArgsStruct( - [["instructionDiscriminator", xIe.uniformFixedSizeArray(xIe.u8, 8)]], - "MintInstructionArgs" - ); - Xf.mintInstructionDiscriminator = [51, 57, 225, 47, 182, 146, 137, 166]; - function PYr( - t, - e = new SIe.PublicKey("CndyV3LdqHUfDLmE5naZjVN8rBZz4tqhdefbAnjHG3JR") - ) { - var r, n; - let [i] = Xf.mintStruct.serialize({ - instructionDiscriminator: Xf.mintInstructionDiscriminator, - }), - o = [ - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.authorityPda, isWritable: !0, isSigner: !1 }, - { pubkey: t.mintAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { pubkey: t.nftMint, isWritable: !0, isSigner: !1 }, - { pubkey: t.nftMintAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.nftMetadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.nftMasterEdition, isWritable: !0, isSigner: !1 }, - { pubkey: t.collectionAuthorityRecord, isWritable: !1, isSigner: !1 }, - { pubkey: t.collectionMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.collectionMetadata, isWritable: !0, isSigner: !1 }, - { pubkey: t.collectionMasterEdition, isWritable: !1, isSigner: !1 }, - { pubkey: t.collectionUpdateAuthority, isWritable: !1, isSigner: !1 }, - { pubkey: t.tokenMetadataProgram, isWritable: !1, isSigner: !1 }, - { - pubkey: - (r = t.tokenProgram) !== null && r !== void 0 - ? r - : kYr.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (n = t.systemProgram) !== null && n !== void 0 - ? n - : SIe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.recentSlothashes, isWritable: !1, isSigner: !1 }, - ]; - return new SIe.TransactionInstruction({ programId: e, keys: o, data: i }); - } - Xf.createMintInstruction = PYr; - }); - var MPt = I((Yf) => { - "use strict"; - m(); - g(); - var OYr = - (Yf && Yf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - BYr = - (Yf && Yf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - MIe = - (Yf && Yf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - OYr(e, t, r); - return BYr(e, t), e; - }; - Object.defineProperty(Yf, "__esModule", { value: !0 }); - Yf.createSetAuthorityInstruction = - Yf.setAuthorityInstructionDiscriminator = - Yf.setAuthorityStruct = - void 0; - var EPt = MIe(Le()), - IYr = MIe(Fi()), - EIe = MIe(sh()); - Yf.setAuthorityStruct = new EIe.BeetArgsStruct( - [ - ["instructionDiscriminator", EIe.uniformFixedSizeArray(EIe.u8, 8)], - ["newAuthority", IYr.publicKey], - ], - "SetAuthorityInstructionArgs" - ); - Yf.setAuthorityInstructionDiscriminator = [ - 133, 250, 37, 21, 110, 163, 26, 121, - ]; - function CYr( - t, - e, - r = new EPt.PublicKey("CndyV3LdqHUfDLmE5naZjVN8rBZz4tqhdefbAnjHG3JR") - ) { - let [n] = Yf.setAuthorityStruct.serialize({ - instructionDiscriminator: Yf.setAuthorityInstructionDiscriminator, - ...e, - }), - i = [ - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !0 }, - ]; - return new EPt.TransactionInstruction({ programId: r, keys: i, data: n }); - } - Yf.createSetAuthorityInstruction = CYr; - }); - var kPt = I((Qf) => { - "use strict"; - m(); - g(); - var RYr = - (Qf && Qf.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - NYr = - (Qf && Qf.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - TPt = - (Qf && Qf.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - RYr(e, t, r); - return NYr(e, t), e; - }; - Object.defineProperty(Qf, "__esModule", { value: !0 }); - Qf.createSetCollectionInstruction = - Qf.setCollectionInstructionDiscriminator = - Qf.setCollectionStruct = - void 0; - var TIe = TPt(sh()), - kIe = TPt(Le()); - Qf.setCollectionStruct = new TIe.BeetArgsStruct( - [["instructionDiscriminator", TIe.uniformFixedSizeArray(TIe.u8, 8)]], - "SetCollectionInstructionArgs" - ); - Qf.setCollectionInstructionDiscriminator = [ - 192, 254, 206, 76, 168, 182, 59, 223, - ]; - function DYr( - t, - e = new kIe.PublicKey("CndyV3LdqHUfDLmE5naZjVN8rBZz4tqhdefbAnjHG3JR") - ) { - var r; - let [n] = Qf.setCollectionStruct.serialize({ - instructionDiscriminator: Qf.setCollectionInstructionDiscriminator, - }), - i = [ - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !0 }, - { pubkey: t.authorityPda, isWritable: !0, isSigner: !1 }, - { pubkey: t.payer, isWritable: !1, isSigner: !0 }, - { pubkey: t.collectionMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.collectionMetadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.collectionAuthorityRecord, isWritable: !0, isSigner: !1 }, - { - pubkey: t.newCollectionUpdateAuthority, - isWritable: !0, - isSigner: !0, - }, - { pubkey: t.newCollectionMetadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.newCollectionMint, isWritable: !1, isSigner: !1 }, - { - pubkey: t.newCollectionMasterEdition, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: t.newCollectionAuthorityRecord, - isWritable: !0, - isSigner: !1, - }, - { pubkey: t.tokenMetadataProgram, isWritable: !1, isSigner: !1 }, - { - pubkey: - (r = t.systemProgram) !== null && r !== void 0 - ? r - : kIe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - ]; - return new kIe.TransactionInstruction({ programId: e, keys: i, data: n }); - } - Qf.createSetCollectionInstruction = DYr; - }); - var BPt = I((ed) => { - "use strict"; - m(); - g(); - var FYr = - (ed && ed.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - LYr = - (ed && ed.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - OPt = - (ed && ed.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - FYr(e, t, r); - return LYr(e, t), e; - }; - Object.defineProperty(ed, "__esModule", { value: !0 }); - ed.createSetMintAuthorityInstruction = - ed.setMintAuthorityInstructionDiscriminator = - ed.setMintAuthorityStruct = - void 0; - var PIe = OPt(sh()), - PPt = OPt(Le()); - ed.setMintAuthorityStruct = new PIe.BeetArgsStruct( - [["instructionDiscriminator", PIe.uniformFixedSizeArray(PIe.u8, 8)]], - "SetMintAuthorityInstructionArgs" - ); - ed.setMintAuthorityInstructionDiscriminator = [ - 67, 127, 155, 187, 100, 174, 103, 121, - ]; - function qYr( - t, - e = new PPt.PublicKey("CndyV3LdqHUfDLmE5naZjVN8rBZz4tqhdefbAnjHG3JR") - ) { - let [r] = ed.setMintAuthorityStruct.serialize({ - instructionDiscriminator: ed.setMintAuthorityInstructionDiscriminator, - }), - n = [ - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !0 }, - { pubkey: t.mintAuthority, isWritable: !1, isSigner: !0 }, - ]; - return new PPt.TransactionInstruction({ programId: e, keys: n, data: r }); - } - ed.createSetMintAuthorityInstruction = qYr; - }); - var RPt = I((td) => { - "use strict"; - m(); - g(); - var zYr = - (td && td.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - jYr = - (td && td.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - CPt = - (td && td.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - zYr(e, t, r); - return jYr(e, t), e; - }; - Object.defineProperty(td, "__esModule", { value: !0 }); - td.createUpdateInstruction = - td.updateInstructionDiscriminator = - td.updateStruct = - void 0; - var OIe = CPt(sh()), - IPt = CPt(Le()), - UYr = LV(); - td.updateStruct = new OIe.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", OIe.uniformFixedSizeArray(OIe.u8, 8)], - ["data", UYr.candyMachineDataBeet], - ], - "UpdateInstructionArgs" - ); - td.updateInstructionDiscriminator = [219, 200, 88, 176, 158, 63, 253, 127]; - function KYr( - t, - e, - r = new IPt.PublicKey("CndyV3LdqHUfDLmE5naZjVN8rBZz4tqhdefbAnjHG3JR") - ) { - let [n] = td.updateStruct.serialize({ - instructionDiscriminator: td.updateInstructionDiscriminator, - ...e, - }), - i = [ - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !0 }, - ]; - return new IPt.TransactionInstruction({ programId: r, keys: i, data: n }); - } - td.createUpdateInstruction = KYr; - }); - var FPt = I((rd) => { - "use strict"; - m(); - g(); - var HYr = - (rd && rd.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - VYr = - (rd && rd.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - DPt = - (rd && rd.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - HYr(e, t, r); - return VYr(e, t), e; - }; - Object.defineProperty(rd, "__esModule", { value: !0 }); - rd.createWithdrawInstruction = - rd.withdrawInstructionDiscriminator = - rd.withdrawStruct = - void 0; - var BIe = DPt(sh()), - NPt = DPt(Le()); - rd.withdrawStruct = new BIe.BeetArgsStruct( - [["instructionDiscriminator", BIe.uniformFixedSizeArray(BIe.u8, 8)]], - "WithdrawInstructionArgs" - ); - rd.withdrawInstructionDiscriminator = [183, 18, 70, 156, 148, 109, 161, 34]; - function WYr( - t, - e = new NPt.PublicKey("CndyV3LdqHUfDLmE5naZjVN8rBZz4tqhdefbAnjHG3JR") - ) { - let [r] = rd.withdrawStruct.serialize({ - instructionDiscriminator: rd.withdrawInstructionDiscriminator, - }), - n = [ - { pubkey: t.candyMachine, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !0, isSigner: !0 }, - ]; - return new NPt.TransactionInstruction({ programId: e, keys: n, data: r }); - } - rd.createWithdrawInstruction = WYr; - }); - var LPt = I((Mp) => { - "use strict"; - m(); - g(); - var GYr = - (Mp && Mp.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - u3 = - (Mp && Mp.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - GYr(e, t, r); - }; - Object.defineProperty(Mp, "__esModule", { value: !0 }); - u3(_Pt(), Mp); - u3(SPt(), Mp); - u3(APt(), Mp); - u3(MPt(), Mp); - u3(kPt(), Mp); - u3(BPt(), Mp); - u3(RPt(), Mp); - u3(FPt(), Mp); - }); - var qPt = I((qg) => { - "use strict"; - m(); - g(); - var JYr = - (qg && qg.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - jV = - (qg && qg.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - JYr(e, t, r); - }; - Object.defineProperty(qg, "__esModule", { value: !0 }); - jV(LV(), qg); - jV(bIe(), qg); - jV(pIe(), qg); - jV(hIe(), qg); - jV(yIe(), qg); - }); - var IIe = I((uh) => { - "use strict"; - m(); - g(); - var $Yr = - (uh && uh.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Kle = - (uh && uh.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - $Yr(e, t, r); - }; - Object.defineProperty(uh, "__esModule", { value: !0 }); - uh.PROGRAM_ID = uh.PROGRAM_ADDRESS = void 0; - var ZYr = Le(); - Kle(gPt(), uh); - Kle(vPt(), uh); - Kle(LPt(), uh); - Kle(qPt(), uh); - uh.PROGRAM_ADDRESS = "CndyV3LdqHUfDLmE5naZjVN8rBZz4tqhdefbAnjHG3JR"; - uh.PROGRAM_ID = new ZYr.PublicKey(uh.PROGRAM_ADDRESS); - }); - var zPt = I((Hle) => { - "use strict"; - m(); - g(); - Object.defineProperty(Hle, "__esModule", { value: !0 }); - Hle.cusper = void 0; - var XYr = JN(), - YYr = IIe(); - Hle.cusper = (0, XYr.initCusper)(YYr.errorFromCode); - }); - var l3 = I((c3) => { - "use strict"; - m(); - g(); - var QYr = - (c3 && c3.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - jPt = - (c3 && c3.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - QYr(e, t, r); - }; - Object.defineProperty(c3, "__esModule", { value: !0 }); - jPt(IIe(), c3); - jPt(zPt(), c3); - }); - var ch = I((nd) => { - "use strict"; - m(); - g(); - Object.defineProperty(nd, "__esModule", { value: !0 }); - nd.isElementCollectionFixedSizeBeet = - nd.isFixableBeet = - nd.assertFixedSizeBeet = - nd.isFixedSizeBeet = - nd.BEET_TYPE_ARG_INNER = - nd.BEET_TYPE_ARG_LEN = - nd.BEET_PACKAGE = - void 0; - var dQr = Dr(); - nd.BEET_PACKAGE = "@metaplex-foundation/beet"; - nd.BEET_TYPE_ARG_LEN = "len"; - nd.BEET_TYPE_ARG_INNER = "Beet<{innner}>"; - function TOt(t) { - return Object.keys(t).includes("byteSize"); - } - nd.isFixedSizeBeet = TOt; - function hQr(t, e = `${t} should have been a fixed beet`) { - (0, dQr.strict)(TOt(t), e); - } - nd.assertFixedSizeBeet = hQr; - function pQr(t) { - return ( - typeof t.toFixedFromData == "function" && - typeof t.toFixedFromValue == "function" - ); - } - nd.isFixableBeet = pQr; - function yQr(t) { - let e = Object.keys(t); - return ( - e.includes("length") && - e.includes("elementByteSize") && - e.includes("lenPrefixByteSize") - ); - } - nd.isElementCollectionFixedSizeBeet = yQr; - }); - var HO = I((Wn) => { - "use strict"; - m(); - g(); - var mQr = - (Wn && Wn.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Wn, "__esModule", { value: !0 }); - Wn.numbersTypeMap = - Wn.bool = - Wn.i512 = - Wn.i256 = - Wn.i128 = - Wn.i64 = - Wn.i32 = - Wn.i16 = - Wn.i8 = - Wn.u512 = - Wn.u256 = - Wn.u128 = - Wn.u64 = - Wn.u32 = - Wn.u16 = - Wn.u8 = - void 0; - var OD = mQr(Ho()), - ka = ch(); - Wn.u8 = { - write: function (t, e, r) { - t.writeUInt8(r, e); - }, - read: function (t, e) { - return t.readUInt8(e); - }, - byteSize: 1, - description: "u8", - }; - Wn.u16 = { - write: function (t, e, r) { - t.writeUInt16LE(r, e); - }, - read: function (t, e) { - return t.readUInt16LE(e); - }, - byteSize: 2, - description: "u16", - }; - Wn.u32 = { - write: function (t, e, r) { - t.writeUInt32LE(r, e); - }, - read: function (t, e) { - return t.readUInt32LE(e); - }, - byteSize: 4, - description: "u32", - }; - function pfe(t, e) { - return { - write: function (r, n, i) { - let a = (OD.default.isBN(i) ? i : new OD.default(i)).toArray( - "le", - this.byteSize - ); - Buffer.from(a).copy(r, n, 0, this.byteSize); - }, - read: function (r, n) { - let i = r.slice(n, n + this.byteSize); - return new OD.default(i, "le"); - }, - byteSize: t, - description: e, - }; - } - Wn.u64 = pfe(8, "u64"); - Wn.u128 = pfe(16, "u128"); - Wn.u256 = pfe(32, "u256"); - Wn.u512 = pfe(64, "u512"); - Wn.i8 = { - write: function (t, e, r) { - t.writeInt8(r, e); - }, - read: function (t, e) { - return t.readInt8(e); - }, - byteSize: 1, - description: "i8", - }; - Wn.i16 = { - write: function (t, e, r) { - t.writeInt16LE(r, e); - }, - read: function (t, e) { - return t.readInt16LE(e); - }, - byteSize: 2, - description: "i16", - }; - Wn.i32 = { - write: function (t, e, r) { - t.writeInt32LE(r, e); - }, - read: function (t, e) { - return t.readInt32LE(e); - }, - byteSize: 4, - description: "i32", - }; - function yfe(t, e) { - let r = t * 8; - return { - write: function (n, i, o) { - let s = (OD.default.isBN(o) ? o : new OD.default(o)) - .toTwos(r) - .toArray("le", this.byteSize); - Buffer.from(s).copy(n, i, 0, this.byteSize); - }, - read: function (n, i) { - let o = n.slice(i, i + this.byteSize); - return new OD.default(o, "le").fromTwos(r); - }, - byteSize: t, - description: e, - }; - } - Wn.i64 = yfe(8, "i64"); - Wn.i128 = yfe(16, "i128"); - Wn.i256 = yfe(32, "i256"); - Wn.i512 = yfe(64, "i512"); - Wn.bool = { - write: function (t, e, r) { - let n = r ? 1 : 0; - Wn.u8.write(t, e, n); - }, - read: function (t, e) { - return Wn.u8.read(t, e) === 1; - }, - byteSize: 1, - description: "bool", - }; - Wn.numbersTypeMap = { - u8: { - beet: "u8", - isFixable: !1, - sourcePack: ka.BEET_PACKAGE, - ts: "number", - }, - u16: { - beet: "u16", - isFixable: !1, - sourcePack: ka.BEET_PACKAGE, - ts: "number", - }, - u32: { - beet: "u32", - isFixable: !1, - sourcePack: ka.BEET_PACKAGE, - ts: "number", - }, - i8: { - beet: "i8", - isFixable: !1, - sourcePack: ka.BEET_PACKAGE, - ts: "number", - }, - i16: { - beet: "i16", - isFixable: !1, - sourcePack: ka.BEET_PACKAGE, - ts: "number", - }, - i32: { - beet: "i32", - isFixable: !1, - sourcePack: ka.BEET_PACKAGE, - ts: "number", - }, - bool: { - beet: "bool", - isFixable: !1, - sourcePack: ka.BEET_PACKAGE, - ts: "boolean", - }, - u64: { - beet: "u64", - isFixable: !1, - sourcePack: ka.BEET_PACKAGE, - ts: "bignum", - pack: ka.BEET_PACKAGE, - }, - u128: { - beet: "u128", - isFixable: !1, - sourcePack: ka.BEET_PACKAGE, - ts: "bignum", - pack: ka.BEET_PACKAGE, - }, - u256: { - beet: "u256", - isFixable: !1, - sourcePack: ka.BEET_PACKAGE, - ts: "bignum", - pack: ka.BEET_PACKAGE, - }, - u512: { - beet: "u512", - isFixable: !1, - sourcePack: ka.BEET_PACKAGE, - ts: "bignum", - pack: ka.BEET_PACKAGE, - }, - i64: { - beet: "i64", - isFixable: !1, - sourcePack: ka.BEET_PACKAGE, - ts: "bignum", - pack: ka.BEET_PACKAGE, - }, - i128: { - beet: "i128", - isFixable: !1, - sourcePack: ka.BEET_PACKAGE, - ts: "bignum", - pack: ka.BEET_PACKAGE, - }, - i256: { - beet: "i256", - isFixable: !1, - sourcePack: ka.BEET_PACKAGE, - ts: "bignum", - pack: ka.BEET_PACKAGE, - }, - i512: { - beet: "i512", - isFixable: !1, - sourcePack: ka.BEET_PACKAGE, - ts: "bignum", - pack: ka.BEET_PACKAGE, - }, - }; - }); - var VO = I((Vu) => { - "use strict"; - m(); - g(); - var POt = - (Vu && Vu.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Vu, "__esModule", { value: !0 }); - Vu.UnreachableCaseError = - Vu.bytes = - Vu.beetBytes = - Vu.logTrace = - Vu.logDebug = - Vu.logInfo = - Vu.logError = - void 0; - var mfe = POt(Nx()), - gQr = POt(Mg()), - kOt = ch(), - { brightBlack: OOt } = gQr.default; - Vu.logError = (0, mfe.default)("beet:error"); - Vu.logInfo = (0, mfe.default)("beet:info"); - Vu.logDebug = (0, mfe.default)("beet:debug"); - Vu.logTrace = (0, mfe.default)("beet:trace"); - function vQr(t, e = !1) { - let r; - if ((0, kOt.isFixableBeet)(t)) r = "? B"; - else if ((0, kOt.isElementCollectionFixedSizeBeet)(t)) { - let n = e ? "length" : t.length, - i = t.lenPrefixByteSize; - r = - i > 0 - ? `${i} + (${t.elementByteSize} * ${n}) B (${t.byteSize} B)` - : `(${t.elementByteSize} * ${n}) B (${t.byteSize} B)`; - } else r = `${t.byteSize} B`; - return OOt(r); - } - Vu.beetBytes = vQr; - function bQr(t) { - return OOt(`${t} B`); - } - Vu.bytes = bQr; - var ZIe = class extends Error { - constructor(e) { - super(`Unreachable case: ${e}`); - } - }; - Vu.UnreachableCaseError = ZIe; - }); - var ID = I((BD) => { - "use strict"; - m(); - g(); - Object.defineProperty(BD, "__esModule", { value: !0 }); - BD.fixBeetFromValue = BD.fixBeetFromData = void 0; - var gfe = ch(), - BOt = VO(); - function wQr(t, e, r) { - if ((0, gfe.isFixedSizeBeet)(t)) return t; - if ((0, gfe.isFixableBeet)(t)) return t.toFixedFromData(e, r); - throw new BOt.UnreachableCaseError(t); - } - BD.fixBeetFromData = wQr; - function _Qr(t, e) { - if ((0, gfe.isFixedSizeBeet)(t)) return t; - if ((0, gfe.isFixableBeet)(t)) return t.toFixedFromValue(e); - throw new BOt.UnreachableCaseError(t); - } - BD.fixBeetFromValue = _Qr; - }); - var vfe = I((id) => { - "use strict"; - m(); - g(); - Object.defineProperty(id, "__esModule", { value: !0 }); - id.collectionsTypeMap = - id.uint8Array = - id.fixedSizeUint8Array = - id.fixedSizeBuffer = - id.array = - id.fixedSizeArray = - id.uniformFixedSizeArray = - void 0; - var CD = ch(), - WO = Dr(), - d3 = HO(), - RD = ch(), - COt = VO(), - IOt = ID(); - function xQr(t, e, r = !1) { - let n = t.byteSize * e, - i = r ? 4 + n : n; - return { - write: function (o, a, s) { - WO.strict.equal( - s.length, - e, - `array length ${s.length} should match len ${e}` - ), - r && (d3.u32.write(o, a, e), (a += 4)); - for (let c = 0; c < e; c++) t.write(o, a + c * t.byteSize, s[c]); - }, - read: function (o, a) { - if (r) { - let c = d3.u32.read(o, a); - WO.strict.equal(c, e, "invalid byte size"), (a += 4); - } - let s = new Array(e); - for (let c = 0; c < e; c++) s[c] = t.read(o, a + c * t.byteSize); - return s; - }, - byteSize: i, - length: e, - elementByteSize: t.byteSize, - lenPrefixByteSize: 4, - description: `Array<${t.description}>(${e})`, - }; - } - id.uniformFixedSizeArray = xQr; - function XIe(t, e) { - let r = t.length, - n = r === 0 ? "" : t[0].description; - return { - write: function (i, o, a) { - WO.strict.equal( - a.length, - r, - `array length ${a.length} should match len ${r}` - ), - d3.u32.write(i, o, r); - let s = o + 4; - for (let c = 0; c < r; c++) { - let u = t[c]; - u.write(i, s, a[c]), (s += u.byteSize); - } - }, - read: function (i, o) { - let a = d3.u32.read(i, o); - WO.strict.equal(a, r, "invalid byte size"); - let s = o + 4, - c = new Array(r); - for (let u = 0; u < r; u++) { - let h = t[u]; - (c[u] = h.read(i, s)), (s += h.byteSize); - } - return c; - }, - byteSize: 4 + e, - length: r, - description: `Array<${n}>(${r})[ 4 + ${e} ]`, - }; - } - id.fixedSizeArray = XIe; - function SQr(t) { - return { - toFixedFromData(e, r) { - let n = d3.u32.read(e, r); - (0, COt.logTrace)(`${this.description}[${n}]`); - let i = r + 4, - o = i, - a = new Array(n); - for (let s = 0; s < n; s++) { - let c = (0, IOt.fixBeetFromData)(t, e, o); - (a[s] = c), (o += c.byteSize); - } - return XIe(a, o - i); - }, - toFixedFromValue(e) { - (0, WO.strict)(Array.isArray(e), `${e} should be an array`); - let r = 0, - n = new Array(e.length); - for (let i = 0; i < e.length; i++) { - let o = (0, IOt.fixBeetFromValue)(t, e[i]); - (n[i] = o), (r += o.byteSize); - } - return XIe(n, r); - }, - description: "array", - }; - } - id.array = SQr; - function ROt(t) { - return { - write: function (e, r, n) { - n.copy(e, r, 0, t); - }, - read: function (e, r) { - return e.slice(r, r + t); - }, - byteSize: t, - description: `Buffer(${t})`, - }; - } - id.fixedSizeBuffer = ROt; - function YIe(t, e = !1) { - let r = ROt(t), - n = e ? t + 4 : t; - return { - write: function (i, o, a) { - WO.strict.equal( - a.byteLength, - t, - `Uint8Array length ${a.byteLength} should match len ${t}` - ), - e && (d3.u32.write(i, o, t), (o += 4)); - let s = Buffer.from(a); - r.write(i, o, s); - }, - read: function (i, o) { - if (e) { - let s = d3.u32.read(i, o); - WO.strict.equal(s, t, "invalid byte size"), (o += 4); - } - let a = r.read(i, o); - return Uint8Array.from(a); - }, - byteSize: n, - description: `Uint8Array(${t})`, - }; - } - id.fixedSizeUint8Array = YIe; - id.uint8Array = { - toFixedFromData(t, e) { - let r = d3.u32.read(t, e); - return (0, COt.logTrace)(`${this.description}[${r}]`), YIe(r, !0); - }, - toFixedFromValue(t) { - let e = t.byteLength; - return YIe(e, !0); - }, - description: "Uint8Array", - }; - id.collectionsTypeMap = { - Array: { - beet: "array", - isFixable: !0, - sourcePack: RD.BEET_PACKAGE, - ts: "Array", - arg: CD.BEET_TYPE_ARG_LEN, - }, - FixedSizeArray: { - beet: "fixedSizeArray", - isFixable: !1, - sourcePack: RD.BEET_PACKAGE, - ts: "Array", - arg: CD.BEET_TYPE_ARG_LEN, - }, - UniformFixedSizeArray: { - beet: "uniformFixedSizeArray", - isFixable: !1, - sourcePack: RD.BEET_PACKAGE, - ts: "Array", - arg: CD.BEET_TYPE_ARG_LEN, - }, - Buffer: { - beet: "fixedSizeBuffer", - isFixable: !1, - sourcePack: RD.BEET_PACKAGE, - ts: "Buffer", - arg: CD.BEET_TYPE_ARG_LEN, - }, - FixedSizeUint8Array: { - beet: "fixedSizeUint8Array", - isFixable: !1, - sourcePack: RD.BEET_PACKAGE, - ts: "Uint8Array", - arg: CD.BEET_TYPE_ARG_LEN, - }, - Uint8Array: { - beet: "uint8Array", - isFixable: !0, - sourcePack: RD.BEET_PACKAGE, - ts: "Uint8Array", - arg: CD.BEET_TYPE_ARG_LEN, - }, - }; - }); - var i5e = I((Tp) => { - "use strict"; - m(); - g(); - Object.defineProperty(Tp, "__esModule", { value: !0 }); - Tp.compositesTypeMap = - Tp.coption = - Tp.coptionSome = - Tp.coptionNone = - Tp.isNoneBuffer = - Tp.isSomeBuffer = - void 0; - var VV = Dr(), - QIe = ch(), - NOt = ch(), - FOt = VO(), - DOt = ID(), - LOt = 0, - qOt = 1; - function r5e(t, e) { - return t[e] === qOt; - } - Tp.isSomeBuffer = r5e; - function n5e(t, e) { - return t[e] === LOt; - } - Tp.isNoneBuffer = n5e; - function e5e(t) { - return ( - (0, FOt.logTrace)(`coptionNone(${t})`), - { - write: function (e, r, n) { - (0, VV.strict)( - n == null, - "coptionNone can only handle `null` values" - ), - (e[r] = LOt); - }, - read: function (e, r) { - return ( - (0, VV.strict)( - n5e(e, r), - "coptionNone can only handle `NONE` data" - ), - null - ); - }, - byteSize: 1, - description: `COption`, - } - ); - } - Tp.coptionNone = e5e; - function t5e(t) { - let e = 1 + t.byteSize, - r = { - write: function (n, i, o) { - (0, QIe.assertFixedSizeBeet)( - t, - `coption inner type ${t.description} needs to be fixed before calling write` - ), - (0, VV.strict)( - o != null, - "coptionSome cannot handle `null` values" - ), - (n[i] = qOt), - t.write(n, i + 1, o); - }, - read: function (n, i) { - return ( - (0, QIe.assertFixedSizeBeet)( - t, - `coption inner type ${t.description} needs to be fixed before calling read` - ), - (0, VV.strict)( - r5e(n, i), - "coptionSome can only handle `SOME` data" - ), - t.read(n, i + 1) - ); - }, - description: `COption<${t.description}>[1 + ${t.byteSize}]`, - byteSize: e, - inner: t, - }; - return (0, FOt.logTrace)(r.description), r; - } - Tp.coptionSome = t5e; - function AQr(t) { - return { - toFixedFromData(e, r) { - if (r5e(e, r)) { - let n = (0, DOt.fixBeetFromData)(t, e, r + 1); - return t5e(n); - } else - return ( - (0, VV.strict)(n5e(e, r), `Expected ${e} to hold a COption`), - e5e(t.description) - ); - }, - toFixedFromValue(e) { - return e == null - ? e5e(t.description) - : t5e((0, DOt.fixBeetFromValue)(t, e)); - }, - description: `COption<${t.description}>`, - }; - } - Tp.coption = AQr; - Tp.compositesTypeMap = { - option: { - beet: "coption", - isFixable: !0, - sourcePack: NOt.BEET_PACKAGE, - ts: "COption", - arg: QIe.BEET_TYPE_ARG_INNER, - pack: NOt.BEET_PACKAGE, - }, - }; - }); - var s5e = I((Kw) => { - "use strict"; - m(); - g(); - Object.defineProperty(Kw, "__esModule", { value: !0 }); - Kw.stringTypeMap = Kw.utf8String = Kw.fixedSizeUtf8String = void 0; - var o5e = ch(), - zOt = Dr(), - a5e = HO(), - EQr = VO(), - MQr = (t) => ({ - write: function (e, r, n) { - let i = Buffer.from(n, "utf8"); - zOt.strict.equal(i.byteLength, t, `${n} has invalid byte size`), - a5e.u32.write(e, r, t), - i.copy(e, r + 4, 0, t); - }, - read: function (e, r) { - let n = a5e.u32.read(e, r); - return ( - zOt.strict.equal(n, t, "invalid byte size"), - e.slice(r + 4, r + 4 + t).toString("utf8") - ); - }, - elementByteSize: 1, - length: t, - lenPrefixByteSize: 4, - byteSize: 4 + t, - description: `Utf8String(4 + ${t})`, - }); - Kw.fixedSizeUtf8String = MQr; - Kw.utf8String = { - toFixedFromData(t, e) { - let r = a5e.u32.read(t, e); - return ( - (0, EQr.logTrace)(`${this.description}[${r}]`), - (0, Kw.fixedSizeUtf8String)(r) - ); - }, - toFixedFromValue(t) { - let e = Buffer.from(t).byteLength; - return (0, Kw.fixedSizeUtf8String)(e); - }, - description: "Utf8String", - }; - Kw.stringTypeMap = { - fixedSizeString: { - beet: "fixedSizeUtf8String", - isFixable: !1, - sourcePack: o5e.BEET_PACKAGE, - ts: "string", - arg: o5e.BEET_TYPE_ARG_LEN, - }, - string: { - beet: "utf8String", - isFixable: !0, - sourcePack: o5e.BEET_PACKAGE, - ts: "string", - }, - }; - }); - var l5e = I((ND) => { - "use strict"; - m(); - g(); - Object.defineProperty(ND, "__esModule", { value: !0 }); - ND.BeetReader = ND.BeetWriter = void 0; - var TQr = Dr(), - u5e = class { - constructor(e) { - (this.buf = Buffer.alloc(e)), (this._offset = 0); - } - get buffer() { - return this.buf; - } - get offset() { - return this._offset; - } - maybeResize(e) { - this._offset + e > this.buf.length && - TQr.strict.fail( - `We shouldn't ever need to resize, but ${this._offset + e} > ${ - this.buf.length - }` - ); - } - write(e, r) { - this.maybeResize(e.byteSize), - e.write(this.buf, this._offset, r), - (this._offset += e.byteSize); - } - writeStruct(e, r) { - for (let [n, i] of r) { - let o = e[n]; - this.write(i, o); - } - } - }; - ND.BeetWriter = u5e; - var c5e = class { - constructor(e, r = 0) { - (this.buffer = e), (this._offset = r); - } - get offset() { - return this._offset; - } - read(e) { - let r = e.read(this.buffer, this._offset); - return (this._offset += e.byteSize), r; - } - readStruct(e) { - let r = {}; - for (let [n, i] of e) r[n] = this.read(i); - return r; - } - }; - ND.BeetReader = c5e; - }); - var bfe = I((h3) => { - "use strict"; - m(); - g(); - Object.defineProperty(h3, "__esModule", { value: !0 }); - h3.BeetArgsStruct = h3.isBeetStruct = h3.BeetStruct = void 0; - var jOt = l5e(), - aS = VO(), - Hw = class { - constructor(e, r, n = Hw.description) { - if ( - ((this.fields = e), - (this.construct = r), - (this.description = n), - (this.byteSize = this.getByteSize()), - aS.logDebug.enabled) - ) { - let i = e.map( - ([o, a]) => - `${String(o)}: ${a.description} ${(0, aS.beetBytes)(a)}` - ).join(` - `); - (0, aS.logDebug)(`struct ${n} { - ${i} -} ${(0, aS.beetBytes)(this)}`); - } - } - read(e, r) { - let [n] = this.deserialize(e, r); - return n; - } - write(e, r, n) { - let [i, o] = this.serialize(n); - i.copy(e, r, 0, o); - } - deserialize(e, r = 0) { - aS.logTrace.enabled && - ((0, aS.logTrace)( - "deserializing [%s] from %d bytes buffer", - this.description, - e.byteLength - ), - (0, aS.logTrace)(e), - (0, aS.logTrace)(e.toJSON().data)); - let n = new jOt.BeetReader(e, r), - i = n.readStruct(this.fields); - return [this.construct(i), n.offset]; - } - serialize(e, r = this.byteSize) { - (0, aS.logTrace)( - "serializing [%s] %o to %d bytes buffer", - this.description, - e, - r - ); - let n = new jOt.BeetWriter(r); - return n.writeStruct(e, this.fields), [n.buffer, n.offset]; - } - getByteSize() { - return this.fields.reduce((e, [r, n]) => e + n.byteSize, 0); - } - get type() { - return Hw.TYPE; - } - }; - h3.BeetStruct = Hw; - Hw.description = "BeetStruct"; - Hw.TYPE = "BeetStruct"; - function kQr(t) { - return t.type === Hw.TYPE; - } - h3.isBeetStruct = kQr; - var DD = class extends Hw { - constructor(e, r = DD.description) { - super(e, (n) => n, r); - } - }; - h3.BeetArgsStruct = DD; - DD.description = "BeetArgsStruct"; - }); - var d5e = I((Vw) => { - "use strict"; - m(); - g(); - var PQr = - (Vw && Vw.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(Vw, "__esModule", { value: !0 }); - Vw.FixableBeetArgsStruct = - Vw.isFixableBeetStruct = - Vw.FixableBeetStruct = - void 0; - var UOt = ID(), - wfe = bfe(), - OQr = ch(), - BQr = Dr(), - f5e = VO(), - IQr = PQr(Mg()), - { brightBlack: CQr } = IQr.default, - wm = class { - constructor(e, r, n = wm.description) { - (this.fields = e), (this.construct = r), (this.description = n); - let i = 0; - if (f5e.logDebug.enabled) { - let o = e.map( - ([s, c]) => ( - (0, OQr.isFixedSizeBeet)(c) && (i += c.byteSize), - `${s}: ${c.description} ${(0, f5e.beetBytes)(c)}` - ) - ).join(` - `), - a = `> ${i} B`; - (0, f5e.logDebug)(`struct ${n} { - ${o} -} ${CQr(a)}`); - } - } - deserialize(e, r = 0) { - return this.toFixedFromData(e, r).deserialize(e, r); - } - serialize(e, r) { - return this.toFixedFromValue(e).serialize(e, r); - } - toFixedFromData(e, r) { - let n = r, - i = new Array(this.fields.length); - for (let o = 0; o < this.fields.length; o++) { - let [a, s] = this.fields[o], - c = (0, UOt.fixBeetFromData)(s, e, n); - (i[o] = [a, c]), (n += c.byteSize); - } - return this.description !== wm.description - ? new wfe.BeetStruct(i, this.construct, this.description) - : new wfe.BeetStruct(i, this.construct); - } - toFixedFromValue(e) { - let r = Object.keys(e), - n = new Array(this.fields.length); - for (let i = 0; i < this.fields.length; i++) { - let [o, a] = this.fields[i]; - (0, BQr.strict)( - r.includes(o), - `Value with keys [ ${r} ] should include struct key '${o}' but doesn't.` - ); - let s = e[o], - c = (0, UOt.fixBeetFromValue)(a, s); - n[i] = [o, c]; - } - return this.description !== wm.description - ? new wfe.BeetStruct(n, this.construct, this.description) - : new wfe.BeetStruct(n, this.construct); - } - get type() { - return wm.TYPE; - } - }; - Vw.FixableBeetStruct = wm; - wm.description = "FixableBeetStruct"; - wm.TYPE = "FixableBeetStruct"; - function RQr(t) { - return t.type === wm.TYPE; - } - Vw.isFixableBeetStruct = RQr; - var FD = class extends wm { - constructor(e, r = FD.description) { - super(e, (n) => n, r); - } - }; - Vw.FixableBeetArgsStruct = FD; - FD.description = "FixableBeetArgsStruct"; - }); - var _fe = I((LD) => { - "use strict"; - m(); - g(); - Object.defineProperty(LD, "__esModule", { value: !0 }); - LD.unitTypeMap = LD.unit = void 0; - var NQr = ch(); - LD.unit = { - write: function (t, e, r) {}, - read: function (t, e) {}, - byteSize: 0, - description: "unit", - }; - LD.unitTypeMap = { - unit: { - beet: "unit", - isFixable: !1, - sourcePack: NQr.BEET_PACKAGE, - ts: "void", - }, - }; - }); - var h5e = I((Ww) => { - "use strict"; - m(); - g(); - Object.defineProperty(Ww, "__esModule", { value: !0 }); - Ww.enumsTypeMap = - Ww.dataEnum = - Ww.uniformDataEnum = - Ww.fixedScalarEnum = - void 0; - var p3 = ch(), - zg = HO(), - qD = Dr(), - DQr = bfe(), - FQr = d5e(), - LQr = _fe(); - function KOt(t, e) { - return e ? `${t}` : t; - } - function qQr(t) { - let e = Object.keys(t); - return { - write(r, n, i) { - let o = typeof i == "number", - a = KOt(i, o); - if ( - (e.includes(a) || - qD.strict.fail( - `${i} should be a variant of the provided enum type, i.e. [ ${Object.values( - t - ).join(", ")} ], but isn't` - ), - o) - ) - zg.u8.write(r, n, i); - else { - let s = t[a]; - zg.u8.write(r, n, s); - } - }, - read(r, n) { - let i = zg.u8.read(r, n), - o = typeof i == "number", - a = KOt(i, o); - return ( - e.includes(a) || - qD.strict.fail( - `${i} should be a of a variant of the provided enum type, i.e. [ ${Object.values( - t - ).join(", ")} ], but isn't` - ), - o ? i : t[a] - ); - }, - byteSize: zg.u8.byteSize, - description: "Enum", - }; - } - Ww.fixedScalarEnum = qQr; - function zQr(t) { - return { - write: function (e, r, n) { - zg.u8.write(e, r, n.kind), t.write(e, r + 1, n.data); - }, - read: function (e, r) { - let n = zg.u8.read(e, r), - i = t.read(e, r + 1); - return { kind: n, data: i }; - }, - byteSize: 1 + t.byteSize, - description: `UniformDataEnum<${t.description}>`, - }; - } - Ww.uniformDataEnum = zQr; - function HOt(t, e, r) { - return { - write(n, i, o) { - zg.u8.write(n, i, e), t.write(n, i + zg.u8.byteSize, o); - }, - read(n, i) { - let o = t.read(n, i + zg.u8.byteSize); - return { __kind: r, ...o }; - }, - byteSize: t.byteSize + zg.u8.byteSize, - description: `EnumData<${t.description}>`, - }; - } - function jQr(t) { - for (let [e, r] of t) - (0, qD.strict)( - (0, DQr.isBeetStruct)(r) || - (0, FQr.isFixableBeetStruct)(r) || - r === LQr.unit, - "dataEnum: variants must be a data beet struct or a scalar unit" - ); - return { - toFixedFromData(e, r) { - let n = zg.u8.read(e, r), - i = t[n]; - (0, qD.strict)( - i != null, - `Discriminant ${n} out of range for ${t.length} variants` - ); - let [o, a] = i, - s = (0, p3.isFixedSizeBeet)(a) ? a : a.toFixedFromData(e, r + 1); - return HOt(s, n, o); - }, - toFixedFromValue(e) { - if (e.__kind == null) { - let u = Object.keys(e).join(", "), - h = t.map(([w]) => w).join(", "); - qD.strict.fail( - `Value with fields [ ${u} ] is missing __kind, which needs to be set to one of [ ${h} ]` - ); - } - let r = t.findIndex(([u]) => u === e.__kind); - if (r < 0) { - let u = t.map(([h]) => h).join(", "); - qD.strict.fail( - `${e.__kind} is not a valid kind, needs to be one of [ ${u} ]` - ); - } - let n = t[r], - { __kind: i, ...o } = e, - [a, s] = n, - c = (0, p3.isFixedSizeBeet)(s) ? s : s.toFixedFromValue(o); - return HOt(c, r, a); - }, - description: `DataEnum<${t.length} variants>`, - }; - } - Ww.dataEnum = jQr; - Ww.enumsTypeMap = { - fixedScalarEnum: { - beet: "fixedScalarEnum", - isFixable: !1, - sourcePack: p3.BEET_PACKAGE, - ts: "", - arg: p3.BEET_TYPE_ARG_INNER, - pack: p3.BEET_PACKAGE, - }, - dataEnum: { - beet: "dataEnum", - isFixable: !1, - sourcePack: p3.BEET_PACKAGE, - ts: "DataEnum", - arg: p3.BEET_TYPE_ARG_INNER, - pack: p3.BEET_PACKAGE, - }, - }; - }); - var p5e = I((zD) => { - "use strict"; - m(); - g(); - Object.defineProperty(zD, "__esModule", { value: !0 }); - zD.aliasesTypeMap = zD.bytes = void 0; - var VOt = vfe(); - zD.bytes = VOt.uint8Array; - zD.aliasesTypeMap = { bytes: VOt.collectionsTypeMap.Uint8Array }; - }); - var g5e = I((y3) => { - "use strict"; - m(); - g(); - Object.defineProperty(y3, "__esModule", { value: !0 }); - y3.tuplesTypeMap = y3.tuple = y3.fixedSizeTuple = void 0; - var WOt = ch(), - y5e = Dr(), - GOt = ID(); - function m5e(t) { - let e = t.length, - r = t.map((o) => o.description), - n = t.map((o) => o.byteSize), - i = n.reduce((o, a) => o + a, 0); - return { - write: function (o, a, s) { - y5e.strict.equal( - s.length, - e, - `tuple value element size ${s.length} should match len ${e}` - ); - let c = a; - for (let u = 0; u < e; u++) { - let h = s[u], - w = t[u]; - w.write(o, c, h), (c += w.byteSize); - } - }, - read: function (o, a) { - let s = [], - c = a; - for (let u = 0; u < e; u++) { - let h = t[u]; - (s[u] = h.read(o, c)), (c += h.byteSize); - } - return s; - }, - byteSize: i, - length: e, - description: `FixedSizeTuple<${r.join(",")}>[ ${n.join(", ")} ]`, - }; - } - y3.fixedSizeTuple = m5e; - function UQr(t) { - let e = t.length, - r = t.map((n) => n.description); - return { - toFixedFromData(n, i) { - let o = i, - a = new Array(e); - for (let s = 0; s < e; s++) { - let c = (0, GOt.fixBeetFromData)(t[s], n, o); - (a[s] = c), (o += c.byteSize); - } - return m5e(a); - }, - toFixedFromValue(n) { - (0, y5e.strict)( - Array.isArray(n), - `${n} should be an array of tuple values` - ), - y5e.strict.equal( - n.length, - e, - `There should be ${e} tuple values, but there are ${n.length}` - ); - let i = new Array(e); - for (let o = 0; o < n.length; o++) { - let a = (0, GOt.fixBeetFromValue)(t[o], n[o]); - i[o] = a; - } - return m5e(i); - }, - description: `Tuple<${r.join(",")}>`, - }; - } - y3.tuple = UQr; - y3.tuplesTypeMap = { - Tuple: { - beet: "tuple", - isFixable: !0, - sourcePack: WOt.BEET_PACKAGE, - ts: "[__tuple_elements__]", - }, - FixedSizeTuple: { - beet: "fixedSizeTuple", - isFixable: !1, - sourcePack: WOt.BEET_PACKAGE, - ts: "[__tuple_elements__]", - }, - }; - }); - var w5e = I((jD) => { - "use strict"; - m(); - g(); - Object.defineProperty(jD, "__esModule", { value: !0 }); - jD.mapsTypeMap = jD.map = void 0; - var WV = ch(), - b5e = HO(), - v5e = Dr(); - function xfe(t, e, r, n) { - let i = (0, WV.isFixedSizeBeet)(t), - o = (0, WV.isFixedSizeBeet)(e); - function a() { - if (i && o) { - let u = t.byteSize + e.byteSize; - return { elementByteSize: u, byteSize: 4 + n * u }; - } else if (i) { - let u = 0; - for (let [w, M] of r.values()) u += M.byteSize; - return { - elementByteSize: t.byteSize + Math.ceil(u / n), - byteSize: 4 + t.byteSize * n + u, - }; - } else if (o) { - let u = 0; - for (let [w, M] of r.values()) u += w.byteSize; - return { - elementByteSize: Math.ceil(u / n) + e.byteSize, - byteSize: 4 + u + e.byteSize * n, - }; - } else { - let u = 0, - h = 0; - for (let [M, k] of r.values()) (u += M.byteSize), (h += k.byteSize); - return { - elementByteSize: Math.ceil(u / n + h / n), - byteSize: 4 + u + h, - }; - } - } - let { elementByteSize: s, byteSize: c } = a(); - return { - write: function (u, h, w) { - let M = h + 4, - k = 0; - for (let [O, D] of w.entries()) { - let F = i ? t : null, - N = o ? e : null; - if (F == null || N == null) { - let q = r.get(O); - (0, v5e.strict)( - q != null, - `Should be able to find beet els for ${O.toString()}, but could not` - ), - F ?? (F = q[0]), - N ?? (N = q[1]); - } - F.write(u, M, O), - (M += F.byteSize), - N.write(u, M, D), - (M += N.byteSize), - k++; - } - b5e.u32.write(u, h, k), - v5e.strict.equal( - k, - n, - `Expected map to have size ${n}, but has ${k}.` - ); - }, - read: function (u, h) { - let w = b5e.u32.read(u, h); - v5e.strict.equal( - w, - n, - `Expected map to have size ${n}, but has ${w}.` - ); - let M = h + 4, - k = new Map(); - for (let O = 0; O < w; O++) { - let D = i ? t : t.toFixedFromData(u, M), - F = D.read(u, M); - M += D.byteSize; - let N = o ? e : e.toFixedFromData(u, M), - q = N.read(u, M); - (M += N.byteSize), k.set(F, q); - } - return k; - }, - elementByteSize: s, - byteSize: c, - length: n, - lenPrefixByteSize: 4, - description: `Map<${t.description}, ${e.description}>`, - }; - } - function KQr(t, e) { - let r = (0, WV.isFixedSizeBeet)(t), - n = (0, WV.isFixedSizeBeet)(e); - return { - toFixedFromData(i, o) { - let a = b5e.u32.read(i, o), - s = o + 4; - if (r && n) return xfe(t, e, new Map(), a); - let c = new Map(); - for (let u = 0; u < a; u++) { - let h = r ? t : t.toFixedFromData(i, s), - w = h.read(i, s); - s += h.byteSize; - let M = n ? e : e.toFixedFromData(i, s); - (s += M.byteSize), c.set(w, [h, M]); - } - return xfe(t, e, c, a); - }, - toFixedFromValue(i) { - let o = i.size; - if (r && n) return xfe(t, e, new Map(), o); - let a = new Map(); - for (let [s, c] of i) { - let u = r ? t : t.toFixedFromValue(s), - h = n ? e : e.toFixedFromValue(c); - a.set(s, [u, h]); - } - return xfe(t, e, a, o); - }, - description: `FixableMap<${t.description}, ${e.description}>`, - }; - } - jD.map = KQr; - jD.mapsTypeMap = { - Map: { - beet: "map", - isFixable: !0, - sourcePack: WV.BEET_PACKAGE, - ts: "Map", - }, - }; - }); - var In = I(($a) => { - "use strict"; - m(); - g(); - var HQr = - ($a && $a.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - kp = - ($a && $a.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - HQr(e, t, r); - }; - Object.defineProperty($a, "__esModule", { value: !0 }); - $a.supportedTypeMap = void 0; - var VQr = vfe(), - WQr = i5e(), - GQr = HO(), - JQr = s5e(), - $Qr = h5e(), - ZQr = p5e(), - XQr = g5e(), - YQr = w5e(), - QQr = _fe(); - kp(p5e(), $a); - kp(vfe(), $a); - kp(i5e(), $a); - kp(h5e(), $a); - kp(w5e(), $a); - kp(HO(), $a); - kp(s5e(), $a); - kp(g5e(), $a); - kp(_fe(), $a); - kp(ID(), $a); - kp(l5e(), $a); - kp(bfe(), $a); - kp(d5e(), $a); - kp(ch(), $a); - $a.supportedTypeMap = { - ...VQr.collectionsTypeMap, - ...JQr.stringTypeMap, - ...WQr.compositesTypeMap, - ...$Qr.enumsTypeMap, - ...GQr.numbersTypeMap, - ...ZQr.aliasesTypeMap, - ...XQr.tuplesTypeMap, - ...YQr.mapsTypeMap, - ...QQr.unitTypeMap, - }; - }); - var x5e = I((fu) => { - "use strict"; - m(); - g(); - var een = - (fu && fu.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - ten = - (fu && fu.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - _5e = - (fu && fu.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - een(e, t, r); - return ten(e, t), e; - }; - Object.defineProperty(fu, "__esModule", { value: !0 }); - fu.auctionHouseBeet = - fu.AuctionHouse = - fu.auctionHouseDiscriminator = - void 0; - var ren = _5e(Le()), - sS = _5e(Fi()), - E0 = _5e(In()); - fu.auctionHouseDiscriminator = [40, 108, 215, 107, 213, 85, 245, 48]; - var Gw = class { - constructor(e, r, n, i, o, a, s, c, u, h, w, M, k, O, D, F, N) { - (this.auctionHouseFeeAccount = e), - (this.auctionHouseTreasury = r), - (this.treasuryWithdrawalDestination = n), - (this.feeWithdrawalDestination = i), - (this.treasuryMint = o), - (this.authority = a), - (this.creator = s), - (this.bump = c), - (this.treasuryBump = u), - (this.feePayerBump = h), - (this.sellerFeeBasisPoints = w), - (this.requiresSignOff = M), - (this.canChangeSalePrice = k), - (this.escrowPaymentBump = O), - (this.hasAuctioneer = D), - (this.auctioneerAddress = F), - (this.scopes = N); - } - static fromArgs(e) { - return new Gw( - e.auctionHouseFeeAccount, - e.auctionHouseTreasury, - e.treasuryWithdrawalDestination, - e.feeWithdrawalDestination, - e.treasuryMint, - e.authority, - e.creator, - e.bump, - e.treasuryBump, - e.feePayerBump, - e.sellerFeeBasisPoints, - e.requiresSignOff, - e.canChangeSalePrice, - e.escrowPaymentBump, - e.hasAuctioneer, - e.auctioneerAddress, - e.scopes - ); - } - static fromAccountInfo(e, r = 0) { - return Gw.deserialize(e.data, r); - } - static async fromAccountAddress(e, r) { - let n = await e.getAccountInfo(r); - if (n == null) - throw new Error(`Unable to find AuctionHouse account at ${r}`); - return Gw.fromAccountInfo(n, 0)[0]; - } - static gpaBuilder( - e = new ren.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - return sS.GpaBuilder.fromStruct(e, fu.auctionHouseBeet); - } - static deserialize(e, r = 0) { - return fu.auctionHouseBeet.deserialize(e, r); - } - serialize() { - return fu.auctionHouseBeet.serialize({ - accountDiscriminator: fu.auctionHouseDiscriminator, - ...this, - }); - } - static get byteSize() { - return fu.auctionHouseBeet.byteSize; - } - static async getMinimumBalanceForRentExemption(e, r) { - return e.getMinimumBalanceForRentExemption(Gw.byteSize, r); - } - static hasCorrectByteSize(e, r = 0) { - return e.byteLength - r === Gw.byteSize; - } - pretty() { - return { - auctionHouseFeeAccount: this.auctionHouseFeeAccount.toBase58(), - auctionHouseTreasury: this.auctionHouseTreasury.toBase58(), - treasuryWithdrawalDestination: - this.treasuryWithdrawalDestination.toBase58(), - feeWithdrawalDestination: this.feeWithdrawalDestination.toBase58(), - treasuryMint: this.treasuryMint.toBase58(), - authority: this.authority.toBase58(), - creator: this.creator.toBase58(), - bump: this.bump, - treasuryBump: this.treasuryBump, - feePayerBump: this.feePayerBump, - sellerFeeBasisPoints: this.sellerFeeBasisPoints, - requiresSignOff: this.requiresSignOff, - canChangeSalePrice: this.canChangeSalePrice, - escrowPaymentBump: this.escrowPaymentBump, - hasAuctioneer: this.hasAuctioneer, - auctioneerAddress: this.auctioneerAddress.toBase58(), - scopes: this.scopes, - }; - } - }; - fu.AuctionHouse = Gw; - fu.auctionHouseBeet = new E0.BeetStruct( - [ - ["accountDiscriminator", E0.uniformFixedSizeArray(E0.u8, 8)], - ["auctionHouseFeeAccount", sS.publicKey], - ["auctionHouseTreasury", sS.publicKey], - ["treasuryWithdrawalDestination", sS.publicKey], - ["feeWithdrawalDestination", sS.publicKey], - ["treasuryMint", sS.publicKey], - ["authority", sS.publicKey], - ["creator", sS.publicKey], - ["bump", E0.u8], - ["treasuryBump", E0.u8], - ["feePayerBump", E0.u8], - ["sellerFeeBasisPoints", E0.u16], - ["requiresSignOff", E0.bool], - ["canChangeSalePrice", E0.bool], - ["escrowPaymentBump", E0.u8], - ["hasAuctioneer", E0.bool], - ["auctioneerAddress", sS.publicKey], - ["scopes", E0.uniformFixedSizeArray(E0.bool, 7)], - ], - Gw.fromArgs, - "AuctionHouse" - ); - }); - var E5e = I((du) => { - "use strict"; - m(); - g(); - var nen = - (du && du.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - ien = - (du && du.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - A5e = - (du && du.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - nen(e, t, r); - return ien(e, t), e; - }; - Object.defineProperty(du, "__esModule", { value: !0 }); - du.auctioneerBeet = du.Auctioneer = du.auctioneerDiscriminator = void 0; - var oen = A5e(Le()), - S5e = A5e(Fi()), - Sfe = A5e(In()); - du.auctioneerDiscriminator = [46, 101, 92, 150, 138, 30, 245, 120]; - var Jw = class { - constructor(e, r, n) { - (this.auctioneerAuthority = e), - (this.auctionHouse = r), - (this.bump = n); - } - static fromArgs(e) { - return new Jw(e.auctioneerAuthority, e.auctionHouse, e.bump); - } - static fromAccountInfo(e, r = 0) { - return Jw.deserialize(e.data, r); - } - static async fromAccountAddress(e, r) { - let n = await e.getAccountInfo(r); - if (n == null) - throw new Error(`Unable to find Auctioneer account at ${r}`); - return Jw.fromAccountInfo(n, 0)[0]; - } - static gpaBuilder( - e = new oen.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - return S5e.GpaBuilder.fromStruct(e, du.auctioneerBeet); - } - static deserialize(e, r = 0) { - return du.auctioneerBeet.deserialize(e, r); - } - serialize() { - return du.auctioneerBeet.serialize({ - accountDiscriminator: du.auctioneerDiscriminator, - ...this, - }); - } - static get byteSize() { - return du.auctioneerBeet.byteSize; - } - static async getMinimumBalanceForRentExemption(e, r) { - return e.getMinimumBalanceForRentExemption(Jw.byteSize, r); - } - static hasCorrectByteSize(e, r = 0) { - return e.byteLength - r === Jw.byteSize; - } - pretty() { - return { - auctioneerAuthority: this.auctioneerAuthority.toBase58(), - auctionHouse: this.auctionHouse.toBase58(), - bump: this.bump, - }; - } - }; - du.Auctioneer = Jw; - du.auctioneerBeet = new Sfe.BeetStruct( - [ - ["accountDiscriminator", Sfe.uniformFixedSizeArray(Sfe.u8, 8)], - ["auctioneerAuthority", S5e.publicKey], - ["auctionHouse", S5e.publicKey], - ["bump", Sfe.u8], - ], - Jw.fromArgs, - "Auctioneer" - ); - }); - var T5e = I((zs) => { - "use strict"; - m(); - g(); - var aen = - (zs && zs.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - sen = - (zs && zs.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - M5e = - (zs && zs.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - aen(e, t, r); - return sen(e, t), e; - }; - Object.defineProperty(zs, "__esModule", { value: !0 }); - zs.bidReceiptBeet = zs.BidReceipt = zs.bidReceiptDiscriminator = void 0; - var uen = M5e(Le()), - _m = M5e(In()), - m3 = M5e(Fi()); - zs.bidReceiptDiscriminator = [186, 150, 141, 135, 59, 122, 39, 99]; - var $w = class { - constructor(e, r, n, i, o, a, s, c, u, h, w, M, k) { - (this.tradeState = e), - (this.bookkeeper = r), - (this.auctionHouse = n), - (this.buyer = i), - (this.metadata = o), - (this.tokenAccount = a), - (this.purchaseReceipt = s), - (this.price = c), - (this.tokenSize = u), - (this.bump = h), - (this.tradeStateBump = w), - (this.createdAt = M), - (this.canceledAt = k); - } - static fromArgs(e) { - return new $w( - e.tradeState, - e.bookkeeper, - e.auctionHouse, - e.buyer, - e.metadata, - e.tokenAccount, - e.purchaseReceipt, - e.price, - e.tokenSize, - e.bump, - e.tradeStateBump, - e.createdAt, - e.canceledAt - ); - } - static fromAccountInfo(e, r = 0) { - return $w.deserialize(e.data, r); - } - static async fromAccountAddress(e, r) { - let n = await e.getAccountInfo(r); - if (n == null) - throw new Error(`Unable to find BidReceipt account at ${r}`); - return $w.fromAccountInfo(n, 0)[0]; - } - static gpaBuilder( - e = new uen.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - return m3.GpaBuilder.fromStruct(e, zs.bidReceiptBeet); - } - static deserialize(e, r = 0) { - return zs.bidReceiptBeet.deserialize(e, r); - } - serialize() { - return zs.bidReceiptBeet.serialize({ - accountDiscriminator: zs.bidReceiptDiscriminator, - ...this, - }); - } - static byteSize(e) { - let r = $w.fromArgs(e); - return zs.bidReceiptBeet.toFixedFromValue({ - accountDiscriminator: zs.bidReceiptDiscriminator, - ...r, - }).byteSize; - } - static async getMinimumBalanceForRentExemption(e, r, n) { - return r.getMinimumBalanceForRentExemption($w.byteSize(e), n); - } - pretty() { - return { - tradeState: this.tradeState.toBase58(), - bookkeeper: this.bookkeeper.toBase58(), - auctionHouse: this.auctionHouse.toBase58(), - buyer: this.buyer.toBase58(), - metadata: this.metadata.toBase58(), - tokenAccount: this.tokenAccount, - purchaseReceipt: this.purchaseReceipt, - price: (() => { - let e = this.price; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - tokenSize: (() => { - let e = this.tokenSize; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - bump: this.bump, - tradeStateBump: this.tradeStateBump, - createdAt: (() => { - let e = this.createdAt; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - canceledAt: this.canceledAt, - }; - } - }; - zs.BidReceipt = $w; - zs.bidReceiptBeet = new _m.FixableBeetStruct( - [ - ["accountDiscriminator", _m.uniformFixedSizeArray(_m.u8, 8)], - ["tradeState", m3.publicKey], - ["bookkeeper", m3.publicKey], - ["auctionHouse", m3.publicKey], - ["buyer", m3.publicKey], - ["metadata", m3.publicKey], - ["tokenAccount", _m.coption(m3.publicKey)], - ["purchaseReceipt", _m.coption(m3.publicKey)], - ["price", _m.u64], - ["tokenSize", _m.u64], - ["bump", _m.u8], - ["tradeStateBump", _m.u8], - ["createdAt", _m.i64], - ["canceledAt", _m.coption(_m.i64)], - ], - $w.fromArgs, - "BidReceipt" - ); - }); - var P5e = I((js) => { - "use strict"; - m(); - g(); - var cen = - (js && js.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - len = - (js && js.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - k5e = - (js && js.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - cen(e, t, r); - return len(e, t), e; - }; - Object.defineProperty(js, "__esModule", { value: !0 }); - js.listingReceiptBeet = - js.ListingReceipt = - js.listingReceiptDiscriminator = - void 0; - var fen = k5e(Le()), - jg = k5e(In()), - GO = k5e(Fi()); - js.listingReceiptDiscriminator = [240, 71, 225, 94, 200, 75, 84, 231]; - var Zw = class { - constructor(e, r, n, i, o, a, s, c, u, h, w, M) { - (this.tradeState = e), - (this.bookkeeper = r), - (this.auctionHouse = n), - (this.seller = i), - (this.metadata = o), - (this.purchaseReceipt = a), - (this.price = s), - (this.tokenSize = c), - (this.bump = u), - (this.tradeStateBump = h), - (this.createdAt = w), - (this.canceledAt = M); - } - static fromArgs(e) { - return new Zw( - e.tradeState, - e.bookkeeper, - e.auctionHouse, - e.seller, - e.metadata, - e.purchaseReceipt, - e.price, - e.tokenSize, - e.bump, - e.tradeStateBump, - e.createdAt, - e.canceledAt - ); - } - static fromAccountInfo(e, r = 0) { - return Zw.deserialize(e.data, r); - } - static async fromAccountAddress(e, r) { - let n = await e.getAccountInfo(r); - if (n == null) - throw new Error(`Unable to find ListingReceipt account at ${r}`); - return Zw.fromAccountInfo(n, 0)[0]; - } - static gpaBuilder( - e = new fen.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - return GO.GpaBuilder.fromStruct(e, js.listingReceiptBeet); - } - static deserialize(e, r = 0) { - return js.listingReceiptBeet.deserialize(e, r); - } - serialize() { - return js.listingReceiptBeet.serialize({ - accountDiscriminator: js.listingReceiptDiscriminator, - ...this, - }); - } - static byteSize(e) { - let r = Zw.fromArgs(e); - return js.listingReceiptBeet.toFixedFromValue({ - accountDiscriminator: js.listingReceiptDiscriminator, - ...r, - }).byteSize; - } - static async getMinimumBalanceForRentExemption(e, r, n) { - return r.getMinimumBalanceForRentExemption(Zw.byteSize(e), n); - } - pretty() { - return { - tradeState: this.tradeState.toBase58(), - bookkeeper: this.bookkeeper.toBase58(), - auctionHouse: this.auctionHouse.toBase58(), - seller: this.seller.toBase58(), - metadata: this.metadata.toBase58(), - purchaseReceipt: this.purchaseReceipt, - price: (() => { - let e = this.price; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - tokenSize: (() => { - let e = this.tokenSize; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - bump: this.bump, - tradeStateBump: this.tradeStateBump, - createdAt: (() => { - let e = this.createdAt; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - canceledAt: this.canceledAt, - }; - } - }; - js.ListingReceipt = Zw; - js.listingReceiptBeet = new jg.FixableBeetStruct( - [ - ["accountDiscriminator", jg.uniformFixedSizeArray(jg.u8, 8)], - ["tradeState", GO.publicKey], - ["bookkeeper", GO.publicKey], - ["auctionHouse", GO.publicKey], - ["seller", GO.publicKey], - ["metadata", GO.publicKey], - ["purchaseReceipt", jg.coption(GO.publicKey)], - ["price", jg.u64], - ["tokenSize", jg.u64], - ["bump", jg.u8], - ["tradeStateBump", jg.u8], - ["createdAt", jg.i64], - ["canceledAt", jg.coption(jg.i64)], - ], - Zw.fromArgs, - "ListingReceipt" - ); - }); - var B5e = I((hu) => { - "use strict"; - m(); - g(); - var den = - (hu && hu.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - hen = - (hu && hu.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - O5e = - (hu && hu.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - den(e, t, r); - return hen(e, t), e; - }; - Object.defineProperty(hu, "__esModule", { value: !0 }); - hu.purchaseReceiptBeet = - hu.PurchaseReceipt = - hu.purchaseReceiptDiscriminator = - void 0; - var pen = O5e(Le()), - JO = O5e(In()), - UD = O5e(Fi()); - hu.purchaseReceiptDiscriminator = [79, 127, 222, 137, 154, 131, 150, 134]; - var Xw = class { - constructor(e, r, n, i, o, a, s, c, u) { - (this.bookkeeper = e), - (this.buyer = r), - (this.seller = n), - (this.auctionHouse = i), - (this.metadata = o), - (this.tokenSize = a), - (this.price = s), - (this.bump = c), - (this.createdAt = u); - } - static fromArgs(e) { - return new Xw( - e.bookkeeper, - e.buyer, - e.seller, - e.auctionHouse, - e.metadata, - e.tokenSize, - e.price, - e.bump, - e.createdAt - ); - } - static fromAccountInfo(e, r = 0) { - return Xw.deserialize(e.data, r); - } - static async fromAccountAddress(e, r) { - let n = await e.getAccountInfo(r); - if (n == null) - throw new Error(`Unable to find PurchaseReceipt account at ${r}`); - return Xw.fromAccountInfo(n, 0)[0]; - } - static gpaBuilder( - e = new pen.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - return UD.GpaBuilder.fromStruct(e, hu.purchaseReceiptBeet); - } - static deserialize(e, r = 0) { - return hu.purchaseReceiptBeet.deserialize(e, r); - } - serialize() { - return hu.purchaseReceiptBeet.serialize({ - accountDiscriminator: hu.purchaseReceiptDiscriminator, - ...this, - }); - } - static get byteSize() { - return hu.purchaseReceiptBeet.byteSize; - } - static async getMinimumBalanceForRentExemption(e, r) { - return e.getMinimumBalanceForRentExemption(Xw.byteSize, r); - } - static hasCorrectByteSize(e, r = 0) { - return e.byteLength - r === Xw.byteSize; - } - pretty() { - return { - bookkeeper: this.bookkeeper.toBase58(), - buyer: this.buyer.toBase58(), - seller: this.seller.toBase58(), - auctionHouse: this.auctionHouse.toBase58(), - metadata: this.metadata.toBase58(), - tokenSize: (() => { - let e = this.tokenSize; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - price: (() => { - let e = this.price; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - bump: this.bump, - createdAt: (() => { - let e = this.createdAt; - if (typeof e.toNumber == "function") - try { - return e.toNumber(); - } catch { - return e; - } - return e; - })(), - }; - } - }; - hu.PurchaseReceipt = Xw; - hu.purchaseReceiptBeet = new JO.BeetStruct( - [ - ["accountDiscriminator", JO.uniformFixedSizeArray(JO.u8, 8)], - ["bookkeeper", UD.publicKey], - ["buyer", UD.publicKey], - ["seller", UD.publicKey], - ["auctionHouse", UD.publicKey], - ["metadata", UD.publicKey], - ["tokenSize", JO.u64], - ["price", JO.u64], - ["bump", JO.u8], - ["createdAt", JO.i64], - ], - Xw.fromArgs, - "PurchaseReceipt" - ); - }); - var JOt = I((M0) => { - "use strict"; - m(); - g(); - var yen = - (M0 && M0.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - GV = - (M0 && M0.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - yen(e, t, r); - }; - Object.defineProperty(M0, "__esModule", { value: !0 }); - M0.accountProviders = void 0; - GV(x5e(), M0); - GV(E5e(), M0); - GV(T5e(), M0); - GV(P5e(), M0); - GV(B5e(), M0); - var men = T5e(), - gen = P5e(), - ven = B5e(), - ben = x5e(), - wen = E5e(); - M0.accountProviders = { - BidReceipt: men.BidReceipt, - ListingReceipt: gen.ListingReceipt, - PurchaseReceipt: ven.PurchaseReceipt, - AuctionHouse: ben.AuctionHouse, - Auctioneer: wen.Auctioneer, - }; - }); - var $Ot = I((Lt) => { - "use strict"; - m(); - g(); - Object.defineProperty(Lt, "__esModule", { value: !0 }); - Lt.errorFromName = - Lt.errorFromCode = - Lt.InsufficientFundsError = - Lt.AuctioneerAuthorityMismatchError = - Lt.AuctionHouseAlreadyDelegatedError = - Lt.PartialPriceMismatchError = - Lt.NotEnoughTokensAvailableForPurchaseError = - Lt.MissingElementForPartialOrderError = - Lt.BuyerTradeStateNotValidError = - Lt.InvalidSeedsOrAuctionHouseNotDelegatedError = - Lt.EscrowUnderRentExemptionError = - Lt.BumpSeedNotInHashMapError = - Lt.AuctionHouseNotDelegatedError = - Lt.TooManyScopesError = - Lt.NoAuctioneerProgramSetError = - Lt.MustUseAuctioneerHandlerError = - Lt.MissingAuctioneerScopeError = - Lt.InvalidAuctioneerError = - Lt.InstructionMismatchError = - Lt.ReceiptIsEmptyError = - Lt.TradeStateIsNotEmptyError = - Lt.TradeStateDoesntExistError = - Lt.InvalidBasisPointsError = - Lt.NoValidSignerPresentError = - Lt.BuyerATACannotHaveDelegateError = - Lt.SellerATACannotHaveDelegateError = - Lt.OldSellerNotInitializedError = - Lt.SaleRequiresSignerError = - Lt.CannotMatchFreeSalesWithoutAuctionHouseOrSellerSignoffError = - Lt.BothPartiesNeedToAgreeToSaleError = - Lt.InvalidTokenAmountError = - Lt.MetadataDoesntExistError = - Lt.DerivedKeyInvalidError = - Lt.NoPayerPresentError = - Lt.CannotTakeThisActionWithoutAuctionHouseSignOffError = - Lt.SOLWalletMustSignError = - Lt.CannotExchangeSOLForSolError = - Lt.ExpectedSolAccountError = - Lt.NumericalOverflowError = - Lt.NotRentExemptError = - Lt.StatementFalseError = - Lt.PublicKeysShouldBeUniqueError = - Lt.IncorrectOwnerError = - Lt.UninitializedAccountError = - Lt.InvalidMintAuthorityError = - Lt.PublicKeyMismatchError = - void 0; - var Zr = new Map(), - Xr = new Map(), - $O = class extends Error { - constructor() { - super("PublicKeyMismatch"), - (this.code = 6e3), - (this.name = "PublicKeyMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, $O); - } - }; - Lt.PublicKeyMismatchError = $O; - Zr.set(6e3, () => new $O()); - Xr.set("PublicKeyMismatch", () => new $O()); - var ZO = class extends Error { - constructor() { - super("InvalidMintAuthority"), - (this.code = 6001), - (this.name = "InvalidMintAuthority"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, ZO); - } - }; - Lt.InvalidMintAuthorityError = ZO; - Zr.set(6001, () => new ZO()); - Xr.set("InvalidMintAuthority", () => new ZO()); - var XO = class extends Error { - constructor() { - super("UninitializedAccount"), - (this.code = 6002), - (this.name = "UninitializedAccount"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, XO); - } - }; - Lt.UninitializedAccountError = XO; - Zr.set(6002, () => new XO()); - Xr.set("UninitializedAccount", () => new XO()); - var YO = class extends Error { - constructor() { - super("IncorrectOwner"), - (this.code = 6003), - (this.name = "IncorrectOwner"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, YO); - } - }; - Lt.IncorrectOwnerError = YO; - Zr.set(6003, () => new YO()); - Xr.set("IncorrectOwner", () => new YO()); - var QO = class extends Error { - constructor() { - super("PublicKeysShouldBeUnique"), - (this.code = 6004), - (this.name = "PublicKeysShouldBeUnique"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, QO); - } - }; - Lt.PublicKeysShouldBeUniqueError = QO; - Zr.set(6004, () => new QO()); - Xr.set("PublicKeysShouldBeUnique", () => new QO()); - var eB = class extends Error { - constructor() { - super("StatementFalse"), - (this.code = 6005), - (this.name = "StatementFalse"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, eB); - } - }; - Lt.StatementFalseError = eB; - Zr.set(6005, () => new eB()); - Xr.set("StatementFalse", () => new eB()); - var tB = class extends Error { - constructor() { - super("NotRentExempt"), - (this.code = 6006), - (this.name = "NotRentExempt"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, tB); - } - }; - Lt.NotRentExemptError = tB; - Zr.set(6006, () => new tB()); - Xr.set("NotRentExempt", () => new tB()); - var rB = class extends Error { - constructor() { - super("NumericalOverflow"), - (this.code = 6007), - (this.name = "NumericalOverflow"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, rB); - } - }; - Lt.NumericalOverflowError = rB; - Zr.set(6007, () => new rB()); - Xr.set("NumericalOverflow", () => new rB()); - var nB = class extends Error { - constructor() { - super("Expected a sol account but got an spl token account instead"), - (this.code = 6008), - (this.name = "ExpectedSolAccount"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, nB); - } - }; - Lt.ExpectedSolAccountError = nB; - Zr.set(6008, () => new nB()); - Xr.set("ExpectedSolAccount", () => new nB()); - var iB = class extends Error { - constructor() { - super("Cannot exchange sol for sol"), - (this.code = 6009), - (this.name = "CannotExchangeSOLForSol"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, iB); - } - }; - Lt.CannotExchangeSOLForSolError = iB; - Zr.set(6009, () => new iB()); - Xr.set("CannotExchangeSOLForSol", () => new iB()); - var oB = class extends Error { - constructor() { - super("If paying with sol, sol wallet must be signer"), - (this.code = 6010), - (this.name = "SOLWalletMustSign"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, oB); - } - }; - Lt.SOLWalletMustSignError = oB; - Zr.set(6010, () => new oB()); - Xr.set("SOLWalletMustSign", () => new oB()); - var aB = class extends Error { - constructor() { - super("Cannot take this action without auction house signing too"), - (this.code = 6011), - (this.name = "CannotTakeThisActionWithoutAuctionHouseSignOff"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, aB); - } - }; - Lt.CannotTakeThisActionWithoutAuctionHouseSignOffError = aB; - Zr.set(6011, () => new aB()); - Xr.set("CannotTakeThisActionWithoutAuctionHouseSignOff", () => new aB()); - var sB = class extends Error { - constructor() { - super("No payer present on this txn"), - (this.code = 6012), - (this.name = "NoPayerPresent"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, sB); - } - }; - Lt.NoPayerPresentError = sB; - Zr.set(6012, () => new sB()); - Xr.set("NoPayerPresent", () => new sB()); - var uB = class extends Error { - constructor() { - super("Derived key invalid"), - (this.code = 6013), - (this.name = "DerivedKeyInvalid"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, uB); - } - }; - Lt.DerivedKeyInvalidError = uB; - Zr.set(6013, () => new uB()); - Xr.set("DerivedKeyInvalid", () => new uB()); - var cB = class extends Error { - constructor() { - super("Metadata doesn't exist"), - (this.code = 6014), - (this.name = "MetadataDoesntExist"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, cB); - } - }; - Lt.MetadataDoesntExistError = cB; - Zr.set(6014, () => new cB()); - Xr.set("MetadataDoesntExist", () => new cB()); - var lB = class extends Error { - constructor() { - super("Invalid token amount"), - (this.code = 6015), - (this.name = "InvalidTokenAmount"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, lB); - } - }; - Lt.InvalidTokenAmountError = lB; - Zr.set(6015, () => new lB()); - Xr.set("InvalidTokenAmount", () => new lB()); - var fB = class extends Error { - constructor() { - super("Both parties need to agree to this sale"), - (this.code = 6016), - (this.name = "BothPartiesNeedToAgreeToSale"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, fB); - } - }; - Lt.BothPartiesNeedToAgreeToSaleError = fB; - Zr.set(6016, () => new fB()); - Xr.set("BothPartiesNeedToAgreeToSale", () => new fB()); - var dB = class extends Error { - constructor() { - super( - "Cannot match free sales unless the auction house or seller signs off" - ), - (this.code = 6017), - (this.name = - "CannotMatchFreeSalesWithoutAuctionHouseOrSellerSignoff"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, dB); - } - }; - Lt.CannotMatchFreeSalesWithoutAuctionHouseOrSellerSignoffError = dB; - Zr.set(6017, () => new dB()); - Xr.set( - "CannotMatchFreeSalesWithoutAuctionHouseOrSellerSignoff", - () => new dB() - ); - var hB = class extends Error { - constructor() { - super("This sale requires a signer"), - (this.code = 6018), - (this.name = "SaleRequiresSigner"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, hB); - } - }; - Lt.SaleRequiresSignerError = hB; - Zr.set(6018, () => new hB()); - Xr.set("SaleRequiresSigner", () => new hB()); - var pB = class extends Error { - constructor() { - super("Old seller not initialized"), - (this.code = 6019), - (this.name = "OldSellerNotInitialized"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, pB); - } - }; - Lt.OldSellerNotInitializedError = pB; - Zr.set(6019, () => new pB()); - Xr.set("OldSellerNotInitialized", () => new pB()); - var yB = class extends Error { - constructor() { - super("Seller ata cannot have a delegate set"), - (this.code = 6020), - (this.name = "SellerATACannotHaveDelegate"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, yB); - } - }; - Lt.SellerATACannotHaveDelegateError = yB; - Zr.set(6020, () => new yB()); - Xr.set("SellerATACannotHaveDelegate", () => new yB()); - var mB = class extends Error { - constructor() { - super("Buyer ata cannot have a delegate set"), - (this.code = 6021), - (this.name = "BuyerATACannotHaveDelegate"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, mB); - } - }; - Lt.BuyerATACannotHaveDelegateError = mB; - Zr.set(6021, () => new mB()); - Xr.set("BuyerATACannotHaveDelegate", () => new mB()); - var gB = class extends Error { - constructor() { - super("No valid signer present"), - (this.code = 6022), - (this.name = "NoValidSignerPresent"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, gB); - } - }; - Lt.NoValidSignerPresentError = gB; - Zr.set(6022, () => new gB()); - Xr.set("NoValidSignerPresent", () => new gB()); - var vB = class extends Error { - constructor() { - super("BP must be less than or equal to 10000"), - (this.code = 6023), - (this.name = "InvalidBasisPoints"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, vB); - } - }; - Lt.InvalidBasisPointsError = vB; - Zr.set(6023, () => new vB()); - Xr.set("InvalidBasisPoints", () => new vB()); - var bB = class extends Error { - constructor() { - super("The trade state account does not exist"), - (this.code = 6024), - (this.name = "TradeStateDoesntExist"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, bB); - } - }; - Lt.TradeStateDoesntExistError = bB; - Zr.set(6024, () => new bB()); - Xr.set("TradeStateDoesntExist", () => new bB()); - var wB = class extends Error { - constructor() { - super("The trade state is not empty"), - (this.code = 6025), - (this.name = "TradeStateIsNotEmpty"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, wB); - } - }; - Lt.TradeStateIsNotEmptyError = wB; - Zr.set(6025, () => new wB()); - Xr.set("TradeStateIsNotEmpty", () => new wB()); - var _B = class extends Error { - constructor() { - super("The receipt is empty"), - (this.code = 6026), - (this.name = "ReceiptIsEmpty"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, _B); - } - }; - Lt.ReceiptIsEmptyError = _B; - Zr.set(6026, () => new _B()); - Xr.set("ReceiptIsEmpty", () => new _B()); - var xB = class extends Error { - constructor() { - super("The instruction does not match"), - (this.code = 6027), - (this.name = "InstructionMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, xB); - } - }; - Lt.InstructionMismatchError = xB; - Zr.set(6027, () => new xB()); - Xr.set("InstructionMismatch", () => new xB()); - var SB = class extends Error { - constructor() { - super("Invalid Auctioneer for this Auction House instance."), - (this.code = 6028), - (this.name = "InvalidAuctioneer"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, SB); - } - }; - Lt.InvalidAuctioneerError = SB; - Zr.set(6028, () => new SB()); - Xr.set("InvalidAuctioneer", () => new SB()); - var AB = class extends Error { - constructor() { - super( - "The Auctioneer does not have the correct scope for this action." - ), - (this.code = 6029), - (this.name = "MissingAuctioneerScope"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, AB); - } - }; - Lt.MissingAuctioneerScopeError = AB; - Zr.set(6029, () => new AB()); - Xr.set("MissingAuctioneerScope", () => new AB()); - var EB = class extends Error { - constructor() { - super("Must use auctioneer handler."), - (this.code = 6030), - (this.name = "MustUseAuctioneerHandler"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, EB); - } - }; - Lt.MustUseAuctioneerHandlerError = EB; - Zr.set(6030, () => new EB()); - Xr.set("MustUseAuctioneerHandler", () => new EB()); - var MB = class extends Error { - constructor() { - super("No Auctioneer program set."), - (this.code = 6031), - (this.name = "NoAuctioneerProgramSet"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, MB); - } - }; - Lt.NoAuctioneerProgramSetError = MB; - Zr.set(6031, () => new MB()); - Xr.set("NoAuctioneerProgramSet", () => new MB()); - var TB = class extends Error { - constructor() { - super("Too many scopes."), - (this.code = 6032), - (this.name = "TooManyScopes"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, TB); - } - }; - Lt.TooManyScopesError = TB; - Zr.set(6032, () => new TB()); - Xr.set("TooManyScopes", () => new TB()); - var kB = class extends Error { - constructor() { - super("Auction House not delegated."), - (this.code = 6033), - (this.name = "AuctionHouseNotDelegated"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, kB); - } - }; - Lt.AuctionHouseNotDelegatedError = kB; - Zr.set(6033, () => new kB()); - Xr.set("AuctionHouseNotDelegated", () => new kB()); - var PB = class extends Error { - constructor() { - super("Bump seed not in hash map."), - (this.code = 6034), - (this.name = "BumpSeedNotInHashMap"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, PB); - } - }; - Lt.BumpSeedNotInHashMapError = PB; - Zr.set(6034, () => new PB()); - Xr.set("BumpSeedNotInHashMap", () => new PB()); - var OB = class extends Error { - constructor() { - super( - "The instruction would drain the escrow below rent exemption threshold" - ), - (this.code = 6035), - (this.name = "EscrowUnderRentExemption"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, OB); - } - }; - Lt.EscrowUnderRentExemptionError = OB; - Zr.set(6035, () => new OB()); - Xr.set("EscrowUnderRentExemption", () => new OB()); - var BB = class extends Error { - constructor() { - super("Invalid seeds or Auction House not delegated"), - (this.code = 6036), - (this.name = "InvalidSeedsOrAuctionHouseNotDelegated"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, BB); - } - }; - Lt.InvalidSeedsOrAuctionHouseNotDelegatedError = BB; - Zr.set(6036, () => new BB()); - Xr.set("InvalidSeedsOrAuctionHouseNotDelegated", () => new BB()); - var IB = class extends Error { - constructor() { - super("The buyer trade state was unable to be initialized."), - (this.code = 6037), - (this.name = "BuyerTradeStateNotValid"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, IB); - } - }; - Lt.BuyerTradeStateNotValidError = IB; - Zr.set(6037, () => new IB()); - Xr.set("BuyerTradeStateNotValid", () => new IB()); - var CB = class extends Error { - constructor() { - super( - "Partial order size and price must both be provided in a partial buy." - ), - (this.code = 6038), - (this.name = "MissingElementForPartialOrder"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, CB); - } - }; - Lt.MissingElementForPartialOrderError = CB; - Zr.set(6038, () => new CB()); - Xr.set("MissingElementForPartialOrder", () => new CB()); - var RB = class extends Error { - constructor() { - super( - "Amount of tokens available for purchase is less than the partial order amount." - ), - (this.code = 6039), - (this.name = "NotEnoughTokensAvailableForPurchase"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, RB); - } - }; - Lt.NotEnoughTokensAvailableForPurchaseError = RB; - Zr.set(6039, () => new RB()); - Xr.set("NotEnoughTokensAvailableForPurchase", () => new RB()); - var NB = class extends Error { - constructor() { - super( - "Calculated partial price does not not partial price that was provided." - ), - (this.code = 6040), - (this.name = "PartialPriceMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, NB); - } - }; - Lt.PartialPriceMismatchError = NB; - Zr.set(6040, () => new NB()); - Xr.set("PartialPriceMismatch", () => new NB()); - var DB = class extends Error { - constructor() { - super("Auction House already delegated."), - (this.code = 6041), - (this.name = "AuctionHouseAlreadyDelegated"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, DB); - } - }; - Lt.AuctionHouseAlreadyDelegatedError = DB; - Zr.set(6041, () => new DB()); - Xr.set("AuctionHouseAlreadyDelegated", () => new DB()); - var FB = class extends Error { - constructor() { - super("Auctioneer Authority Mismatch"), - (this.code = 6042), - (this.name = "AuctioneerAuthorityMismatch"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, FB); - } - }; - Lt.AuctioneerAuthorityMismatchError = FB; - Zr.set(6042, () => new FB()); - Xr.set("AuctioneerAuthorityMismatch", () => new FB()); - var LB = class extends Error { - constructor() { - super("Insufficient funds in escrow account to purchase."), - (this.code = 6043), - (this.name = "InsufficientFunds"), - typeof Error.captureStackTrace == "function" && - Error.captureStackTrace(this, LB); - } - }; - Lt.InsufficientFundsError = LB; - Zr.set(6043, () => new LB()); - Xr.set("InsufficientFunds", () => new LB()); - function _en(t) { - let e = Zr.get(t); - return e != null ? e() : null; - } - Lt.errorFromCode = _en; - function xen(t) { - let e = Xr.get(t); - return e != null ? e() : null; - } - Lt.errorFromName = xen; - }); - var ZOt = I((od) => { - "use strict"; - m(); - g(); - var Sen = - (od && od.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Aen = - (od && od.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - I5e = - (od && od.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - Sen(e, t, r); - return Aen(e, t), e; - }; - Object.defineProperty(od, "__esModule", { value: !0 }); - od.createAuctioneerBuyInstruction = - od.auctioneerBuyInstructionDiscriminator = - od.auctioneerBuyStruct = - void 0; - var Een = I5e((pa(), jo(ha))), - qB = I5e(In()), - Afe = I5e(Le()); - od.auctioneerBuyStruct = new qB.BeetArgsStruct( - [ - ["instructionDiscriminator", qB.uniformFixedSizeArray(qB.u8, 8)], - ["tradeStateBump", qB.u8], - ["escrowPaymentBump", qB.u8], - ["buyerPrice", qB.u64], - ["tokenSize", qB.u64], - ], - "AuctioneerBuyInstructionArgs" - ); - od.auctioneerBuyInstructionDiscriminator = [ - 17, 106, 133, 46, 229, 48, 45, 208, - ]; - function Men( - t, - e, - r = new Afe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n, i, o; - let [a] = od.auctioneerBuyStruct.serialize({ - instructionDiscriminator: od.auctioneerBuyInstructionDiscriminator, - ...e, - }), - s = [ - { pubkey: t.wallet, isWritable: !1, isSigner: !0 }, - { pubkey: t.paymentAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.transferAuthority, isWritable: !1, isSigner: !1 }, - { pubkey: t.treasuryMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.tokenAccount, isWritable: !1, isSigner: !1 }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.escrowPaymentAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctioneerAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.auctionHouse, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouseFeeAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.buyerTradeState, isWritable: !0, isSigner: !1 }, - { pubkey: t.ahAuctioneerPda, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : Een.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : Afe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (o = t.rent) !== null && o !== void 0 - ? o - : Afe.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let u of t.anchorRemainingAccounts) s.push(u); - return new Afe.TransactionInstruction({ programId: r, keys: s, data: a }); - } - od.createAuctioneerBuyInstruction = Men; - }); - var YOt = I((ad) => { - "use strict"; - m(); - g(); - var Ten = - (ad && ad.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - ken = - (ad && ad.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - C5e = - (ad && ad.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - Ten(e, t, r); - return ken(e, t), e; - }; - Object.defineProperty(ad, "__esModule", { value: !0 }); - ad.createAuctioneerCancelInstruction = - ad.auctioneerCancelInstructionDiscriminator = - ad.auctioneerCancelStruct = - void 0; - var Pen = C5e((pa(), jo(ha))), - JV = C5e(In()), - XOt = C5e(Le()); - ad.auctioneerCancelStruct = new JV.BeetArgsStruct( - [ - ["instructionDiscriminator", JV.uniformFixedSizeArray(JV.u8, 8)], - ["buyerPrice", JV.u64], - ["tokenSize", JV.u64], - ], - "AuctioneerCancelInstructionArgs" - ); - ad.auctioneerCancelInstructionDiscriminator = [ - 197, 97, 152, 196, 115, 204, 64, 215, - ]; - function Oen( - t, - e, - r = new XOt.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n; - let [i] = ad.auctioneerCancelStruct.serialize({ - instructionDiscriminator: ad.auctioneerCancelInstructionDiscriminator, - ...e, - }), - o = [ - { pubkey: t.wallet, isWritable: !0, isSigner: !1 }, - { pubkey: t.tokenAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.tokenMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctioneerAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.auctionHouse, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouseFeeAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.tradeState, isWritable: !0, isSigner: !1 }, - { pubkey: t.ahAuctioneerPda, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : Pen.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let s of t.anchorRemainingAccounts) o.push(s); - return new XOt.TransactionInstruction({ programId: r, keys: o, data: i }); - } - ad.createAuctioneerCancelInstruction = Oen; - }); - var QOt = I((sd) => { - "use strict"; - m(); - g(); - var Ben = - (sd && sd.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Ien = - (sd && sd.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - R5e = - (sd && sd.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - Ben(e, t, r); - return Ien(e, t), e; - }; - Object.defineProperty(sd, "__esModule", { value: !0 }); - sd.createAuctioneerDepositInstruction = - sd.auctioneerDepositInstructionDiscriminator = - sd.auctioneerDepositStruct = - void 0; - var Cen = R5e((pa(), jo(ha))), - $V = R5e(In()), - Efe = R5e(Le()); - sd.auctioneerDepositStruct = new $V.BeetArgsStruct( - [ - ["instructionDiscriminator", $V.uniformFixedSizeArray($V.u8, 8)], - ["escrowPaymentBump", $V.u8], - ["amount", $V.u64], - ], - "AuctioneerDepositInstructionArgs" - ); - sd.auctioneerDepositInstructionDiscriminator = [ - 79, 122, 37, 162, 120, 173, 57, 127, - ]; - function Ren( - t, - e, - r = new Efe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n, i, o; - let [a] = sd.auctioneerDepositStruct.serialize({ - instructionDiscriminator: - sd.auctioneerDepositInstructionDiscriminator, - ...e, - }), - s = [ - { pubkey: t.wallet, isWritable: !1, isSigner: !0 }, - { pubkey: t.paymentAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.transferAuthority, isWritable: !1, isSigner: !1 }, - { pubkey: t.escrowPaymentAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.treasuryMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctioneerAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.auctionHouse, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouseFeeAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.ahAuctioneerPda, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : Cen.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : Efe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (o = t.rent) !== null && o !== void 0 - ? o - : Efe.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let u of t.anchorRemainingAccounts) s.push(u); - return new Efe.TransactionInstruction({ programId: r, keys: s, data: a }); - } - sd.createAuctioneerDepositInstruction = Ren; - }); - var tBt = I((ud) => { - "use strict"; - m(); - g(); - var Nen = - (ud && ud.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Den = - (ud && ud.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - N5e = - (ud && ud.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - Nen(e, t, r); - return Den(e, t), e; - }; - Object.defineProperty(ud, "__esModule", { value: !0 }); - ud.createAuctioneerExecutePartialSaleInstruction = - ud.auctioneerExecutePartialSaleInstructionDiscriminator = - ud.auctioneerExecutePartialSaleStruct = - void 0; - var eBt = N5e((pa(), jo(ha))), - xm = N5e(In()), - Mfe = N5e(Le()); - ud.auctioneerExecutePartialSaleStruct = new xm.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", xm.uniformFixedSizeArray(xm.u8, 8)], - ["escrowPaymentBump", xm.u8], - ["freeTradeStateBump", xm.u8], - ["programAsSignerBump", xm.u8], - ["buyerPrice", xm.u64], - ["tokenSize", xm.u64], - ["partialOrderSize", xm.coption(xm.u64)], - ["partialOrderPrice", xm.coption(xm.u64)], - ], - "AuctioneerExecutePartialSaleInstructionArgs" - ); - ud.auctioneerExecutePartialSaleInstructionDiscriminator = [ - 9, 44, 46, 15, 161, 143, 21, 54, - ]; - function Fen( - t, - e, - r = new Mfe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n, i, o, a; - let [s] = ud.auctioneerExecutePartialSaleStruct.serialize({ - instructionDiscriminator: - ud.auctioneerExecutePartialSaleInstructionDiscriminator, - ...e, - }), - c = [ - { pubkey: t.buyer, isWritable: !0, isSigner: !1 }, - { pubkey: t.seller, isWritable: !0, isSigner: !1 }, - { pubkey: t.tokenAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.tokenMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.treasuryMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.escrowPaymentAccount, isWritable: !0, isSigner: !1 }, - { - pubkey: t.sellerPaymentReceiptAccount, - isWritable: !0, - isSigner: !1, - }, - { pubkey: t.buyerReceiptTokenAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctioneerAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.auctionHouse, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouseFeeAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.auctionHouseTreasury, isWritable: !0, isSigner: !1 }, - { pubkey: t.buyerTradeState, isWritable: !0, isSigner: !1 }, - { pubkey: t.sellerTradeState, isWritable: !0, isSigner: !1 }, - { pubkey: t.freeTradeState, isWritable: !0, isSigner: !1 }, - { pubkey: t.ahAuctioneerPda, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : eBt.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : Mfe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (o = t.ataProgram) !== null && o !== void 0 - ? o - : eBt.ASSOCIATED_TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.programAsSigner, isWritable: !1, isSigner: !1 }, - { - pubkey: - (a = t.rent) !== null && a !== void 0 - ? a - : Mfe.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let h of t.anchorRemainingAccounts) c.push(h); - return new Mfe.TransactionInstruction({ programId: r, keys: c, data: s }); - } - ud.createAuctioneerExecutePartialSaleInstruction = Fen; - }); - var nBt = I((cd) => { - "use strict"; - m(); - g(); - var Len = - (cd && cd.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - qen = - (cd && cd.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - D5e = - (cd && cd.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - Len(e, t, r); - return qen(e, t), e; - }; - Object.defineProperty(cd, "__esModule", { value: !0 }); - cd.createAuctioneerExecuteSaleInstruction = - cd.auctioneerExecuteSaleInstructionDiscriminator = - cd.auctioneerExecuteSaleStruct = - void 0; - var rBt = D5e((pa(), jo(ha))), - g3 = D5e(In()), - Tfe = D5e(Le()); - cd.auctioneerExecuteSaleStruct = new g3.BeetArgsStruct( - [ - ["instructionDiscriminator", g3.uniformFixedSizeArray(g3.u8, 8)], - ["escrowPaymentBump", g3.u8], - ["freeTradeStateBump", g3.u8], - ["programAsSignerBump", g3.u8], - ["buyerPrice", g3.u64], - ["tokenSize", g3.u64], - ], - "AuctioneerExecuteSaleInstructionArgs" - ); - cd.auctioneerExecuteSaleInstructionDiscriminator = [ - 68, 125, 32, 65, 251, 43, 35, 53, - ]; - function zen( - t, - e, - r = new Tfe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n, i, o, a; - let [s] = cd.auctioneerExecuteSaleStruct.serialize({ - instructionDiscriminator: - cd.auctioneerExecuteSaleInstructionDiscriminator, - ...e, - }), - c = [ - { pubkey: t.buyer, isWritable: !0, isSigner: !1 }, - { pubkey: t.seller, isWritable: !0, isSigner: !1 }, - { pubkey: t.tokenAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.tokenMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.treasuryMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.escrowPaymentAccount, isWritable: !0, isSigner: !1 }, - { - pubkey: t.sellerPaymentReceiptAccount, - isWritable: !0, - isSigner: !1, - }, - { pubkey: t.buyerReceiptTokenAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctioneerAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.auctionHouse, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouseFeeAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.auctionHouseTreasury, isWritable: !0, isSigner: !1 }, - { pubkey: t.buyerTradeState, isWritable: !0, isSigner: !1 }, - { pubkey: t.sellerTradeState, isWritable: !0, isSigner: !1 }, - { pubkey: t.freeTradeState, isWritable: !0, isSigner: !1 }, - { pubkey: t.ahAuctioneerPda, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : rBt.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : Tfe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (o = t.ataProgram) !== null && o !== void 0 - ? o - : rBt.ASSOCIATED_TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.programAsSigner, isWritable: !1, isSigner: !1 }, - { - pubkey: - (a = t.rent) !== null && a !== void 0 - ? a - : Tfe.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let h of t.anchorRemainingAccounts) c.push(h); - return new Tfe.TransactionInstruction({ programId: r, keys: c, data: s }); - } - cd.createAuctioneerExecuteSaleInstruction = zen; - }); - var iBt = I((ld) => { - "use strict"; - m(); - g(); - var jen = - (ld && ld.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Uen = - (ld && ld.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - F5e = - (ld && ld.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - jen(e, t, r); - return Uen(e, t), e; - }; - Object.defineProperty(ld, "__esModule", { value: !0 }); - ld.createAuctioneerPublicBuyInstruction = - ld.auctioneerPublicBuyInstructionDiscriminator = - ld.auctioneerPublicBuyStruct = - void 0; - var Ken = F5e((pa(), jo(ha))), - zB = F5e(In()), - kfe = F5e(Le()); - ld.auctioneerPublicBuyStruct = new zB.BeetArgsStruct( - [ - ["instructionDiscriminator", zB.uniformFixedSizeArray(zB.u8, 8)], - ["tradeStateBump", zB.u8], - ["escrowPaymentBump", zB.u8], - ["buyerPrice", zB.u64], - ["tokenSize", zB.u64], - ], - "AuctioneerPublicBuyInstructionArgs" - ); - ld.auctioneerPublicBuyInstructionDiscriminator = [ - 221, 239, 99, 240, 86, 46, 213, 126, - ]; - function Hen( - t, - e, - r = new kfe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n, i, o; - let [a] = ld.auctioneerPublicBuyStruct.serialize({ - instructionDiscriminator: - ld.auctioneerPublicBuyInstructionDiscriminator, - ...e, - }), - s = [ - { pubkey: t.wallet, isWritable: !1, isSigner: !0 }, - { pubkey: t.paymentAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.transferAuthority, isWritable: !1, isSigner: !1 }, - { pubkey: t.treasuryMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.tokenAccount, isWritable: !1, isSigner: !1 }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.escrowPaymentAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctioneerAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.auctionHouse, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouseFeeAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.buyerTradeState, isWritable: !0, isSigner: !1 }, - { pubkey: t.ahAuctioneerPda, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : Ken.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : kfe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (o = t.rent) !== null && o !== void 0 - ? o - : kfe.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let u of t.anchorRemainingAccounts) s.push(u); - return new kfe.TransactionInstruction({ programId: r, keys: s, data: a }); - } - ld.createAuctioneerPublicBuyInstruction = Hen; - }); - var oBt = I((fd) => { - "use strict"; - m(); - g(); - var Ven = - (fd && fd.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Wen = - (fd && fd.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - L5e = - (fd && fd.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - Ven(e, t, r); - return Wen(e, t), e; - }; - Object.defineProperty(fd, "__esModule", { value: !0 }); - fd.createAuctioneerSellInstruction = - fd.auctioneerSellInstructionDiscriminator = - fd.auctioneerSellStruct = - void 0; - var Gen = L5e((pa(), jo(ha))), - jB = L5e(In()), - Pfe = L5e(Le()); - fd.auctioneerSellStruct = new jB.BeetArgsStruct( - [ - ["instructionDiscriminator", jB.uniformFixedSizeArray(jB.u8, 8)], - ["tradeStateBump", jB.u8], - ["freeTradeStateBump", jB.u8], - ["programAsSignerBump", jB.u8], - ["tokenSize", jB.u64], - ], - "AuctioneerSellInstructionArgs" - ); - fd.auctioneerSellInstructionDiscriminator = [ - 251, 60, 142, 195, 121, 203, 26, 183, - ]; - function Jen( - t, - e, - r = new Pfe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n, i, o; - let [a] = fd.auctioneerSellStruct.serialize({ - instructionDiscriminator: fd.auctioneerSellInstructionDiscriminator, - ...e, - }), - s = [ - { pubkey: t.wallet, isWritable: !0, isSigner: !1 }, - { pubkey: t.tokenAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctioneerAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.auctionHouse, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouseFeeAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.sellerTradeState, isWritable: !0, isSigner: !1 }, - { pubkey: t.freeSellerTradeState, isWritable: !0, isSigner: !1 }, - { pubkey: t.ahAuctioneerPda, isWritable: !1, isSigner: !1 }, - { pubkey: t.programAsSigner, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : Gen.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : Pfe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (o = t.rent) !== null && o !== void 0 - ? o - : Pfe.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let u of t.anchorRemainingAccounts) s.push(u); - return new Pfe.TransactionInstruction({ programId: r, keys: s, data: a }); - } - fd.createAuctioneerSellInstruction = Jen; - }); - var sBt = I((dd) => { - "use strict"; - m(); - g(); - var $en = - (dd && dd.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Zen = - (dd && dd.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - q5e = - (dd && dd.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - $en(e, t, r); - return Zen(e, t), e; - }; - Object.defineProperty(dd, "__esModule", { value: !0 }); - dd.createAuctioneerWithdrawInstruction = - dd.auctioneerWithdrawInstructionDiscriminator = - dd.auctioneerWithdrawStruct = - void 0; - var aBt = q5e((pa(), jo(ha))), - ZV = q5e(In()), - Ofe = q5e(Le()); - dd.auctioneerWithdrawStruct = new ZV.BeetArgsStruct( - [ - ["instructionDiscriminator", ZV.uniformFixedSizeArray(ZV.u8, 8)], - ["escrowPaymentBump", ZV.u8], - ["amount", ZV.u64], - ], - "AuctioneerWithdrawInstructionArgs" - ); - dd.auctioneerWithdrawInstructionDiscriminator = [ - 85, 166, 219, 110, 168, 143, 180, 236, - ]; - function Xen( - t, - e, - r = new Ofe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n, i, o, a; - let [s] = dd.auctioneerWithdrawStruct.serialize({ - instructionDiscriminator: - dd.auctioneerWithdrawInstructionDiscriminator, - ...e, - }), - c = [ - { pubkey: t.wallet, isWritable: !1, isSigner: !1 }, - { pubkey: t.receiptAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.escrowPaymentAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.treasuryMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctioneerAuthority, isWritable: !1, isSigner: !0 }, - { pubkey: t.auctionHouse, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouseFeeAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.ahAuctioneerPda, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : aBt.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : Ofe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (o = t.ataProgram) !== null && o !== void 0 - ? o - : aBt.ASSOCIATED_TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (a = t.rent) !== null && a !== void 0 - ? a - : Ofe.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let h of t.anchorRemainingAccounts) c.push(h); - return new Ofe.TransactionInstruction({ programId: r, keys: c, data: s }); - } - dd.createAuctioneerWithdrawInstruction = Xen; - }); - var uBt = I((hd) => { - "use strict"; - m(); - g(); - var Yen = - (hd && hd.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Qen = - (hd && hd.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - z5e = - (hd && hd.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - Yen(e, t, r); - return Qen(e, t), e; - }; - Object.defineProperty(hd, "__esModule", { value: !0 }); - hd.createBuyInstruction = - hd.buyInstructionDiscriminator = - hd.buyStruct = - void 0; - var etn = z5e((pa(), jo(ha))), - UB = z5e(In()), - Bfe = z5e(Le()); - hd.buyStruct = new UB.BeetArgsStruct( - [ - ["instructionDiscriminator", UB.uniformFixedSizeArray(UB.u8, 8)], - ["tradeStateBump", UB.u8], - ["escrowPaymentBump", UB.u8], - ["buyerPrice", UB.u64], - ["tokenSize", UB.u64], - ], - "BuyInstructionArgs" - ); - hd.buyInstructionDiscriminator = [102, 6, 61, 18, 1, 218, 235, 234]; - function ttn( - t, - e, - r = new Bfe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n, i, o; - let [a] = hd.buyStruct.serialize({ - instructionDiscriminator: hd.buyInstructionDiscriminator, - ...e, - }), - s = [ - { pubkey: t.wallet, isWritable: !1, isSigner: !0 }, - { pubkey: t.paymentAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.transferAuthority, isWritable: !1, isSigner: !1 }, - { pubkey: t.treasuryMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.tokenAccount, isWritable: !1, isSigner: !1 }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.escrowPaymentAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouse, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouseFeeAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.buyerTradeState, isWritable: !0, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : etn.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : Bfe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (o = t.rent) !== null && o !== void 0 - ? o - : Bfe.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let u of t.anchorRemainingAccounts) s.push(u); - return new Bfe.TransactionInstruction({ programId: r, keys: s, data: a }); - } - hd.createBuyInstruction = ttn; - }); - var lBt = I((pd) => { - "use strict"; - m(); - g(); - var rtn = - (pd && pd.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - ntn = - (pd && pd.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - j5e = - (pd && pd.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - rtn(e, t, r); - return ntn(e, t), e; - }; - Object.defineProperty(pd, "__esModule", { value: !0 }); - pd.createCancelInstruction = - pd.cancelInstructionDiscriminator = - pd.cancelStruct = - void 0; - var itn = j5e((pa(), jo(ha))), - XV = j5e(In()), - cBt = j5e(Le()); - pd.cancelStruct = new XV.BeetArgsStruct( - [ - ["instructionDiscriminator", XV.uniformFixedSizeArray(XV.u8, 8)], - ["buyerPrice", XV.u64], - ["tokenSize", XV.u64], - ], - "CancelInstructionArgs" - ); - pd.cancelInstructionDiscriminator = [232, 219, 223, 41, 219, 236, 220, 190]; - function otn( - t, - e, - r = new cBt.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n; - let [i] = pd.cancelStruct.serialize({ - instructionDiscriminator: pd.cancelInstructionDiscriminator, - ...e, - }), - o = [ - { pubkey: t.wallet, isWritable: !0, isSigner: !1 }, - { pubkey: t.tokenAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.tokenMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouse, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouseFeeAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.tradeState, isWritable: !0, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : itn.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let s of t.anchorRemainingAccounts) o.push(s); - return new cBt.TransactionInstruction({ programId: r, keys: o, data: i }); - } - pd.createCancelInstruction = otn; - }); - var dBt = I((yd) => { - "use strict"; - m(); - g(); - var atn = - (yd && yd.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - stn = - (yd && yd.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - fBt = - (yd && yd.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - atn(e, t, r); - return stn(e, t), e; - }; - Object.defineProperty(yd, "__esModule", { value: !0 }); - yd.createCancelBidReceiptInstruction = - yd.cancelBidReceiptInstructionDiscriminator = - yd.cancelBidReceiptStruct = - void 0; - var U5e = fBt(In()), - K5e = fBt(Le()); - yd.cancelBidReceiptStruct = new U5e.BeetArgsStruct( - [["instructionDiscriminator", U5e.uniformFixedSizeArray(U5e.u8, 8)]], - "CancelBidReceiptInstructionArgs" - ); - yd.cancelBidReceiptInstructionDiscriminator = [ - 246, 108, 27, 229, 220, 42, 176, 43, - ]; - function utn( - t, - e = new K5e.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var r; - let [n] = yd.cancelBidReceiptStruct.serialize({ - instructionDiscriminator: yd.cancelBidReceiptInstructionDiscriminator, - }), - i = [ - { pubkey: t.receipt, isWritable: !0, isSigner: !1 }, - { - pubkey: - (r = t.systemProgram) !== null && r !== void 0 - ? r - : K5e.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.instruction, isWritable: !1, isSigner: !1 }, - ]; - if (t.anchorRemainingAccounts != null) - for (let a of t.anchorRemainingAccounts) i.push(a); - return new K5e.TransactionInstruction({ programId: e, keys: i, data: n }); - } - yd.createCancelBidReceiptInstruction = utn; - }); - var pBt = I((md) => { - "use strict"; - m(); - g(); - var ctn = - (md && md.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - ltn = - (md && md.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - hBt = - (md && md.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - ctn(e, t, r); - return ltn(e, t), e; - }; - Object.defineProperty(md, "__esModule", { value: !0 }); - md.createCancelListingReceiptInstruction = - md.cancelListingReceiptInstructionDiscriminator = - md.cancelListingReceiptStruct = - void 0; - var H5e = hBt(In()), - V5e = hBt(Le()); - md.cancelListingReceiptStruct = new H5e.BeetArgsStruct( - [["instructionDiscriminator", H5e.uniformFixedSizeArray(H5e.u8, 8)]], - "CancelListingReceiptInstructionArgs" - ); - md.cancelListingReceiptInstructionDiscriminator = [ - 171, 59, 138, 126, 246, 189, 91, 11, - ]; - function ftn( - t, - e = new V5e.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var r; - let [n] = md.cancelListingReceiptStruct.serialize({ - instructionDiscriminator: - md.cancelListingReceiptInstructionDiscriminator, - }), - i = [ - { pubkey: t.receipt, isWritable: !0, isSigner: !1 }, - { - pubkey: - (r = t.systemProgram) !== null && r !== void 0 - ? r - : V5e.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.instruction, isWritable: !1, isSigner: !1 }, - ]; - if (t.anchorRemainingAccounts != null) - for (let a of t.anchorRemainingAccounts) i.push(a); - return new V5e.TransactionInstruction({ programId: e, keys: i, data: n }); - } - md.createCancelListingReceiptInstruction = ftn; - }); - var mBt = I((gd) => { - "use strict"; - m(); - g(); - var dtn = - (gd && gd.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - htn = - (gd && gd.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - yBt = - (gd && gd.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - dtn(e, t, r); - return htn(e, t), e; - }; - Object.defineProperty(gd, "__esModule", { value: !0 }); - gd.createCloseEscrowAccountInstruction = - gd.closeEscrowAccountInstructionDiscriminator = - gd.closeEscrowAccountStruct = - void 0; - var Ife = yBt(In()), - W5e = yBt(Le()); - gd.closeEscrowAccountStruct = new Ife.BeetArgsStruct( - [ - ["instructionDiscriminator", Ife.uniformFixedSizeArray(Ife.u8, 8)], - ["escrowPaymentBump", Ife.u8], - ], - "CloseEscrowAccountInstructionArgs" - ); - gd.closeEscrowAccountInstructionDiscriminator = [ - 209, 42, 208, 179, 140, 78, 18, 43, - ]; - function ptn( - t, - e, - r = new W5e.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n; - let [i] = gd.closeEscrowAccountStruct.serialize({ - instructionDiscriminator: - gd.closeEscrowAccountInstructionDiscriminator, - ...e, - }), - o = [ - { pubkey: t.wallet, isWritable: !1, isSigner: !0 }, - { pubkey: t.escrowPaymentAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.auctionHouse, isWritable: !1, isSigner: !1 }, - { - pubkey: - (n = t.systemProgram) !== null && n !== void 0 - ? n - : W5e.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let s of t.anchorRemainingAccounts) o.push(s); - return new W5e.TransactionInstruction({ programId: r, keys: o, data: i }); - } - gd.createCloseEscrowAccountInstruction = ptn; - }); - var vBt = I((vd) => { - "use strict"; - m(); - g(); - var ytn = - (vd && vd.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - mtn = - (vd && vd.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - G5e = - (vd && vd.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - ytn(e, t, r); - return mtn(e, t), e; - }; - Object.defineProperty(vd, "__esModule", { value: !0 }); - vd.createCreateAuctionHouseInstruction = - vd.createAuctionHouseInstructionDiscriminator = - vd.createAuctionHouseStruct = - void 0; - var gBt = G5e((pa(), jo(ha))), - uS = G5e(In()), - Cfe = G5e(Le()); - vd.createAuctionHouseStruct = new uS.BeetArgsStruct( - [ - ["instructionDiscriminator", uS.uniformFixedSizeArray(uS.u8, 8)], - ["bump", uS.u8], - ["feePayerBump", uS.u8], - ["treasuryBump", uS.u8], - ["sellerFeeBasisPoints", uS.u16], - ["requiresSignOff", uS.bool], - ["canChangeSalePrice", uS.bool], - ], - "CreateAuctionHouseInstructionArgs" - ); - vd.createAuctionHouseInstructionDiscriminator = [ - 221, 66, 242, 159, 249, 206, 134, 241, - ]; - function gtn( - t, - e, - r = new Cfe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n, i, o, a; - let [s] = vd.createAuctionHouseStruct.serialize({ - instructionDiscriminator: - vd.createAuctionHouseInstructionDiscriminator, - ...e, - }), - c = [ - { pubkey: t.treasuryMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.payer, isWritable: !0, isSigner: !0 }, - { pubkey: t.authority, isWritable: !1, isSigner: !1 }, - { pubkey: t.feeWithdrawalDestination, isWritable: !0, isSigner: !1 }, - { - pubkey: t.treasuryWithdrawalDestination, - isWritable: !0, - isSigner: !1, - }, - { - pubkey: t.treasuryWithdrawalDestinationOwner, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.auctionHouse, isWritable: !0, isSigner: !1 }, - { pubkey: t.auctionHouseFeeAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.auctionHouseTreasury, isWritable: !0, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : gBt.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : Cfe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (o = t.ataProgram) !== null && o !== void 0 - ? o - : gBt.ASSOCIATED_TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (a = t.rent) !== null && a !== void 0 - ? a - : Cfe.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let h of t.anchorRemainingAccounts) c.push(h); - return new Cfe.TransactionInstruction({ programId: r, keys: c, data: s }); - } - vd.createCreateAuctionHouseInstruction = gtn; - }); - var Rfe = I((T0) => { - "use strict"; - m(); - g(); - var vtn = - (T0 && T0.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - btn = - (T0 && T0.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - wtn = - (T0 && T0.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - vtn(e, t, r); - return btn(e, t), e; - }; - Object.defineProperty(T0, "__esModule", { value: !0 }); - T0.authorityScopeBeet = T0.AuthorityScope = void 0; - var _tn = wtn(In()), - bBt; - (function (t) { - (t[(t.Deposit = 0)] = "Deposit"), - (t[(t.Buy = 1)] = "Buy"), - (t[(t.PublicBuy = 2)] = "PublicBuy"), - (t[(t.ExecuteSale = 3)] = "ExecuteSale"), - (t[(t.Sell = 4)] = "Sell"), - (t[(t.Cancel = 5)] = "Cancel"), - (t[(t.Withdraw = 6)] = "Withdraw"); - })((bBt = T0.AuthorityScope || (T0.AuthorityScope = {}))); - T0.authorityScopeBeet = _tn.fixedScalarEnum(bBt); - }); - var _Bt = I((bd) => { - "use strict"; - m(); - g(); - var xtn = - (bd && bd.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Stn = - (bd && bd.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - wBt = - (bd && bd.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - xtn(e, t, r); - return Stn(e, t), e; - }; - Object.defineProperty(bd, "__esModule", { value: !0 }); - bd.createDelegateAuctioneerInstruction = - bd.delegateAuctioneerInstructionDiscriminator = - bd.delegateAuctioneerStruct = - void 0; - var Nfe = wBt(In()), - J5e = wBt(Le()), - Atn = Rfe(); - bd.delegateAuctioneerStruct = new Nfe.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", Nfe.uniformFixedSizeArray(Nfe.u8, 8)], - ["scopes", Nfe.array(Atn.authorityScopeBeet)], - ], - "DelegateAuctioneerInstructionArgs" - ); - bd.delegateAuctioneerInstructionDiscriminator = [ - 106, 178, 12, 122, 74, 173, 251, 222, - ]; - function Etn( - t, - e, - r = new J5e.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n; - let [i] = bd.delegateAuctioneerStruct.serialize({ - instructionDiscriminator: - bd.delegateAuctioneerInstructionDiscriminator, - ...e, - }), - o = [ - { pubkey: t.auctionHouse, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !0, isSigner: !0 }, - { pubkey: t.auctioneerAuthority, isWritable: !1, isSigner: !1 }, - { pubkey: t.ahAuctioneerPda, isWritable: !0, isSigner: !1 }, - { - pubkey: - (n = t.systemProgram) !== null && n !== void 0 - ? n - : J5e.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let s of t.anchorRemainingAccounts) o.push(s); - return new J5e.TransactionInstruction({ programId: r, keys: o, data: i }); - } - bd.createDelegateAuctioneerInstruction = Etn; - }); - var xBt = I((wd) => { - "use strict"; - m(); - g(); - var Mtn = - (wd && wd.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Ttn = - (wd && wd.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - $5e = - (wd && wd.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - Mtn(e, t, r); - return Ttn(e, t), e; - }; - Object.defineProperty(wd, "__esModule", { value: !0 }); - wd.createDepositInstruction = - wd.depositInstructionDiscriminator = - wd.depositStruct = - void 0; - var ktn = $5e((pa(), jo(ha))), - YV = $5e(In()), - Dfe = $5e(Le()); - wd.depositStruct = new YV.BeetArgsStruct( - [ - ["instructionDiscriminator", YV.uniformFixedSizeArray(YV.u8, 8)], - ["escrowPaymentBump", YV.u8], - ["amount", YV.u64], - ], - "DepositInstructionArgs" - ); - wd.depositInstructionDiscriminator = [242, 35, 198, 137, 82, 225, 242, 182]; - function Ptn( - t, - e, - r = new Dfe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n, i, o; - let [a] = wd.depositStruct.serialize({ - instructionDiscriminator: wd.depositInstructionDiscriminator, - ...e, - }), - s = [ - { pubkey: t.wallet, isWritable: !1, isSigner: !0 }, - { pubkey: t.paymentAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.transferAuthority, isWritable: !1, isSigner: !1 }, - { pubkey: t.escrowPaymentAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.treasuryMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouse, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouseFeeAccount, isWritable: !0, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : ktn.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : Dfe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (o = t.rent) !== null && o !== void 0 - ? o - : Dfe.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let u of t.anchorRemainingAccounts) s.push(u); - return new Dfe.TransactionInstruction({ programId: r, keys: s, data: a }); - } - wd.createDepositInstruction = Ptn; - }); - var ABt = I((_d) => { - "use strict"; - m(); - g(); - var Otn = - (_d && _d.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Btn = - (_d && _d.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Z5e = - (_d && _d.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - Otn(e, t, r); - return Btn(e, t), e; - }; - Object.defineProperty(_d, "__esModule", { value: !0 }); - _d.createExecutePartialSaleInstruction = - _d.executePartialSaleInstructionDiscriminator = - _d.executePartialSaleStruct = - void 0; - var SBt = Z5e((pa(), jo(ha))), - Sm = Z5e(In()), - Ffe = Z5e(Le()); - _d.executePartialSaleStruct = new Sm.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", Sm.uniformFixedSizeArray(Sm.u8, 8)], - ["escrowPaymentBump", Sm.u8], - ["freeTradeStateBump", Sm.u8], - ["programAsSignerBump", Sm.u8], - ["buyerPrice", Sm.u64], - ["tokenSize", Sm.u64], - ["partialOrderSize", Sm.coption(Sm.u64)], - ["partialOrderPrice", Sm.coption(Sm.u64)], - ], - "ExecutePartialSaleInstructionArgs" - ); - _d.executePartialSaleInstructionDiscriminator = [ - 163, 18, 35, 157, 49, 164, 203, 133, - ]; - function Itn( - t, - e, - r = new Ffe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n, i, o, a; - let [s] = _d.executePartialSaleStruct.serialize({ - instructionDiscriminator: - _d.executePartialSaleInstructionDiscriminator, - ...e, - }), - c = [ - { pubkey: t.buyer, isWritable: !0, isSigner: !1 }, - { pubkey: t.seller, isWritable: !0, isSigner: !1 }, - { pubkey: t.tokenAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.tokenMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.treasuryMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.escrowPaymentAccount, isWritable: !0, isSigner: !1 }, - { - pubkey: t.sellerPaymentReceiptAccount, - isWritable: !0, - isSigner: !1, - }, - { pubkey: t.buyerReceiptTokenAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouse, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouseFeeAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.auctionHouseTreasury, isWritable: !0, isSigner: !1 }, - { pubkey: t.buyerTradeState, isWritable: !0, isSigner: !1 }, - { pubkey: t.sellerTradeState, isWritable: !0, isSigner: !1 }, - { pubkey: t.freeTradeState, isWritable: !0, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : SBt.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : Ffe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (o = t.ataProgram) !== null && o !== void 0 - ? o - : SBt.ASSOCIATED_TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.programAsSigner, isWritable: !1, isSigner: !1 }, - { - pubkey: - (a = t.rent) !== null && a !== void 0 - ? a - : Ffe.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let h of t.anchorRemainingAccounts) c.push(h); - return new Ffe.TransactionInstruction({ programId: r, keys: c, data: s }); - } - _d.createExecutePartialSaleInstruction = Itn; - }); - var MBt = I((xd) => { - "use strict"; - m(); - g(); - var Ctn = - (xd && xd.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Rtn = - (xd && xd.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - X5e = - (xd && xd.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - Ctn(e, t, r); - return Rtn(e, t), e; - }; - Object.defineProperty(xd, "__esModule", { value: !0 }); - xd.createExecuteSaleInstruction = - xd.executeSaleInstructionDiscriminator = - xd.executeSaleStruct = - void 0; - var EBt = X5e((pa(), jo(ha))), - v3 = X5e(In()), - Lfe = X5e(Le()); - xd.executeSaleStruct = new v3.BeetArgsStruct( - [ - ["instructionDiscriminator", v3.uniformFixedSizeArray(v3.u8, 8)], - ["escrowPaymentBump", v3.u8], - ["freeTradeStateBump", v3.u8], - ["programAsSignerBump", v3.u8], - ["buyerPrice", v3.u64], - ["tokenSize", v3.u64], - ], - "ExecuteSaleInstructionArgs" - ); - xd.executeSaleInstructionDiscriminator = [37, 74, 217, 157, 79, 49, 35, 6]; - function Ntn( - t, - e, - r = new Lfe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n, i, o, a; - let [s] = xd.executeSaleStruct.serialize({ - instructionDiscriminator: xd.executeSaleInstructionDiscriminator, - ...e, - }), - c = [ - { pubkey: t.buyer, isWritable: !0, isSigner: !1 }, - { pubkey: t.seller, isWritable: !0, isSigner: !1 }, - { pubkey: t.tokenAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.tokenMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.treasuryMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.escrowPaymentAccount, isWritable: !0, isSigner: !1 }, - { - pubkey: t.sellerPaymentReceiptAccount, - isWritable: !0, - isSigner: !1, - }, - { pubkey: t.buyerReceiptTokenAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouse, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouseFeeAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.auctionHouseTreasury, isWritable: !0, isSigner: !1 }, - { pubkey: t.buyerTradeState, isWritable: !0, isSigner: !1 }, - { pubkey: t.sellerTradeState, isWritable: !0, isSigner: !1 }, - { pubkey: t.freeTradeState, isWritable: !0, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : EBt.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : Lfe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (o = t.ataProgram) !== null && o !== void 0 - ? o - : EBt.ASSOCIATED_TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.programAsSigner, isWritable: !1, isSigner: !1 }, - { - pubkey: - (a = t.rent) !== null && a !== void 0 - ? a - : Lfe.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let h of t.anchorRemainingAccounts) c.push(h); - return new Lfe.TransactionInstruction({ programId: r, keys: c, data: s }); - } - xd.createExecuteSaleInstruction = Ntn; - }); - var kBt = I((Sd) => { - "use strict"; - m(); - g(); - var Dtn = - (Sd && Sd.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Ftn = - (Sd && Sd.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - TBt = - (Sd && Sd.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - Dtn(e, t, r); - return Ftn(e, t), e; - }; - Object.defineProperty(Sd, "__esModule", { value: !0 }); - Sd.createPrintBidReceiptInstruction = - Sd.printBidReceiptInstructionDiscriminator = - Sd.printBidReceiptStruct = - void 0; - var qfe = TBt(In()), - zfe = TBt(Le()); - Sd.printBidReceiptStruct = new qfe.BeetArgsStruct( - [ - ["instructionDiscriminator", qfe.uniformFixedSizeArray(qfe.u8, 8)], - ["receiptBump", qfe.u8], - ], - "PrintBidReceiptInstructionArgs" - ); - Sd.printBidReceiptInstructionDiscriminator = [ - 94, 249, 90, 230, 239, 64, 68, 218, - ]; - function Ltn( - t, - e, - r = new zfe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n, i; - let [o] = Sd.printBidReceiptStruct.serialize({ - instructionDiscriminator: Sd.printBidReceiptInstructionDiscriminator, - ...e, - }), - a = [ - { pubkey: t.receipt, isWritable: !0, isSigner: !1 }, - { pubkey: t.bookkeeper, isWritable: !0, isSigner: !0 }, - { - pubkey: - (n = t.systemProgram) !== null && n !== void 0 - ? n - : zfe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.rent) !== null && i !== void 0 - ? i - : zfe.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.instruction, isWritable: !1, isSigner: !1 }, - ]; - if (t.anchorRemainingAccounts != null) - for (let c of t.anchorRemainingAccounts) a.push(c); - return new zfe.TransactionInstruction({ programId: r, keys: a, data: o }); - } - Sd.createPrintBidReceiptInstruction = Ltn; - }); - var OBt = I((Ad) => { - "use strict"; - m(); - g(); - var qtn = - (Ad && Ad.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - ztn = - (Ad && Ad.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - PBt = - (Ad && Ad.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - qtn(e, t, r); - return ztn(e, t), e; - }; - Object.defineProperty(Ad, "__esModule", { value: !0 }); - Ad.createPrintListingReceiptInstruction = - Ad.printListingReceiptInstructionDiscriminator = - Ad.printListingReceiptStruct = - void 0; - var jfe = PBt(In()), - Ufe = PBt(Le()); - Ad.printListingReceiptStruct = new jfe.BeetArgsStruct( - [ - ["instructionDiscriminator", jfe.uniformFixedSizeArray(jfe.u8, 8)], - ["receiptBump", jfe.u8], - ], - "PrintListingReceiptInstructionArgs" - ); - Ad.printListingReceiptInstructionDiscriminator = [ - 207, 107, 44, 160, 75, 222, 195, 27, - ]; - function jtn( - t, - e, - r = new Ufe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n, i; - let [o] = Ad.printListingReceiptStruct.serialize({ - instructionDiscriminator: - Ad.printListingReceiptInstructionDiscriminator, - ...e, - }), - a = [ - { pubkey: t.receipt, isWritable: !0, isSigner: !1 }, - { pubkey: t.bookkeeper, isWritable: !0, isSigner: !0 }, - { - pubkey: - (n = t.systemProgram) !== null && n !== void 0 - ? n - : Ufe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.rent) !== null && i !== void 0 - ? i - : Ufe.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.instruction, isWritable: !1, isSigner: !1 }, - ]; - if (t.anchorRemainingAccounts != null) - for (let c of t.anchorRemainingAccounts) a.push(c); - return new Ufe.TransactionInstruction({ programId: r, keys: a, data: o }); - } - Ad.createPrintListingReceiptInstruction = jtn; - }); - var IBt = I((Ed) => { - "use strict"; - m(); - g(); - var Utn = - (Ed && Ed.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Ktn = - (Ed && Ed.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - BBt = - (Ed && Ed.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - Utn(e, t, r); - return Ktn(e, t), e; - }; - Object.defineProperty(Ed, "__esModule", { value: !0 }); - Ed.createPrintPurchaseReceiptInstruction = - Ed.printPurchaseReceiptInstructionDiscriminator = - Ed.printPurchaseReceiptStruct = - void 0; - var Kfe = BBt(In()), - Hfe = BBt(Le()); - Ed.printPurchaseReceiptStruct = new Kfe.BeetArgsStruct( - [ - ["instructionDiscriminator", Kfe.uniformFixedSizeArray(Kfe.u8, 8)], - ["purchaseReceiptBump", Kfe.u8], - ], - "PrintPurchaseReceiptInstructionArgs" - ); - Ed.printPurchaseReceiptInstructionDiscriminator = [ - 227, 154, 251, 7, 180, 56, 100, 143, - ]; - function Htn( - t, - e, - r = new Hfe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n, i; - let [o] = Ed.printPurchaseReceiptStruct.serialize({ - instructionDiscriminator: - Ed.printPurchaseReceiptInstructionDiscriminator, - ...e, - }), - a = [ - { pubkey: t.purchaseReceipt, isWritable: !0, isSigner: !1 }, - { pubkey: t.listingReceipt, isWritable: !0, isSigner: !1 }, - { pubkey: t.bidReceipt, isWritable: !0, isSigner: !1 }, - { pubkey: t.bookkeeper, isWritable: !0, isSigner: !0 }, - { - pubkey: - (n = t.systemProgram) !== null && n !== void 0 - ? n - : Hfe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.rent) !== null && i !== void 0 - ? i - : Hfe.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.instruction, isWritable: !1, isSigner: !1 }, - ]; - if (t.anchorRemainingAccounts != null) - for (let c of t.anchorRemainingAccounts) a.push(c); - return new Hfe.TransactionInstruction({ programId: r, keys: a, data: o }); - } - Ed.createPrintPurchaseReceiptInstruction = Htn; - }); - var CBt = I((Md) => { - "use strict"; - m(); - g(); - var Vtn = - (Md && Md.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Wtn = - (Md && Md.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Y5e = - (Md && Md.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - Vtn(e, t, r); - return Wtn(e, t), e; - }; - Object.defineProperty(Md, "__esModule", { value: !0 }); - Md.createPublicBuyInstruction = - Md.publicBuyInstructionDiscriminator = - Md.publicBuyStruct = - void 0; - var Gtn = Y5e((pa(), jo(ha))), - KB = Y5e(In()), - Vfe = Y5e(Le()); - Md.publicBuyStruct = new KB.BeetArgsStruct( - [ - ["instructionDiscriminator", KB.uniformFixedSizeArray(KB.u8, 8)], - ["tradeStateBump", KB.u8], - ["escrowPaymentBump", KB.u8], - ["buyerPrice", KB.u64], - ["tokenSize", KB.u64], - ], - "PublicBuyInstructionArgs" - ); - Md.publicBuyInstructionDiscriminator = [169, 84, 218, 35, 42, 206, 16, 171]; - function Jtn( - t, - e, - r = new Vfe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n, i, o; - let [a] = Md.publicBuyStruct.serialize({ - instructionDiscriminator: Md.publicBuyInstructionDiscriminator, - ...e, - }), - s = [ - { pubkey: t.wallet, isWritable: !1, isSigner: !0 }, - { pubkey: t.paymentAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.transferAuthority, isWritable: !1, isSigner: !1 }, - { pubkey: t.treasuryMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.tokenAccount, isWritable: !1, isSigner: !1 }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.escrowPaymentAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouse, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouseFeeAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.buyerTradeState, isWritable: !0, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : Gtn.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : Vfe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (o = t.rent) !== null && o !== void 0 - ? o - : Vfe.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let u of t.anchorRemainingAccounts) s.push(u); - return new Vfe.TransactionInstruction({ programId: r, keys: s, data: a }); - } - Md.createPublicBuyInstruction = Jtn; - }); - var RBt = I((Td) => { - "use strict"; - m(); - g(); - var $tn = - (Td && Td.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Ztn = - (Td && Td.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Q5e = - (Td && Td.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - $tn(e, t, r); - return Ztn(e, t), e; - }; - Object.defineProperty(Td, "__esModule", { value: !0 }); - Td.createSellInstruction = - Td.sellInstructionDiscriminator = - Td.sellStruct = - void 0; - var Xtn = Q5e((pa(), jo(ha))), - b3 = Q5e(In()), - Wfe = Q5e(Le()); - Td.sellStruct = new b3.BeetArgsStruct( - [ - ["instructionDiscriminator", b3.uniformFixedSizeArray(b3.u8, 8)], - ["tradeStateBump", b3.u8], - ["freeTradeStateBump", b3.u8], - ["programAsSignerBump", b3.u8], - ["buyerPrice", b3.u64], - ["tokenSize", b3.u64], - ], - "SellInstructionArgs" - ); - Td.sellInstructionDiscriminator = [51, 230, 133, 164, 1, 127, 131, 173]; - function Ytn( - t, - e, - r = new Wfe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n, i, o; - let [a] = Td.sellStruct.serialize({ - instructionDiscriminator: Td.sellInstructionDiscriminator, - ...e, - }), - s = [ - { pubkey: t.wallet, isWritable: !1, isSigner: !1 }, - { pubkey: t.tokenAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.metadata, isWritable: !1, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouse, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouseFeeAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.sellerTradeState, isWritable: !0, isSigner: !1 }, - { pubkey: t.freeSellerTradeState, isWritable: !0, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : Xtn.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : Wfe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.programAsSigner, isWritable: !1, isSigner: !1 }, - { - pubkey: - (o = t.rent) !== null && o !== void 0 - ? o - : Wfe.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let u of t.anchorRemainingAccounts) s.push(u); - return new Wfe.TransactionInstruction({ programId: r, keys: s, data: a }); - } - Td.createSellInstruction = Ytn; - }); - var DBt = I((kd) => { - "use strict"; - m(); - g(); - var Qtn = - (kd && kd.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - ern = - (kd && kd.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - eCe = - (kd && kd.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - Qtn(e, t, r); - return ern(e, t), e; - }; - Object.defineProperty(kd, "__esModule", { value: !0 }); - kd.createUpdateAuctionHouseInstruction = - kd.updateAuctionHouseInstructionDiscriminator = - kd.updateAuctionHouseStruct = - void 0; - var NBt = eCe((pa(), jo(ha))), - cS = eCe(In()), - Gfe = eCe(Le()); - kd.updateAuctionHouseStruct = new cS.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", cS.uniformFixedSizeArray(cS.u8, 8)], - ["sellerFeeBasisPoints", cS.coption(cS.u16)], - ["requiresSignOff", cS.coption(cS.bool)], - ["canChangeSalePrice", cS.coption(cS.bool)], - ], - "UpdateAuctionHouseInstructionArgs" - ); - kd.updateAuctionHouseInstructionDiscriminator = [ - 84, 215, 2, 172, 241, 0, 245, 219, - ]; - function trn( - t, - e, - r = new Gfe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n, i, o, a; - let [s] = kd.updateAuctionHouseStruct.serialize({ - instructionDiscriminator: - kd.updateAuctionHouseInstructionDiscriminator, - ...e, - }), - c = [ - { pubkey: t.treasuryMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.payer, isWritable: !1, isSigner: !0 }, - { pubkey: t.authority, isWritable: !1, isSigner: !0 }, - { pubkey: t.newAuthority, isWritable: !1, isSigner: !1 }, - { pubkey: t.feeWithdrawalDestination, isWritable: !0, isSigner: !1 }, - { - pubkey: t.treasuryWithdrawalDestination, - isWritable: !0, - isSigner: !1, - }, - { - pubkey: t.treasuryWithdrawalDestinationOwner, - isWritable: !1, - isSigner: !1, - }, - { pubkey: t.auctionHouse, isWritable: !0, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : NBt.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : Gfe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (o = t.ataProgram) !== null && o !== void 0 - ? o - : NBt.ASSOCIATED_TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (a = t.rent) !== null && a !== void 0 - ? a - : Gfe.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let h of t.anchorRemainingAccounts) c.push(h); - return new Gfe.TransactionInstruction({ programId: r, keys: c, data: s }); - } - kd.createUpdateAuctionHouseInstruction = trn; - }); - var LBt = I((Pd) => { - "use strict"; - m(); - g(); - var rrn = - (Pd && Pd.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - nrn = - (Pd && Pd.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - FBt = - (Pd && Pd.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - rrn(e, t, r); - return nrn(e, t), e; - }; - Object.defineProperty(Pd, "__esModule", { value: !0 }); - Pd.createUpdateAuctioneerInstruction = - Pd.updateAuctioneerInstructionDiscriminator = - Pd.updateAuctioneerStruct = - void 0; - var Jfe = FBt(In()), - tCe = FBt(Le()), - irn = Rfe(); - Pd.updateAuctioneerStruct = new Jfe.FixableBeetArgsStruct( - [ - ["instructionDiscriminator", Jfe.uniformFixedSizeArray(Jfe.u8, 8)], - ["scopes", Jfe.array(irn.authorityScopeBeet)], - ], - "UpdateAuctioneerInstructionArgs" - ); - Pd.updateAuctioneerInstructionDiscriminator = [ - 103, 255, 80, 234, 94, 56, 168, 208, - ]; - function orn( - t, - e, - r = new tCe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n; - let [i] = Pd.updateAuctioneerStruct.serialize({ - instructionDiscriminator: Pd.updateAuctioneerInstructionDiscriminator, - ...e, - }), - o = [ - { pubkey: t.auctionHouse, isWritable: !0, isSigner: !1 }, - { pubkey: t.authority, isWritable: !0, isSigner: !0 }, - { pubkey: t.auctioneerAuthority, isWritable: !1, isSigner: !1 }, - { pubkey: t.ahAuctioneerPda, isWritable: !0, isSigner: !1 }, - { - pubkey: - (n = t.systemProgram) !== null && n !== void 0 - ? n - : tCe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let s of t.anchorRemainingAccounts) o.push(s); - return new tCe.TransactionInstruction({ programId: r, keys: o, data: i }); - } - Pd.createUpdateAuctioneerInstruction = orn; - }); - var zBt = I((Od) => { - "use strict"; - m(); - g(); - var arn = - (Od && Od.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - srn = - (Od && Od.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - rCe = - (Od && Od.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - arn(e, t, r); - return srn(e, t), e; - }; - Object.defineProperty(Od, "__esModule", { value: !0 }); - Od.createWithdrawInstruction = - Od.withdrawInstructionDiscriminator = - Od.withdrawStruct = - void 0; - var qBt = rCe((pa(), jo(ha))), - QV = rCe(In()), - $fe = rCe(Le()); - Od.withdrawStruct = new QV.BeetArgsStruct( - [ - ["instructionDiscriminator", QV.uniformFixedSizeArray(QV.u8, 8)], - ["escrowPaymentBump", QV.u8], - ["amount", QV.u64], - ], - "WithdrawInstructionArgs" - ); - Od.withdrawInstructionDiscriminator = [183, 18, 70, 156, 148, 109, 161, 34]; - function urn( - t, - e, - r = new $fe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n, i, o, a; - let [s] = Od.withdrawStruct.serialize({ - instructionDiscriminator: Od.withdrawInstructionDiscriminator, - ...e, - }), - c = [ - { pubkey: t.wallet, isWritable: !1, isSigner: !1 }, - { pubkey: t.receiptAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.escrowPaymentAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.treasuryMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouse, isWritable: !1, isSigner: !1 }, - { pubkey: t.auctionHouseFeeAccount, isWritable: !0, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : qBt.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : $fe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (o = t.ataProgram) !== null && o !== void 0 - ? o - : qBt.ASSOCIATED_TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (a = t.rent) !== null && a !== void 0 - ? a - : $fe.SYSVAR_RENT_PUBKEY, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let h of t.anchorRemainingAccounts) c.push(h); - return new $fe.TransactionInstruction({ programId: r, keys: c, data: s }); - } - Od.createWithdrawInstruction = urn; - }); - var UBt = I((Bd) => { - "use strict"; - m(); - g(); - var crn = - (Bd && Bd.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - lrn = - (Bd && Bd.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - jBt = - (Bd && Bd.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - crn(e, t, r); - return lrn(e, t), e; - }; - Object.defineProperty(Bd, "__esModule", { value: !0 }); - Bd.createWithdrawFromFeeInstruction = - Bd.withdrawFromFeeInstructionDiscriminator = - Bd.withdrawFromFeeStruct = - void 0; - var Zfe = jBt(In()), - nCe = jBt(Le()); - Bd.withdrawFromFeeStruct = new Zfe.BeetArgsStruct( - [ - ["instructionDiscriminator", Zfe.uniformFixedSizeArray(Zfe.u8, 8)], - ["amount", Zfe.u64], - ], - "WithdrawFromFeeInstructionArgs" - ); - Bd.withdrawFromFeeInstructionDiscriminator = [ - 179, 208, 190, 154, 32, 179, 19, 59, - ]; - function frn( - t, - e, - r = new nCe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n; - let [i] = Bd.withdrawFromFeeStruct.serialize({ - instructionDiscriminator: Bd.withdrawFromFeeInstructionDiscriminator, - ...e, - }), - o = [ - { pubkey: t.authority, isWritable: !1, isSigner: !0 }, - { pubkey: t.feeWithdrawalDestination, isWritable: !0, isSigner: !1 }, - { pubkey: t.auctionHouseFeeAccount, isWritable: !0, isSigner: !1 }, - { pubkey: t.auctionHouse, isWritable: !0, isSigner: !1 }, - { - pubkey: - (n = t.systemProgram) !== null && n !== void 0 - ? n - : nCe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let s of t.anchorRemainingAccounts) o.push(s); - return new nCe.TransactionInstruction({ programId: r, keys: o, data: i }); - } - Bd.createWithdrawFromFeeInstruction = frn; - }); - var KBt = I((Id) => { - "use strict"; - m(); - g(); - var drn = - (Id && Id.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - hrn = - (Id && Id.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - oCe = - (Id && Id.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - drn(e, t, r); - return hrn(e, t), e; - }; - Object.defineProperty(Id, "__esModule", { value: !0 }); - Id.createWithdrawFromTreasuryInstruction = - Id.withdrawFromTreasuryInstructionDiscriminator = - Id.withdrawFromTreasuryStruct = - void 0; - var prn = oCe((pa(), jo(ha))), - Xfe = oCe(In()), - iCe = oCe(Le()); - Id.withdrawFromTreasuryStruct = new Xfe.BeetArgsStruct( - [ - ["instructionDiscriminator", Xfe.uniformFixedSizeArray(Xfe.u8, 8)], - ["amount", Xfe.u64], - ], - "WithdrawFromTreasuryInstructionArgs" - ); - Id.withdrawFromTreasuryInstructionDiscriminator = [ - 0, 164, 86, 76, 56, 72, 12, 170, - ]; - function yrn( - t, - e, - r = new iCe.PublicKey("hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk") - ) { - var n, i; - let [o] = Id.withdrawFromTreasuryStruct.serialize({ - instructionDiscriminator: - Id.withdrawFromTreasuryInstructionDiscriminator, - ...e, - }), - a = [ - { pubkey: t.treasuryMint, isWritable: !1, isSigner: !1 }, - { pubkey: t.authority, isWritable: !1, isSigner: !0 }, - { - pubkey: t.treasuryWithdrawalDestination, - isWritable: !0, - isSigner: !1, - }, - { pubkey: t.auctionHouseTreasury, isWritable: !0, isSigner: !1 }, - { pubkey: t.auctionHouse, isWritable: !0, isSigner: !1 }, - { - pubkey: - (n = t.tokenProgram) !== null && n !== void 0 - ? n - : prn.TOKEN_PROGRAM_ID, - isWritable: !1, - isSigner: !1, - }, - { - pubkey: - (i = t.systemProgram) !== null && i !== void 0 - ? i - : iCe.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - ]; - if (t.anchorRemainingAccounts != null) - for (let c of t.anchorRemainingAccounts) a.push(c); - return new iCe.TransactionInstruction({ programId: r, keys: a, data: o }); - } - Id.createWithdrawFromTreasuryInstruction = yrn; - }); - var HBt = I((xi) => { - "use strict"; - m(); - g(); - var mrn = - (xi && xi.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - bo = - (xi && xi.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - mrn(e, t, r); - }; - Object.defineProperty(xi, "__esModule", { value: !0 }); - bo(ZOt(), xi); - bo(YOt(), xi); - bo(QOt(), xi); - bo(tBt(), xi); - bo(nBt(), xi); - bo(iBt(), xi); - bo(oBt(), xi); - bo(sBt(), xi); - bo(uBt(), xi); - bo(lBt(), xi); - bo(dBt(), xi); - bo(pBt(), xi); - bo(mBt(), xi); - bo(vBt(), xi); - bo(_Bt(), xi); - bo(xBt(), xi); - bo(ABt(), xi); - bo(MBt(), xi); - bo(kBt(), xi); - bo(OBt(), xi); - bo(IBt(), xi); - bo(CBt(), xi); - bo(RBt(), xi); - bo(DBt(), xi); - bo(LBt(), xi); - bo(zBt(), xi); - bo(UBt(), xi); - bo(KBt(), xi); - }); - var WBt = I((k0) => { - "use strict"; - m(); - g(); - var grn = - (k0 && k0.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - vrn = - (k0 && k0.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - brn = - (k0 && k0.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - grn(e, t, r); - return vrn(e, t), e; - }; - Object.defineProperty(k0, "__esModule", { value: !0 }); - k0.bidTypeBeet = k0.BidType = void 0; - var wrn = brn(In()), - VBt; - (function (t) { - (t[(t.PublicSale = 0)] = "PublicSale"), - (t[(t.PrivateSale = 1)] = "PrivateSale"), - (t[(t.AuctioneerPublicSale = 2)] = "AuctioneerPublicSale"), - (t[(t.AuctioneerPrivateSale = 3)] = "AuctioneerPrivateSale"); - })((VBt = k0.BidType || (k0.BidType = {}))); - k0.bidTypeBeet = wrn.fixedScalarEnum(VBt); - }); - var JBt = I((P0) => { - "use strict"; - m(); - g(); - var _rn = - (P0 && P0.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - xrn = - (P0 && P0.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Srn = - (P0 && P0.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - _rn(e, t, r); - return xrn(e, t), e; - }; - Object.defineProperty(P0, "__esModule", { value: !0 }); - P0.cancelTypeBeet = P0.CancelType = void 0; - var Arn = Srn(In()), - GBt; - (function (t) { - (t[(t.Cancel = 0)] = "Cancel"), - (t[(t.AuctioneerCancel = 1)] = "AuctioneerCancel"); - })((GBt = P0.CancelType || (P0.CancelType = {}))); - P0.cancelTypeBeet = Arn.fixedScalarEnum(GBt); - }); - var ZBt = I((O0) => { - "use strict"; - m(); - g(); - var Ern = - (O0 && O0.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Mrn = - (O0 && O0.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Trn = - (O0 && O0.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - Ern(e, t, r); - return Mrn(e, t), e; - }; - Object.defineProperty(O0, "__esModule", { value: !0 }); - O0.listingTypeBeet = O0.ListingType = void 0; - var krn = Trn(In()), - $Bt; - (function (t) { - (t[(t.Sell = 0)] = "Sell"), - (t[(t.AuctioneerSell = 1)] = "AuctioneerSell"); - })(($Bt = O0.ListingType || (O0.ListingType = {}))); - O0.listingTypeBeet = krn.fixedScalarEnum($Bt); - }); - var YBt = I((B0) => { - "use strict"; - m(); - g(); - var Prn = - (B0 && B0.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Orn = - (B0 && B0.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Brn = - (B0 && B0.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - Prn(e, t, r); - return Orn(e, t), e; - }; - Object.defineProperty(B0, "__esModule", { value: !0 }); - B0.purchaseTypeBeet = B0.PurchaseType = void 0; - var Irn = Brn(In()), - XBt; - (function (t) { - (t[(t.ExecuteSale = 0)] = "ExecuteSale"), - (t[(t.AuctioneerExecuteSale = 1)] = "AuctioneerExecuteSale"); - })((XBt = B0.PurchaseType || (B0.PurchaseType = {}))); - B0.purchaseTypeBeet = Irn.fixedScalarEnum(XBt); - }); - var QBt = I((Ug) => { - "use strict"; - m(); - g(); - var Crn = - (Ug && Ug.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - eW = - (Ug && Ug.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - Crn(e, t, r); - }; - Object.defineProperty(Ug, "__esModule", { value: !0 }); - eW(Rfe(), Ug); - eW(WBt(), Ug); - eW(JBt(), Ug); - eW(ZBt(), Ug); - eW(YBt(), Ug); - }); - var aCe = I((lh) => { - "use strict"; - m(); - g(); - var Rrn = - (lh && lh.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Yfe = - (lh && lh.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - Rrn(e, t, r); - }; - Object.defineProperty(lh, "__esModule", { value: !0 }); - lh.PROGRAM_ID = lh.PROGRAM_ADDRESS = void 0; - var Nrn = Le(); - Yfe(JOt(), lh); - Yfe($Ot(), lh); - Yfe(HBt(), lh); - Yfe(QBt(), lh); - lh.PROGRAM_ADDRESS = "hausS13jsjafwWwGqZTUQRmWyvyxn9EQpqMwV1PBBmk"; - lh.PROGRAM_ID = new Nrn.PublicKey(lh.PROGRAM_ADDRESS); - }); - var eIt = I((Qfe) => { - "use strict"; - m(); - g(); - Object.defineProperty(Qfe, "__esModule", { value: !0 }); - Qfe.cusper = void 0; - var Drn = JN(), - Frn = aCe(); - Qfe.cusper = (0, Drn.initCusper)(Frn.errorFromCode); - }); - var fh = I((w3) => { - "use strict"; - m(); - g(); - var Lrn = - (w3 && w3.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - tIt = - (w3 && w3.__exportStar) || - function (t, e) { - for (var r in t) - r !== "default" && - !Object.prototype.hasOwnProperty.call(e, r) && - Lrn(e, t, r); - }; - Object.defineProperty(w3, "__esModule", { value: !0 }); - tIt(eIt(), w3); - tIt(aCe(), w3); - }); - var i5t = I((GD) => { - "use strict"; - m(); - g(); - Object.defineProperty(GD, "__esModule", { value: !0 }); - GD.decode = GD.encode = void 0; - var n5t = Qr(); - function Enn(t) { - return t.reduce((e, r) => e + r.toString(16).padStart(2, "0"), "0x"); - } - GD.encode = Enn; - function Mnn(t) { - t.indexOf("0x") === 0 && (t = t.substr(2)), - t.length % 2 === 1 && (t = "0" + t); - let e = t.match(/.{2}/g); - return e === null - ? n5t.Buffer.from([]) - : n5t.Buffer.from(e.map((r) => parseInt(r, 16))); - } - GD.decode = Mnn; - }); - var ohe = I((JD) => { - "use strict"; - m(); - g(); - var _Ce; - Object.defineProperty(JD, "__esModule", { value: !0 }); - JD.chunks = JD.isBrowser = void 0; - JD.isBrowser = - process.env.ANCHOR_BROWSER || - (typeof window < "u" && - !( - !((_Ce = window.process) === null || _Ce === void 0) && - _Ce.hasOwnProperty("type") - )); - function Tnn(t, e) { - return Array.apply(0, new Array(Math.ceil(t.length / e))).map((r, n) => - t.slice(n * e, (n + 1) * e) - ); - } - JD.chunks = Tnn; - }); - var a5t = I(($D) => { - "use strict"; - m(); - g(); - Object.defineProperty($D, "__esModule", { value: !0 }); - $D.encode = $D.decode = void 0; - var o5t = ohe(); - function knn(t) { - return ( - o5t.isBrowser - ? new TextDecoder("utf-8") - : new (es().TextDecoder)("utf-8") - ).decode(t); - } - $D.decode = knn; - function Pnn(t) { - return ( - o5t.isBrowser ? new TextEncoder() : new (es().TextEncoder)("utf-8") - ).encode(t); - } - $D.encode = Pnn; - }); - var u5t = I((S3) => { - "use strict"; - m(); - g(); - var Onn = - (S3 && S3.__importDefault) || - function (t) { - return t && t.__esModule ? t : { default: t }; - }; - Object.defineProperty(S3, "__esModule", { value: !0 }); - S3.decode = S3.encode = void 0; - var s5t = Onn(xv()); - function Bnn(t) { - return s5t.default.encode(t); - } - S3.encode = Bnn; - function Inn(t) { - return s5t.default.decode(t); - } - S3.decode = Inn; - }); - var l5t = I((Am) => { - "use strict"; - m(); - g(); - var Cnn = - (Am && Am.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - Rnn = - (Am && Am.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - Nnn = - (Am && Am.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - Cnn(e, t, r); - return Rnn(e, t), e; - }; - Object.defineProperty(Am, "__esModule", { value: !0 }); - Am.decode = Am.encode = void 0; - var Dnn = Qr(), - c5t = Nnn(QI()); - function Fnn(t) { - return c5t.fromByteArray(t); - } - Am.encode = Fnn; - function Lnn(t) { - return Dnn.Buffer.from(c5t.toByteArray(t)); - } - Am.decode = Lnn; - }); - var f5t = I((Rd) => { - "use strict"; - m(); - g(); - var qnn = - (Rd && Rd.__createBinding) || - (Object.create - ? function (t, e, r, n) { - n === void 0 && (n = r); - var i = Object.getOwnPropertyDescriptor(e, r); - (!i || - ("get" in i ? !e.__esModule : i.writable || i.configurable)) && - (i = { - enumerable: !0, - get: function () { - return e[r]; - }, - }), - Object.defineProperty(t, n, i); - } - : function (t, e, r, n) { - n === void 0 && (n = r), (t[n] = e[r]); - }), - znn = - (Rd && Rd.__setModuleDefault) || - (Object.create - ? function (t, e) { - Object.defineProperty(t, "default", { enumerable: !0, value: e }); - } - : function (t, e) { - t.default = e; - }), - ahe = - (Rd && Rd.__importStar) || - function (t) { - if (t && t.__esModule) return t; - var e = {}; - if (t != null) - for (var r in t) - r !== "default" && - Object.prototype.hasOwnProperty.call(t, r) && - qnn(e, t, r); - return znn(e, t), e; - }; - Object.defineProperty(Rd, "__esModule", { value: !0 }); - Rd.base64 = Rd.bs58 = Rd.utf8 = Rd.hex = void 0; - Rd.hex = ahe(i5t()); - Rd.utf8 = ahe(a5t()); - Rd.bs58 = ahe(u5t()); - Rd.base64 = ahe(l5t()); - }); - var p5t = I((Qw) => { - "use strict"; - m(); - g(); - Object.defineProperty(Qw, "__esModule", { value: !0 }); - Qw.translateAddress = - Qw.validateAccounts = - Qw.toInstruction = - Qw.parseIdlErrors = - void 0; - var d5t = Le(); - function jnn(t) { - let e = new Map(); - return ( - t.errors && - t.errors.forEach((r) => { - var n; - let i = (n = r.msg) !== null && n !== void 0 ? n : r.name; - e.set(r.code, i); - }), - e - ); - } - Qw.parseIdlErrors = jnn; - function Unn(t, ...e) { - if (t.args.length != e.length) throw new Error("Invalid argument length"); - let r = {}, - n = 0; - return ( - t.args.forEach((i) => { - (r[i.name] = e[n]), (n += 1); - }), - r - ); - } - Qw.toInstruction = Unn; - function h5t(t, e = {}) { - t.forEach((r) => { - if ("accounts" in r) h5t(r.accounts, e[r.name]); - else if (e[r.name] === void 0) - throw new Error(`Invalid arguments: ${r.name} not provided.`); - }); - } - Qw.validateAccounts = h5t; - function Knn(t) { - return t instanceof d5t.PublicKey ? t : new d5t.PublicKey(t); - } - Qw.translateAddress = Knn; - }); - var x5t = I((Tr) => { - "use strict"; - m(); - g(); - Object.defineProperty(Tr, "__esModule", { value: !0 }); - var she = class extends TypeError { - constructor(e, r) { - let n, - { message: i, ...o } = e, - { path: a } = e, - s = a.length === 0 ? i : "At path: " + a.join(".") + " -- " + i; - super(s), - (this.value = void 0), - (this.key = void 0), - (this.type = void 0), - (this.refinement = void 0), - (this.path = void 0), - (this.branch = void 0), - (this.failures = void 0), - Object.assign(this, o), - (this.name = this.constructor.name), - (this.failures = () => { - var c; - return (c = n) != null ? c : (n = [e, ...r()]); - }); - } - }; - function Hnn(t) { - return Kg(t) && typeof t[Symbol.iterator] == "function"; - } - function Kg(t) { - return typeof t == "object" && t != null; - } - function y5t(t) { - if (Object.prototype.toString.call(t) !== "[object Object]") return !1; - let e = Object.getPrototypeOf(t); - return e === null || e === Object.prototype; - } - function pu(t) { - return typeof t == "string" ? JSON.stringify(t) : "" + t; - } - function Vnn(t) { - let { done: e, value: r } = t.next(); - return e ? void 0 : r; - } - function Wnn(t, e, r, n) { - if (t === !0) return; - t === !1 ? (t = {}) : typeof t == "string" && (t = { message: t }); - let { path: i, branch: o } = e, - { type: a } = r, - { - refinement: s, - message: c = "Expected a value of type `" + - a + - "`" + - (s ? " with refinement `" + s + "`" : "") + - ", but received: `" + - pu(n) + - "`", - } = t; - return { - value: n, - type: a, - refinement: s, - key: i[i.length - 1], - path: i, - branch: o, - ...t, - message: c, - }; - } - function* xCe(t, e, r, n) { - Hnn(t) || (t = [t]); - for (let i of t) { - let o = Wnn(i, e, r, n); - o && (yield o); - } - } - function* SCe(t, e, r) { - r === void 0 && (r = {}); - let { path: n = [], branch: i = [t], coerce: o = !1, mask: a = !1 } = r, - s = { path: n, branch: i }; - if ( - o && - ((t = e.coercer(t, s)), - a && e.type !== "type" && Kg(e.schema) && Kg(t) && !Array.isArray(t)) - ) - for (let u in t) e.schema[u] === void 0 && delete t[u]; - let c = !0; - for (let u of e.validator(t, s)) (c = !1), yield [u, void 0]; - for (let [u, h, w] of e.entries(t, s)) { - let M = SCe(h, w, { - path: u === void 0 ? n : [...n, u], - branch: u === void 0 ? i : [...i, h], - coerce: o, - mask: a, - }); - for (let k of M) - k[0] - ? ((c = !1), yield [k[0], void 0]) - : o && - ((h = k[1]), - u === void 0 - ? (t = h) - : t instanceof Map - ? t.set(u, h) - : t instanceof Set - ? t.add(h) - : Kg(t) && (t[u] = h)); - } - if (c) for (let u of e.refiner(t, s)) (c = !1), yield [u, void 0]; - c && (yield [void 0, t]); - } - var Pa = class { - constructor(e) { - (this.TYPE = void 0), - (this.type = void 0), - (this.schema = void 0), - (this.coercer = void 0), - (this.validator = void 0), - (this.refiner = void 0), - (this.entries = void 0); - let { - type: r, - schema: n, - validator: i, - refiner: o, - coercer: a = (c) => c, - entries: s = function* () {}, - } = e; - (this.type = r), - (this.schema = n), - (this.entries = s), - (this.coercer = a), - i - ? (this.validator = (c, u) => { - let h = i(c, u); - return xCe(h, u, this, c); - }) - : (this.validator = () => []), - o - ? (this.refiner = (c, u) => { - let h = o(c, u); - return xCe(h, u, this, c); - }) - : (this.refiner = () => []); - } - assert(e) { - return m5t(e, this); - } - create(e) { - return g5t(e, this); - } - is(e) { - return ACe(e, this); - } - mask(e) { - return v5t(e, this); - } - validate(e, r) { - return r === void 0 && (r = {}), ZD(e, this, r); - } - }; - function m5t(t, e) { - let r = ZD(t, e); - if (r[0]) throw r[0]; - } - function g5t(t, e) { - let r = ZD(t, e, { coerce: !0 }); - if (r[0]) throw r[0]; - return r[1]; - } - function v5t(t, e) { - let r = ZD(t, e, { coerce: !0, mask: !0 }); - if (r[0]) throw r[0]; - return r[1]; - } - function ACe(t, e) { - return !ZD(t, e)[0]; - } - function ZD(t, e, r) { - r === void 0 && (r = {}); - let n = SCe(t, e, r), - i = Vnn(n); - if (i[0]) - return [ - new she(i[0], function* () { - for (let a of n) a[0] && (yield a[0]); - }), - void 0, - ]; - { - let o = i[1]; - return [void 0, o]; - } - } - function Gnn() { - for (var t = arguments.length, e = new Array(t), r = 0; r < t; r++) - e[r] = arguments[r]; - let n = e[0].type === "type", - i = e.map((a) => a.schema), - o = Object.assign({}, ...i); - return n ? MCe(o) : rW(o); - } - function Pp(t, e) { - return new Pa({ type: t, schema: null, validator: e }); - } - function Jnn(t, e) { - return new Pa({ - ...t, - refiner: (r, n) => r === void 0 || t.refiner(r, n), - validator(r, n) { - return r === void 0 ? !0 : (e(r, n), t.validator(r, n)); - }, - }); - } - function $nn(t) { - return new Pa({ - type: "dynamic", - schema: null, - *entries(e, r) { - yield* t(e, r).entries(e, r); - }, - validator(e, r) { - return t(e, r).validator(e, r); - }, - coercer(e, r) { - return t(e, r).coercer(e, r); - }, - refiner(e, r) { - return t(e, r).refiner(e, r); - }, - }); - } - function Znn(t) { - let e; - return new Pa({ - type: "lazy", - schema: null, - *entries(r, n) { - var i; - (i = e) != null || (e = t()), yield* e.entries(r, n); - }, - validator(r, n) { - var i; - return (i = e) != null || (e = t()), e.validator(r, n); - }, - coercer(r, n) { - var i; - return (i = e) != null || (e = t()), e.coercer(r, n); - }, - refiner(r, n) { - var i; - return (i = e) != null || (e = t()), e.refiner(r, n); - }, - }); - } - function Xnn(t, e) { - let { schema: r } = t, - n = { ...r }; - for (let i of e) delete n[i]; - switch (t.type) { - case "type": - return MCe(n); - default: - return rW(n); - } - } - function Ynn(t) { - let e = t instanceof Pa ? { ...t.schema } : { ...t }; - for (let r in e) e[r] = b5t(e[r]); - return rW(e); - } - function Qnn(t, e) { - let { schema: r } = t, - n = {}; - for (let i of e) n[i] = r[i]; - return rW(n); - } - function ein(t, e) { - return ( - console.warn( - "superstruct@0.11 - The `struct` helper has been renamed to `define`." - ), - Pp(t, e) - ); - } - function tin() { - return Pp("any", () => !0); - } - function rin(t) { - return new Pa({ - type: "array", - schema: t, - *entries(e) { - if (t && Array.isArray(e)) - for (let [r, n] of e.entries()) yield [r, n, t]; - }, - coercer(e) { - return Array.isArray(e) ? e.slice() : e; - }, - validator(e) { - return ( - Array.isArray(e) || - "Expected an array value, but received: " + pu(e) - ); - }, - }); - } - function nin() { - return Pp("bigint", (t) => typeof t == "bigint"); - } - function iin() { - return Pp("boolean", (t) => typeof t == "boolean"); - } - function oin() { - return Pp( - "date", - (t) => - (t instanceof Date && !isNaN(t.getTime())) || - "Expected a valid `Date` object, but received: " + pu(t) - ); - } - function ain(t) { - let e = {}, - r = t.map((n) => pu(n)).join(); - for (let n of t) e[n] = n; - return new Pa({ - type: "enums", - schema: e, - validator(n) { - return ( - t.includes(n) || - "Expected one of `" + r + "`, but received: " + pu(n) - ); - }, - }); - } - function sin() { - return Pp( - "func", - (t) => - typeof t == "function" || - "Expected a function, but received: " + pu(t) - ); - } - function uin(t) { - return Pp( - "instance", - (e) => - e instanceof t || - "Expected a `" + t.name + "` instance, but received: " + pu(e) - ); - } - function cin() { - return Pp( - "integer", - (t) => - (typeof t == "number" && !isNaN(t) && Number.isInteger(t)) || - "Expected an integer, but received: " + pu(t) - ); - } - function lin(t) { - return new Pa({ - type: "intersection", - schema: null, - *entries(e, r) { - for (let n of t) yield* n.entries(e, r); - }, - *validator(e, r) { - for (let n of t) yield* n.validator(e, r); - }, - *refiner(e, r) { - for (let n of t) yield* n.refiner(e, r); - }, - }); - } - function fin(t) { - let e = pu(t), - r = typeof t; - return new Pa({ - type: "literal", - schema: r === "string" || r === "number" || r === "boolean" ? t : null, - validator(n) { - return ( - n === t || - "Expected the literal `" + e + "`, but received: " + pu(n) - ); - }, - }); - } - function din(t, e) { - return new Pa({ - type: "map", - schema: null, - *entries(r) { - if (t && e && r instanceof Map) - for (let [n, i] of r.entries()) yield [n, n, t], yield [n, i, e]; - }, - coercer(r) { - return r instanceof Map ? new Map(r) : r; - }, - validator(r) { - return ( - r instanceof Map || - "Expected a `Map` object, but received: " + pu(r) - ); - }, - }); - } - function ECe() { - return Pp("never", () => !1); - } - function hin(t) { - return new Pa({ - ...t, - validator: (e, r) => e === null || t.validator(e, r), - refiner: (e, r) => e === null || t.refiner(e, r), - }); - } - function pin() { - return Pp( - "number", - (t) => - (typeof t == "number" && !isNaN(t)) || - "Expected a number, but received: " + pu(t) - ); - } - function rW(t) { - let e = t ? Object.keys(t) : [], - r = ECe(); - return new Pa({ - type: "object", - schema: t || null, - *entries(n) { - if (t && Kg(n)) { - let i = new Set(Object.keys(n)); - for (let o of e) i.delete(o), yield [o, n[o], t[o]]; - for (let o of i) yield [o, n[o], r]; - } - }, - validator(n) { - return Kg(n) || "Expected an object, but received: " + pu(n); - }, - coercer(n) { - return Kg(n) ? { ...n } : n; - }, - }); - } - function b5t(t) { - return new Pa({ - ...t, - validator: (e, r) => e === void 0 || t.validator(e, r), - refiner: (e, r) => e === void 0 || t.refiner(e, r), - }); - } - function yin(t, e) { - return new Pa({ - type: "record", - schema: null, - *entries(r) { - if (Kg(r)) - for (let n in r) { - let i = r[n]; - yield [n, n, t], yield [n, i, e]; - } - }, - validator(r) { - return Kg(r) || "Expected an object, but received: " + pu(r); - }, - }); - } - function min() { - return Pp("regexp", (t) => t instanceof RegExp); - } - function gin(t) { - return new Pa({ - type: "set", - schema: null, - *entries(e) { - if (t && e instanceof Set) for (let r of e) yield [r, r, t]; - }, - coercer(e) { - return e instanceof Set ? new Set(e) : e; - }, - validator(e) { - return ( - e instanceof Set || - "Expected a `Set` object, but received: " + pu(e) - ); - }, - }); - } - function w5t() { - return Pp( - "string", - (t) => - typeof t == "string" || "Expected a string, but received: " + pu(t) - ); - } - function vin(t) { - let e = ECe(); - return new Pa({ - type: "tuple", - schema: null, - *entries(r) { - if (Array.isArray(r)) { - let n = Math.max(t.length, r.length); - for (let i = 0; i < n; i++) yield [i, r[i], t[i] || e]; - } - }, - validator(r) { - return ( - Array.isArray(r) || "Expected an array, but received: " + pu(r) - ); - }, - }); - } - function MCe(t) { - let e = Object.keys(t); - return new Pa({ - type: "type", - schema: t, - *entries(r) { - if (Kg(r)) for (let n of e) yield [n, r[n], t[n]]; - }, - validator(r) { - return Kg(r) || "Expected an object, but received: " + pu(r); - }, - }); - } - function bin(t) { - let e = t.map((r) => r.type).join(" | "); - return new Pa({ - type: "union", - schema: null, - coercer(r, n) { - return ( - t.find((o) => { - let [a] = o.validate(r, { coerce: !0 }); - return !a; - }) || TCe() - ).coercer(r, n); - }, - validator(r, n) { - let i = []; - for (let o of t) { - let [...a] = SCe(r, o, n), - [s] = a; - if (s[0]) for (let [c] of a) c && i.push(c); - else return []; - } - return [ - "Expected the value to satisfy a union of `" + - e + - "`, but received: " + - pu(r), - ...i, - ]; - }, - }); - } - function TCe() { - return Pp("unknown", () => !0); - } - function kCe(t, e, r) { - return new Pa({ - ...t, - coercer: (n, i) => - ACe(n, e) ? t.coercer(r(n, i), i) : t.coercer(n, i), - }); - } - function win(t, e, r) { - return ( - r === void 0 && (r = {}), - kCe(t, TCe(), (n) => { - let i = typeof e == "function" ? e() : e; - if (n === void 0) return i; - if (!r.strict && y5t(n) && y5t(i)) { - let o = { ...n }, - a = !1; - for (let s in i) o[s] === void 0 && ((o[s] = i[s]), (a = !0)); - if (a) return o; - } - return n; - }) - ); - } - function _in(t) { - return kCe(t, w5t(), (e) => e.trim()); - } - function xin(t) { - return HB(t, "empty", (e) => { - let r = _5t(e); - return ( - r === 0 || - "Expected an empty " + - t.type + - " but received one with a size of `" + - r + - "`" - ); - }); - } - function _5t(t) { - return t instanceof Map || t instanceof Set ? t.size : t.length; - } - function Sin(t, e, r) { - r === void 0 && (r = {}); - let { exclusive: n } = r; - return HB(t, "max", (i) => - n - ? i < e - : i <= e || - "Expected a " + - t.type + - " less than " + - (n ? "" : "or equal to ") + - e + - " but received `" + - i + - "`" - ); - } - function Ain(t, e, r) { - r === void 0 && (r = {}); - let { exclusive: n } = r; - return HB(t, "min", (i) => - n - ? i > e - : i >= e || - "Expected a " + - t.type + - " greater than " + - (n ? "" : "or equal to ") + - e + - " but received `" + - i + - "`" - ); - } - function Ein(t) { - return HB( - t, - "nonempty", - (e) => - _5t(e) > 0 || - "Expected a nonempty " + t.type + " but received an empty one" - ); - } - function Min(t, e) { - return HB( - t, - "pattern", - (r) => - e.test(r) || - "Expected a " + - t.type + - " matching `/" + - e.source + - '/` but received "' + - r + - '"' - ); - } - function Tin(t, e, r) { - r === void 0 && (r = e); - let n = "Expected a " + t.type, - i = e === r ? "of `" + e + "`" : "between `" + e + "` and `" + r + "`"; - return HB(t, "size", (o) => { - if (typeof o == "number" || o instanceof Date) - return ( - (e <= o && o <= r) || n + " " + i + " but received `" + o + "`" - ); - if (o instanceof Map || o instanceof Set) { - let { size: a } = o; - return ( - (e <= a && a <= r) || - n + - " with a size " + - i + - " but received one with a size of `" + - a + - "`" - ); - } else { - let { length: a } = o; - return ( - (e <= a && a <= r) || - n + - " with a length " + - i + - " but received one with a length of `" + - a + - "`" - ); - } - }); - } - function HB(t, e, r) { - return new Pa({ - ...t, - *refiner(n, i) { - yield* t.refiner(n, i); - let o = r(n, i), - a = xCe(o, i, t, n); - for (let s of a) yield { ...s, refinement: e }; - }, - }); - } - Tr.Struct = Pa; - Tr.StructError = she; - Tr.any = tin; - Tr.array = rin; - Tr.assert = m5t; - Tr.assign = Gnn; - Tr.bigint = nin; - Tr.boolean = iin; - Tr.coerce = kCe; - Tr.create = g5t; - Tr.date = oin; - Tr.defaulted = win; - Tr.define = Pp; - Tr.deprecated = Jnn; - Tr.dynamic = $nn; - Tr.empty = xin; - Tr.enums = ain; - Tr.func = sin; - Tr.instance = uin; - Tr.integer = cin; - Tr.intersection = lin; - Tr.is = ACe; - Tr.lazy = Znn; - Tr.literal = fin; - Tr.map = din; - Tr.mask = v5t; - Tr.max = Sin; - Tr.min = Ain; - Tr.never = ECe; - Tr.nonempty = Ein; - Tr.nullable = hin; - Tr.number = pin; - Tr.object = rW; - Tr.omit = Xnn; - Tr.optional = b5t; - Tr.partial = Ynn; - Tr.pattern = Min; - Tr.pick = Qnn; - Tr.record = yin; - Tr.refine = HB; - Tr.regexp = min; - Tr.set = gin; - Tr.size = Tin; - Tr.string = w5t; - Tr.struct = ein; - Tr.trimmed = _in; - Tr.tuple = vin; - Tr.type = MCe; - Tr.union = bin; - Tr.unknown = TCe; - Tr.validate = ZD; - }); - var M5t = I((A3) => { - "use strict"; - m(); - g(); - Object.defineProperty(A3, "__esModule", { value: !0 }); - A3.simulateTransaction = A3.getMultipleAccounts = A3.invoke = void 0; - var PCe = Le(), - kin = ohe(), - Pin = p5t(), - Oin = OCe(), - wn = x5t(); - async function Bin(t, e, r, n) { - (t = (0, Pin.translateAddress)(t)), n || (n = (0, Oin.getProvider)()); - let i = new PCe.Transaction(); - if ( - (i.add( - new PCe.TransactionInstruction({ - programId: t, - keys: e ?? [], - data: r, - }) - ), - n.sendAndConfirm === void 0) - ) - throw new Error( - "This function requires 'Provider.sendAndConfirm' to be implemented." - ); - return await n.sendAndConfirm(i, []); - } - A3.invoke = Bin; - var S5t = 99; - async function Iin(t, e, r) { - if (e.length <= S5t) return await A5t(t, e, r); - { - let n = (0, kin.chunks)(e, S5t); - return (await Promise.all(n.map((o) => A5t(t, o, r)))).flat(); - } - } - A3.getMultipleAccounts = Iin; - async function A5t(t, e, r) { - let n = r ?? t.commitment; - return (await t.getMultipleAccountsInfo(e, n)).map((o, a) => - o === null ? null : { publicKey: e[a], account: o } - ); - } - async function Cin(t, e, r, n, i) { - r && r.length > 0 && e.sign(...r); - let o = e._compile(), - a = o.serialize(), - c = e._serialize(a).toString("base64"), - u = { encoding: "base64", commitment: n ?? t.commitment }; - if (i) { - let k = (Array.isArray(i) ? i : o.nonProgramIds()).map((O) => - O.toBase58() - ); - u.accounts = { encoding: "base64", addresses: k }; - } - r && (u.sigVerify = !0); - let h = [c, u], - w = await t._rpcRequest("simulateTransaction", h), - M = (0, wn.create)(w, Fin); - if ("error" in M) { - let k; - if ( - "data" in M.error && - ((k = M.error.data.logs), k && Array.isArray(k)) - ) { - let O = ` - `, - D = O + k.join(O); - console.error(M.error.message, D); - } - throw new PCe.SendTransactionError( - "failed to simulate transaction: " + M.error.message, - k - ); - } - return M.result; - } - A3.simulateTransaction = Cin; - function Rin(t) { - return (0, wn.coerce)(E5t(t), Nin, (e) => - "error" in e ? e : { ...e, result: (0, wn.create)(e.result, t) } - ); - } - var Nin = E5t((0, wn.unknown)()); - function E5t(t) { - return (0, wn.union)([ - (0, wn.type)({ - jsonrpc: (0, wn.literal)("2.0"), - id: (0, wn.string)(), - result: t, - }), - (0, wn.type)({ - jsonrpc: (0, wn.literal)("2.0"), - id: (0, wn.string)(), - error: (0, wn.type)({ - code: (0, wn.unknown)(), - message: (0, wn.string)(), - data: (0, wn.optional)((0, wn.any)()), - }), - }), - ]); - } - function Din(t) { - return Rin( - (0, wn.type)({ - context: (0, wn.type)({ slot: (0, wn.number)() }), - value: t, - }) - ); - } - var Fin = Din( - (0, wn.type)({ - err: (0, wn.nullable)( - (0, wn.union)([(0, wn.type)({}), (0, wn.string)()]) - ), - logs: (0, wn.nullable)((0, wn.array)((0, wn.string)())), - accounts: (0, wn.optional)( - (0, wn.nullable)( - (0, wn.array)( - (0, wn.nullable)( - (0, wn.type)({ - executable: (0, wn.boolean)(), - owner: (0, wn.string)(), - lamports: (0, wn.number)(), - data: (0, wn.array)((0, wn.string)()), - rentEpoch: (0, wn.optional)((0, wn.number)()), - }) - ) - ) - ) - ), - unitsConsumed: (0, wn.optional)((0, wn.number)()), - }) - ); - }); - var CCe = I((zqn, O5t) => { - m(); - g(); - var ps = (O5t.exports = {}), - e_, - t_; - function BCe() { - throw new Error("setTimeout has not been defined"); - } - function ICe() { - throw new Error("clearTimeout has not been defined"); - } - (function () { - try { - typeof setTimeout == "function" ? (e_ = setTimeout) : (e_ = BCe); - } catch { - e_ = BCe; - } - try { - typeof clearTimeout == "function" ? (t_ = clearTimeout) : (t_ = ICe); - } catch { - t_ = ICe; - } - })(); - function T5t(t) { - if (e_ === setTimeout) return setTimeout(t, 0); - if ((e_ === BCe || !e_) && setTimeout) - return (e_ = setTimeout), setTimeout(t, 0); - try { - return e_(t, 0); - } catch { - try { - return e_.call(null, t, 0); - } catch { - return e_.call(this, t, 0); - } - } - } - function Lin(t) { - if (t_ === clearTimeout) return clearTimeout(t); - if ((t_ === ICe || !t_) && clearTimeout) - return (t_ = clearTimeout), clearTimeout(t); - try { - return t_(t); - } catch { - try { - return t_.call(null, t); - } catch { - return t_.call(this, t); - } - } - } - var fS = [], - XD = !1, - VB, - uhe = -1; - function qin() { - !XD || - !VB || - ((XD = !1), - VB.length ? (fS = VB.concat(fS)) : (uhe = -1), - fS.length && k5t()); - } - function k5t() { - if (!XD) { - var t = T5t(qin); - XD = !0; - for (var e = fS.length; e; ) { - for (VB = fS, fS = []; ++uhe < e; ) VB && VB[uhe].run(); - (uhe = -1), (e = fS.length); - } - (VB = null), (XD = !1), Lin(t); - } - } - ps.nextTick = function (t) { - var e = new Array(arguments.length - 1); - if (arguments.length > 1) - for (var r = 1; r < arguments.length; r++) e[r - 1] = arguments[r]; - fS.push(new P5t(t, e)), fS.length === 1 && !XD && T5t(k5t); - }; - function P5t(t, e) { - (this.fun = t), (this.array = e); - } - P5t.prototype.run = function () { - this.fun.apply(null, this.array); - }; - ps.title = "browser"; - ps.browser = !0; - ps.env = {}; - ps.argv = []; - ps.version = ""; - ps.versions = {}; - function dS() {} - ps.on = dS; - ps.addListener = dS; - ps.once = dS; - ps.off = dS; - ps.removeListener = dS; - ps.removeAllListeners = dS; - ps.emit = dS; - ps.prependListener = dS; - ps.prependOnceListener = dS; - ps.listeners = function (t) { - return []; - }; - ps.binding = function (t) { - throw new Error("process.binding is not supported"); - }; - ps.cwd = function () { - return "/"; - }; - ps.chdir = function (t) { - throw new Error("process.chdir is not supported"); - }; - ps.umask = function () { - return 0; - }; - }); - var I5t = I((jqn, B5t) => { - "use strict"; - m(); - g(); - var zin = null; - B5t.exports = zin; - }); - var NCe = I((RCe) => { - "use strict"; - m(); - g(); - Object.defineProperty(RCe, "__esModule", { value: !0 }); - var jin = Qr(), - Uin = Le(), - nW = class { - constructor(e) { - this.payer = e; - } - static local() { - let e = CCe(); - if (!e.env.ANCHOR_WALLET || e.env.ANCHOR_WALLET === "") - throw new Error( - "expected environment variable `ANCHOR_WALLET` is not set." - ); - let r = Uin.Keypair.fromSecretKey( - jin.Buffer.from( - JSON.parse( - I5t().readFileSync(e.env.ANCHOR_WALLET, { encoding: "utf-8" }) - ) - ) - ); - return new nW(r); - } - async signTransaction(e) { - return e.partialSign(this.payer), e; - } - async signAllTransactions(e) { - return e.map((r) => (r.partialSign(this.payer), r)); - } - get publicKey() { - return this.payer.publicKey; - } - }; - RCe.default = nW; - }); - var OCe = I((E3) => { - "use strict"; - m(); - g(); - Object.defineProperty(E3, "__esModule", { value: !0 }); - E3.getProvider = E3.setProvider = E3.AnchorProvider = void 0; - var DCe = Le(), - Kin = f5t(), - C5t = ohe(), - Hin = M5t(), - hS = class { - constructor(e, r, n) { - (this.connection = e), - (this.wallet = r), - (this.opts = n), - (this.publicKey = r.publicKey); - } - static defaultOptions() { - return { preflightCommitment: "processed", commitment: "processed" }; - } - static local(e, r) { - if (C5t.isBrowser) - throw new Error("Provider local is not available on browser."); - r = r ?? hS.defaultOptions(); - let n = new DCe.Connection( - e ?? "http://localhost:8899", - r.preflightCommitment - ), - o = NCe().default.local(); - return new hS(n, o, r); - } - static env() { - if (C5t.isBrowser) - throw new Error("Provider env is not available on browser."); - let r = CCe().env.ANCHOR_PROVIDER_URL; - if (r === void 0) - throw new Error("ANCHOR_PROVIDER_URL is not defined"); - let n = hS.defaultOptions(), - i = new DCe.Connection(r, n.commitment), - a = NCe().default.local(); - return new hS(i, a, n); - } - async sendAndConfirm(e, r, n) { - var i; - n === void 0 && (n = this.opts), - (e.feePayer = this.wallet.publicKey), - (e.recentBlockhash = ( - await this.connection.getRecentBlockhash(n.preflightCommitment) - ).blockhash), - (e = await this.wallet.signTransaction(e)), - (r ?? []).forEach((a) => { - e.partialSign(a); - }); - let o = e.serialize(); - try { - return await R5t(this.connection, o, n); - } catch (a) { - if (a instanceof che) { - let s = await this.connection.getTransaction( - Kin.bs58.encode(e.signature), - { commitment: "confirmed" } - ); - if (s) { - let c = - (i = s.meta) === null || i === void 0 - ? void 0 - : i.logMessages; - throw c ? new DCe.SendTransactionError(a.message, c) : a; - } else throw a; - } else throw a; - } - } - async sendAll(e, r) { - r === void 0 && (r = this.opts); - let n = await this.connection.getRecentBlockhash( - r.preflightCommitment - ), - i = e.map((s) => { - var c; - let u = s.tx, - h = (c = s.signers) !== null && c !== void 0 ? c : []; - return ( - (u.feePayer = this.wallet.publicKey), - (u.recentBlockhash = n.blockhash), - h.forEach((w) => { - u.partialSign(w); - }), - u - ); - }), - o = await this.wallet.signAllTransactions(i), - a = []; - for (let s = 0; s < i.length; s += 1) { - let u = o[s].serialize(); - a.push(await R5t(this.connection, u, r)); - } - return a; - } - async simulate(e, r, n, i) { - (e.feePayer = this.wallet.publicKey), - (e.recentBlockhash = ( - await this.connection.getLatestBlockhash( - n ?? this.connection.commitment - ) - ).blockhash), - (e = await this.wallet.signTransaction(e)); - let o = await (0, Hin.simulateTransaction)( - this.connection, - e, - r, - n, - i - ); - if (o.value.err) throw new FCe(o.value); - return o.value; - } - }; - E3.AnchorProvider = hS; - var FCe = class extends Error { - constructor(e, r) { - super(r), (this.simulationResponse = e); - } - }; - async function R5t(t, e, r) { - let n = r && { - skipPreflight: r.skipPreflight, - preflightCommitment: r.preflightCommitment || r.commitment, - }, - i = await t.sendRawTransaction(e, n), - o = (await t.confirmTransaction(i, r && r.commitment)).value; - if (o.err) - throw new che(`Raw transaction ${i} failed (${JSON.stringify(o)})`); - return i; - } - var che = class extends Error { - constructor(e) { - super(e); - } - }; - function Vin(t) { - LCe = t; - } - E3.setProvider = Vin; - function Win() { - return LCe === null ? hS.local() : LCe; - } - E3.getProvider = Win; - var LCe = null; - }); - var U5t = I((j5t, UCe) => { - m(); - g(); - (function () { - "use strict"; - var t = Object.assign; - typeof t != "function" && - (t = function () { - var n = arguments, - i = arguments[0]; - if (i == null) - throw new TypeError("Cannot convert undefined or null to object"); - i = Object(i); - for (var o = 1; o < n.length; o++) - if (n[o] && typeof n[o] == "object") - for (var a in n[o]) i[a] = n[o][a]; - return i; - }); - function e(n) { - var i = n + "", - o = i.indexOf("..."); - return o >= 0 && (o < i.indexOf(")") || i.indexOf("arguments") >= 0); - } - function r(n, i) { - i || (i = {}); - var o = i.vargs || e(n), - a = Object.create(null), - s = [], - c = [], - u, - h = new WeakMap(), - w = function (q, z, H) { - return setTimeout(function () { - if (H) { - z.splice(q, 1), H.splice(q, 1); - return; - } - z instanceof WeakMap ? z.delete(q) : delete z[q]; - }, i.maxAge); - }, - M = i.maxAge > 0 && i.maxAge < 1 / 0 ? w : 0, - k = i.equals - ? i.equals - : function (q, z) { - return q === z; - }, - O = i.maxArgs, - D = i.serializer, - F, - N; - return ( - n.length === 1 && !i.equals && !o - ? ((F = function (q) { - var z = typeof q; - if (!D && ((z === "object" && q) || z === "function")) { - var H; - return ( - h.get(q) || - (!M || M(q, h), h.set(q, (H = n.call(this, q))), H) - ); - } - var Z = - z === "number" || z === "boolean" || q == null - ? q - : z === "string" - ? JSON.stringify(q) - : D(q); - return a[Z] || (!M || M(Z, a), (a[Z] = n.call(this, q))); - }.bind(this)), - (N = 1)) - : (F = function () { - var q = arguments.length; - if (!q && u != null) return c[u]; - var z = O || q, - H; - for (H = s.length - 1; H >= 0; H--) - if (!(!O && s[H].length !== z)) { - for (var Z = z - 1; Z >= 0 && k(s[H][Z], arguments[Z]); Z--) - if (Z === 0) return c[H]; - } - return ( - (H = s.length - (H + 1)), - !q && u == null && (u = H), - !M || M(H, c, s), - (c[H] = n.apply(this, (s[H] = arguments))) - ); - }.bind(this)), - (F.clear = function () { - (h = new WeakMap()), - (a = Object.create(null)), - (s = []), - (c = []), - (u = void 0); - }), - (F.keys = function () { - return N ? null : s.slice(); - }), - (F.values = function () { - return N ? null : c.slice(); - }), - (F.keyValues = function () { - return N ? { primitives: t({}, a), objects: h } : null; - }), - F - ); - } - typeof UCe < "u" && (UCe.exports = r), - typeof window < "u" && (window.nanomemoize = r); - }.call(j5t)); - }); - m(); - g(); - var vhe = qe(to()); - m(); - g(); - m(); - g(); - var S9e = qe(pNe()), - A9e = qe(lI()); - m(); - g(); - m(); - g(); - m(); - g(); - var Lpe = "mobile-logs"; - m(); - g(); - m(); - g(); - m(); - g(); - m(); - g(); - m(); - g(); - var mNe = (t) => { - let e, - r = new Set(), - n = (c, u) => { - let h = typeof c == "function" ? c(e) : c; - if (h !== e) { - let w = e; - (e = u ? h : Object.assign({}, e, h)), r.forEach((M) => M(e, w)); - } - }, - i = () => e, - s = { - setState: n, - getState: i, - subscribe: (c) => (r.add(c), () => r.delete(c)), - destroy: () => r.clear(), - }; - return (e = t(n, i, s)), s; - }, - cG = (t) => (t ? mNe(t) : mNe); - var MNe = qe(to(), 1), - TNe = qe(ANe(), 1), - { useSyncExternalStoreWithSelector: T7t } = TNe.default; - function k7t(t, e = t.getState, r) { - let n = T7t(t.subscribe, t.getState, t.getServerState || t.getState, e, r); - return (0, MNe.useDebugValue)(n), n; - } - var ENe = (t) => { - let e = typeof t == "function" ? cG(t) : t, - r = (n, i) => k7t(e, n, i); - return Object.assign(r, e), r; - }, - P7t = (t) => (t ? ENe(t) : ENe), - kNe = P7t; - var zpe = cG((t) => ({ - injectJavaScript: void 0, - setInjectJavaScript: (e) => t(() => ({ injectJavaScript: e })), - })), - Kon = kNe(zpe); - m(); - g(); - var $Ne = globalThis.chrome ? !1 : !globalThis.browser; - function ZNe() { - return globalThis.clients !== void 0; - } - m(); - g(); - var XNe = "debug"; - function mG(t) { - return ( - gG === void 0 && Q7t(), - (() => { - let e = t, - r = ZNe() ? "service-worker:" : ""; - return { - debug: (n, ...i) => Z7t(`backpack:${r} ${e}: ${n}`, ...i), - error: (n, ...i) => X7t(`backpack:${r} ${e}: ${n}`, ...i), - _log: QNe, - }; - })() - ); - } - function Z7t(t, ...e) { - gG <= h_.Debug && YNe(t, ...e); - } - function X7t(t, ...e) { - gG <= h_.Error && YNe(`ERROR: ${t}`, ...e); - } - function YNe(t, ...e) { - $Ne ? Y7t(t, ...e) : QNe(t, ...e); - } - function QNe(t, ...e) { - console.log(t, ...e); - } - async function Y7t(...t) { - var e, r; - try { - ( - await self.clients.matchAll({ includeUncontrolled: !0, type: "window" }) - ).forEach((i) => { - i.postMessage({ channel: Lpe, data: t }); - }); - } catch { - (r = - (e = zpe.getState()) === null || e === void 0 - ? void 0 - : e.injectJavaScript) === null || - r === void 0 || - r.call( - e, - `navigator.serviceWorker.onmessage(${JSON.stringify({ - data: { channel: Lpe, data: t }, - })}); true;` - ); - } - } - var gG, h_; - (function (t) { - (t[(t.Trace = 0)] = "Trace"), - (t[(t.Debug = 1)] = "Debug"), - (t[(t.Info = 2)] = "Info"), - (t[(t.Warning = 3)] = "Warning"), - (t[(t.Error = 4)] = "Error"); - })(h_ || (h_ = {})); - function Q7t() { - gG = (() => { - switch (XNe) { - case "trace": - return h_.Trace; - case "debug": - return h_.Debug; - case "info": - return h_.Info; - case "warning": - return h_.Warning; - case "error": - return h_.Error; - default: - throw new Error("invalid log level"); - } - })(); - } - var e9e = mG("react-xnft/reconciler"), - Zpe = class { - constructor() { - (this._renderUpdatesTimer = 1e3), (this._timeouts = {}); - } - addRenderUpdate(e) { - this._timeouts[e] && window.clearTimeout(this._timeouts[e]), - (this._timeouts[e] = window.setTimeout(() => { - console.error(`Render fn222 not found for instance ${e}`), - delete this._timeouts[e]; - }, this._renderUpdatesTimer)); - } - isPendingRender(e) { - return !!this._timeouts[e]; - } - removeRenderUpdate(e) { - this._timeouts[e] && - (window.clearTimeout(this._timeouts[e]), delete this._timeouts[e]); - } - }, - gh = class { - constructor() { - this.clear(), (this.pendingUpdates = new Zpe()); - } - static getInstance() { - return this.instance || (this.instance = new gh()), this.instance; - } - clear() { - (this._vdomRoot = { children: [] }), - (this._vdom = new Map()), - (this._renderFns = new Map()); - } - onRender(e, r) { - if ( - (this._renderFns.set(e, r), this.pendingUpdates.isPendingRender(e)) - ) { - let n = this._vdom.get(e); - if (!n) throw new Error("element not found"); - r(n), this.pendingUpdates.removeRenderUpdate(e); - } - } - onRenderRoot(e) { - (this._renderRootFn = e), - this._needsRenderRoot && - ((this._needsRenderRoot = !1), this._renderRoot()); - } - commitUpdate(e, r) { - let n = this._vdom.get(e); - if ((e9e.debug("commitUpdate", e, r, n), !n)) - throw new Error("element not found"); - (n.props = { ...r.props }), this._render(e); - } - commitTextUpdate(e, r) { - let n = this._vdom.get(e); - (n.text = r), this._render(e); - } - appendChildToContainer(e) { - this._vdomRoot.children.push(e), this._saveToDom(e), this._renderRoot(); - } - appendChild(e, r) { - this._vdom.get(e).children.push(r), this._saveToDom(r), this._render(e); - } - insertInContainerBefore(e, r) { - let n = this._vdomRoot.children.find((a) => a.id === r); - if (!n) throw new Error("element not found"); - let i = this._vdomRoot.children.filter((a) => a.id !== e.id), - o = i.indexOf(n); - if (o === -1) throw new Error("child not found"); - (this._vdomRoot.children = i - .slice(0, o) - .concat([e]) - .concat(i.slice(o))), - this._saveToDom(e), - this._renderRoot(); - } - insertBefore(e, r, n) { - let i = this._vdom.get(e); - if (!i) throw new Error("parent not found"); - let o = i.children.find((c) => c.id === n); - if (!o) - throw ( - (e9e.error("before element not found", i, r, n), - new Error("before element not found")) - ); - let a = i.children.filter((c) => c.id !== r.id), - s = a.indexOf(o); - if (s === -1) throw new Error("child not found"); - (i.children = a.slice(0, s).concat([r]).concat(a.slice(s))), - this._saveToDom(r), - this._render(e); - } - removeChild(e, r) { - let n = this._vdom.get(e); - if (!n) throw new Error("parent not found"); - (n.children = n.children.filter((i) => i.id !== r)), - this._removeFromDom(this._vdom.get(r)), - this._render(e); - } - removeChildFromContainer(e) { - (this._vdomRoot.children = this._vdomRoot.children.filter( - (r) => r.id !== e - )), - this._removeFromDom(this._vdom.get(e)), - this._renderRoot(); - } - _renderRoot() { - if (!this._renderRootFn) throw new Error("render root fn not found"); - this._renderRootFn(this._vdomRoot.children); - } - _render(e) { - let r = this._vdom.get(e); - if (!r) throw new Error("element not found"); - let n = this._renderFns.get(e); - if (!n) { - this.pendingUpdates.addRenderUpdate(e); - return; - } - n(r); - } - _saveToDom(e) { - this._vdom.set(e.id, e), - e.children && - e.children.forEach((r) => { - this._saveToDom(r); - }); - } - _removeFromDom(e) { - this._vdom.delete(e.id), - e.children && - e.children.forEach((r) => { - this._removeFromDom(r); - }); - } - }; - window.dom || - Object.defineProperties(window, { dom: { value: gh.getInstance() } }); - m(); - g(); - var m9e = qe(OS()), - AG = qe(to()); - m(); - g(); - m(); - g(); - m(); - g(); - function vG(t) { - return t; - } - var _G = 0.8, - iNt = "#fff", - F3 = "#18181b", - oNt = F3, - p_ = "#27272a", - bG = "#3F3F46", - xG = "#FFFFFF", - DF = "#71717A", - o9e = "#D4D4D8", - a9e = "#A1A1AA", - Ype = "#FFFFFF", - aNt = xG, - sNt = "#393C43"; - var u9e = "#35A63A", - c9e = "#E95050", - l9e = "rgb(153 164 180)", - uNt = DF, - cNt = "linear-gradient(180deg, #F8F8F9 0%, #F0F0F2 100%), #FFFFFF", - NF = "#F0F0F2", - y_ = "#ffffff", - lNt = NF, - SG = "#030A19", - f9e = "#4E5768", - fNt = SG, - s9e = f9e, - Qpe = SG, - dNt = xG, - e0e = "#DFE0E6", - wG = "#F0F0F2", - hNt = u9e, - pNt = c9e, - yNt = l9e, - d9e = "#787C89", - h9e = "#DC2626", - p9e = vG({ - typography: { - fontFamily: ["Inter", "sans-serif"].join(","), - fontWeight: 500, - allVariants: { fontWeight: 500 }, - body: { fontWeight: 500 }, - p: { fontWeight: 500 }, - }, - }), - mNt = { - MuiButton: { styleOverrides: { root: { "&:hover": { opacity: _G } } } }, - MuiListItem: { styleOverrides: { root: { "&:hover": { opacity: _G } } } }, - MuiIconButton: { - styleOverrides: { root: { "&:hover": { opacity: _G } } }, - }, - MuiPaper: { styleOverrides: { root: { backgroundImage: "none" } } }, - MuiSelect: { styleOverrides: { icon: { color: DF } } }, - }, - y9e = { - ...p9e, - components: mNt, - custom: { - colors: { - brandColor: Ype, - background: F3, - backgroundBackdrop: oNt, - bg2: bG, - bg3: F3, - nav: p_, - fontColor: xG, - fontColor2: o9e, - fontColor3: a9e, - subtext: a9e, - secondary: DF, - primaryButton: Ype, - primaryButtonTextColor: p_, - secondaryButton: bG, - secondaryButtonTextColor: xG, - buttonFontColor: aNt, - border1: bG, - border: p_, - borderColor: sNt, - textInputBorderFull: "solid 2pt rgba(255, 255, 255, 0.1)", - textInputBorderFocussed: "solid 2pt rgba(255, 255, 255, 0.1)", - textInputBorderHovered: "solid 2pt rgba(255, 255, 255, 0.2)", - borderFull: `solid 2px ${p_}`, - borderButton: void 0, - textFieldTextColor: o9e, - copyTooltipColor: Ype, - copyTooltipTextColor: p_, - tableBorder: F3, - balanceSkeleton: p_, - balanceChangeNegative: "rgb(233, 80, 80, .1)", - balanceChangePositive: "rgb(53, 166, 58, .1)", - balanceChangeNeutral: "rgb(78, 87, 104, .1)", - textBackground: p_, - textPlaceholder: DF, - textBorder: p_, - swapTokensButton: F3, - icon: "#787C89", - approveTransactionTableBackground: bG, - approveTransactionCloseBackground: F3, - hoverIconBackground: `rgb(39, 39, 42, ${_G})`, - avatarIconBackground: "#DFE0E5", - text: iNt, - dangerButton: h9e, - alpha: "#8F929E", - scrollbarTrack: F3, - scrollbarThumb: l9e, - positive: u9e, - negative: c9e, - neutral: "rgb(78, 87, 104)", - negativeButtonTextColor: "#fff", - drawerGradient: `linear-gradient(180deg, ${p_} 0%, rgba(41, 44, 51, 0) 100%)`, - boxShadow: "0px 0px 4px rgba(0, 0, 0, 0.15)", - tabBarBoxShadow: "0px -4px 4px rgba(3, 10, 25, 0.02)", - coralGradient: - "linear-gradient(113.94deg, #3EECB8 15.93%, #A372FE 58.23%, #FE7D4A 98.98%)", - }, - }, - }, - gNt = { - MuiButton: { - styleOverrides: { - root: { "&:hover": { background: "#F8F8F9 !important" } }, - }, - }, - MuiListItem: { - styleOverrides: { - root: { "&:hover": { background: "#F8F8F9 !important" } }, - }, - }, - MuiIconButton: { - styleOverrides: { - root: { "&:hover": { "& svg": { color: `${d9e} !important` } } }, - }, - }, - MuiPaper: { styleOverrides: { root: { backgroundImage: "none" } } }, - MuiSelect: { styleOverrides: { icon: { color: DF } } }, - }, - Zan = { - ...p9e, - components: gNt, - custom: { - colors: { - brandColor: Qpe, - backgroundBackdrop: cNt, - background: NF, - nav: y_, - bg2: lNt, - bg3: y_, - fontColor: SG, - fontColor2: fNt, - fontColor3: s9e, - subtext: s9e, - secondary: f9e, - primaryButton: Qpe, - primaryButtonTextColor: y_, - secondaryButton: y_, - secondaryButtonTextColor: SG, - buttonFontColor: dNt, - textInputBorderFull: `solid 2px ${NF}`, - textInputBorderFocussed: `solid 2px ${NF}`, - textInputBorderHovered: `solid 2px ${e0e}`, - border: y_, - border1: wG, - borderColor: wG, - borderFull: `solid 2px ${wG}`, - borderButton: `solid 2px ${wG}`, - copyTooltipColor: Qpe, - copyTooltipTextColor: y_, - tableBorder: e0e, - balanceSkeleton: "rgba(0,0,0,0.15)", - balanceChangeNegative: "rgb(233, 80, 80, .1)", - balanceChangePositive: "rgb(53, 166, 58, .1)", - balanceChangeNeutral: "rgb(78, 87, 104, .1)", - textBackground: y_, - textBorder: e0e, - textPlaceholder: "#4E5768", - swapTokensButton: "#FFFFFF", - icon: "#8F929E", - approveTransactionTableBackground: y_, - approveTransactionCloseBackground: "#C2C4CC", - hoverIconBackground: d9e, - avatarIconBackground: "#DFE0E5", - text: uNt, - dangerButton: h9e, - alpha: "#8F929E", - scrollbarTrack: NF, - scrollbarThumb: yNt, - positive: hNt, - negative: pNt, - neutral: "rgb(78, 87, 104)", - negativeButtonTextColor: "#fff", - drawerGradient: `linear-gradient(180deg, ${y_} 0%, rgba(41, 44, 51, 0) 100%)`, - boxShadow: "0px 0px 4px rgba(0, 0, 0, 0.15)", - tabBarBoxShadow: "0px -4px 4px rgba(3, 10, 25, 0.02)", - coralGradient: - "linear-gradient(113.94deg, #3EECB8 15.93%, #A372FE 58.23%, #FE7D4A 98.98%)", - }, - }, - }; - var g9e = (0, AG.createContext)(null), - FF = []; - function v9e(t) { - return (0, m9e.jsx)(g9e.Provider, { - value: { theme: y9e }, - children: t.children, - }); - } - function vNt() { - let t = (0, AG.useContext)(g9e); - if (t === null) throw new Error("Context not available"); - return t; - } - function dI() { - let { theme: t } = vNt(); - return t; - } - m(); - g(); - var b9e = "connect", - w9e = "solana-connect", - _9e = "ethereum-connect"; - var ko = mG("react-xnft/reconciler"), - EG = new A9e.EventEmitter(), - E9e = { - events: EG, - render(t) { - window.addEventListener("load", () => { - window.xnft.on("connect", () => { - ko.debug("connect"), FF.push(t), EG.emit(b9e); - }), - window.xnft.solana.on("connect", () => { - EG.emit(w9e); - }), - window.xnft.ethereum.on("connect", () => { - EG.emit(_9e); - }), - window.xnft.on("mount", () => { - ko.debug("mount"); - let e = FF[FF.length - 1]; - bNt(e); - }), - window.xnft.on("unmount", () => { - ko.debug("unmount"); - }), - window.xnft.on("pop", () => { - ko.debug("pop"), FF.pop(); - }); - }); - }, - renderWidget(t) {}, - }; - function bNt(t) { - let e = () => {}, - r = { host: KNt, children: [] }, - n = x9e.createContainer(r, !1, !1); - x9e.updateContainer(t, n, null, e); - } - var x9e = (0, S9e.default)({ - isPrimaryRenderer: !0, - supportsMutation: !0, - supportsHydration: !1, - supportsPersistence: !1, - now: Date.now, - noTimeout: -1, - getRootHostContext: (t) => (ko.debug("getRootHostContext"), t.host), - getChildHostContext: (t, e, r) => (ko.debug("getChildHostContext"), t), - createInstance: (t, e, r, n, i) => { - switch ((ko.debug("createInstance", t, e), t)) { - case Nr.View: - return wNt(t, e, r, n, i); - case Nr.Table: - return _Nt(t, e, r, n, i); - case Nr.TableRow: - return xNt(t, e, r, n, i); - case Nr.Text: - return SNt(t, e, r, n, i); - case Nr.TextField: - return ANt(t, e, r, n, i); - case Nr.Image: - return ENt(t, e, r, n, i); - case Nr.Button: - return MNt(t, e, r, n, i); - case Nr.Loading: - return PNt(t, e, r, n, i); - case Nr.Audio: - return TNt(t, e, r, n, i); - case Nr.Video: - return kNt(t, e, r, n, i); - case Nr.ScrollBar: - return ONt(t, e, r, n, i); - case Nr.Svg: - return BNt(t, e, r, n, i); - case Nr.Path: - return INt(t, e, r, n, i); - case Nr.Circle: - return CNt(t, e, r, n, i); - case Nr.Iframe: - return RNt(t, e, r, n, i); - case Nr.NavAnimation: - return DNt(t, e, r, n, i); - case Nr.BalancesTable: - return FNt(t, e, r, n, i); - case Nr.BalancesTableHead: - return LNt(t, e, r, n, i); - case Nr.BalancesTableContent: - return qNt(t, e, r, n, i); - case Nr.BalancesTableRow: - return zNt(t, e, r, n, i); - case Nr.BalancesTableCell: - return jNt(t, e, r, n, i); - case Nr.BalancesTableFooter: - return UNt(t, e, r, n, i); - case Nr.Custom: - if (!e.component) - throw new Error("Component not found in Custom Node"); - return NNt(t, e, r, n, i); - default: - throw new Error( - `Component ${t} is not part of the ReactXnft library, please use the available set of components.` - ); - } - }, - createTextInstance: (t, e, r, n) => ( - ko.debug("createTextInstance", t), - { id: r.nextId(), kind: "raw", text: t } - ), - appendInitialChild: (t, e) => { - ko.debug("appendInitialChild", t, e), t.children.push(e); - }, - prepareUpdate: (t, e, r, n, i, o) => ( - ko.debug("prepareUpdate", t, e, r, n), { props: n } - ), - finalizeInitialChildren: (t, e, r, n, i) => ( - ko.debug("finalizeInitialChildren", t, e, r, n, i), !1 - ), - prepareForCommit: (t) => (ko.debug("prepareForCommit", t), null), - commitUpdate: (t, e, r, n, i, o) => { - ko.debug("commitUpdate", t, r, e, n, i), - !(e === null || Object.keys(e).length === 0) && - ((t.props = e.props), gh.getInstance().commitUpdate(t.id, e)); - }, - commitTextUpdate: (t, e, r) => { - ko.debug("commitTextUpdate"), - (t.text = r), - gh.getInstance().commitTextUpdate(t.id, r); - }, - appendChildToContainer: (t, e) => { - ko.debug("appendChildToContainer", t, e), - gh.getInstance().appendChildToContainer(e); - }, - appendChild: (t, e) => { - ko.debug("appendChild", t, e), gh.getInstance().appendChild(t.id, e); - }, - insertInContainerBefore: (t, e, r) => { - ko.debug("insertInContainerBefore"), - gh.getInstance().insertInContainerBefore(e, r.id); - }, - insertBefore: (t, e, r) => { - ko.debug("insertBefore"), gh.getInstance().insertBefore(t.id, e, r.id); - }, - removeChild: (t, e) => { - ko.debug("removeChild", t, e), gh.getInstance().removeChild(t.id, e.id); - }, - removeChildFromContainer: (t, e) => { - ko.debug("removeChildFromContainer", t, e), - gh.getInstance().removeChildFromContainer(e.id); - }, - getPublicInstance: (t) => (ko.debug("getPublicInstance"), t), - shouldSetTextContent: () => (ko.debug("shouldSetTextContent"), !1), - resetAfterCommit: (t) => { - ko.debug("resetAfterCommit", t); - }, - clearContainer: (t) => { - ko.debug("clearContainer", t), (t.children = []); - }, - shouldDeleteUnhydratedTailInstances: () => { - ko.debug("shouldDeleteUnhydratedTailInstances"); - }, - scheduleTimeout: (t, e) => (ko.debug("scheduleTimeout"), setTimeout(t, e)), - }); - function wNt(t, e, r, n, i) { - return { id: n.nextId(), kind: Nr.View, props: e, children: [] }; - } - function _Nt(t, e, r, n, i) { - return { id: n.nextId(), kind: Nr.Table, props: e, children: [] }; - } - function xNt(t, e, r, n, i) { - return { id: n.nextId(), kind: Nr.TableRow, props: e, children: [] }; - } - function SNt(t, e, r, n, i) { - return { id: n.nextId(), kind: Nr.Text, props: e, children: [] }; - } - function ANt(t, e, r, n, i) { - return { id: n.nextId(), kind: Nr.TextField, props: e, children: [] }; - } - function ENt(t, e, r, n, i) { - let o = n.nextId(), - a = e.src; - return { - id: o, - kind: Nr.Image, - props: { ...e, src: a, children: e.children }, - children: [], - }; - } - function MNt(t, e, r, n, i) { - return { id: n.nextId(), kind: Nr.Button, props: e, children: [] }; - } - function TNt(t, e, r, n, i) { - return { id: n.nextId(), kind: Nr.Audio, props: e, children: [] }; - } - function kNt(t, e, r, n, i) { - return { id: n.nextId(), kind: Nr.Video, props: e, children: [] }; - } - function PNt(t, e, r, n, i) { - return { id: n.nextId(), kind: Nr.Loading, props: e, children: [] }; - } - function ONt(t, e, r, n, i) { - return { id: n.nextId(), kind: Nr.ScrollBar, props: e, children: [] }; - } - function BNt(t, e, r, n, i) { - return { id: n.nextId(), kind: Nr.Svg, props: e, children: [] }; - } - function INt(t, e, r, n, i) { - return { id: n.nextId(), kind: Nr.Path, props: { ...e }, children: [] }; - } - function CNt(t, e, r, n, i) { - return { id: n.nextId(), kind: Nr.Circle, props: { ...e }, children: [] }; - } - function RNt(t, e, r, n, i) { - return { id: n.nextId(), kind: Nr.Iframe, props: { ...e }, children: [] }; - } - function NNt(t, e, r, n, i) { - return { - id: n.nextId(), - kind: Nr.Custom, - props: e, - children: [], - component: t, - }; - } - function DNt(t, e, r, n, i) { - return { id: n.nextId(), kind: Nr.NavAnimation, props: e, children: [] }; - } - function FNt(t, e, r, n, i) { - return { id: n.nextId(), kind: Nr.BalancesTable, props: e, children: [] }; - } - function LNt(t, e, r, n, i) { - return { - id: n.nextId(), - kind: Nr.BalancesTableHead, - props: e, - children: [], - }; - } - function qNt(t, e, r, n, i) { - return { - id: n.nextId(), - kind: Nr.BalancesTableContent, - props: e, - children: [], - }; - } - function zNt(t, e, r, n, i) { - return { - id: n.nextId(), - kind: Nr.BalancesTableRow, - props: e, - children: [], - }; - } - function jNt(t, e, r, n, i) { - return { - id: n.nextId(), - kind: Nr.BalancesTableCell, - props: e, - children: [], - }; - } - function UNt(t, e, r, n, i) { - return { - id: n.nextId(), - kind: Nr.BalancesTableFooter, - props: e, - children: [], - }; - } - var KNt = { - nextId: (() => { - let t = 0; - return () => t++; - })(), - }, - Nr; - (function (t) { - (t.Table = "Table"), - (t.TableRow = "TableRow"), - (t.Text = "Text"), - (t.TextField = "TextField"), - (t.Image = "Image"), - (t.View = "View"), - (t.Audio = "Audio"), - (t.Video = "Video"), - (t.Button = "Button"), - (t.Loading = "Loading"), - (t.ScrollBar = "ScrollBar"), - (t.Svg = "Svg"), - (t.Path = "Path"), - (t.Circle = "Circle"), - (t.Iframe = "Iframe"), - (t.NavAnimation = "NavAnimation"), - (t.BalancesTable = "BalancesTable"), - (t.BalancesTableHead = "BalancesTableHead"), - (t.BalancesTableContent = "BalancesTableContent"), - (t.BalancesTableRow = "BalancesTableRow"), - (t.BalancesTableCell = "BalancesTableCell"), - (t.BalancesTableFooter = "BalancesTableFooter"), - (t.Custom = "Custom"); - })(Nr || (Nr = {})); - m(); - g(); - var M9e = qe(OS()); - function T9e({ children: t }) { - return (0, M9e.jsx)(v9e, { children: t }); - } - m(); - g(); - var k9e = qe(to()), - ya = (t) => (e) => k9e.default.createElement(t, e), - vh = ya("Text"), - MG = ya("TextField"), - LF = ya("Image"), - usn = ya("Table"), - csn = ya("TableHead"), - lsn = ya("TableRow"), - fsn = ya("TableFooter"), - dr = ya("View"), - Fd = ya("Button"), - P9e = ya("Loading"), - qF = ya("ScrollBar"), - TG = ya("Svg"), - zF = ya("Path"), - dsn = ya("Circle"), - O9e = ya("NavAnimation"), - hsn = ya("Iframe"), - psn = ya("BalancesTable"), - ysn = ya("BalancesTableContent"), - msn = ya("BalancesTableHead"), - gsn = ya("BalancesTableRow"), - vsn = ya("BalancesTableCell"), - bsn = ya("BalancesTableFooter"), - wsn = ya("Custom"); - m(); - g(); - var B9e = qe(to()); - m(); - g(); - m(); - g(); - var t0e = qe(OS()), - kG = qe(to()); - var Esn = kG.default.createContext(null); - m(); - g(); - var r0e = qe(OS()); - function I9e({ fill: t = "#99A4B4" }) { - return (0, r0e.jsx)(TG, { - width: 24, - height: 24, - viewBox: "0 0 24 24", - fill: "none", - children: (0, r0e.jsx)(zF, { - d: "M18.7912 11.0051H7.62124L12.5012 6.1251C12.8912 5.7351 12.8912 5.0951 12.5012 4.7051C12.1112 4.3151 11.4812 4.3151 11.0912 4.7051L4.50124 11.2951C4.11124 11.6851 4.11124 12.3151 4.50124 12.7051L11.0912 19.2951C11.4812 19.6851 12.1112 19.6851 12.5012 19.2951C12.8912 18.9051 12.8912 18.2751 12.5012 17.8851L7.62124 13.0051H18.7912C19.3412 13.0051 19.7912 12.5551 19.7912 12.0051C19.7912 11.4551 19.3412 11.0051 18.7912 11.0051Z", - fill: t, - }), - }); - } - m(); - g(); - var _o = qe(OS()); - m(); - g(); - var C9e = qe(OS()), - km = qe(to()), - R9e = km.default.createContext(null); - function m_() { - let t = (0, km.useContext)(R9e); - if (t === null) throw new Error("Context not available"); - return t; - } - function N9e({ - initialRoute: t, - navButtonRight: e, - style: r, - titleStyle: n, - children: i, - }) { - let [o, a] = (0, km.useState)([{ navAction: "push", ...t }]), - [s, c] = (0, km.useState)(t.title), - [u, h] = (0, km.useState)(e), - [w, M] = (0, km.useState)(r), - [k, O] = (0, km.useState)({}), - [D, F] = (0, km.useState)(n), - N = (H, Z) => { - a(($) => [...$, { name: H, props: Z, navAction: "push" }]); - }, - q = () => { - a((H) => { - let Z = [...H]; - return ( - (Z = Z.slice(0, Z.length - 1)), - (Z[Z.length - 1].navAction = "pop"), - Z - ); - }); - }, - z = () => { - a([o[0]]); - }; - return (0, C9e.jsx)(R9e.Provider, { - value: { - activeRoute: o[o.length - 1], - push: N, - pop: q, - isRoot: o.length === 1, - toRoot: z, - title: s, - setTitle: c, - navButtonRight: u, - setNavButtonRight: h, - style: w, - setStyle: M, - contentStyle: k, - setContentStyle: O, - titleStyle: D, - setTitleStyle: F, - }, - children: i, - }); - } - var HNt = 56, - n0e = 38, - jF = { Navigator: VNt, Screen: GNt }; - function VNt({ - initialRoute: t, - children: e, - options: r, - style: n, - titleStyle: i, - navButtonRight: o, - }) { - let a = e && e.length !== void 0; - return (0, _o.jsx)(N9e, { - initialRoute: t, - style: n, - titleStyle: i, - navButtonRight: o, - children: (0, _o.jsx)(WNt, { - navScreens: e === void 0 ? [] : a ? e : [e], - options: r, - }), - }); - } - function WNt({ navScreens: t, options: e }) { - var r; - let { - isRoot: n, - activeRoute: i, - pop: o, - navButtonRight: a, - title: s, - style: c, - contentStyle: u, - titleStyle: h, - } = m_(), - w = n ? null : (0, _o.jsx)(ZNt, { onClick: () => o() }), - M = t.find((O) => O.props.name === i.name), - { title: k } = e({ route: i }); - return ( - s || (s = k), - (0, _o.jsx)(O9e, { - routeName: i.name, - navAction: "push", - children: (0, _o.jsx)(JNt, { - title: s, - navButtonLeft: w, - navButtonRight: a, - navbarStyle: c, - navbarTitleStyle: h, - navContentStyle: u, - children: M.props.component({ - ...((r = i.props) !== null && r !== void 0 ? r : {}), - }), - }), - }) - ); - } - function GNt({ component: t, name: e }) { - return (0, _o.jsx)(dr, { style: { display: "none" } }); - } - function JNt({ - title: t, - navButtonLeft: e, - navButtonRight: r, - children: n, - navbarStyle: i = {}, - navbarTitleStyle: o = {}, - navContentStyle: a = {}, - }) { - return (0, _o.jsxs)(dr, { - style: { display: "flex", flexDirection: "column", height: "100%" }, - children: [ - (0, _o.jsx)($Nt, { - title: t || "", - navButtonLeft: e, - navButtonRight: r, - style: i, - titleStyle: o, - }), - (0, _o.jsx)(XNt, { style: a, renderComponent: n }), - ], - }); - } - function $Nt({ - title: t, - navButtonLeft: e, - navButtonRight: r, - style: n = {}, - titleStyle: i = {}, - }) { - return (0, _o.jsx)(dr, { - style: { - display: "flex", - height: `${HNt}px`, - position: "relative", - justifyContent: "space-between", - padding: "10px 16px", - ...n, - }, - children: (0, _o.jsxs)(dr, { - style: { position: "relative", width: "100%", display: "flex" }, - children: [ - (0, _o.jsx)(D9e, { button: e }), - (0, _o.jsx)(YNt, { title: t, titleStyle: i }), - (0, _o.jsx)(D9e, { button: r, align: "right" }), - ], - }), - }); - } - function D9e({ button: t, align: e = "left" }) { - let r = { [e]: 0 }; - return (0, _o.jsx)(dr, { - style: { - position: "absolute", - height: "100%", - display: "flex", - justifyContent: "center", - flexDirection: "column", - ...r, - }, - children: t || (0, _o.jsx)(e9t, {}), - }); - } - function ZNt({ onClick: t }) { - let e = dI(); - return (0, _o.jsx)(dr, { - style: { - width: `${n0e}px`, - display: "flex", - justifyContent: "center", - flexDirection: "column", - position: "relative", - }, - children: (0, _o.jsx)(Fd, { - onClick: t, - style: { - backgroundColor: "transparent", - height: "24px", - width: "24px", - minWidth: "24px", - padding: 0, - }, - children: (0, _o.jsx)(I9e, { fill: e.custom.colors.secondary }), - }), - }); - } - function XNt({ renderComponent: t, style: e }) { - let r = { flex: 1, ...e }; - return (0, _o.jsx)(dr, { - style: r, - children: (0, _o.jsx)(qF, { children: t }), - }); - } - function YNt({ title: t, titleStyle: e }) { - return (0, _o.jsx)(dr, { - style: { - visibility: t ? void 0 : "hidden", - overflow: "hidden", - maxWidth: `calc(100% - ${n0e * 2}px)`, - margin: "0 auto", - display: "flex", - alignItems: "center", - }, - children: (0, _o.jsx)(QNt, { title: t, style: e }), - }); - } - function QNt({ title: t, style: e }) { - let r = dI(); - return (0, _o.jsx)(vh, { - style: { - fontSize: "18px", - fontWeight: 500, - color: r.custom.colors.fontColor, - overflow: "hidden", - textOverflow: "ellipsis", - whiteSpace: "nowrap", - textAlign: "center", - lineHeight: "24px", - ...e, - }, - children: t, - }); - } - function e9t() { - return (0, _o.jsx)(dr, { - style: { - width: `${n0e}px`, - display: "flex", - justifyContent: "center", - flexDirection: "column", - }, - }); - } - m(); - g(); - var t9t = qe(OS()); - m(); - g(); - var F9e = E9e; - m(); - g(); - m(); - g(); - var i0e = qe(to()); - function r9t() { - return i0e.default.createElement( - dr, - { - style: { - display: "flex", - justifyContent: "center", - alignItems: "center", - height: "100%", - }, - }, - i0e.default.createElement(P9e, null) - ); - } - var PG = r9t; - var aW = qe(to()); - m(); - g(); - var na = qe(to()), - JLe = qe(MLe()); - function XDt(t) { - let e = new Error(t); - if (e.stack === void 0) - try { - throw e; - } catch {} - return e; - } - var YDt = XDt, - Pn = YDt; - function QDt(t) { - return !!t && typeof t.then == "function"; - } - var ta = QDt; - function eFt(t, e) { - if (t != null) return t; - throw Pn(e ?? "Got unexpected null or undefined"); - } - var ra = eFt; - function fn(t, e, r) { - return ( - e in t - ? Object.defineProperty(t, e, { - value: r, - enumerable: !0, - configurable: !0, - writable: !0, - }) - : (t[e] = r), - t - ); - } - var HI = class { - getValue() { - throw Pn("BaseLoadable"); - } - toPromise() { - throw Pn("BaseLoadable"); - } - valueMaybe() { - throw Pn("BaseLoadable"); - } - valueOrThrow() { - throw Pn(`Loadable expected value, but in "${this.state}" state`); - } - promiseMaybe() { - throw Pn("BaseLoadable"); - } - promiseOrThrow() { - throw Pn(`Loadable expected promise, but in "${this.state}" state`); - } - errorMaybe() { - throw Pn("BaseLoadable"); - } - errorOrThrow() { - throw Pn(`Loadable expected error, but in "${this.state}" state`); - } - is(e) { - return e.state === this.state && e.contents === this.contents; - } - map(e) { - throw Pn("BaseLoadable"); - } - }, - dme = class extends HI { - constructor(e) { - super(), - fn(this, "state", "hasValue"), - fn(this, "contents", void 0), - (this.contents = e); - } - getValue() { - return this.contents; - } - toPromise() { - return Promise.resolve(this.contents); - } - valueMaybe() { - return this.contents; - } - valueOrThrow() { - return this.contents; - } - promiseMaybe() {} - errorMaybe() {} - map(e) { - try { - let r = e(this.contents); - return ta(r) ? Q3(r) : VI(r) ? r : JL(r); - } catch (r) { - return ta(r) ? Q3(r.next(() => this.map(e))) : t$(r); - } - } - }, - hme = class extends HI { - constructor(e) { - super(), - fn(this, "state", "hasError"), - fn(this, "contents", void 0), - (this.contents = e); - } - getValue() { - throw this.contents; - } - toPromise() { - return Promise.reject(this.contents); - } - valueMaybe() {} - promiseMaybe() {} - errorMaybe() { - return this.contents; - } - errorOrThrow() { - return this.contents; - } - map(e) { - return this; - } - }, - UJ = class extends HI { - constructor(e) { - super(), - fn(this, "state", "loading"), - fn(this, "contents", void 0), - (this.contents = e); - } - getValue() { - throw this.contents; - } - toPromise() { - return this.contents; - } - valueMaybe() {} - promiseMaybe() { - return this.contents; - } - promiseOrThrow() { - return this.contents; - } - errorMaybe() {} - map(e) { - return Q3( - this.contents - .then((r) => { - let n = e(r); - if (VI(n)) { - let i = n; - switch (i.state) { - case "hasValue": - return i.contents; - case "hasError": - throw i.contents; - case "loading": - return i.contents; - } - } - return n; - }) - .catch((r) => { - if (ta(r)) return r.then(() => this.map(e).contents); - throw r; - }) - ); - } - }; - function JL(t) { - return Object.freeze(new dme(t)); - } - function t$(t) { - return Object.freeze(new hme(t)); - } - function Q3(t) { - return Object.freeze(new UJ(t)); - } - function $Le() { - return Object.freeze(new UJ(new Promise(() => {}))); - } - function tFt(t) { - return t.every((e) => e.state === "hasValue") - ? JL(t.map((e) => e.contents)) - : t.some((e) => e.state === "hasError") - ? t$( - ra( - t.find((e) => e.state === "hasError"), - "Invalid loadable passed to loadableAll" - ).contents - ) - : Q3(Promise.all(t.map((e) => e.contents))); - } - function ZLe(t) { - let r = ( - Array.isArray(t) ? t : Object.getOwnPropertyNames(t).map((i) => t[i]) - ).map((i) => (VI(i) ? i : ta(i) ? Q3(i) : JL(i))), - n = tFt(r); - return Array.isArray(t) - ? n - : n.map((i) => - Object.getOwnPropertyNames(t).reduce( - (o, a, s) => ({ ...o, [a]: i[s] }), - {} - ) - ); - } - function VI(t) { - return t instanceof HI; - } - var rFt = { - of: (t) => (ta(t) ? Q3(t) : VI(t) ? t : JL(t)), - error: (t) => t$(t), - loading: () => $Le(), - all: ZLe, - isLoadable: VI, - }, - rM = { - loadableWithValue: JL, - loadableWithError: t$, - loadableWithPromise: Q3, - loadableLoading: $Le, - loadableAll: ZLe, - isLoadable: VI, - RecoilLoadable: rFt, - }, - nFt = rM.loadableWithValue, - iFt = rM.loadableWithError, - oFt = rM.loadableWithPromise, - aFt = rM.loadableLoading, - sFt = rM.loadableAll, - uFt = rM.isLoadable, - cFt = rM.RecoilLoadable, - $L = Object.freeze({ - __proto__: null, - loadableWithValue: nFt, - loadableWithError: iFt, - loadableWithPromise: oFt, - loadableLoading: aFt, - loadableAll: sFt, - isLoadable: uFt, - RecoilLoadable: cFt, - }), - r$ = new Map() - .set("recoil_hamt_2020", !0) - .set("recoil_sync_external_store", !0) - .set("recoil_suppress_rerender_in_callback", !0) - .set("recoil_memory_managament_2020", !0); - function n$(t) { - var e; - return (e = r$.get(t)) !== null && e !== void 0 ? e : !1; - } - n$.setPass = (t) => { - r$.set(t, !0); - }; - n$.setFail = (t) => { - r$.set(t, !1); - }; - n$.clear = () => { - r$.clear(); - }; - var xo = n$, - ime, - ome, - ame, - lFt = - (ime = na.default.createMutableSource) !== null && ime !== void 0 - ? ime - : na.default.unstable_createMutableSource, - XLe = - (ome = na.default.useMutableSource) !== null && ome !== void 0 - ? ome - : na.default.unstable_useMutableSource, - YLe = - (ame = na.default.useSyncExternalStore) !== null && ame !== void 0 - ? ame - : na.default.unstable_useSyncExternalStore; - function fFt() { - return xo("recoil_transition_support") - ? { mode: "TRANSITION_SUPPORT", early: !0, concurrent: !0 } - : xo("recoil_sync_external_store") && YLe != null - ? { mode: "SYNC_EXTERNAL_STORE", early: !0, concurrent: !1 } - : xo("recoil_mutable_source") && - XLe != null && - typeof window < "u" && - !window.$disableRecoilValueMutableSource_TEMP_HACK_DO_NOT_USE - ? xo("recoil_suppress_rerender_in_callback") - ? { mode: "MUTABLE_SOURCE", early: !0, concurrent: !0 } - : { mode: "MUTABLE_SOURCE", early: !1, concurrent: !1 } - : xo("recoil_suppress_rerender_in_callback") - ? { mode: "LEGACY", early: !0, concurrent: !1 } - : { mode: "LEGACY", early: !1, concurrent: !1 }; - } - function dFt() { - return !1; - } - var ZI = { - createMutableSource: lFt, - useMutableSource: XLe, - useSyncExternalStore: YLe, - reactMode: fFt, - isFastRefreshEnabled: dFt, - }, - VL = class { - constructor(e) { - fn(this, "key", void 0), (this.key = e); - } - toJSON() { - return { key: this.key }; - } - }, - KJ = class extends VL {}, - HJ = class extends VL {}; - function hFt(t) { - return t instanceof KJ || t instanceof HJ; - } - var i$ = { - AbstractRecoilValue: VL, - RecoilState: KJ, - RecoilValueReadOnly: HJ, - isRecoilValue: hFt, - }, - pFt = i$.AbstractRecoilValue, - yFt = i$.RecoilState, - mFt = i$.RecoilValueReadOnly, - gFt = i$.isRecoilValue, - eM = Object.freeze({ - __proto__: null, - AbstractRecoilValue: pFt, - RecoilState: yFt, - RecoilValueReadOnly: mFt, - isRecoilValue: gFt, - }); - function vFt(t, ...e) {} - var bFt = vFt, - Tme = bFt; - function wFt(t, e) { - return (function* () { - let r = 0; - for (let n of t) yield e(n, r++); - })(); - } - var o$ = wFt; - function _Ft(t, e, { error: r } = {}) { - return null; - } - var xFt = _Ft, - Ah = xFt, - { isFastRefreshEnabled: aun } = ZI, - VJ = class {}, - SFt = new VJ(), - tM = new Map(), - kme = new Map(); - function AFt(t) { - return o$(t, (e) => ra(kme.get(e))); - } - function EFt(t) { - if (tM.has(t.key)) { - let r = `Duplicate atom key "${t.key}". This is a FATAL ERROR in - production. But it is safe to ignore this warning if it occurred because of - hot module replacement.`; - console.warn(r); - } - tM.set(t.key, t); - let e = - t.set == null - ? new eM.RecoilValueReadOnly(t.key) - : new eM.RecoilState(t.key); - return kme.set(t.key, e), e; - } - var WJ = class extends Error {}; - function MFt(t) { - let e = tM.get(t); - if (e == null) throw new WJ(`Missing definition for RecoilValue: "${t}""`); - return e; - } - function TFt(t) { - return tM.get(t); - } - var GJ = new Map(); - function kFt(t) { - var e; - if (!xo("recoil_memory_managament_2020")) return; - let r = tM.get(t); - if ( - r != null && - (e = r.shouldDeleteConfigOnRelease) !== null && - e !== void 0 && - e.call(r) - ) { - var n; - tM.delete(t), (n = QLe(t)) === null || n === void 0 || n(), GJ.delete(t); - } - } - function PFt(t, e) { - !xo("recoil_memory_managament_2020") || - (e === void 0 ? GJ.delete(t) : GJ.set(t, e)); - } - function QLe(t) { - return GJ.get(t); - } - var Eh = { - nodes: tM, - recoilValues: kme, - registerNode: EFt, - getNode: MFt, - getNodeMaybe: TFt, - deleteNodeConfigIfPossible: kFt, - setConfigDeletionHandler: PFt, - getConfigDeletionHandler: QLe, - recoilValuesForKeys: AFt, - NodeMissingError: WJ, - DefaultValue: VJ, - DEFAULT_VALUE: SFt, - }; - function OFt(t, e) { - e(); - } - var BFt = { enqueueExecution: OFt }; - function IFt(t, e) { - return (e = { exports: {} }), t(e, e.exports), e.exports; - } - var CFt = IFt(function (t) { - var e = - typeof Symbol == "function" && typeof Symbol.iterator == "symbol" - ? function (pe) { - return typeof pe; - } - : function (pe) { - return pe && - typeof Symbol == "function" && - pe.constructor === Symbol && - pe !== Symbol.prototype - ? "symbol" - : typeof pe; - }, - r = {}, - n = 5, - i = Math.pow(2, n), - o = i - 1, - a = i / 2, - s = i / 4, - c = {}, - u = function (Re) { - return function () { - return Re; - }; - }, - h = (r.hash = function (pe) { - var Re = typeof pe > "u" ? "undefined" : e(pe); - if (Re === "number") return pe; - Re !== "string" && (pe += ""); - for (var Se = 0, Pe = 0, At = pe.length; Pe < At; ++Pe) { - var Ie = pe.charCodeAt(Pe); - Se = ((Se << 5) - Se + Ie) | 0; - } - return Se; - }), - w = function (Re) { - return ( - (Re -= (Re >> 1) & 1431655765), - (Re = (Re & 858993459) + ((Re >> 2) & 858993459)), - (Re = (Re + (Re >> 4)) & 252645135), - (Re += Re >> 8), - (Re += Re >> 16), - Re & 127 - ); - }, - M = function (Re, Se) { - return (Se >>> Re) & o; - }, - k = function (Re) { - return 1 << Re; - }, - O = function (Re, Se) { - return w(Re & (Se - 1)); - }, - D = function (Re, Se, Pe, At) { - var Ie = At; - if (!Re) { - var je = At.length; - Ie = new Array(je); - for (var qt = 0; qt < je; ++qt) Ie[qt] = At[qt]; - } - return (Ie[Se] = Pe), Ie; - }, - F = function (Re, Se, Pe) { - var At = Pe.length - 1, - Ie = 0, - je = 0, - qt = Pe; - if (Re) Ie = je = Se; - else for (qt = new Array(At); Ie < Se; ) qt[je++] = Pe[Ie++]; - for (++Ie; Ie <= At; ) qt[je++] = Pe[Ie++]; - return Re && (qt.length = At), qt; - }, - N = function (Re, Se, Pe, At) { - var Ie = At.length; - if (Re) { - for (var je = Ie; je >= Se; ) At[je--] = At[je]; - return (At[Se] = Pe), At; - } - for (var qt = 0, Fe = 0, He = new Array(Ie + 1); qt < Se; ) - He[Fe++] = At[qt++]; - for (He[Se] = Pe; qt < Ie; ) He[++Fe] = At[qt++]; - return He; - }, - q = 1, - z = 2, - H = 3, - Z = 4, - $ = { __hamt_isEmpty: !0 }, - ue = function (Re) { - return Re === $ || (Re && Re.__hamt_isEmpty); - }, - te = function (Re, Se, Pe, At) { - return { - type: q, - edit: Re, - hash: Se, - key: Pe, - value: At, - _modify: b, - }; - }, - ne = function (Re, Se, Pe) { - return { type: z, edit: Re, hash: Se, children: Pe, _modify: f }; - }, - A = function (Re, Se, Pe) { - return { type: H, edit: Re, mask: Se, children: Pe, _modify: x }; - }, - l = function (Re, Se, Pe) { - return { type: Z, edit: Re, size: Se, children: Pe, _modify: C }; - }, - p = function (Re) { - return Re === $ || Re.type === q || Re.type === z; - }, - y = function (Re, Se, Pe, At, Ie) { - for (var je = [], qt = At, Fe = 0, He = 0; qt; ++He) - qt & 1 && (je[He] = Ie[Fe++]), (qt >>>= 1); - return (je[Se] = Pe), l(Re, Fe + 1, je); - }, - d = function (Re, Se, Pe, At) { - for ( - var Ie = new Array(Se - 1), je = 0, qt = 0, Fe = 0, He = At.length; - Fe < He; - ++Fe - ) - if (Fe !== Pe) { - var lr = At[Fe]; - lr && !ue(lr) && ((Ie[je++] = lr), (qt |= 1 << Fe)); - } - return A(Re, qt, Ie); - }, - v = function pe(Re, Se, Pe, At, Ie, je) { - if (Pe === Ie) return ne(Re, Pe, [je, At]); - var qt = M(Se, Pe), - Fe = M(Se, Ie); - return A( - Re, - k(qt) | k(Fe), - qt === Fe - ? [pe(Re, Se + n, Pe, At, Ie, je)] - : qt < Fe - ? [At, je] - : [je, At] - ); - }, - _ = function (Re, Se, Pe, At, Ie, je, qt, Fe) { - for (var He = Ie.length, lr = 0; lr < He; ++lr) { - var Xe = Ie[lr]; - if (Pe(qt, Xe.key)) { - var Ze = Xe.value, - Ir = je(Ze); - return Ir === Ze - ? Ie - : Ir === c - ? (--Fe.value, F(Re, lr, Ie)) - : D(Re, lr, te(Se, At, qt, Ir), Ie); - } - } - var $e = je(); - return $e === c - ? Ie - : (++Fe.value, D(Re, He, te(Se, At, qt, $e), Ie)); - }, - S = function (Re, Se) { - return Re === Se.edit; - }, - b = function (Re, Se, Pe, At, Ie, je, qt) { - if (Se(je, this.key)) { - var Fe = At(this.value); - return Fe === this.value - ? this - : Fe === c - ? (--qt.value, $) - : S(Re, this) - ? ((this.value = Fe), this) - : te(Re, Ie, je, Fe); - } - var He = At(); - return He === c - ? this - : (++qt.value, v(Re, Pe, this.hash, this, Ie, te(Re, Ie, je, He))); - }, - f = function (Re, Se, Pe, At, Ie, je, qt) { - if (Ie === this.hash) { - var Fe = S(Re, this), - He = _(Fe, Re, Se, this.hash, this.children, At, je, qt); - return He === this.children - ? this - : He.length > 1 - ? ne(Re, this.hash, He) - : He[0]; - } - var lr = At(); - return lr === c - ? this - : (++qt.value, v(Re, Pe, this.hash, this, Ie, te(Re, Ie, je, lr))); - }, - x = function (Re, Se, Pe, At, Ie, je, qt) { - var Fe = this.mask, - He = this.children, - lr = M(Pe, Ie), - Xe = k(lr), - Ze = O(Fe, Xe), - Ir = Fe & Xe, - $e = Ir ? He[Ze] : $, - tt = $e._modify(Re, Se, Pe + n, At, Ie, je, qt); - if ($e === tt) return this; - var oe = S(Re, this), - ie = Fe, - re = void 0; - if (Ir && ue(tt)) { - if (((ie &= ~Xe), !ie)) return $; - if (He.length <= 2 && p(He[Ze ^ 1])) return He[Ze ^ 1]; - re = F(oe, Ze, He); - } else if (!Ir && !ue(tt)) { - if (He.length >= a) return y(Re, lr, tt, Fe, He); - (ie |= Xe), (re = N(oe, Ze, tt, He)); - } else re = D(oe, Ze, tt, He); - return oe - ? ((this.mask = ie), (this.children = re), this) - : A(Re, ie, re); - }, - C = function (Re, Se, Pe, At, Ie, je, qt) { - var Fe = this.size, - He = this.children, - lr = M(Pe, Ie), - Xe = He[lr], - Ze = (Xe || $)._modify(Re, Se, Pe + n, At, Ie, je, qt); - if (Xe === Ze) return this; - var Ir = S(Re, this), - $e = void 0; - if (ue(Xe) && !ue(Ze)) ++Fe, ($e = D(Ir, lr, Ze, He)); - else if (!ue(Xe) && ue(Ze)) { - if ((--Fe, Fe <= s)) return d(Re, Fe, lr, He); - $e = D(Ir, lr, $, He); - } else $e = D(Ir, lr, Ze, He); - return Ir - ? ((this.size = Fe), (this.children = $e), this) - : l(Re, Fe, $e); - }; - $._modify = function (pe, Re, Se, Pe, At, Ie, je) { - var qt = Pe(); - return qt === c ? $ : (++je.value, te(pe, At, Ie, qt)); - }; - function E(pe, Re, Se, Pe, At) { - (this._editable = pe), - (this._edit = Re), - (this._config = Se), - (this._root = Pe), - (this._size = At); - } - E.prototype.setTree = function (pe, Re) { - return this._editable - ? ((this._root = pe), (this._size = Re), this) - : pe === this._root - ? this - : new E(this._editable, this._edit, this._config, pe, Re); - }; - var B = (r.tryGetHash = function (pe, Re, Se, Pe) { - for (var At = Pe._root, Ie = 0, je = Pe._config.keyEq; ; ) - switch (At.type) { - case q: - return je(Se, At.key) ? At.value : pe; - case z: { - if (Re === At.hash) - for ( - var qt = At.children, Fe = 0, He = qt.length; - Fe < He; - ++Fe - ) { - var lr = qt[Fe]; - if (je(Se, lr.key)) return lr.value; - } - return pe; - } - case H: { - var Xe = M(Ie, Re), - Ze = k(Xe); - if (At.mask & Ze) { - (At = At.children[O(At.mask, Ze)]), (Ie += n); - break; - } - return pe; - } - case Z: { - if (((At = At.children[M(Ie, Re)]), At)) { - Ie += n; - break; - } - return pe; - } - default: - return pe; - } - }); - E.prototype.tryGetHash = function (pe, Re, Se) { - return B(pe, Re, Se, this); - }; - var G = (r.tryGet = function (pe, Re, Se) { - return B(pe, Se._config.hash(Re), Re, Se); - }); - E.prototype.tryGet = function (pe, Re) { - return G(pe, Re, this); - }; - var L = (r.getHash = function (pe, Re, Se) { - return B(void 0, pe, Re, Se); - }); - E.prototype.getHash = function (pe, Re) { - return L(pe, Re, this); - }; - var ee = (r.get = function (pe, Re) { - return B(void 0, Re._config.hash(pe), pe, Re); - }); - E.prototype.get = function (pe, Re) { - return G(Re, pe, this); - }; - var ge = (r.has = function (pe, Re, Se) { - return B(c, pe, Re, Se) !== c; - }); - E.prototype.hasHash = function (pe, Re) { - return ge(pe, Re, this); - }; - var fe = (r.has = function (pe, Re) { - return ge(Re._config.hash(pe), pe, Re); - }); - E.prototype.has = function (pe) { - return fe(pe, this); - }; - var V = function (Re, Se) { - return Re === Se; - }; - (r.make = function (pe) { - return new E( - 0, - 0, - { keyEq: (pe && pe.keyEq) || V, hash: (pe && pe.hash) || h }, - $, - 0 - ); - }), - (r.empty = r.make()); - var ye = (r.isEmpty = function (pe) { - return pe && !!ue(pe._root); - }); - E.prototype.isEmpty = function () { - return ye(this); - }; - var ae = (r.modifyHash = function (pe, Re, Se, Pe) { - var At = { value: Pe._size }, - Ie = Pe._root._modify( - Pe._editable ? Pe._edit : NaN, - Pe._config.keyEq, - 0, - pe, - Re, - Se, - At - ); - return Pe.setTree(Ie, At.value); - }); - E.prototype.modifyHash = function (pe, Re, Se) { - return ae(Se, pe, Re, this); - }; - var le = (r.modify = function (pe, Re, Se) { - return ae(pe, Se._config.hash(Re), Re, Se); - }); - E.prototype.modify = function (pe, Re) { - return le(Re, pe, this); - }; - var Me = (r.setHash = function (pe, Re, Se, Pe) { - return ae(u(Se), pe, Re, Pe); - }); - E.prototype.setHash = function (pe, Re, Se) { - return Me(pe, Re, Se, this); - }; - var de = (r.set = function (pe, Re, Se) { - return Me(Se._config.hash(pe), pe, Re, Se); - }); - E.prototype.set = function (pe, Re) { - return de(pe, Re, this); - }; - var ve = u(c), - De = (r.removeHash = function (pe, Re, Se) { - return ae(ve, pe, Re, Se); - }); - E.prototype.removeHash = E.prototype.deleteHash = function (pe, Re) { - return De(pe, Re, this); - }; - var me = (r.remove = function (pe, Re) { - return De(Re._config.hash(pe), pe, Re); - }); - E.prototype.remove = E.prototype.delete = function (pe) { - return me(pe, this); - }; - var _e = (r.beginMutation = function (pe) { - return new E( - pe._editable + 1, - pe._edit + 1, - pe._config, - pe._root, - pe._size - ); - }); - E.prototype.beginMutation = function () { - return _e(this); - }; - var Ye = (r.endMutation = function (pe) { - return (pe._editable = pe._editable && pe._editable - 1), pe; - }); - E.prototype.endMutation = function () { - return Ye(this); - }; - var Ee = (r.mutate = function (pe, Re) { - var Se = _e(Re); - return pe(Se), Ye(Se); - }); - E.prototype.mutate = function (pe) { - return Ee(pe, this); - }; - var Be = function (Re) { - return Re && kt(Re[0], Re[1], Re[2], Re[3], Re[4]); - }, - kt = function (Re, Se, Pe, At, Ie) { - for (; Pe < Re; ) { - var je = Se[Pe++]; - if (je && !ue(je)) return Ve(je, At, [Re, Se, Pe, At, Ie]); - } - return Be(Ie); - }, - Ve = function (Re, Se, Pe) { - switch (Re.type) { - case q: - return { value: Se(Re), rest: Pe }; - case z: - case Z: - case H: - var At = Re.children; - return kt(At.length, At, 0, Se, Pe); - default: - return Be(Pe); - } - }, - We = { done: !0 }; - function er(pe) { - this.v = pe; - } - (er.prototype.next = function () { - if (!this.v) return We; - var pe = this.v; - return (this.v = Be(pe.rest)), pe; - }), - (er.prototype[Symbol.iterator] = function () { - return this; - }); - var Ue = function (Re, Se) { - return new er(Ve(Re._root, Se)); - }, - Y = function (Re) { - return [Re.key, Re.value]; - }, - W = (r.entries = function (pe) { - return Ue(pe, Y); - }); - E.prototype.entries = E.prototype[Symbol.iterator] = function () { - return W(this); - }; - var j = function (Re) { - return Re.key; - }, - ce = (r.keys = function (pe) { - return Ue(pe, j); - }); - E.prototype.keys = function () { - return ce(this); - }; - var ze = function (Re) { - return Re.value; - }, - we = - (r.values = - E.prototype.values = - function (pe) { - return Ue(pe, ze); - }); - E.prototype.values = function () { - return we(this); - }; - var xe = (r.fold = function (pe, Re, Se) { - var Pe = Se._root; - if (Pe.type === q) return pe(Re, Pe.value, Pe.key); - for (var At = [Pe.children], Ie = void 0; (Ie = At.pop()); ) - for (var je = 0, qt = Ie.length; je < qt; ) { - var Fe = Ie[je++]; - Fe && - Fe.type && - (Fe.type === q - ? (Re = pe(Re, Fe.value, Fe.key)) - : At.push(Fe.children)); - } - return Re; - }); - E.prototype.fold = function (pe, Re) { - return xe(pe, Re, this); - }; - var Ft = (r.forEach = function (pe, Re) { - return xe( - function (Se, Pe, At) { - return pe(Pe, At, Re); - }, - null, - Re - ); - }); - E.prototype.forEach = function (pe) { - return Ft(pe, this); - }; - var Ke = (r.count = function (pe) { - return pe._size; - }); - (E.prototype.count = function () { - return Ke(this); - }), - Object.defineProperty(E.prototype, "size", { get: E.prototype.count }), - t.exports ? (t.exports = r) : ((void 0).hamt = r); - }), - pme = class { - constructor(e) { - fn(this, "_map", void 0), (this._map = new Map(e?.entries())); - } - keys() { - return this._map.keys(); - } - entries() { - return this._map.entries(); - } - get(e) { - return this._map.get(e); - } - has(e) { - return this._map.has(e); - } - set(e, r) { - return this._map.set(e, r), this; - } - delete(e) { - return this._map.delete(e), this; - } - clone() { - return Pme(this); - } - toMap() { - return new Map(this._map); - } - }, - WL = class { - constructor(e) { - if ((fn(this, "_hamt", CFt.empty.beginMutation()), e instanceof WL)) { - let r = e._hamt.endMutation(); - (e._hamt = r.beginMutation()), (this._hamt = r.beginMutation()); - } else if (e) for (let [r, n] of e.entries()) this._hamt.set(r, n); - } - keys() { - return this._hamt.keys(); - } - entries() { - return this._hamt.entries(); - } - get(e) { - return this._hamt.get(e); - } - has(e) { - return this._hamt.has(e); - } - set(e, r) { - return this._hamt.set(e, r), this; - } - delete(e) { - return this._hamt.delete(e), this; - } - clone() { - return Pme(this); - } - toMap() { - return new Map(this._hamt); - } - }; - function Pme(t) { - return xo("recoil_hamt_2020") ? new WL(t) : new pme(t); - } - var RFt = { persistentMap: Pme }, - NFt = RFt.persistentMap, - DFt = Object.freeze({ __proto__: null, persistentMap: NFt }); - function FFt(t, ...e) { - let r = new Set(); - e: for (let n of t) { - for (let i of e) if (i.has(n)) continue e; - r.add(n); - } - return r; - } - var UL = FFt; - function LFt(t, e) { - let r = new Map(); - return ( - t.forEach((n, i) => { - r.set(i, e(n, i)); - }), - r - ); - } - var JJ = LFt; - function qFt() { - return { nodeDeps: new Map(), nodeToNodeSubscriptions: new Map() }; - } - function zFt(t) { - return { - nodeDeps: JJ(t.nodeDeps, (e) => new Set(e)), - nodeToNodeSubscriptions: JJ(t.nodeToNodeSubscriptions, (e) => new Set(e)), - }; - } - function sme(t, e, r, n) { - let { nodeDeps: i, nodeToNodeSubscriptions: o } = r, - a = i.get(t); - if (a && n && a !== n.nodeDeps.get(t)) return; - i.set(t, e); - let s = a == null ? e : UL(e, a); - for (let c of s) o.has(c) || o.set(c, new Set()), ra(o.get(c)).add(t); - if (a) { - let c = UL(a, e); - for (let u of c) { - if (!o.has(u)) return; - let h = ra(o.get(u)); - h.delete(t), h.size === 0 && o.delete(u); - } - } - } - function jFt(t, e, r, n) { - var i, o, a, s; - let c = r.getState(); - n === c.currentTree.version || - n === ((i = c.nextTree) === null || i === void 0 ? void 0 : i.version) || - n === - ((o = c.previousTree) === null || o === void 0 ? void 0 : o.version) || - Ah("Tried to save dependencies to a discarded tree"); - let u = r.getGraph(n); - if ( - (sme(t, e, u), - n === - ((a = c.previousTree) === null || a === void 0 ? void 0 : a.version)) - ) { - let w = r.getGraph(c.currentTree.version); - sme(t, e, w, u); - } - if ( - n === - ((s = c.previousTree) === null || s === void 0 ? void 0 : s.version) || - n === c.currentTree.version - ) { - var h; - let w = (h = c.nextTree) === null || h === void 0 ? void 0 : h.version; - if (w !== void 0) { - let M = r.getGraph(w); - sme(t, e, M, u); - } - } - } - var ZL = { cloneGraph: zFt, graph: qFt, saveDepsToStore: jFt }, - UFt = 0, - KFt = () => UFt++, - HFt = 0, - VFt = () => HFt++, - WFt = 0, - GFt = () => WFt++, - a$ = { - getNextTreeStateVersion: KFt, - getNextStoreID: VFt, - getNextComponentID: GFt, - }, - { persistentMap: TLe } = DFt, - { graph: JFt } = ZL, - { getNextTreeStateVersion: eqe } = a$; - function tqe() { - let t = eqe(); - return { - version: t, - stateID: t, - transactionMetadata: {}, - dirtyAtoms: new Set(), - atomValues: TLe(), - nonvalidatedAtoms: TLe(), - }; - } - function $Ft() { - let t = tqe(); - return { - currentTree: t, - nextTree: null, - previousTree: null, - commitDepth: 0, - knownAtoms: new Set(), - knownSelectors: new Set(), - transactionSubscriptions: new Map(), - nodeTransactionSubscriptions: new Map(), - nodeToComponentSubscriptions: new Map(), - queuedComponentCallbacks_DEPRECATED: [], - suspendedComponentResolvers: new Set(), - graphsByVersion: new Map().set(t.version, JFt()), - retention: { - referenceCounts: new Map(), - nodesRetainedByZone: new Map(), - retainablesToCheckForRelease: new Set(), - }, - nodeCleanupFunctions: new Map(), - }; - } - var rqe = { - makeEmptyTreeState: tqe, - makeEmptyStoreState: $Ft, - getNextTreeStateVersion: eqe, - }, - $J = class {}; - function ZFt() { - return new $J(); - } - var s$ = { RetentionZone: $J, retentionZone: ZFt }; - function XFt(t, e) { - let r = new Set(t); - return r.add(e), r; - } - function YFt(t, e) { - let r = new Set(t); - return r.delete(e), r; - } - function QFt(t, e, r) { - let n = new Map(t); - return n.set(e, r), n; - } - function eLt(t, e, r) { - let n = new Map(t); - return n.set(e, r(n.get(e))), n; - } - function tLt(t, e) { - let r = new Map(t); - return r.delete(e), r; - } - function rLt(t, e) { - let r = new Map(t); - return e.forEach((n) => r.delete(n)), r; - } - var nqe = { - setByAddingToSet: XFt, - setByDeletingFromSet: YFt, - mapBySettingInMap: QFt, - mapByUpdatingInMap: eLt, - mapByDeletingFromMap: tLt, - mapByDeletingMultipleFromMap: rLt, - }; - function* nLt(t, e) { - let r = 0; - for (let n of t) e(n, r++) && (yield n); - } - var Ome = nLt; - function iLt(t, e) { - return new Proxy(t, { - get: (n, i) => (!(i in n) && i in e && (n[i] = e[i]()), n[i]), - ownKeys: (n) => Object.keys(n), - }); - } - var iqe = iLt, - { getNode: XL, getNodeMaybe: oLt, recoilValuesForKeys: kLe } = Eh, - { RetentionZone: PLe } = s$, - { setByAddingToSet: aLt } = nqe, - sLt = Object.freeze(new Set()), - yme = class extends Error {}; - function uLt(t, e, r) { - if (!xo("recoil_memory_managament_2020")) return () => {}; - let { nodesRetainedByZone: n } = t.getState().retention; - function i(o) { - let a = n.get(o); - a || n.set(o, (a = new Set())), a.add(e); - } - if (r instanceof PLe) i(r); - else if (Array.isArray(r)) for (let o of r) i(o); - return () => { - if (!xo("recoil_memory_managament_2020")) return; - let { retention: o } = t.getState(); - function a(s) { - let c = o.nodesRetainedByZone.get(s); - c?.delete(e), c && c.size === 0 && o.nodesRetainedByZone.delete(s); - } - if (r instanceof PLe) a(r); - else if (Array.isArray(r)) for (let s of r) a(s); - }; - } - function Bme(t, e, r, n) { - let i = t.getState(); - if (i.nodeCleanupFunctions.has(r)) return; - let o = XL(r), - a = uLt(t, r, o.retainedBy), - s = o.init(t, e, n); - i.nodeCleanupFunctions.set(r, () => { - s(), a(); - }); - } - function cLt(t, e, r) { - Bme(t, t.getState().currentTree, e, r); - } - function lLt(t, e) { - var r; - let n = t.getState(); - (r = n.nodeCleanupFunctions.get(e)) === null || r === void 0 || r(), - n.nodeCleanupFunctions.delete(e); - } - function fLt(t, e, r) { - return Bme(t, e, r, "get"), XL(r).get(t, e); - } - function oqe(t, e, r) { - return XL(r).peek(t, e); - } - function dLt(t, e, r) { - var n; - let i = oLt(e); - return ( - i == null || (n = i.invalidate) === null || n === void 0 || n.call(i, t), - { - ...t, - atomValues: t.atomValues.clone().delete(e), - nonvalidatedAtoms: t.nonvalidatedAtoms.clone().set(e, r), - dirtyAtoms: aLt(t.dirtyAtoms, e), - } - ); - } - function hLt(t, e, r, n) { - let i = XL(r); - if (i.set == null) - throw new yme(`Attempt to set read-only RecoilValue: ${r}`); - let o = i.set; - return Bme(t, e, r, "set"), o(t, e, n); - } - function pLt(t, e, r) { - let n = t.getState(), - i = t.getGraph(e.version), - o = XL(r).nodeType; - return iqe( - { type: o }, - { - loadable: () => oqe(t, e, r), - isActive: () => n.knownAtoms.has(r) || n.knownSelectors.has(r), - isSet: () => (o === "selector" ? !1 : e.atomValues.has(r)), - isModified: () => e.dirtyAtoms.has(r), - deps: () => { - var a; - return kLe((a = i.nodeDeps.get(r)) !== null && a !== void 0 ? a : []); - }, - subscribers: () => { - var a, s; - return { - nodes: kLe(Ome(aqe(t, e, new Set([r])), (c) => c !== r)), - components: o$( - (a = - (s = n.nodeToComponentSubscriptions.get(r)) === null || - s === void 0 - ? void 0 - : s.values()) !== null && a !== void 0 - ? a - : [], - ([c]) => ({ name: c }) - ), - }; - }, - } - ); - } - function aqe(t, e, r) { - let n = new Set(), - i = Array.from(r), - o = t.getGraph(e.version); - for (let s = i.pop(); s; s = i.pop()) { - var a; - n.add(s); - let c = - (a = o.nodeToNodeSubscriptions.get(s)) !== null && a !== void 0 - ? a - : sLt; - for (let u of c) n.has(u) || i.push(u); - } - return n; - } - var YS = { - getNodeLoadable: fLt, - peekNodeLoadable: oqe, - setNodeValue: hLt, - initializeNode: cLt, - cleanUpNode: lLt, - setUnvalidatedAtomValue_DEPRECATED: dLt, - peekNodeInfo: pLt, - getDownstreamNodes: aqe, - }, - sqe = null; - function yLt(t) { - sqe = t; - } - function mLt() { - var t; - (t = sqe) === null || t === void 0 || t(); - } - var uqe = { - setInvalidateMemoizedSnapshot: yLt, - invalidateMemoizedSnapshot: mLt, - }, - { getDownstreamNodes: gLt, getNodeLoadable: cqe, setNodeValue: vLt } = YS, - { getNextComponentID: bLt } = a$, - { getNode: wLt, getNodeMaybe: lqe } = Eh, - { DefaultValue: Ime } = Eh, - { reactMode: _Lt } = ZI, - { - AbstractRecoilValue: xLt, - RecoilState: SLt, - RecoilValueReadOnly: ALt, - isRecoilValue: ELt, - } = eM, - { invalidateMemoizedSnapshot: MLt } = uqe; - function TLt(t, { key: e }, r = t.getState().currentTree) { - var n, i; - let o = t.getState(); - r.version === o.currentTree.version || - r.version === - ((n = o.nextTree) === null || n === void 0 ? void 0 : n.version) || - r.version === - ((i = o.previousTree) === null || i === void 0 ? void 0 : i.version) || - Ah("Tried to read from a discarded tree"); - let a = cqe(t, r, e); - return a.state === "loading" && a.contents.catch(() => {}), a; - } - function kLt(t, e) { - let r = t.clone(); - return ( - e.forEach((n, i) => { - n.state === "hasValue" && n.contents instanceof Ime - ? r.delete(i) - : r.set(i, n); - }), - r - ); - } - function PLt(t, e, { key: r }, n) { - if (typeof n == "function") { - let i = cqe(t, e, r); - if (i.state === "loading") { - let o = `Tried to set atom or selector "${r}" using an updater function while the current state is pending, this is not currently supported.`; - throw (Ah(o), Pn(o)); - } else if (i.state === "hasError") throw i.contents; - return n(i.contents); - } else return n; - } - function OLt(t, e, r) { - if (r.type === "set") { - let { recoilValue: i, valueOrUpdater: o } = r, - a = PLt(t, e, i, o), - s = vLt(t, e, i.key, a); - for (let [c, u] of s.entries()) mme(e, c, u); - } else if (r.type === "setLoadable") { - let { - recoilValue: { key: i }, - loadable: o, - } = r; - mme(e, i, o); - } else if (r.type === "markModified") { - let { - recoilValue: { key: i }, - } = r; - e.dirtyAtoms.add(i); - } else if (r.type === "setUnvalidated") { - var n; - let { - recoilValue: { key: i }, - unvalidatedValue: o, - } = r, - a = lqe(i); - a == null || (n = a.invalidate) === null || n === void 0 || n.call(a, e), - e.atomValues.delete(i), - e.nonvalidatedAtoms.set(i, o), - e.dirtyAtoms.add(i); - } else Ah(`Unknown action ${r.type}`); - } - function mme(t, e, r) { - r.state === "hasValue" && r.contents instanceof Ime - ? t.atomValues.delete(e) - : t.atomValues.set(e, r), - t.dirtyAtoms.add(e), - t.nonvalidatedAtoms.delete(e); - } - function fqe(t, e) { - t.replaceState((r) => { - let n = dqe(r); - for (let i of e) OLt(t, n, i); - return hqe(t, n), MLt(), n; - }); - } - function u$(t, e) { - if (KL.length) { - let r = KL[KL.length - 1], - n = r.get(t); - n || r.set(t, (n = [])), n.push(e); - } else fqe(t, [e]); - } - var KL = []; - function BLt() { - let t = new Map(); - return ( - KL.push(t), - () => { - for (let [r, n] of t) fqe(r, n); - KL.pop() !== t && Ah("Incorrect order of batch popping"); - } - ); - } - function dqe(t) { - return { - ...t, - atomValues: t.atomValues.clone(), - nonvalidatedAtoms: t.nonvalidatedAtoms.clone(), - dirtyAtoms: new Set(t.dirtyAtoms), - }; - } - function hqe(t, e) { - let r = gLt(t, e, e.dirtyAtoms); - for (let o of r) { - var n, i; - (n = lqe(o)) === null || - n === void 0 || - (i = n.invalidate) === null || - i === void 0 || - i.call(n, e); - } - } - function pqe(t, e, r) { - u$(t, { type: "set", recoilValue: e, valueOrUpdater: r }); - } - function ILt(t, e, r) { - if (r instanceof Ime) return pqe(t, e, r); - u$(t, { type: "setLoadable", recoilValue: e, loadable: r }); - } - function CLt(t, e) { - u$(t, { type: "markModified", recoilValue: e }); - } - function RLt(t, e, r) { - u$(t, { type: "setUnvalidated", recoilValue: e, unvalidatedValue: r }); - } - function NLt(t, { key: e }, r, n = null) { - let i = bLt(), - o = t.getState(); - o.nodeToComponentSubscriptions.has(e) || - o.nodeToComponentSubscriptions.set(e, new Map()), - ra(o.nodeToComponentSubscriptions.get(e)).set(i, [ - n ?? "", - r, - ]); - let a = _Lt(); - if (a.early && (a.mode === "LEGACY" || a.mode === "MUTABLE_SOURCE")) { - let s = t.getState().nextTree; - s && s.dirtyAtoms.has(e) && r(s); - } - return { - release: () => { - let s = t.getState(), - c = s.nodeToComponentSubscriptions.get(e); - if (c === void 0 || !c.has(i)) { - Ah( - `Subscription missing at release time for atom ${e}. This is a bug in Recoil.` - ); - return; - } - c.delete(i), c.size === 0 && s.nodeToComponentSubscriptions.delete(e); - }, - }; - } - function DLt(t, e) { - var r; - let { currentTree: n } = t.getState(), - i = wLt(e.key); - (r = i.clearCache) === null || r === void 0 || r.call(i, t, n); - } - var ov = { - RecoilValueReadOnly: ALt, - AbstractRecoilValue: xLt, - RecoilState: SLt, - getRecoilValueAsLoadable: TLt, - setRecoilValue: pqe, - setRecoilValueLoadable: ILt, - markRecoilValueModified: CLt, - setUnvalidatedRecoilValue: RLt, - subscribeToRecoilValue: NLt, - isRecoilValue: ELt, - applyAtomValueWrites: kLt, - batchStart: BLt, - writeLoadableToTreeState: mme, - invalidateDownstreams: hqe, - copyTreeState: dqe, - refreshRecoilValue: DLt, - }; - function FLt(t, e, r) { - let n = t.entries(), - i = n.next(); - for (; !i.done; ) { - let o = i.value; - if (e.call(r, o[1], o[0], t)) return !0; - i = n.next(); - } - return !1; - } - var LLt = FLt, - { cleanUpNode: qLt } = YS, - { deleteNodeConfigIfPossible: zLt, getNode: yqe } = Eh, - { RetentionZone: mqe } = s$, - jLt = 12e4, - gqe = new Set(); - function vqe(t, e) { - let r = t.getState(), - n = r.currentTree; - if (r.nextTree) { - Ah( - "releaseNodesNowOnCurrentTree should only be called at the end of a batch" - ); - return; - } - let i = new Set(); - for (let a of e) - if (a instanceof mqe) for (let s of VLt(r, a)) i.add(s); - else i.add(a); - let o = ULt(t, i); - for (let a of o) HLt(t, n, a); - } - function ULt(t, e) { - let r = t.getState(), - n = r.currentTree, - i = t.getGraph(n.version), - o = new Set(), - a = new Set(); - return s(e), o; - function s(c) { - let u = new Set(), - h = KLt(t, n, c, o, a); - for (let O of h) { - var w; - if (yqe(O).retainedBy === "recoilRoot") { - a.add(O); - continue; - } - if ( - ((w = r.retention.referenceCounts.get(O)) !== null && w !== void 0 - ? w - : 0) > 0 - ) { - a.add(O); - continue; - } - if (bqe(O).some((F) => r.retention.referenceCounts.get(F))) { - a.add(O); - continue; - } - let D = i.nodeToNodeSubscriptions.get(O); - if (D && LLt(D, (F) => a.has(F))) { - a.add(O); - continue; - } - o.add(O), u.add(O); - } - let M = new Set(); - for (let O of u) - for (let D of (k = i.nodeDeps.get(O)) !== null && k !== void 0 - ? k - : gqe) { - var k; - o.has(D) || M.add(D); - } - M.size && s(M); - } - } - function KLt(t, e, r, n, i) { - let o = t.getGraph(e.version), - a = [], - s = new Set(); - for (; r.size > 0; ) c(ra(r.values().next().value)); - return a; - function c(u) { - if (n.has(u) || i.has(u)) { - r.delete(u); - return; - } - if (s.has(u)) return; - let h = o.nodeToNodeSubscriptions.get(u); - if (h) for (let w of h) c(w); - s.add(u), r.delete(u), a.push(u); - } - } - function HLt(t, e, r) { - if (!xo("recoil_memory_managament_2020")) return; - qLt(t, r); - let n = t.getState(); - n.knownAtoms.delete(r), - n.knownSelectors.delete(r), - n.nodeTransactionSubscriptions.delete(r), - n.retention.referenceCounts.delete(r); - let i = bqe(r); - for (let c of i) { - var o; - (o = n.retention.nodesRetainedByZone.get(c)) === null || - o === void 0 || - o.delete(r); - } - e.atomValues.delete(r), - e.dirtyAtoms.delete(r), - e.nonvalidatedAtoms.delete(r); - let a = n.graphsByVersion.get(e.version); - if (a) { - let c = a.nodeDeps.get(r); - if (c !== void 0) { - a.nodeDeps.delete(r); - for (let u of c) { - var s; - (s = a.nodeToNodeSubscriptions.get(u)) === null || - s === void 0 || - s.delete(r); - } - } - a.nodeToNodeSubscriptions.delete(r); - } - zLt(r); - } - function VLt(t, e) { - var r; - return (r = t.retention.nodesRetainedByZone.get(e)) !== null && r !== void 0 - ? r - : gqe; - } - function bqe(t) { - let e = yqe(t).retainedBy; - return e === void 0 || e === "components" || e === "recoilRoot" - ? [] - : e instanceof mqe - ? [e] - : e; - } - function WLt(t, e) { - let r = t.getState(); - r.nextTree - ? r.retention.retainablesToCheckForRelease.add(e) - : vqe(t, new Set([e])); - } - function GLt(t, e, r) { - var n; - if (!xo("recoil_memory_managament_2020")) return; - let i = t.getState().retention.referenceCounts, - o = ((n = i.get(e)) !== null && n !== void 0 ? n : 0) + r; - o === 0 ? wqe(t, e) : i.set(e, o); - } - function wqe(t, e) { - if (!xo("recoil_memory_managament_2020")) return; - t.getState().retention.referenceCounts.delete(e), WLt(t, e); - } - function JLt(t) { - if (!xo("recoil_memory_managament_2020")) return; - let e = t.getState(); - vqe(t, e.retention.retainablesToCheckForRelease), - e.retention.retainablesToCheckForRelease.clear(); - } - function $Lt(t) { - return t === void 0 ? "recoilRoot" : t; - } - var nM = { - SUSPENSE_TIMEOUT_MS: jLt, - updateRetainCount: GLt, - updateRetainCountToZero: wqe, - releaseScheduledRetainablesNow: JLt, - retainedByOptionWithDefault: $Lt, - }, - { unstable_batchedUpdates: ZLt } = JLe.default, - XLt = { unstable_batchedUpdates: ZLt }, - { unstable_batchedUpdates: YLt } = XLt, - QLt = { unstable_batchedUpdates: YLt }, - { batchStart: eqt } = ov, - { unstable_batchedUpdates: tqt } = QLt, - Cme = tqt, - rqt = (t) => { - Cme = t; - }, - nqt = () => Cme, - iqt = (t) => { - Cme(() => { - let e = () => {}; - try { - (e = eqt()), t(); - } finally { - e(); - } - }); - }, - c$ = { getBatcher: nqt, setBatcher: rqt, batchUpdates: iqt }; - function* oqt(t) { - for (let e of t) for (let r of e) yield r; - } - var _qe = oqt, - xqe = typeof Window > "u" || typeof window > "u", - aqt = (t) => !xqe && (t === window || t instanceof Window), - sqt = typeof navigator < "u" && navigator.product === "ReactNative", - l$ = { isSSR: xqe, isReactNative: sqt, isWindow: aqt }; - function uqt(t, e) { - let r; - return (...i) => { - r || (r = {}); - let o = e(...i); - return Object.hasOwnProperty.call(r, o) || (r[o] = t(...i)), r[o]; - }; - } - function cqt(t, e) { - let r, n; - return (...o) => { - let a = e(...o); - return r === a || ((r = a), (n = t(...o))), n; - }; - } - function lqt(t, e) { - let r, n; - return [ - (...a) => { - let s = e(...a); - return r === s || ((r = s), (n = t(...a))), n; - }, - () => { - r = null; - }, - ]; - } - var fqt = { - memoizeWithArgsHash: uqt, - memoizeOneWithArgsHash: cqt, - memoizeOneWithArgsHashAndInvalidation: lqt, - }, - { batchUpdates: gme } = c$, - { initializeNode: dqt, peekNodeInfo: hqt } = YS, - { graph: pqt } = ZL, - { getNextStoreID: yqt } = a$, - { DEFAULT_VALUE: mqt, recoilValues: OLe, recoilValuesForKeys: BLe } = Eh, - { - AbstractRecoilValue: gqt, - getRecoilValueAsLoadable: vqt, - setRecoilValue: ILe, - setUnvalidatedRecoilValue: bqt, - } = ov, - { updateRetainCount: jJ } = nM, - { setInvalidateMemoizedSnapshot: wqt } = uqe, - { getNextTreeStateVersion: _qt, makeEmptyStoreState: xqt } = rqe, - { isSSR: Sqt } = l$, - { memoizeOneWithArgsHashAndInvalidation: Aqt } = fqt; - var WI = class { - constructor(e, r) { - fn(this, "_store", void 0), - fn(this, "_refCount", 1), - fn( - this, - "getLoadable", - (n) => (this.checkRefCount_INTERNAL(), vqt(this._store, n)) - ), - fn( - this, - "getPromise", - (n) => ( - this.checkRefCount_INTERNAL(), this.getLoadable(n).toPromise() - ) - ), - fn(this, "getNodes_UNSTABLE", (n) => { - if ((this.checkRefCount_INTERNAL(), n?.isModified === !0)) { - if (n?.isInitialized === !1) return []; - let a = this._store.getState().currentTree; - return BLe(a.dirtyAtoms); - } - let i = this._store.getState().knownAtoms, - o = this._store.getState().knownSelectors; - return n?.isInitialized == null - ? OLe.values() - : n.isInitialized === !0 - ? BLe(_qe([i, o])) - : Ome(OLe.values(), ({ key: a }) => !i.has(a) && !o.has(a)); - }), - fn( - this, - "getInfo_UNSTABLE", - ({ key: n }) => ( - this.checkRefCount_INTERNAL(), - hqt(this._store, this._store.getState().currentTree, n) - ) - ), - fn(this, "map", (n) => { - this.checkRefCount_INTERNAL(); - let i = new GL(this, gme); - return n(i), i; - }), - fn(this, "asyncMap", async (n) => { - this.checkRefCount_INTERNAL(); - let i = new GL(this, gme); - return i.retain(), await n(i), i.autoRelease_INTERNAL(), i; - }), - (this._store = { - storeID: yqt(), - parentStoreID: r, - getState: () => e, - replaceState: (n) => { - e.currentTree = n(e.currentTree); - }, - getGraph: (n) => { - let i = e.graphsByVersion; - if (i.has(n)) return ra(i.get(n)); - let o = pqt(); - return i.set(n, o), o; - }, - subscribeToTransactions: () => ({ release: () => {} }), - addTransactionMetadata: () => { - throw Pn("Cannot subscribe to Snapshots"); - }, - }); - for (let n of this._store.getState().knownAtoms) - dqt(this._store, n, "get"), jJ(this._store, n, 1); - this.autoRelease_INTERNAL(); - } - retain() { - this._refCount <= 0 && - Ah("Attempt to retain() Snapshot that was already released."), - this._refCount++; - let e = !1; - return () => { - e || ((e = !0), this._release()); - }; - } - autoRelease_INTERNAL() { - Sqt || window.setTimeout(() => this._release(), 10); - } - _release() { - if ((this._refCount--, this._refCount === 0)) { - if ( - (this._store.getState().nodeCleanupFunctions.forEach((e) => e()), - this._store.getState().nodeCleanupFunctions.clear(), - !xo("recoil_memory_managament_2020")) - ) - return; - } else this._refCount < 0; - } - isRetained() { - return this._refCount > 0; - } - checkRefCount_INTERNAL() { - xo("recoil_memory_managament_2020") && this._refCount <= 0; - } - getStore_INTERNAL() { - return this.checkRefCount_INTERNAL(), this._store; - } - getID() { - return ( - this.checkRefCount_INTERNAL(), - this._store.getState().currentTree.stateID - ); - } - getStoreID() { - return this.checkRefCount_INTERNAL(), this._store.storeID; - } - }; - function Sqe(t, e, r = !1) { - let n = t.getState(), - i = r ? _qt() : e.version; - return { - currentTree: { - version: r ? i : e.version, - stateID: r ? i : e.stateID, - transactionMetadata: { ...e.transactionMetadata }, - dirtyAtoms: new Set(e.dirtyAtoms), - atomValues: e.atomValues.clone(), - nonvalidatedAtoms: e.nonvalidatedAtoms.clone(), - }, - commitDepth: 0, - nextTree: null, - previousTree: null, - knownAtoms: new Set(n.knownAtoms), - knownSelectors: new Set(n.knownSelectors), - transactionSubscriptions: new Map(), - nodeTransactionSubscriptions: new Map(), - nodeToComponentSubscriptions: new Map(), - queuedComponentCallbacks_DEPRECATED: [], - suspendedComponentResolvers: new Set(), - graphsByVersion: new Map().set(i, t.getGraph(e.version)), - retention: { - referenceCounts: new Map(), - nodesRetainedByZone: new Map(), - retainablesToCheckForRelease: new Set(), - }, - nodeCleanupFunctions: new Map( - o$(n.nodeCleanupFunctions.entries(), ([o]) => [o, () => {}]) - ), - }; - } - function Eqt(t) { - let e = new WI(xqt()); - return t != null ? e.map(t) : e; - } - var [CLe, Aqe] = Aqt( - (t, e) => { - var r; - let n = t.getState(), - i = - e === "latest" - ? (r = n.nextTree) !== null && r !== void 0 - ? r - : n.currentTree - : ra(n.previousTree); - return new WI(Sqe(t, i), t.storeID); - }, - (t, e) => { - var r, n; - return ( - String(e) + - String(t.storeID) + - String( - (r = t.getState().nextTree) === null || r === void 0 - ? void 0 - : r.version - ) + - String(t.getState().currentTree.version) + - String( - (n = t.getState().previousTree) === null || n === void 0 - ? void 0 - : n.version - ) - ); - } - ); - wqt(Aqe); - function Mqt(t, e = "latest") { - let r = CLe(t, e); - return r.isRetained() ? r : (Aqe(), CLe(t, e)); - } - var GL = class extends WI { - constructor(e, r) { - super( - Sqe( - e.getStore_INTERNAL(), - e.getStore_INTERNAL().getState().currentTree, - !0 - ), - e.getStoreID() - ), - fn(this, "_batch", void 0), - fn(this, "set", (n, i) => { - this.checkRefCount_INTERNAL(); - let o = this.getStore_INTERNAL(); - this._batch(() => { - jJ(o, n.key, 1), ILe(this.getStore_INTERNAL(), n, i); - }); - }), - fn(this, "reset", (n) => { - this.checkRefCount_INTERNAL(); - let i = this.getStore_INTERNAL(); - this._batch(() => { - jJ(i, n.key, 1), ILe(this.getStore_INTERNAL(), n, mqt); - }); - }), - fn(this, "setUnvalidatedAtomValues_DEPRECATED", (n) => { - this.checkRefCount_INTERNAL(); - let i = this.getStore_INTERNAL(); - gme(() => { - for (let [o, a] of n.entries()) - jJ(i, o, 1), bqt(i, new gqt(o), a); - }); - }), - (this._batch = r); - } - }, - f$ = { - Snapshot: WI, - MutableSnapshot: GL, - freshSnapshot: Eqt, - cloneSnapshot: Mqt, - }, - Tqt = f$.Snapshot, - kqt = f$.MutableSnapshot, - Pqt = f$.freshSnapshot, - Oqt = f$.cloneSnapshot, - d$ = Object.freeze({ - __proto__: null, - Snapshot: Tqt, - MutableSnapshot: kqt, - freshSnapshot: Pqt, - cloneSnapshot: Oqt, - }); - function Bqt(...t) { - let e = new Set(); - for (let r of t) for (let n of r) e.add(n); - return e; - } - var Iqt = Bqt, - { useRef: Cqt } = na.default; - function Rqt(t) { - let e = Cqt(t); - return e.current === t && typeof t == "function" && (e.current = t()), e; - } - var RLe = Rqt, - { getNextTreeStateVersion: Nqt, makeEmptyStoreState: Eqe } = rqe, - { - cleanUpNode: Dqt, - getDownstreamNodes: Fqt, - initializeNode: Lqt, - setNodeValue: qqt, - setUnvalidatedAtomValue_DEPRECATED: zqt, - } = YS, - { graph: jqt } = ZL, - { cloneGraph: Uqt } = ZL, - { getNextStoreID: Mqe } = a$, - { createMutableSource: ume, reactMode: Tqe } = ZI, - { applyAtomValueWrites: Kqt } = ov, - { releaseScheduledRetainablesNow: kqe } = nM, - { freshSnapshot: Hqt } = d$, - { - useCallback: Vqt, - useContext: Pqe, - useEffect: vme, - useMemo: Wqt, - useRef: Gqt, - useState: Jqt, - } = na.default; - function DL() { - throw Pn("This component must be used inside a component."); - } - var Oqe = Object.freeze({ - storeID: Mqe(), - getState: DL, - replaceState: DL, - getGraph: DL, - subscribeToTransactions: DL, - addTransactionMetadata: DL, - }), - bme = !1; - function NLe(t) { - if (bme) - throw Pn( - "An atom update was triggered within the execution of a state updater function. State updater functions provided to Recoil must be pure functions." - ); - let e = t.getState(); - if (e.nextTree === null) { - xo("recoil_memory_managament_2020") && - xo("recoil_release_on_cascading_update_killswitch_2021") && - e.commitDepth > 0 && - kqe(t); - let r = e.currentTree.version, - n = Nqt(); - (e.nextTree = { - ...e.currentTree, - version: n, - stateID: n, - dirtyAtoms: new Set(), - transactionMetadata: {}, - }), - e.graphsByVersion.set(n, Uqt(ra(e.graphsByVersion.get(r)))); - } - } - var Bqe = na.default.createContext({ current: Oqe }), - h$ = () => Pqe(Bqe), - Iqe = na.default.createContext(null); - function $qt() { - let t = Pqe(Iqe); - return ( - t == null && - Tme( - "Attempted to use a Recoil hook outside of a . must be an ancestor of any component that uses Recoil hooks." - ), - t - ); - } - function Rme(t, e, r) { - let n = Fqt(t, r, r.dirtyAtoms); - for (let i of n) { - let o = e.nodeToComponentSubscriptions.get(i); - if (o) for (let [a, [s, c]] of o) c(r); - } - } - function Cqe(t) { - let e = t.getState(), - r = e.currentTree, - n = r.dirtyAtoms; - if (n.size) { - for (let [i, o] of e.nodeTransactionSubscriptions) - if (n.has(i)) for (let [a, s] of o) s(t); - for (let [i, o] of e.transactionSubscriptions) o(t); - (!Tqe().early || e.suspendedComponentResolvers.size > 0) && - (Rme(t, e, r), - e.suspendedComponentResolvers.forEach((i) => i()), - e.suspendedComponentResolvers.clear()); - } - e.queuedComponentCallbacks_DEPRECATED.forEach((i) => i(r)), - e.queuedComponentCallbacks_DEPRECATED.splice( - 0, - e.queuedComponentCallbacks_DEPRECATED.length - ); - } - function Zqt(t) { - let e = t.getState(); - e.commitDepth++; - try { - let { nextTree: r } = e; - if (r == null) return; - (e.previousTree = e.currentTree), - (e.currentTree = r), - (e.nextTree = null), - Cqe(t), - e.previousTree != null - ? e.graphsByVersion.delete(e.previousTree.version) - : Ah( - "Ended batch with no previous state, which is unexpected", - "recoil" - ), - (e.previousTree = null), - xo("recoil_memory_managament_2020") && r == null && kqe(t); - } finally { - e.commitDepth--; - } - } - function Xqt({ setNotifyBatcherOfChange: t }) { - let e = h$(), - [, r] = Jqt([]); - return ( - t(() => r({})), - vme( - () => ( - t(() => r({})), - () => { - t(() => {}); - } - ), - [t] - ), - vme(() => { - BFt.enqueueExecution("Batcher", () => { - Zqt(e.current); - }); - }), - null - ); - } - function Yqt(t, e) { - let r = Eqe(); - return ( - e({ - set: (n, i) => { - let o = r.currentTree, - a = qqt(t, o, n.key, i), - s = new Set(a.keys()), - c = o.nonvalidatedAtoms.clone(); - for (let u of s) c.delete(u); - r.currentTree = { - ...o, - dirtyAtoms: Iqt(o.dirtyAtoms, s), - atomValues: Kqt(o.atomValues, a), - nonvalidatedAtoms: c, - }; - }, - setUnvalidatedAtomValues: (n) => { - n.forEach((i, o) => { - r.currentTree = zqt(r.currentTree, o, i); - }); - }, - }), - r - ); - } - function Qqt(t) { - let e = Hqt(t), - r = e.getStore_INTERNAL().getState(); - return ( - e.retain(), - r.nodeCleanupFunctions.forEach((n) => n()), - r.nodeCleanupFunctions.clear(), - r - ); - } - var DLe = 0; - function ezt({ - initializeState_DEPRECATED: t, - initializeState: e, - store_INTERNAL: r, - children: n, - }) { - let i, - o = (k) => { - let O = i.current.graphsByVersion; - if (O.has(k)) return ra(O.get(k)); - let D = jqt(); - return O.set(k, D), D; - }, - a = (k, O) => { - if (O == null) { - let { transactionSubscriptions: D } = w.current.getState(), - F = DLe++; - return ( - D.set(F, k), - { - release: () => { - D.delete(F); - }, - } - ); - } else { - let { nodeTransactionSubscriptions: D } = w.current.getState(); - D.has(O) || D.set(O, new Map()); - let F = DLe++; - return ( - ra(D.get(O)).set(F, k), - { - release: () => { - let N = D.get(O); - N && (N.delete(F), N.size === 0 && D.delete(O)); - }, - } - ); - } - }, - s = (k) => { - NLe(w.current); - for (let O of Object.keys(k)) - ra(w.current.getState().nextTree).transactionMetadata[O] = k[O]; - }, - c = (k) => { - NLe(w.current); - let O = ra(i.current.nextTree), - D; - try { - (bme = !0), (D = k(O)); - } finally { - bme = !1; - } - D !== O && - ((i.current.nextTree = D), - Tqe().early && Rme(w.current, i.current, D), - ra(u.current)()); - }, - u = Gqt(null), - h = Vqt( - (k) => { - u.current = k; - }, - [u] - ), - w = RLe( - () => - r ?? { - storeID: Mqe(), - getState: () => i.current, - replaceState: c, - getGraph: o, - subscribeToTransactions: a, - addTransactionMetadata: s, - } - ); - r != null && (w.current = r), - (i = RLe(() => - t != null ? Yqt(w.current, t) : e != null ? Qqt(e) : Eqe() - )); - let M = Wqt(() => ume?.(i, () => i.current.currentTree.version), [i]); - return ( - vme(() => { - let k = w.current; - for (let O of new Set(k.getState().knownAtoms)) Lqt(k, O, "get"); - return () => { - for (let O of k.getState().knownAtoms) Dqt(k, O); - }; - }, [w]), - na.default.createElement( - Bqe.Provider, - { value: w }, - na.default.createElement( - Iqe.Provider, - { value: M }, - na.default.createElement(Xqt, { setNotifyBatcherOfChange: h }), - n - ) - ) - ); - } - function tzt(t) { - let { override: e, ...r } = t, - n = h$(); - return e === !1 && n.current !== Oqe - ? t.children - : na.default.createElement(ezt, r); - } - function rzt() { - return h$().current.storeID; - } - var S_ = { - RecoilRoot: tzt, - useStoreRef: h$, - useRecoilMutableSource: $qt, - useRecoilStoreID: rzt, - notifyComponents_FOR_TESTING: Rme, - sendEndOfBatchNotifications_FOR_TESTING: Cqe, - }; - function nzt(t, e) { - if (t === e) return !0; - if (t.length !== e.length) return !1; - for (let r = 0, n = t.length; r < n; r++) if (t[r] !== e[r]) return !1; - return !0; - } - var izt = nzt, - { useEffect: ozt, useRef: azt } = na.default; - function szt(t) { - let e = azt(); - return ( - ozt(() => { - e.current = t; - }), - e.current - ); - } - var Rqe = szt, - { useStoreRef: uzt } = S_, - { SUSPENSE_TIMEOUT_MS: czt } = nM, - { updateRetainCount: FL } = nM, - { RetentionZone: lzt } = s$, - { useEffect: fzt, useRef: dzt } = na.default, - { isSSR: FLe } = l$; - function hzt(t) { - if (!!xo("recoil_memory_managament_2020")) return pzt(t); - } - function pzt(t) { - let r = (Array.isArray(t) ? t : [t]).map((a) => - a instanceof lzt ? a : a.key - ), - n = uzt(); - fzt(() => { - if (!xo("recoil_memory_managament_2020")) return; - let a = n.current; - if (i.current && !FLe) window.clearTimeout(i.current), (i.current = null); - else for (let s of r) FL(a, s, 1); - return () => { - for (let s of r) FL(a, s, -1); - }; - }, [n, ...r]); - let i = dzt(), - o = Rqe(r); - if (!FLe && (o === void 0 || !izt(o, r))) { - let a = n.current; - for (let s of r) FL(a, s, 1); - if (o) for (let s of o) FL(a, s, -1); - i.current && window.clearTimeout(i.current), - (i.current = window.setTimeout(() => { - i.current = null; - for (let s of r) FL(a, s, -1); - }, czt)); - } - } - var Nme = hzt; - function yzt() { - return ""; - } - var YL = yzt, - { batchUpdates: mzt } = c$, - { DEFAULT_VALUE: Nqe } = Eh, - { reactMode: XI, useMutableSource: gzt, useSyncExternalStore: vzt } = ZI, - { useRecoilMutableSource: bzt, useStoreRef: av } = S_, - { isRecoilValue: sun } = eM, - { - AbstractRecoilValue: wme, - getRecoilValueAsLoadable: QL, - setRecoilValue: ZJ, - setUnvalidatedRecoilValue: wzt, - subscribeToRecoilValue: GI, - } = ov, - { - useCallback: Sh, - useEffect: JI, - useMemo: Dqe, - useRef: HL, - useState: Dme, - } = na.default, - { setByAddingToSet: _zt } = nqe; - function Fme(t, e, r) { - if (t.state === "hasValue") return t.contents; - throw t.state === "loading" - ? new Promise((i) => { - r.current.getState().suspendedComponentResolvers.add(i); - }) - : t.state === "hasError" - ? t.contents - : Pn(`Invalid value of loadable atom "${e.key}"`); - } - function xzt() { - let t = YL(), - e = av(), - [, r] = Dme([]), - n = HL(new Set()); - n.current = new Set(); - let i = HL(new Set()), - o = HL(new Map()), - a = Sh( - (c) => { - let u = o.current.get(c); - u && (u.release(), o.current.delete(c)); - }, - [o] - ), - s = Sh((c, u) => { - o.current.has(u) && r([]); - }, []); - return ( - JI(() => { - let c = e.current; - UL(n.current, i.current).forEach((u) => { - if (o.current.has(u)) { - Tme(`Double subscription to RecoilValue "${u}"`); - return; - } - let h = GI(c, new wme(u), (M) => s(M, u), t); - o.current.set(u, h), - c.getState().nextTree - ? c.getState().queuedComponentCallbacks_DEPRECATED.push(() => { - s(c.getState(), u); - }) - : s(c.getState(), u); - }), - UL(i.current, n.current).forEach((u) => { - a(u); - }), - (i.current = n.current); - }), - JI(() => { - let c = o.current; - return ( - UL(n.current, new Set(c.keys())).forEach((u) => { - let h = GI(e.current, new wme(u), (w) => s(w, u), t); - c.set(u, h); - }), - () => c.forEach((u, h) => a(h)) - ); - }, [t, e, a, s]), - Dqe(() => { - function c(O) { - return (D) => { - ZJ(e.current, O, D); - }; - } - function u(O) { - return () => ZJ(e.current, O, Nqe); - } - function h(O) { - var D; - n.current.has(O.key) || (n.current = _zt(n.current, O.key)); - let F = e.current.getState(); - return QL( - e.current, - O, - XI().early && (D = F.nextTree) !== null && D !== void 0 - ? D - : F.currentTree - ); - } - function w(O) { - let D = h(O); - return Fme(D, O, e); - } - function M(O) { - return [w(O), c(O)]; - } - function k(O) { - return [h(O), c(O)]; - } - return { - getRecoilValue: w, - getRecoilValueLoadable: h, - getRecoilState: M, - getRecoilStateLoadable: k, - getSetRecoilState: c, - getResetRecoilState: u, - }; - }, [n, e]) - ); - } - var Szt = { current: 0 }; - function Azt(t) { - let e = av(), - r = YL(), - n = Sh(() => { - var s; - let c = e.current, - u = c.getState(), - h = - XI().early && (s = u.nextTree) !== null && s !== void 0 - ? s - : u.currentTree; - return { loadable: QL(c, t, h), key: t.key }; - }, [e, t]), - i = Sh((s) => { - let c; - return () => { - var u, h; - let w = s(); - return (u = c) !== null && - u !== void 0 && - u.loadable.is(w.loadable) && - ((h = c) === null || h === void 0 ? void 0 : h.key) === w.key - ? c - : ((c = w), w); - }; - }, []), - o = Dqe(() => i(n), [n, i]), - a = Sh( - (s) => { - let c = e.current; - return GI(c, t, s, r).release; - }, - [e, t, r] - ); - return vzt(a, o, o).loadable; - } - function Ezt(t) { - let e = av(), - r = Sh(() => { - var u; - let h = e.current, - w = h.getState(), - M = - XI().early && (u = w.nextTree) !== null && u !== void 0 - ? u - : w.currentTree; - return QL(h, t, M); - }, [e, t]), - n = Sh(() => r(), [r]), - i = YL(), - o = Sh( - (u, h) => { - let w = e.current; - return GI( - w, - t, - () => { - if (!xo("recoil_suppress_rerender_in_callback")) return h(); - let k = r(); - c.current.is(k) || h(), (c.current = k); - }, - i - ).release; - }, - [e, t, i, r] - ), - a = bzt(); - if (a == null) - throw Pn( - "Recoil hooks must be used in components contained within a component." - ); - let s = gzt(a, n, o), - c = HL(s); - return ( - JI(() => { - c.current = s; - }), - s - ); - } - function Fqe(t) { - let e = av(), - r = YL(), - n = Sh(() => { - var c; - let u = e.current, - h = u.getState(), - w = - XI().early && (c = h.nextTree) !== null && c !== void 0 - ? c - : h.currentTree; - return QL(u, t, w); - }, [e, t]), - i = Sh(() => ({ loadable: n(), key: t.key }), [n, t.key]), - o = Sh( - (c) => { - let u = i(); - return c.loadable.is(u.loadable) && c.key === u.key ? c : u; - }, - [i] - ); - JI(() => { - let c = GI( - e.current, - t, - (u) => { - s(o); - }, - r - ); - return s(o), c.release; - }, [r, t, e, o]); - let [a, s] = Dme(i); - return a.key !== t.key ? i().loadable : a.loadable; - } - function Mzt(t) { - let e = av(), - [, r] = Dme([]), - n = YL(), - i = Sh(() => { - var s; - let c = e.current, - u = c.getState(), - h = - XI().early && (s = u.nextTree) !== null && s !== void 0 - ? s - : u.currentTree; - return QL(c, t, h); - }, [e, t]), - o = i(), - a = HL(o); - return ( - JI(() => { - a.current = o; - }), - JI(() => { - let s = e.current, - c = s.getState(), - u = GI( - s, - t, - (w) => { - var M; - if (!xo("recoil_suppress_rerender_in_callback")) return r([]); - let k = i(); - ((M = a.current) !== null && M !== void 0 && M.is(k)) || r(k), - (a.current = k); - }, - n - ); - if (c.nextTree) - s.getState().queuedComponentCallbacks_DEPRECATED.push(() => { - (a.current = null), r([]); - }); - else { - var h; - if (!xo("recoil_suppress_rerender_in_callback")) return r([]); - let w = i(); - ((h = a.current) !== null && h !== void 0 && h.is(w)) || r(w), - (a.current = w); - } - return u.release; - }, [n, i, t, e]), - o - ); - } - function Lme(t) { - return ( - xo("recoil_memory_managament_2020") && Nme(t), - { - TRANSITION_SUPPORT: Fqe, - SYNC_EXTERNAL_STORE: Azt, - MUTABLE_SOURCE: Ezt, - LEGACY: Mzt, - }[XI().mode](t) - ); - } - function Lqe(t) { - let e = av(), - r = Lme(t); - return Fme(r, t, e); - } - function p$(t) { - let e = av(); - return Sh( - (r) => { - ZJ(e.current, t, r); - }, - [e, t] - ); - } - function Tzt(t) { - let e = av(); - return Sh(() => { - ZJ(e.current, t, Nqe); - }, [e, t]); - } - function kzt(t) { - return [Lqe(t), p$(t)]; - } - function Pzt(t) { - return [Lme(t), p$(t)]; - } - function Ozt() { - let t = av(); - return (e, r = {}) => { - mzt(() => { - t.current.addTransactionMetadata(r), - e.forEach((n, i) => wzt(t.current, new wme(i), n)); - }); - }; - } - function qqe(t) { - return xo("recoil_memory_managament_2020") && Nme(t), Fqe(t); - } - function zqe(t) { - let e = av(), - r = qqe(t); - return Fme(r, t, e); - } - function Bzt(t) { - return [zqe(t), p$(t)]; - } - var Izt = { - recoilComponentGetRecoilValueCount_FOR_TESTING: Szt, - useRecoilInterface: xzt, - useRecoilState: kzt, - useRecoilStateLoadable: Pzt, - useRecoilValue: Lqe, - useRecoilValueLoadable: Lme, - useResetRecoilState: Tzt, - useSetRecoilState: p$, - useSetUnvalidatedAtomValues: Ozt, - useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE: qqe, - useRecoilValue_TRANSITION_SUPPORT_UNSTABLE: zqe, - useRecoilState_TRANSITION_SUPPORT_UNSTABLE: Bzt, - }; - function Czt(t, e) { - let r = new Map(); - for (let [n, i] of t) e(i, n) && r.set(n, i); - return r; - } - var Rzt = Czt; - function Nzt(t, e) { - let r = new Set(); - for (let n of t) e(n) && r.add(n); - return r; - } - var Dzt = Nzt; - function Fzt(...t) { - let e = new Map(); - for (let r = 0; r < t.length; r++) { - let n = t[r].keys(), - i; - for (; !(i = n.next()).done; ) e.set(i.value, t[r].get(i.value)); - } - return e; - } - var Lzt = Fzt, - { batchUpdates: qzt } = c$, - { DEFAULT_VALUE: zzt, getNode: jqe, nodes: jzt } = Eh, - { useStoreRef: qme } = S_, - { AbstractRecoilValue: Uzt, setRecoilValueLoadable: Kzt } = ov, - { SUSPENSE_TIMEOUT_MS: Hzt } = nM, - { cloneSnapshot: XJ } = d$, - { - useCallback: y$, - useEffect: Uqe, - useRef: LLe, - useState: Vzt, - } = na.default, - { isSSR: qLe } = l$; - function m$(t) { - let e = qme(); - Uqe(() => e.current.subscribeToTransactions(t).release, [t, e]); - } - function zLe(t) { - let e = t.atomValues.toMap(), - r = JJ( - Rzt(e, (n, i) => { - let a = jqe(i).persistence_UNSTABLE; - return a != null && a.type !== "none" && n.state === "hasValue"; - }), - (n) => n.contents - ); - return Lzt(t.nonvalidatedAtoms.toMap(), r); - } - function Wzt(t) { - m$( - y$( - (e) => { - let r = e.getState().previousTree, - n = e.getState().currentTree; - r || - (Ah( - "Transaction subscribers notified without a previous tree being present -- this is a bug in Recoil" - ), - (r = e.getState().currentTree)); - let i = zLe(n), - o = zLe(r), - a = JJ(jzt, (c) => { - var u, h, w, M; - return { - persistence_UNSTABLE: { - type: - (u = - (h = c.persistence_UNSTABLE) === null || h === void 0 - ? void 0 - : h.type) !== null && u !== void 0 - ? u - : "none", - backButton: - (w = - (M = c.persistence_UNSTABLE) === null || M === void 0 - ? void 0 - : M.backButton) !== null && w !== void 0 - ? w - : !1, - }, - }; - }), - s = Dzt(n.dirtyAtoms, (c) => i.has(c) || o.has(c)); - t({ - atomValues: i, - previousAtomValues: o, - atomInfo: a, - modifiedAtoms: s, - transactionMetadata: { ...n.transactionMetadata }, - }); - }, - [t] - ) - ); - } - function Gzt(t) { - m$( - y$( - (e) => { - let r = XJ(e, "latest"), - n = XJ(e, "previous"); - t({ snapshot: r, previousSnapshot: n }); - }, - [t] - ) - ); - } - function Jzt() { - let t = qme(), - [e, r] = Vzt(() => XJ(t.current)), - n = Rqe(e), - i = LLe(), - o = LLe(); - if ( - (m$(y$((s) => r(XJ(s)), [])), - Uqe(() => { - let s = e.retain(); - if (i.current && !qLe) { - var c; - window.clearTimeout(i.current), - (i.current = null), - (c = o.current) === null || c === void 0 || c.call(o), - (o.current = null); - } - return () => { - window.setTimeout(s, 10); - }; - }, [e]), - n !== e && !qLe) - ) { - if (i.current) { - var a; - window.clearTimeout(i.current), - (i.current = null), - (a = o.current) === null || a === void 0 || a.call(o), - (o.current = null); - } - (o.current = e.retain()), - (i.current = window.setTimeout(() => { - var s; - (i.current = null), - (s = o.current) === null || s === void 0 || s.call(o), - (o.current = null); - }, Hzt)); - } - return e; - } - function Kqe(t, e) { - var r; - let n = t.getState(), - i = (r = n.nextTree) !== null && r !== void 0 ? r : n.currentTree, - o = e.getStore_INTERNAL().getState().currentTree; - qzt(() => { - let a = new Set(); - for (let u of [i.atomValues.keys(), o.atomValues.keys()]) - for (let h of u) { - var s, c; - ((s = i.atomValues.get(h)) === null || s === void 0 - ? void 0 - : s.contents) !== - ((c = o.atomValues.get(h)) === null || c === void 0 - ? void 0 - : c.contents) && - jqe(h).shouldRestoreFromSnapshots && - a.add(h); - } - a.forEach((u) => { - Kzt(t, new Uzt(u), o.atomValues.has(u) ? ra(o.atomValues.get(u)) : zzt); - }), - t.replaceState((u) => ({ ...u, stateID: e.getID() })); - }); - } - function $zt() { - let t = qme(); - return y$((e) => Kqe(t.current, e), [t]); - } - var Hqe = { - useRecoilSnapshot: Jzt, - gotoSnapshot: Kqe, - useGotoRecoilSnapshot: $zt, - useRecoilTransactionObserver: Gzt, - useTransactionObservation_DEPRECATED: Wzt, - useTransactionSubscription_DEPRECATED: m$, - }, - { peekNodeInfo: Zzt } = YS, - { useStoreRef: Xzt } = S_; - function Yzt() { - let t = Xzt(); - return ({ key: e }) => Zzt(t.current, t.current.getState().currentTree, e); - } - var Qzt = Yzt, - { reactMode: ejt } = ZI, - { RecoilRoot: tjt, useStoreRef: rjt } = S_, - { useMemo: njt } = na.default; - function ijt() { - ejt().mode === "MUTABLE_SOURCE" && - console.warn( - "Warning: There are known issues using useRecoilBridgeAcrossReactRoots() in recoil_mutable_source rendering mode. Please consider upgrading to recoil_sync_external_store mode." - ); - let t = rjt().current; - return njt(() => { - function e({ children: r }) { - return na.default.createElement(tjt, { store_INTERNAL: t }, r); - } - return e; - }, [t]); - } - var ojt = ijt, - { loadableWithValue: ajt } = $L, - { initializeNode: sjt } = YS, - { DEFAULT_VALUE: ujt, getNode: cjt } = Eh, - { - copyTreeState: ljt, - getRecoilValueAsLoadable: fjt, - invalidateDownstreams: djt, - writeLoadableToTreeState: hjt, - } = ov; - function jLe(t) { - return cjt(t.key).nodeType === "atom"; - } - var _me = class { - constructor(e, r) { - fn(this, "_store", void 0), - fn(this, "_treeState", void 0), - fn(this, "_changes", void 0), - fn(this, "get", (n) => { - if (this._changes.has(n.key)) return this._changes.get(n.key); - if (!jLe(n)) - throw Pn("Reading selectors within atomicUpdate is not supported"); - let i = fjt(this._store, n, this._treeState); - if (i.state === "hasValue") return i.contents; - throw i.state === "hasError" - ? i.contents - : Pn( - `Expected Recoil atom ${n.key} to have a value, but it is in a loading state.` - ); - }), - fn(this, "set", (n, i) => { - if (!jLe(n)) - throw Pn("Setting selectors within atomicUpdate is not supported"); - if (typeof i == "function") { - let o = this.get(n); - this._changes.set(n.key, i(o)); - } else sjt(this._store, n.key, "set"), this._changes.set(n.key, i); - }), - fn(this, "reset", (n) => { - this.set(n, ujt); - }), - (this._store = e), - (this._treeState = r), - (this._changes = new Map()); - } - newTreeState_INTERNAL() { - if (this._changes.size === 0) return this._treeState; - let e = ljt(this._treeState); - for (let [r, n] of this._changes) hjt(e, r, ajt(n)); - return djt(this._store, e), e; - } - }; - function pjt(t) { - return (e) => { - t.replaceState((r) => { - let n = new _me(t, r); - return e(n), n.newTreeState_INTERNAL(); - }); - }; - } - var yjt = { atomicUpdater: pjt }, - mjt = yjt.atomicUpdater, - Vqe = Object.freeze({ __proto__: null, atomicUpdater: mjt }); - function gjt(t, e) { - if (!t) throw new Error(e); - } - var vjt = gjt, - jL = vjt, - { atomicUpdater: bjt } = Vqe, - { batchUpdates: wjt } = c$, - { DEFAULT_VALUE: _jt } = Eh, - { useStoreRef: xjt } = S_, - { refreshRecoilValue: Sjt, setRecoilValue: ULe } = ov, - { cloneSnapshot: Ajt } = d$, - { gotoSnapshot: Ejt } = Hqe, - { useCallback: Mjt } = na.default, - YJ = class {}, - Tjt = new YJ(); - function Wqe(t, e, r, n) { - let i = Tjt, - o; - if ( - (wjt(() => { - let s = - "useRecoilCallback() expects a function that returns a function: it accepts a function of the type (RecoilInterface) => (Args) => ReturnType and returns a callback function (Args) => ReturnType, where RecoilInterface is an object {snapshot, set, ...} and Args and ReturnType are the argument and return types of the callback you want to create. Please see the docs at recoiljs.org for details."; - if (typeof e != "function") throw Pn(s); - let c = iqe( - { - ...(n ?? {}), - set: (h, w) => ULe(t, h, w), - reset: (h) => ULe(t, h, _jt), - refresh: (h) => Sjt(t, h), - gotoSnapshot: (h) => Ejt(t, h), - transact_UNSTABLE: (h) => bjt(t)(h), - }, - { - snapshot: () => { - let h = Ajt(t); - return (o = h.retain()), h; - }, - } - ), - u = e(c); - if (typeof u != "function") throw Pn(s); - i = u(...r); - }), - i instanceof YJ && jL(!1), - ta(i)) - ) - i.finally(() => { - var s; - (s = o) === null || s === void 0 || s(); - }); - else { - var a; - (a = o) === null || a === void 0 || a(); - } - return i; - } - function kjt(t, e) { - let r = xjt(); - return Mjt((...n) => Wqe(r.current, t, n), e != null ? [...e, r] : void 0); - } - var Gqe = { recoilCallback: Wqe, useRecoilCallback: kjt }, - { useStoreRef: Pjt } = S_, - { refreshRecoilValue: Ojt } = ov, - { useCallback: Bjt } = na.default; - function Ijt(t) { - let e = Pjt(); - return Bjt(() => { - let r = e.current; - Ojt(r, t); - }, [t, e]); - } - var Cjt = Ijt, - { atomicUpdater: Rjt } = Vqe, - { useStoreRef: Njt } = S_, - { useMemo: Djt } = na.default; - function Fjt(t, e) { - let r = Njt(); - return Djt( - () => - (...n) => { - Rjt(r.current)((o) => { - t(o)(...n); - }); - }, - e != null ? [...e, r] : void 0 - ); - } - var Ljt = Fjt, - xme = class { - constructor(e) { - fn(this, "value", void 0), (this.value = e); - } - }, - qjt = { WrappedValue: xme }, - zjt = qjt.WrappedValue, - Jqe = Object.freeze({ __proto__: null, WrappedValue: zjt }), - { isFastRefreshEnabled: jjt } = ZI, - QJ = class extends Error {}, - Sme = class { - constructor(e) { - var r, n, i; - fn(this, "_name", void 0), - fn(this, "_numLeafs", void 0), - fn(this, "_root", void 0), - fn(this, "_onHit", void 0), - fn(this, "_onSet", void 0), - fn(this, "_mapNodeValue", void 0), - (this._name = e?.name), - (this._numLeafs = 0), - (this._root = null), - (this._onHit = - (r = e?.onHit) !== null && r !== void 0 ? r : () => {}), - (this._onSet = - (n = e?.onSet) !== null && n !== void 0 ? n : () => {}), - (this._mapNodeValue = - (i = e?.mapNodeValue) !== null && i !== void 0 ? i : (o) => o); - } - size() { - return this._numLeafs; - } - root() { - return this._root; - } - get(e, r) { - var n; - return (n = this.getLeafNode(e, r)) === null || n === void 0 - ? void 0 - : n.value; - } - getLeafNode(e, r) { - if (this._root == null) return; - let n = this._root; - for (; n; ) { - if ((r?.onNodeVisit(n), n.type === "leaf")) return this._onHit(n), n; - let i = this._mapNodeValue(e(n.nodeKey)); - n = n.branches.get(i); - } - } - set(e, r, n) { - let i = () => { - var o, a, s, c; - let u, h; - for (let [F, N] of e) { - var w, M, k; - let q = this._root; - if (q?.type === "leaf") throw this.invalidCacheError(); - let z = u; - if ( - ((u = z ? z.branches.get(h) : q), - (u = - (w = u) !== null && w !== void 0 - ? w - : { - type: "branch", - nodeKey: F, - parent: z, - branches: new Map(), - branchKey: h, - }), - u.type !== "branch" || u.nodeKey !== F) - ) - throw this.invalidCacheError(); - z?.branches.set(h, u), - n == null || - (M = n.onNodeVisit) === null || - M === void 0 || - M.call(n, u), - (h = this._mapNodeValue(N)), - (this._root = (k = this._root) !== null && k !== void 0 ? k : u); - } - let O = u - ? (o = u) === null || o === void 0 - ? void 0 - : o.branches.get(h) - : this._root; - if (O != null && (O.type !== "leaf" || O.branchKey !== h)) - throw this.invalidCacheError(); - let D = { type: "leaf", value: r, parent: u, branchKey: h }; - (a = u) === null || a === void 0 || a.branches.set(h, D), - (this._root = (s = this._root) !== null && s !== void 0 ? s : D), - this._numLeafs++, - this._onSet(D), - n == null || - (c = n.onNodeVisit) === null || - c === void 0 || - c.call(n, D); - }; - try { - i(); - } catch (o) { - if (o instanceof QJ) this.clear(), i(); - else throw o; - } - } - delete(e) { - let r = this.root(); - if (!r) return !1; - if (e === r) return (this._root = null), (this._numLeafs = 0), !0; - let n = e.parent, - i = e.branchKey; - for (; n; ) { - var o; - if ((n.branches.delete(i), n === r)) - return ( - n.branches.size === 0 - ? ((this._root = null), (this._numLeafs = 0)) - : this._numLeafs--, - !0 - ); - if (n.branches.size > 0) break; - (i = (o = n) === null || o === void 0 ? void 0 : o.branchKey), - (n = n.parent); - } - for (; n !== r; n = n.parent) if (n == null) return !1; - return this._numLeafs--, !0; - } - clear() { - (this._numLeafs = 0), (this._root = null); - } - invalidCacheError() { - let e = jjt() - ? "Possible Fast Refresh module reload detected. This may also be caused by an selector returning inconsistent values. Resetting cache." - : "Invalid cache values. This happens when selectors do not return consistent values for the same input dependency values. That may also be caused when using Fast Refresh to change a selector implementation. Resetting cache."; - throw ( - (Ah(e + (this._name != null ? ` - ${this._name}` : "")), new QJ()) - ); - } - }, - Ujt = { TreeCache: Sme }, - Kjt = Ujt.TreeCache, - $qe = Object.freeze({ __proto__: null, TreeCache: Kjt }), - Ame = class { - constructor(e) { - var r; - fn(this, "_maxSize", void 0), - fn(this, "_size", void 0), - fn(this, "_head", void 0), - fn(this, "_tail", void 0), - fn(this, "_map", void 0), - fn(this, "_keyMapper", void 0), - (this._maxSize = e.maxSize), - (this._size = 0), - (this._head = null), - (this._tail = null), - (this._map = new Map()), - (this._keyMapper = - (r = e.mapKey) !== null && r !== void 0 ? r : (n) => n); - } - head() { - return this._head; - } - tail() { - return this._tail; - } - size() { - return this._size; - } - maxSize() { - return this._maxSize; - } - has(e) { - return this._map.has(this._keyMapper(e)); - } - get(e) { - let r = this._keyMapper(e), - n = this._map.get(r); - if (!!n) return this.set(e, n.value), n.value; - } - set(e, r) { - let n = this._keyMapper(e); - this._map.get(n) && this.delete(e); - let o = this.head(), - a = { key: e, right: o, left: null, value: r }; - o ? (o.left = a) : (this._tail = a), - this._map.set(n, a), - (this._head = a), - this._size++, - this._maybeDeleteLRU(); - } - _maybeDeleteLRU() { - this.size() > this.maxSize() && this.deleteLru(); - } - deleteLru() { - let e = this.tail(); - e && this.delete(e.key); - } - delete(e) { - let r = this._keyMapper(e); - if (!this._size || !this._map.has(r)) return; - let n = ra(this._map.get(r)), - i = n.right, - o = n.left; - i && (i.left = n.left), - o && (o.right = n.right), - n === this.head() && (this._head = i), - n === this.tail() && (this._tail = o), - this._map.delete(r), - this._size--; - } - clear() { - (this._size = 0), - (this._head = null), - (this._tail = null), - (this._map = new Map()); - } - }, - Hjt = { LRUCache: Ame }, - Vjt = Hjt.LRUCache, - Zqe = Object.freeze({ __proto__: null, LRUCache: Vjt }), - { LRUCache: Wjt } = Zqe, - { TreeCache: Gjt } = $qe; - function Jjt({ name: t, maxSize: e, mapNodeValue: r = (n) => n }) { - let n = new Wjt({ maxSize: e }), - i = new Gjt({ - name: t, - mapNodeValue: r, - onHit: (o) => { - n.set(o, !0); - }, - onSet: (o) => { - let a = n.tail(); - n.set(o, !0), a && i.size() > e && i.delete(a.key); - }, - }); - return i; - } - var KLe = Jjt; - function Bm(t, e, r) { - if (typeof t == "string" && !t.includes('"') && !t.includes("\\")) - return `"${t}"`; - switch (typeof t) { - case "undefined": - return ""; - case "boolean": - return t ? "true" : "false"; - case "number": - case "symbol": - return String(t); - case "string": - return JSON.stringify(t); - case "function": - if (e?.allowFunctions !== !0) - throw Pn("Attempt to serialize function in a Recoil cache key"); - return `__FUNCTION(${t.name})__`; - } - if (t === null) return "null"; - if (typeof t != "object") { - var n; - return (n = JSON.stringify(t)) !== null && n !== void 0 ? n : ""; - } - if (ta(t)) return "__PROMISE__"; - if (Array.isArray(t)) return `[${t.map((i, o) => Bm(i, e, o.toString()))}]`; - if (typeof t.toJSON == "function") return Bm(t.toJSON(r), e, r); - if (t instanceof Map) { - let i = {}; - for (let [o, a] of t) i[typeof o == "string" ? o : Bm(o, e)] = a; - return Bm(i, e, r); - } - return t instanceof Set - ? Bm( - Array.from(t).sort((i, o) => Bm(i, e).localeCompare(Bm(o, e))), - e, - r - ) - : Symbol !== void 0 && - t[Symbol.iterator] != null && - typeof t[Symbol.iterator] == "function" - ? Bm(Array.from(t), e, r) - : `{${Object.keys(t) - .filter((i) => t[i] !== void 0) - .sort() - .map((i) => `${Bm(i, e)}:${Bm(t[i], e, i)}`) - .join(",")}}`; - } - function $jt(t, e = { allowFunctions: !1 }) { - return Bm(t, e); - } - var g$ = $jt, - { TreeCache: Zjt } = $qe, - DJ = { equality: "reference", eviction: "keep-all", maxSize: 1 / 0 }; - function Xjt( - { - equality: t = DJ.equality, - eviction: e = DJ.eviction, - maxSize: r = DJ.maxSize, - } = DJ, - n - ) { - let i = Yjt(t); - return Qjt(e, r, i, n); - } - function Yjt(t) { - switch (t) { - case "reference": - return (e) => e; - case "value": - return (e) => g$(e); - } - throw Pn(`Unrecognized equality policy ${t}`); - } - function Qjt(t, e, r, n) { - switch (t) { - case "keep-all": - return new Zjt({ name: n, mapNodeValue: r }); - case "lru": - return KLe({ name: n, maxSize: ra(e), mapNodeValue: r }); - case "most-recent": - return KLe({ name: n, maxSize: 1, mapNodeValue: r }); - } - throw Pn(`Unrecognized eviction policy ${t}`); - } - var eUt = Xjt; - var { isReactNative: uun, isWindow: cun } = l$; - function tUt(t) { - return () => null; - } - var rUt = { startPerfBlock: tUt }, - { - isLoadable: nUt, - loadableWithError: FJ, - loadableWithPromise: iUt, - loadableWithValue: cme, - } = $L, - { WrappedValue: Xqe } = Jqe, - { getNodeLoadable: LJ, peekNodeLoadable: oUt, setNodeValue: aUt } = YS, - { saveDepsToStore: sUt } = ZL, - { - DEFAULT_VALUE: uUt, - getConfigDeletionHandler: cUt, - getNode: lUt, - registerNode: HLe, - } = Eh, - { isRecoilValue: fUt } = eM, - { markRecoilValueModified: VLe } = ov, - { retainedByOptionWithDefault: dUt } = nM, - { recoilCallback: hUt } = Gqe, - { startPerfBlock: pUt } = rUt, - e$ = class {}, - LL = new e$(), - qL = [], - qJ = new Map(), - yUt = (() => { - let t = 0; - return () => t++; - })(); - function Yqe(t) { - let e = null, - { key: r, get: n, cachePolicy_UNSTABLE: i } = t, - o = t.set != null ? t.set : void 0, - a = new Set(), - s = eUt(i ?? { equality: "reference", eviction: "keep-all" }, r), - c = dUt(t.retainedBy_UNSTABLE), - u = new Map(), - h = 0; - function w() { - return !xo("recoil_memory_managament_2020") || h > 0; - } - function M(E) { - return ( - E.getState().knownSelectors.add(r), - h++, - () => { - h--; - } - ); - } - function k() { - return cUt(r) !== void 0 && !w(); - } - function O(E, B, G, L, ee) { - _(B, L, ee), D(E, G); - } - function D(E, B) { - d(E, B) && y(E), N(B, !0); - } - function F(E, B) { - d(E, B) && (ra(A(E)).stateVersions.clear(), N(B, !1)); - } - function N(E, B) { - let G = qJ.get(E); - if (G != null) { - for (let L of G) VLe(L, ra(e)); - B && qJ.delete(E); - } - } - function q(E, B) { - let G = qJ.get(B); - G == null && qJ.set(B, (G = new Set())), G.add(E); - } - function z(E, B, G, L, ee, ge) { - return B.then((fe) => { - if (!w()) throw (y(E), LL); - let V = cme(fe); - return O(E, G, ee, V, L), fe; - }).catch((fe) => { - if (!w()) throw (y(E), LL); - if (ta(fe)) return H(E, fe, G, L, ee, ge); - let V = FJ(fe); - throw (O(E, G, ee, V, L), fe); - }); - } - function H(E, B, G, L, ee, ge) { - return B.then((fe) => { - if (!w()) throw (y(E), LL); - ge.loadingDepKey != null && ge.loadingDepPromise === B - ? G.atomValues.set(ge.loadingDepKey, cme(fe)) - : E.getState().knownSelectors.forEach((le) => { - G.atomValues.delete(le); - }); - let V = ue(E, G); - if (V && V.state !== "loading") { - if (((d(E, ee) || A(E) == null) && D(E, ee), V.state === "hasValue")) - return V.contents; - throw V.contents; - } - if (!d(E, ee)) { - let le = ne(E, G); - if (le != null) return le.loadingLoadable.contents; - } - let [ye, ae] = $(E, G, ee); - if ( - (ye.state !== "loading" && O(E, G, ee, ye, ae), - ye.state === "hasError") - ) - throw ye.contents; - return ye.contents; - }).catch((fe) => { - if (fe instanceof e$) throw LL; - if (!w()) throw (y(E), LL); - let V = FJ(fe); - throw (O(E, G, ee, V, L), fe); - }); - } - function Z(E, B, G, L) { - var ee, ge, fe, V; - if ( - d(E, L) || - B.version === - ((ee = E.getState()) === null || - ee === void 0 || - (ge = ee.currentTree) === null || - ge === void 0 - ? void 0 - : ge.version) || - B.version === - ((fe = E.getState()) === null || - fe === void 0 || - (V = fe.nextTree) === null || - V === void 0 - ? void 0 - : V.version) - ) { - var ye, ae, le; - sUt( - r, - G, - E, - (ye = - (ae = E.getState()) === null || - ae === void 0 || - (le = ae.nextTree) === null || - le === void 0 - ? void 0 - : le.version) !== null && ye !== void 0 - ? ye - : E.getState().currentTree.version - ); - } - for (let Me of G) a.add(Me); - } - function $(E, B, G) { - let L = pUt(r), - ee = !0, - ge = !0, - fe = () => { - L(), (ge = !1); - }, - V, - ye = !1, - ae, - le = { loadingDepKey: null, loadingDepPromise: null }, - Me = new Map(); - function de({ key: De }) { - let me = LJ(E, B, De); - switch ( - (Me.set(De, me), - ee || (Z(E, B, new Set(Me.keys()), G), F(E, G)), - me.state) - ) { - case "hasValue": - return me.contents; - case "hasError": - throw me.contents; - case "loading": - throw ( - ((le.loadingDepKey = De), - (le.loadingDepPromise = me.contents), - me.contents) - ); - } - throw Pn("Invalid Loadable state"); - } - let ve = - (De) => - (...me) => { - if (ge) - throw Pn( - "Callbacks from getCallback() should only be called asynchronously after the selector is evalutated. It can be used for selectors to return objects with callbacks that can work with Recoil state without a subscription." - ); - return e == null && jL(!1), hUt(E, De, me, { node: e }); - }; - try { - (V = n({ get: de, getCallback: ve })), - (V = fUt(V) ? de(V) : V), - nUt(V) && (V.state === "hasError" && (ye = !0), (V = V.contents)), - ta(V) ? (V = z(E, V, B, Me, G, le).finally(fe)) : fe(), - (V = V instanceof Xqe ? V.value : V); - } catch (De) { - (V = De), - ta(V) ? (V = H(E, V, B, Me, G, le).finally(fe)) : ((ye = !0), fe()); - } - return ( - ye ? (ae = FJ(V)) : ta(V) ? (ae = iUt(V)) : (ae = cme(V)), - (ee = !1), - p(E, G, Me), - Z(E, B, new Set(Me.keys()), G), - [ae, Me] - ); - } - function ue(E, B) { - let G = B.atomValues.get(r); - if (G != null) return G; - let L = new Set(); - try { - G = s.get( - (ge) => (typeof ge != "string" && jL(!1), LJ(E, B, ge).contents), - { - onNodeVisit: (ge) => { - ge.type === "branch" && ge.nodeKey !== r && L.add(ge.nodeKey); - }, - } - ); - } catch (ge) { - throw Pn( - `Problem with cache lookup for selector "${r}": ${ge.message}` - ); - } - if (G) { - var ee; - B.atomValues.set(r, G), - Z( - E, - B, - L, - (ee = A(E)) === null || ee === void 0 ? void 0 : ee.executionID - ); - } - return G; - } - function te(E, B) { - let G = ue(E, B); - if (G != null) return y(E), G; - let L = ne(E, B); - if (L != null) { - var ee; - return ( - ((ee = L.loadingLoadable) === null || ee === void 0 - ? void 0 - : ee.state) === "loading" && q(E, L.executionID), - L.loadingLoadable - ); - } - let ge = yUt(), - [fe, V] = $(E, B, ge); - return ( - fe.state === "loading" - ? (l(E, ge, fe, V, B), q(E, ge)) - : (y(E), _(B, fe, V)), - fe - ); - } - function ne(E, B) { - let G = _qe([ - u.has(E) ? [ra(u.get(E))] : [], - o$( - Ome(u, ([ee]) => ee !== E), - ([, ee]) => ee - ), - ]); - function L(ee) { - for (let [ge, fe] of ee) if (!LJ(E, B, ge).is(fe)) return !0; - return !1; - } - for (let ee of G) { - if ( - ee.stateVersions.get(B.version) || - !L(ee.depValuesDiscoveredSoFarDuringAsyncWork) - ) - return ee.stateVersions.set(B.version, !0), ee; - ee.stateVersions.set(B.version, !1); - } - } - function A(E) { - return u.get(E); - } - function l(E, B, G, L, ee) { - u.set(E, { - depValuesDiscoveredSoFarDuringAsyncWork: L, - executionID: B, - loadingLoadable: G, - stateVersions: new Map([[ee.version, !0]]), - }); - } - function p(E, B, G) { - if (d(E, B)) { - let L = A(E); - L != null && (L.depValuesDiscoveredSoFarDuringAsyncWork = G); - } - } - function y(E) { - u.delete(E); - } - function d(E, B) { - var G; - return ( - B === ((G = A(E)) === null || G === void 0 ? void 0 : G.executionID) - ); - } - function v(E) { - return Array.from(E.entries()).map(([B, G]) => [B, G.contents]); - } - function _(E, B, G) { - E.atomValues.set(r, B); - try { - s.set(v(G), B); - } catch (L) { - throw Pn( - `Problem with setting cache for selector "${r}": ${L.message}` - ); - } - } - function S(E) { - if (qL.includes(r)) { - let B = `Recoil selector has circular dependencies: ${qL - .slice(qL.indexOf(r)) - .join(" \u2192 ")}`; - return FJ(Pn(B)); - } - qL.push(r); - try { - return E(); - } finally { - qL.pop(); - } - } - function b(E, B) { - let G = B.atomValues.get(r); - return ( - G ?? - s.get((L) => { - var ee; - return ( - typeof L != "string" && jL(!1), - (ee = oUt(E, B, L)) === null || ee === void 0 ? void 0 : ee.contents - ); - }) - ); - } - function f(E, B) { - return S(() => te(E, B)); - } - function x(E) { - E.atomValues.delete(r); - } - function C(E, B) { - e == null && jL(!1); - for (let L of a) { - var G; - let ee = lUt(L); - (G = ee.clearCache) === null || G === void 0 || G.call(ee, E, B); - } - a.clear(), x(B), s.clear(), VLe(E, e); - } - return o != null - ? (e = HLe({ - key: r, - nodeType: "selector", - peek: b, - get: f, - set: (B, G, L) => { - let ee = !1, - ge = new Map(); - function fe({ key: le }) { - if (ee) - throw Pn( - "Recoil: Async selector sets are not currently supported." - ); - let Me = LJ(B, G, le); - if (Me.state === "hasValue") return Me.contents; - if (Me.state === "loading") { - let de = `Getting value of asynchronous atom or selector "${le}" in a pending state while setting selector "${r}" is not yet supported.`; - throw (Ah(de), Pn(de)); - } else throw Me.contents; - } - function V(le, Me) { - if (ee) { - let De = - "Recoil: Async selector sets are not currently supported."; - throw (Ah(De), Pn(De)); - } - let de = typeof Me == "function" ? Me(fe(le)) : Me; - aUt(B, G, le.key, de).forEach((De, me) => ge.set(me, De)); - } - function ye(le) { - V(le, uUt); - } - let ae = o({ set: V, get: fe, reset: ye }, L); - if (ae !== void 0) - throw ta(ae) - ? Pn("Recoil: Async selector sets are not currently supported.") - : Pn("Recoil: selector set should be a void function."); - return (ee = !0), ge; - }, - init: M, - invalidate: x, - clearCache: C, - shouldDeleteConfigOnRelease: k, - dangerouslyAllowMutability: t.dangerouslyAllowMutability, - shouldRestoreFromSnapshots: !1, - retainedBy: c, - })) - : (e = HLe({ - key: r, - nodeType: "selector", - peek: b, - get: f, - init: M, - invalidate: x, - clearCache: C, - shouldDeleteConfigOnRelease: k, - dangerouslyAllowMutability: t.dangerouslyAllowMutability, - shouldRestoreFromSnapshots: !1, - retainedBy: c, - })); - } - Yqe.value = (t) => new Xqe(t); - var $I = Yqe, - { - isLoadable: mUt, - loadableWithError: lme, - loadableWithPromise: fme, - loadableWithValue: UI, - } = $L, - { WrappedValue: Qqe } = Jqe, - { peekNodeInfo: gUt } = YS, - { - DEFAULT_VALUE: Y3, - DefaultValue: XS, - getConfigDeletionHandler: eze, - registerNode: vUt, - setConfigDeletionHandler: bUt, - } = Eh, - { isRecoilValue: wUt } = eM, - { - getRecoilValueAsLoadable: _Ut, - markRecoilValueModified: xUt, - setRecoilValue: WLe, - setRecoilValueLoadable: SUt, - } = ov, - { retainedByOptionWithDefault: AUt } = nM, - zL = (t) => (t instanceof Qqe ? t.value : t); - function EUt(t) { - let { key: e, persistence_UNSTABLE: r } = t, - n = AUt(t.retainedBy_UNSTABLE), - i = 0; - function o(q) { - return fme( - q - .then((z) => ((a = UI(z)), z)) - .catch((z) => { - throw ((a = lme(z)), z); - }) - ); - } - let a = ta(t.default) - ? o(t.default) - : mUt(t.default) - ? t.default.state === "loading" - ? o(t.default.contents) - : t.default - : UI(zL(t.default)); - a.contents; - let s, - c = new Map(); - function u(q) { - return q; - } - function h(q, z) { - let H = z - .then((Z) => { - var $, ue; - return ( - ((ue = ( - ($ = q.getState().nextTree) !== null && $ !== void 0 - ? $ - : q.getState().currentTree - ).atomValues.get(e)) === null || ue === void 0 - ? void 0 - : ue.contents) === H && WLe(q, N, Z), - Z - ); - }) - .catch((Z) => { - var $, ue; - throw ( - (((ue = ( - ($ = q.getState().nextTree) !== null && $ !== void 0 - ? $ - : q.getState().currentTree - ).atomValues.get(e)) === null || ue === void 0 - ? void 0 - : ue.contents) === H && SUt(q, N, lme(Z)), - Z) - ); - }); - return H; - } - function w(q, z, H) { - var Z; - i++; - let $ = () => { - var A; - i--, - (A = c.get(q)) === null || A === void 0 || A.forEach((l) => l()), - c.delete(q); - }; - if ((q.getState().knownAtoms.add(e), a.state === "loading")) { - let A = () => { - var l; - ((l = q.getState().nextTree) !== null && l !== void 0 - ? l - : q.getState().currentTree - ).atomValues.has(e) || xUt(q, N); - }; - a.contents.finally(A); - } - let ue = - (Z = t.effects) !== null && Z !== void 0 ? Z : t.effects_UNSTABLE; - if (ue != null) { - let d = function (x) { - if (l && x.key === e) { - let C = A; - return C instanceof XS - ? M(q, z) - : ta(C) - ? fme(C.then((E) => (E instanceof XS ? a.toPromise() : E))) - : UI(C); - } - return _Ut(q, x); - }, - v = function (x) { - return d(x).toPromise(); - }, - _ = function (x) { - var C; - let E = gUt( - q, - (C = q.getState().nextTree) !== null && C !== void 0 - ? C - : q.getState().currentTree, - x.key - ); - return l && x.key === e && !(A instanceof XS) - ? { ...E, isSet: !0, loadable: d(x) } - : E; - }, - A = Y3, - l = !0, - p = !1, - y = null, - S = (x) => (C) => { - if (l) { - let E = d(N), - B = E.state === "hasValue" ? E.contents : Y3; - (A = typeof C == "function" ? C(B) : C), - ta(A) && - (A = A.then((G) => ((y = { effect: x, value: G }), G))); - } else { - if (ta(C)) - throw Pn("Setting atoms to async values is not implemented."); - typeof C != "function" && (y = { effect: x, value: zL(C) }), - WLe( - q, - N, - typeof C == "function" - ? (E) => { - let B = zL(C(E)); - return (y = { effect: x, value: B }), B; - } - : zL(C) - ); - } - }, - b = (x) => () => S(x)(Y3), - f = (x) => (C) => { - var E; - let { release: B } = q.subscribeToTransactions((G) => { - var L; - let { currentTree: ee, previousTree: ge } = G.getState(); - ge || - (Ah( - "Transaction subscribers notified without a next tree being present -- this is a bug in Recoil" - ), - (ge = ee)); - let fe = - (L = ee.atomValues.get(e)) !== null && L !== void 0 ? L : a; - if (fe.state === "hasValue") { - var V, ye, ae, le; - let Me = fe.contents, - de = - (V = ge.atomValues.get(e)) !== null && V !== void 0 ? V : a, - ve = de.state === "hasValue" ? de.contents : Y3; - ((ye = y) === null || ye === void 0 ? void 0 : ye.effect) !== - x || - ((ae = y) === null || ae === void 0 ? void 0 : ae.value) !== Me - ? C(Me, ve, !ee.atomValues.has(e)) - : ((le = y) === null || le === void 0 - ? void 0 - : le.effect) === x && (y = null); - } - }, e); - c.set(q, [ - ...((E = c.get(q)) !== null && E !== void 0 ? E : []), - B, - ]); - }; - for (let x of ue) - try { - let C = x({ - node: N, - storeID: q.storeID, - parentStoreID_UNSTABLE: q.parentStoreID, - trigger: H, - setSelf: S(x), - resetSelf: b(x), - onSet: f(x), - getPromise: v, - getLoadable: d, - getInfo_UNSTABLE: _, - }); - if (C != null) { - var te; - c.set(q, [ - ...((te = c.get(q)) !== null && te !== void 0 ? te : []), - C, - ]); - } - } catch (C) { - (A = C), (p = !0); - } - if (((l = !1), !(A instanceof XS))) { - var ne; - let x = p ? lme(A) : ta(A) ? fme(h(q, A)) : UI(zL(A)); - x.contents, - z.atomValues.set(e, x), - (ne = q.getState().nextTree) === null || - ne === void 0 || - ne.atomValues.set(e, x); - } - } - return $; - } - function M(q, z) { - var H, Z; - return (H = - (Z = z.atomValues.get(e)) !== null && Z !== void 0 ? Z : s) !== null && - H !== void 0 - ? H - : a; - } - function k(q, z) { - if (z.atomValues.has(e)) return ra(z.atomValues.get(e)); - if (z.nonvalidatedAtoms.has(e)) { - if (s != null) return s; - if (r == null) - return ( - Tme( - `Tried to restore a persisted value for atom ${e} but it has no persistence settings.` - ), - a - ); - let H = z.nonvalidatedAtoms.get(e), - Z = r.validator(H, Y3); - return (s = Z instanceof XS ? a : UI(Z)), s; - } else return a; - } - function O() { - s = void 0; - } - function D(q, z, H) { - if (z.atomValues.has(e)) { - let Z = ra(z.atomValues.get(e)); - if (Z.state === "hasValue" && H === Z.contents) return new Map(); - } else if (!z.nonvalidatedAtoms.has(e) && H instanceof XS) - return new Map(); - return (s = void 0), new Map().set(e, UI(H)); - } - function F() { - return eze(e) !== void 0 && i <= 0; - } - let N = vUt({ - key: e, - nodeType: "atom", - peek: M, - get: k, - set: D, - init: w, - invalidate: O, - shouldDeleteConfigOnRelease: F, - dangerouslyAllowMutability: t.dangerouslyAllowMutability, - persistence_UNSTABLE: t.persistence_UNSTABLE - ? { - type: t.persistence_UNSTABLE.type, - backButton: t.persistence_UNSTABLE.backButton, - } - : void 0, - shouldRestoreFromSnapshots: !0, - retainedBy: n, - }); - return N; - } - function zme(t) { - let { ...e } = t, - r = "default" in t ? t.default : new Promise(() => {}); - return wUt(r) ? MUt({ ...e, default: r }) : EUt({ ...e, default: r }); - } - function MUt(t) { - let e = zme({ - ...t, - default: Y3, - persistence_UNSTABLE: - t.persistence_UNSTABLE === void 0 - ? void 0 - : { - ...t.persistence_UNSTABLE, - validator: (n) => - n instanceof XS - ? n - : ra(t.persistence_UNSTABLE).validator(n, Y3), - }, - effects: t.effects, - effects_UNSTABLE: t.effects_UNSTABLE, - }), - r = $I({ - key: `${t.key}__withFallback`, - get: ({ get: n }) => { - let i = n(e); - return i instanceof XS ? t.default : i; - }, - set: ({ set: n }, i) => n(e, i), - cachePolicy_UNSTABLE: { eviction: "most-recent" }, - dangerouslyAllowMutability: t.dangerouslyAllowMutability, - }); - return bUt(r.key, eze(t.key)), r; - } - zme.value = (t) => new Qqe(t); - var tze = zme, - Eme = class { - constructor(e) { - var r; - fn(this, "_map", void 0), - fn(this, "_keyMapper", void 0), - (this._map = new Map()), - (this._keyMapper = - (r = e?.mapKey) !== null && r !== void 0 ? r : (n) => n); - } - size() { - return this._map.size; - } - has(e) { - return this._map.has(this._keyMapper(e)); - } - get(e) { - return this._map.get(this._keyMapper(e)); - } - set(e, r) { - this._map.set(this._keyMapper(e), r); - } - delete(e) { - this._map.delete(this._keyMapper(e)); - } - clear() { - this._map.clear(); - } - }, - TUt = { MapCache: Eme }, - kUt = TUt.MapCache, - PUt = Object.freeze({ __proto__: null, MapCache: kUt }), - { LRUCache: GLe } = Zqe, - { MapCache: OUt } = PUt, - zJ = { equality: "reference", eviction: "none", maxSize: 1 / 0 }; - function BUt({ - equality: t = zJ.equality, - eviction: e = zJ.eviction, - maxSize: r = zJ.maxSize, - } = zJ) { - let n = IUt(t); - return CUt(e, r, n); - } - function IUt(t) { - switch (t) { - case "reference": - return (e) => e; - case "value": - return (e) => g$(e); - } - throw Pn(`Unrecognized equality policy ${t}`); - } - function CUt(t, e, r) { - switch (t) { - case "keep-all": - return new OUt({ mapKey: r }); - case "lru": - return new GLe({ mapKey: r, maxSize: ra(e) }); - case "most-recent": - return new GLe({ mapKey: r, maxSize: 1 }); - } - throw Pn(`Unrecognized eviction policy ${t}`); - } - var rze = BUt, - { setConfigDeletionHandler: RUt } = Eh; - function NUt(t) { - var e, r; - let n = rze({ - equality: - (e = - (r = t.cachePolicyForParams_UNSTABLE) === null || r === void 0 - ? void 0 - : r.equality) !== null && e !== void 0 - ? e - : "value", - eviction: "keep-all", - }); - return (i) => { - var o, a; - let s = n.get(i); - if (s != null) return s; - let { cachePolicyForParams_UNSTABLE: c, ...u } = t, - h = "default" in t ? t.default : new Promise(() => {}), - w = tze({ - ...u, - key: `${t.key}__${(o = g$(i)) !== null && o !== void 0 ? o : "void"}`, - default: typeof h == "function" ? h(i) : h, - retainedBy_UNSTABLE: - typeof t.retainedBy_UNSTABLE == "function" - ? t.retainedBy_UNSTABLE(i) - : t.retainedBy_UNSTABLE, - effects: - typeof t.effects == "function" - ? t.effects(i) - : typeof t.effects_UNSTABLE == "function" - ? t.effects_UNSTABLE(i) - : (a = t.effects) !== null && a !== void 0 - ? a - : t.effects_UNSTABLE, - }); - return ( - n.set(i, w), - RUt(w.key, () => { - n.delete(i); - }), - w - ); - }; - } - var DUt = NUt, - { setConfigDeletionHandler: FUt } = Eh, - LUt = 0; - function qUt(t) { - var e, r; - let n = rze({ - equality: - (e = - (r = t.cachePolicyForParams_UNSTABLE) === null || r === void 0 - ? void 0 - : r.equality) !== null && e !== void 0 - ? e - : "value", - eviction: "keep-all", - }); - return (i) => { - var o; - let a; - try { - a = n.get(i); - } catch (M) { - throw Pn( - `Problem with cache lookup for selector ${t.key}: ${M.message}` - ); - } - if (a != null) return a; - let s = `${t.key}__selectorFamily/${ - (o = g$(i, { allowFunctions: !0 })) !== null && o !== void 0 - ? o - : "void" - }/${LUt++}`, - c = (M) => t.get(i)(M), - u = t.cachePolicy_UNSTABLE, - h = - typeof t.retainedBy_UNSTABLE == "function" - ? t.retainedBy_UNSTABLE(i) - : t.retainedBy_UNSTABLE, - w; - if (t.set != null) { - let M = t.set; - w = $I({ - key: s, - get: c, - set: (O, D) => M(i)(O, D), - cachePolicy_UNSTABLE: u, - dangerouslyAllowMutability: t.dangerouslyAllowMutability, - retainedBy_UNSTABLE: h, - }); - } else - w = $I({ - key: s, - get: c, - cachePolicy_UNSTABLE: u, - dangerouslyAllowMutability: t.dangerouslyAllowMutability, - retainedBy_UNSTABLE: h, - }); - return ( - n.set(i, w), - FUt(w.key, () => { - n.delete(i); - }), - w - ); - }; - } - var QS = qUt, - zUt = QS({ - key: "__constant", - get: (t) => () => t, - cachePolicyForParams_UNSTABLE: { equality: "reference" }, - }); - function jUt(t) { - return zUt(t); - } - var UUt = jUt, - KUt = QS({ - key: "__error", - get: (t) => () => { - throw Pn(t); - }, - cachePolicyForParams_UNSTABLE: { equality: "reference" }, - }); - function HUt(t) { - return KUt(t); - } - var VUt = HUt; - function WUt(t) { - return t; - } - var GUt = WUt, - { - loadableWithError: nze, - loadableWithPromise: ize, - loadableWithValue: oze, - } = $L; - function v$(t, e) { - let r = Array(e.length).fill(void 0), - n = Array(e.length).fill(void 0); - for (let [i, o] of e.entries()) - try { - r[i] = t(o); - } catch (a) { - n[i] = a; - } - return [r, n]; - } - function JUt(t) { - return t != null && !ta(t); - } - function b$(t) { - return Array.isArray(t) - ? t - : Object.getOwnPropertyNames(t).map((e) => t[e]); - } - function Mme(t, e) { - return Array.isArray(t) - ? e - : Object.getOwnPropertyNames(t).reduce( - (r, n, i) => ({ ...r, [n]: e[i] }), - {} - ); - } - function KI(t, e, r) { - let n = r.map((i, o) => (i == null ? oze(e[o]) : ta(i) ? ize(i) : nze(i))); - return Mme(t, n); - } - function $Ut(t, e) { - return e.map((r, n) => (r === void 0 ? t[n] : r)); - } - var ZUt = QS({ - key: "__waitForNone", - get: - (t) => - ({ get: e }) => { - let r = b$(t), - [n, i] = v$(e, r); - return KI(t, n, i); - }, - dangerouslyAllowMutability: !0, - }), - XUt = QS({ - key: "__waitForAny", - get: - (t) => - ({ get: e }) => { - let r = b$(t), - [n, i] = v$(e, r); - return i.some((o) => !ta(o)) - ? KI(t, n, i) - : new Promise((o) => { - for (let [a, s] of i.entries()) - ta(s) && - s - .then((c) => { - (n[a] = c), (i[a] = void 0), o(KI(t, n, i)); - }) - .catch((c) => { - (i[a] = c), o(KI(t, n, i)); - }); - }); - }, - dangerouslyAllowMutability: !0, - }), - YUt = QS({ - key: "__waitForAll", - get: - (t) => - ({ get: e }) => { - let r = b$(t), - [n, i] = v$(e, r); - if (i.every((a) => a == null)) return Mme(t, n); - let o = i.find(JUt); - if (o != null) throw o; - return Promise.all(i).then((a) => Mme(t, $Ut(n, a))); - }, - dangerouslyAllowMutability: !0, - }), - QUt = QS({ - key: "__waitForAllSettled", - get: - (t) => - ({ get: e }) => { - let r = b$(t), - [n, i] = v$(e, r); - return i.every((o) => !ta(o)) - ? KI(t, n, i) - : Promise.all( - i.map((o, a) => - ta(o) - ? o - .then((s) => { - (n[a] = s), (i[a] = void 0); - }) - .catch((s) => { - (n[a] = void 0), (i[a] = s); - }) - : null - ) - ).then(() => KI(t, n, i)); - }, - dangerouslyAllowMutability: !0, - }), - eKt = QS({ - key: "__noWait", - get: - (t) => - ({ get: e }) => { - try { - return $I.value(oze(e(t))); - } catch (r) { - return $I.value(ta(r) ? ize(r) : nze(r)); - } - }, - dangerouslyAllowMutability: !0, - }), - tKt = { - waitForNone: ZUt, - waitForAny: XUt, - waitForAll: YUt, - waitForAllSettled: QUt, - noWait: eKt, - }, - { RecoilLoadable: rKt } = $L, - { DefaultValue: nKt } = Eh, - { RecoilRoot: iKt, useRecoilStoreID: oKt } = S_, - { isRecoilValue: aKt } = eM, - { retentionZone: sKt } = s$, - { freshSnapshot: uKt } = d$, - { - useRecoilState: cKt, - useRecoilState_TRANSITION_SUPPORT_UNSTABLE: lKt, - useRecoilStateLoadable: fKt, - useRecoilValue: dKt, - useRecoilValue_TRANSITION_SUPPORT_UNSTABLE: hKt, - useRecoilValueLoadable: pKt, - useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE: yKt, - useResetRecoilState: mKt, - useSetRecoilState: gKt, - } = Izt, - { - useGotoRecoilSnapshot: vKt, - useRecoilSnapshot: bKt, - useRecoilTransactionObserver: wKt, - } = Hqe, - { useRecoilCallback: _Kt } = Gqe, - { - noWait: xKt, - waitForAll: SKt, - waitForAllSettled: AKt, - waitForAny: EKt, - waitForNone: MKt, - } = tKt, - Gn = { - DefaultValue: nKt, - isRecoilValue: aKt, - RecoilLoadable: rKt, - RecoilRoot: iKt, - useRecoilStoreID: oKt, - useRecoilBridgeAcrossReactRoots_UNSTABLE: ojt, - atom: tze, - selector: $I, - atomFamily: DUt, - selectorFamily: QS, - constSelector: UUt, - errorSelector: VUt, - readOnlySelector: GUt, - noWait: xKt, - waitForNone: MKt, - waitForAny: EKt, - waitForAll: SKt, - waitForAllSettled: AKt, - useRecoilValue: dKt, - useRecoilValueLoadable: pKt, - useRecoilState: cKt, - useRecoilStateLoadable: fKt, - useSetRecoilState: gKt, - useResetRecoilState: mKt, - useGetRecoilValueInfo_UNSTABLE: Qzt, - useRecoilRefresher_UNSTABLE: Cjt, - useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE: yKt, - useRecoilValue_TRANSITION_SUPPORT_UNSTABLE: hKt, - useRecoilState_TRANSITION_SUPPORT_UNSTABLE: lKt, - useRecoilCallback: _Kt, - useRecoilTransaction_UNSTABLE: Ljt, - useGotoRecoilSnapshot: vKt, - useRecoilSnapshot: bKt, - useRecoilTransactionObserver_UNSTABLE: wKt, - snapshot_UNSTABLE: uKt, - useRetain: Nme, - retentionZone: sKt, - }, - lun = Gn.DefaultValue, - fun = Gn.isRecoilValue, - dun = Gn.RecoilLoadable, - aze = Gn.RecoilRoot, - hun = Gn.useRecoilStoreID, - pun = Gn.useRecoilBridgeAcrossReactRoots_UNSTABLE, - e2 = Gn.atom, - w$ = Gn.selector, - sze = Gn.atomFamily, - yun = Gn.selectorFamily, - mun = Gn.constSelector, - gun = Gn.errorSelector, - vun = Gn.readOnlySelector, - bun = Gn.noWait, - wun = Gn.waitForNone, - _un = Gn.waitForAny, - xun = Gn.waitForAll, - Sun = Gn.waitForAllSettled, - Aun = Gn.useRecoilValue, - YI = Gn.useRecoilValueLoadable, - uze = Gn.useRecoilState, - cze = Gn.useRecoilStateLoadable, - Eun = Gn.useSetRecoilState, - Mun = Gn.useResetRecoilState, - Tun = Gn.useGetRecoilValueInfo_UNSTABLE, - kun = Gn.useRecoilRefresher_UNSTABLE, - Pun = Gn.useRecoilValueLoadable_TRANSITION_SUPPORT_UNSTABLE, - Oun = Gn.useRecoilValue_TRANSITION_SUPPORT_UNSTABLE, - Bun = Gn.useRecoilState_TRANSITION_SUPPORT_UNSTABLE, - Iun = Gn.useRecoilCallback, - Cun = Gn.useRecoilTransaction_UNSTABLE, - Run = Gn.useGotoRecoilSnapshot, - Nun = Gn.useRecoilSnapshot, - Dun = Gn.useRecoilTransactionObserver_UNSTABLE, - Fun = Gn.snapshot_UNSTABLE, - Lun = Gn.useRetain, - qun = Gn.retentionZone; - m(); - g(); - var T3 = qe(to()); - m(); - g(); - var un = qe(to()); - m(); - g(); - var lze = qe(to()); - m(); - g(); - var _$ = qe(to()); - function TKt({ - path: t, - pathHeight: e, - pathWidth: r, - height: n, - width: i, - color: o, - isFilled: a = !0, - strokeWidth: s = 0, - style: c = {}, - tw: u = "", - }) { - return _$.default.createElement( - TG, - { - key: t, - width: i, - height: n, - viewBox: `-${s} -${s} ${e + s * 2} ${r + s * 2}`, - fill: "none", - tw: u, - }, - _$.default.createElement(zF, { d: `M0 0h${e}v${r}H0V0z`, fill: "none" }), - _$.default.createElement(zF, { - d: t, - fill: a ? o : "none", - stroke: o, - style: { strokeWidth: s, ...c }, - }) - ); - } - var Mh = TKt; - function kKt({ size: t, ...e }) { - return lze.default.createElement(Mh, { - path: "M3 17v2h6v-2H3zM3 5v2h10V5H3zm10 16v-2h8v-2h-8v-2h-2v6h2zM7 9v2H3v2h4v2h2V9H7zm14 4v-2H11v2h10zm-6-4h2V7h4V5h-4V3h-2v6z", - pathHeight: 24, - pathWidth: 24, - width: t, - height: t, - ...e, - }); - } - var fze = kKt; - m(); - g(); - m(); - g(); - var dze = e2({ - key: "appFilterStoreageAtom", - default: { - sortBy: "ratings", - sortDesc: !0, - includeSuspended: !1, - includePrice: "all", - includeInstalled: !0, - }, - }), - PKt = w$({ - key: "appFilterAtom", - get: ({ get: t }) => t(dze), - set: ({ set: t }, e) => t(dze, (r) => ({ ...r, ...e })), - }), - x$ = PKt; - m(); - g(); - m(); - g(); - var Ki = qe(Qr()), - Bn = qe(Le()), - hhn = qe(Le()), - WQ = qe(Ho()), - hT = qe(Ho()), - X2 = qe(xv()), - uT = qe(QI()), - Zs = qe(HZe()), - eA = qe(qz()), - fr = qe(GZe()); - m(); - g(); - function SC(t) { - let e = t.length; - for (; --e >= 0; ) t[e] = 0; - } - var Dar = 0, - IXe = 1, - Far = 2, - Lar = 3, - qar = 258, - Rwe = 29, - ij = 256, - Zz = ij + 1 + Rwe, - xC = 30, - Nwe = 19, - CXe = 2 * Zz + 1, - ZM = 15, - mwe = 16, - zar = 7, - Dwe = 256, - RXe = 16, - NXe = 17, - DXe = 18, - Owe = new Uint8Array([ - 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, - 5, 5, 5, 0, - ]), - uQ = new Uint8Array([ - 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, - 11, 11, 12, 12, 13, 13, - ]), - jar = new Uint8Array([ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7, - ]), - FXe = new Uint8Array([ - 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15, - ]), - Uar = 512, - Y_ = new Array((Zz + 2) * 2); - SC(Y_); - var Gz = new Array(xC * 2); - SC(Gz); - var Xz = new Array(Uar); - SC(Xz); - var Yz = new Array(qar - Lar + 1); - SC(Yz); - var Fwe = new Array(Rwe); - SC(Fwe); - var dQ = new Array(xC); - SC(dQ); - function gwe(t, e, r, n, i) { - (this.static_tree = t), - (this.extra_bits = e), - (this.extra_base = r), - (this.elems = n), - (this.max_length = i), - (this.has_stree = t && t.length); - } - var LXe, qXe, zXe; - function vwe(t, e) { - (this.dyn_tree = t), (this.max_code = 0), (this.stat_desc = e); - } - var jXe = (t) => (t < 256 ? Xz[t] : Xz[256 + (t >>> 7)]), - Qz = (t, e) => { - (t.pending_buf[t.pending++] = e & 255), - (t.pending_buf[t.pending++] = (e >>> 8) & 255); - }, - Nh = (t, e, r) => { - t.bi_valid > mwe - r - ? ((t.bi_buf |= (e << t.bi_valid) & 65535), - Qz(t, t.bi_buf), - (t.bi_buf = e >> (mwe - t.bi_valid)), - (t.bi_valid += r - mwe)) - : ((t.bi_buf |= (e << t.bi_valid) & 65535), (t.bi_valid += r)); - }, - Ov = (t, e, r) => { - Nh(t, r[e * 2], r[e * 2 + 1]); - }, - UXe = (t, e) => { - let r = 0; - do (r |= t & 1), (t >>>= 1), (r <<= 1); - while (--e > 0); - return r >>> 1; - }, - Kar = (t) => { - t.bi_valid === 16 - ? (Qz(t, t.bi_buf), (t.bi_buf = 0), (t.bi_valid = 0)) - : t.bi_valid >= 8 && - ((t.pending_buf[t.pending++] = t.bi_buf & 255), - (t.bi_buf >>= 8), - (t.bi_valid -= 8)); - }, - Har = (t, e) => { - let r = e.dyn_tree, - n = e.max_code, - i = e.stat_desc.static_tree, - o = e.stat_desc.has_stree, - a = e.stat_desc.extra_bits, - s = e.stat_desc.extra_base, - c = e.stat_desc.max_length, - u, - h, - w, - M, - k, - O, - D = 0; - for (M = 0; M <= ZM; M++) t.bl_count[M] = 0; - for (r[t.heap[t.heap_max] * 2 + 1] = 0, u = t.heap_max + 1; u < CXe; u++) - (h = t.heap[u]), - (M = r[r[h * 2 + 1] * 2 + 1] + 1), - M > c && ((M = c), D++), - (r[h * 2 + 1] = M), - !(h > n) && - (t.bl_count[M]++, - (k = 0), - h >= s && (k = a[h - s]), - (O = r[h * 2]), - (t.opt_len += O * (M + k)), - o && (t.static_len += O * (i[h * 2 + 1] + k))); - if (D !== 0) { - do { - for (M = c - 1; t.bl_count[M] === 0; ) M--; - t.bl_count[M]--, (t.bl_count[M + 1] += 2), t.bl_count[c]--, (D -= 2); - } while (D > 0); - for (M = c; M !== 0; M--) - for (h = t.bl_count[M]; h !== 0; ) - (w = t.heap[--u]), - !(w > n) && - (r[w * 2 + 1] !== M && - ((t.opt_len += (M - r[w * 2 + 1]) * r[w * 2]), - (r[w * 2 + 1] = M)), - h--); - } - }, - KXe = (t, e, r) => { - let n = new Array(ZM + 1), - i = 0, - o, - a; - for (o = 1; o <= ZM; o++) n[o] = i = (i + r[o - 1]) << 1; - for (a = 0; a <= e; a++) { - let s = t[a * 2 + 1]; - s !== 0 && (t[a * 2] = UXe(n[s]++, s)); - } - }, - Var = () => { - let t, - e, - r, - n, - i, - o = new Array(ZM + 1); - for (r = 0, n = 0; n < Rwe - 1; n++) - for (Fwe[n] = r, t = 0; t < 1 << Owe[n]; t++) Yz[r++] = n; - for (Yz[r - 1] = n, i = 0, n = 0; n < 16; n++) - for (dQ[n] = i, t = 0; t < 1 << uQ[n]; t++) Xz[i++] = n; - for (i >>= 7; n < xC; n++) - for (dQ[n] = i << 7, t = 0; t < 1 << (uQ[n] - 7); t++) - Xz[256 + i++] = n; - for (e = 0; e <= ZM; e++) o[e] = 0; - for (t = 0; t <= 143; ) (Y_[t * 2 + 1] = 8), t++, o[8]++; - for (; t <= 255; ) (Y_[t * 2 + 1] = 9), t++, o[9]++; - for (; t <= 279; ) (Y_[t * 2 + 1] = 7), t++, o[7]++; - for (; t <= 287; ) (Y_[t * 2 + 1] = 8), t++, o[8]++; - for (KXe(Y_, Zz + 1, o), t = 0; t < xC; t++) - (Gz[t * 2 + 1] = 5), (Gz[t * 2] = UXe(t, 5)); - (LXe = new gwe(Y_, Owe, ij + 1, Zz, ZM)), - (qXe = new gwe(Gz, uQ, 0, xC, ZM)), - (zXe = new gwe(new Array(0), jar, 0, Nwe, zar)); - }, - HXe = (t) => { - let e; - for (e = 0; e < Zz; e++) t.dyn_ltree[e * 2] = 0; - for (e = 0; e < xC; e++) t.dyn_dtree[e * 2] = 0; - for (e = 0; e < Nwe; e++) t.bl_tree[e * 2] = 0; - (t.dyn_ltree[Dwe * 2] = 1), - (t.opt_len = t.static_len = 0), - (t.last_lit = t.matches = 0); - }, - VXe = (t) => { - t.bi_valid > 8 - ? Qz(t, t.bi_buf) - : t.bi_valid > 0 && (t.pending_buf[t.pending++] = t.bi_buf), - (t.bi_buf = 0), - (t.bi_valid = 0); - }, - War = (t, e, r, n) => { - VXe(t), - n && (Qz(t, r), Qz(t, ~r)), - t.pending_buf.set(t.window.subarray(e, e + r), t.pending), - (t.pending += r); - }, - JZe = (t, e, r, n) => { - let i = e * 2, - o = r * 2; - return t[i] < t[o] || (t[i] === t[o] && n[e] <= n[r]); - }, - bwe = (t, e, r) => { - let n = t.heap[r], - i = r << 1; - for ( - ; - i <= t.heap_len && - (i < t.heap_len && JZe(e, t.heap[i + 1], t.heap[i], t.depth) && i++, - !JZe(e, n, t.heap[i], t.depth)); - - ) - (t.heap[r] = t.heap[i]), (r = i), (i <<= 1); - t.heap[r] = n; - }, - $Ze = (t, e, r) => { - let n, - i, - o = 0, - a, - s; - if (t.last_lit !== 0) - do - (n = - (t.pending_buf[t.d_buf + o * 2] << 8) | - t.pending_buf[t.d_buf + o * 2 + 1]), - (i = t.pending_buf[t.l_buf + o]), - o++, - n === 0 - ? Ov(t, i, e) - : ((a = Yz[i]), - Ov(t, a + ij + 1, e), - (s = Owe[a]), - s !== 0 && ((i -= Fwe[a]), Nh(t, i, s)), - n--, - (a = jXe(n)), - Ov(t, a, r), - (s = uQ[a]), - s !== 0 && ((n -= dQ[a]), Nh(t, n, s))); - while (o < t.last_lit); - Ov(t, Dwe, e); - }, - Bwe = (t, e) => { - let r = e.dyn_tree, - n = e.stat_desc.static_tree, - i = e.stat_desc.has_stree, - o = e.stat_desc.elems, - a, - s, - c = -1, - u; - for (t.heap_len = 0, t.heap_max = CXe, a = 0; a < o; a++) - r[a * 2] !== 0 - ? ((t.heap[++t.heap_len] = c = a), (t.depth[a] = 0)) - : (r[a * 2 + 1] = 0); - for (; t.heap_len < 2; ) - (u = t.heap[++t.heap_len] = c < 2 ? ++c : 0), - (r[u * 2] = 1), - (t.depth[u] = 0), - t.opt_len--, - i && (t.static_len -= n[u * 2 + 1]); - for (e.max_code = c, a = t.heap_len >> 1; a >= 1; a--) bwe(t, r, a); - u = o; - do - (a = t.heap[1]), - (t.heap[1] = t.heap[t.heap_len--]), - bwe(t, r, 1), - (s = t.heap[1]), - (t.heap[--t.heap_max] = a), - (t.heap[--t.heap_max] = s), - (r[u * 2] = r[a * 2] + r[s * 2]), - (t.depth[u] = - (t.depth[a] >= t.depth[s] ? t.depth[a] : t.depth[s]) + 1), - (r[a * 2 + 1] = r[s * 2 + 1] = u), - (t.heap[1] = u++), - bwe(t, r, 1); - while (t.heap_len >= 2); - (t.heap[--t.heap_max] = t.heap[1]), Har(t, e), KXe(r, c, t.bl_count); - }, - ZZe = (t, e, r) => { - let n, - i = -1, - o, - a = e[0 * 2 + 1], - s = 0, - c = 7, - u = 4; - for ( - a === 0 && ((c = 138), (u = 3)), e[(r + 1) * 2 + 1] = 65535, n = 0; - n <= r; - n++ - ) - (o = a), - (a = e[(n + 1) * 2 + 1]), - !(++s < c && o === a) && - (s < u - ? (t.bl_tree[o * 2] += s) - : o !== 0 - ? (o !== i && t.bl_tree[o * 2]++, t.bl_tree[RXe * 2]++) - : s <= 10 - ? t.bl_tree[NXe * 2]++ - : t.bl_tree[DXe * 2]++, - (s = 0), - (i = o), - a === 0 - ? ((c = 138), (u = 3)) - : o === a - ? ((c = 6), (u = 3)) - : ((c = 7), (u = 4))); - }, - XZe = (t, e, r) => { - let n, - i = -1, - o, - a = e[0 * 2 + 1], - s = 0, - c = 7, - u = 4; - for (a === 0 && ((c = 138), (u = 3)), n = 0; n <= r; n++) - if (((o = a), (a = e[(n + 1) * 2 + 1]), !(++s < c && o === a))) { - if (s < u) - do Ov(t, o, t.bl_tree); - while (--s !== 0); - else - o !== 0 - ? (o !== i && (Ov(t, o, t.bl_tree), s--), - Ov(t, RXe, t.bl_tree), - Nh(t, s - 3, 2)) - : s <= 10 - ? (Ov(t, NXe, t.bl_tree), Nh(t, s - 3, 3)) - : (Ov(t, DXe, t.bl_tree), Nh(t, s - 11, 7)); - (s = 0), - (i = o), - a === 0 - ? ((c = 138), (u = 3)) - : o === a - ? ((c = 6), (u = 3)) - : ((c = 7), (u = 4)); - } - }, - Gar = (t) => { - let e; - for ( - ZZe(t, t.dyn_ltree, t.l_desc.max_code), - ZZe(t, t.dyn_dtree, t.d_desc.max_code), - Bwe(t, t.bl_desc), - e = Nwe - 1; - e >= 3 && t.bl_tree[FXe[e] * 2 + 1] === 0; - e-- - ); - return (t.opt_len += 3 * (e + 1) + 5 + 5 + 4), e; - }, - Jar = (t, e, r, n) => { - let i; - for ( - Nh(t, e - 257, 5), Nh(t, r - 1, 5), Nh(t, n - 4, 4), i = 0; - i < n; - i++ - ) - Nh(t, t.bl_tree[FXe[i] * 2 + 1], 3); - XZe(t, t.dyn_ltree, e - 1), XZe(t, t.dyn_dtree, r - 1); - }, - $ar = (t) => { - let e = 4093624447, - r; - for (r = 0; r <= 31; r++, e >>>= 1) - if (e & 1 && t.dyn_ltree[r * 2] !== 0) return 0; - if ( - t.dyn_ltree[9 * 2] !== 0 || - t.dyn_ltree[10 * 2] !== 0 || - t.dyn_ltree[13 * 2] !== 0 - ) - return 1; - for (r = 32; r < ij; r++) if (t.dyn_ltree[r * 2] !== 0) return 1; - return 0; - }, - YZe = !1, - Zar = (t) => { - YZe || (Var(), (YZe = !0)), - (t.l_desc = new vwe(t.dyn_ltree, LXe)), - (t.d_desc = new vwe(t.dyn_dtree, qXe)), - (t.bl_desc = new vwe(t.bl_tree, zXe)), - (t.bi_buf = 0), - (t.bi_valid = 0), - HXe(t); - }, - WXe = (t, e, r, n) => { - Nh(t, (Dar << 1) + (n ? 1 : 0), 3), War(t, e, r, !0); - }, - Xar = (t) => { - Nh(t, IXe << 1, 3), Ov(t, Dwe, Y_), Kar(t); - }, - Yar = (t, e, r, n) => { - let i, - o, - a = 0; - t.level > 0 - ? (t.strm.data_type === 2 && (t.strm.data_type = $ar(t)), - Bwe(t, t.l_desc), - Bwe(t, t.d_desc), - (a = Gar(t)), - (i = (t.opt_len + 3 + 7) >>> 3), - (o = (t.static_len + 3 + 7) >>> 3), - o <= i && (i = o)) - : (i = o = r + 5), - r + 4 <= i && e !== -1 - ? WXe(t, e, r, n) - : t.strategy === 4 || o === i - ? (Nh(t, (IXe << 1) + (n ? 1 : 0), 3), $Ze(t, Y_, Gz)) - : (Nh(t, (Far << 1) + (n ? 1 : 0), 3), - Jar(t, t.l_desc.max_code + 1, t.d_desc.max_code + 1, a + 1), - $Ze(t, t.dyn_ltree, t.dyn_dtree)), - HXe(t), - n && VXe(t); - }, - Qar = (t, e, r) => ( - (t.pending_buf[t.d_buf + t.last_lit * 2] = (e >>> 8) & 255), - (t.pending_buf[t.d_buf + t.last_lit * 2 + 1] = e & 255), - (t.pending_buf[t.l_buf + t.last_lit] = r & 255), - t.last_lit++, - e === 0 - ? t.dyn_ltree[r * 2]++ - : (t.matches++, - e--, - t.dyn_ltree[(Yz[r] + ij + 1) * 2]++, - t.dyn_dtree[jXe(e) * 2]++), - t.last_lit === t.lit_bufsize - 1 - ), - esr = Zar, - tsr = WXe, - rsr = Yar, - nsr = Qar, - isr = Xar, - osr = { - _tr_init: esr, - _tr_stored_block: tsr, - _tr_flush_block: rsr, - _tr_tally: nsr, - _tr_align: isr, - }, - asr = (t, e, r, n) => { - let i = (t & 65535) | 0, - o = ((t >>> 16) & 65535) | 0, - a = 0; - for (; r !== 0; ) { - (a = r > 2e3 ? 2e3 : r), (r -= a); - do (i = (i + e[n++]) | 0), (o = (o + i) | 0); - while (--a); - (i %= 65521), (o %= 65521); - } - return i | (o << 16) | 0; - }, - ej = asr, - ssr = () => { - let t, - e = []; - for (var r = 0; r < 256; r++) { - t = r; - for (var n = 0; n < 8; n++) - t = t & 1 ? 3988292384 ^ (t >>> 1) : t >>> 1; - e[r] = t; - } - return e; - }, - usr = new Uint32Array(ssr()), - csr = (t, e, r, n) => { - let i = usr, - o = n + r; - t ^= -1; - for (let a = n; a < o; a++) t = (t >>> 8) ^ i[(t ^ e[a]) & 255]; - return t ^ -1; - }, - Au = csr, - YM = { - 2: "need dictionary", - 1: "stream end", - 0: "", - "-1": "file error", - "-2": "stream error", - "-3": "data error", - "-4": "insufficient memory", - "-5": "buffer error", - "-6": "incompatible version", - }, - AC = { - Z_NO_FLUSH: 0, - Z_PARTIAL_FLUSH: 1, - Z_SYNC_FLUSH: 2, - Z_FULL_FLUSH: 3, - Z_FINISH: 4, - Z_BLOCK: 5, - Z_TREES: 6, - Z_OK: 0, - Z_STREAM_END: 1, - Z_NEED_DICT: 2, - Z_ERRNO: -1, - Z_STREAM_ERROR: -2, - Z_DATA_ERROR: -3, - Z_MEM_ERROR: -4, - Z_BUF_ERROR: -5, - Z_NO_COMPRESSION: 0, - Z_BEST_SPEED: 1, - Z_BEST_COMPRESSION: 9, - Z_DEFAULT_COMPRESSION: -1, - Z_FILTERED: 1, - Z_HUFFMAN_ONLY: 2, - Z_RLE: 3, - Z_FIXED: 4, - Z_DEFAULT_STRATEGY: 0, - Z_BINARY: 0, - Z_TEXT: 1, - Z_UNKNOWN: 2, - Z_DEFLATED: 8, - }, - { - _tr_init: lsr, - _tr_stored_block: fsr, - _tr_flush_block: dsr, - _tr_tally: K2, - _tr_align: hsr, - } = osr, - { - Z_NO_FLUSH: rT, - Z_PARTIAL_FLUSH: psr, - Z_FULL_FLUSH: ysr, - Z_FINISH: H2, - Z_BLOCK: QZe, - Z_OK: Bv, - Z_STREAM_END: eXe, - Z_STREAM_ERROR: gy, - Z_DATA_ERROR: msr, - Z_BUF_ERROR: wwe, - Z_DEFAULT_COMPRESSION: gsr, - Z_FILTERED: vsr, - Z_HUFFMAN_ONLY: nQ, - Z_RLE: bsr, - Z_FIXED: wsr, - Z_DEFAULT_STRATEGY: _sr, - Z_UNKNOWN: xsr, - Z_DEFLATED: yQ, - } = AC, - Ssr = 9, - Asr = 15, - Esr = 8, - Msr = 29, - Tsr = 256, - Iwe = Tsr + 1 + Msr, - ksr = 30, - Psr = 19, - Osr = 2 * Iwe + 1, - Bsr = 15, - ui = 3, - j2 = 258, - Xm = j2 + ui + 1, - Isr = 32, - mQ = 42, - Cwe = 69, - cQ = 73, - lQ = 91, - fQ = 103, - XM = 113, - Vz = 666, - $s = 1, - oj = 2, - QM = 3, - EC = 4, - Csr = 3, - U2 = (t, e) => ((t.msg = YM[e]), e), - tXe = (t) => (t << 1) - (t > 4 ? 9 : 0), - z2 = (t) => { - let e = t.length; - for (; --e >= 0; ) t[e] = 0; - }, - Rsr = (t, e, r) => ((e << t.hash_shift) ^ r) & t.hash_mask, - V2 = Rsr, - q2 = (t) => { - let e = t.state, - r = e.pending; - r > t.avail_out && (r = t.avail_out), - r !== 0 && - (t.output.set( - e.pending_buf.subarray(e.pending_out, e.pending_out + r), - t.next_out - ), - (t.next_out += r), - (e.pending_out += r), - (t.total_out += r), - (t.avail_out -= r), - (e.pending -= r), - e.pending === 0 && (e.pending_out = 0)); - }, - ic = (t, e) => { - dsr( - t, - t.block_start >= 0 ? t.block_start : -1, - t.strstart - t.block_start, - e - ), - (t.block_start = t.strstart), - q2(t.strm); - }, - Ci = (t, e) => { - t.pending_buf[t.pending++] = e; - }, - Hz = (t, e) => { - (t.pending_buf[t.pending++] = (e >>> 8) & 255), - (t.pending_buf[t.pending++] = e & 255); - }, - Nsr = (t, e, r, n) => { - let i = t.avail_in; - return ( - i > n && (i = n), - i === 0 - ? 0 - : ((t.avail_in -= i), - e.set(t.input.subarray(t.next_in, t.next_in + i), r), - t.state.wrap === 1 - ? (t.adler = ej(t.adler, e, i, r)) - : t.state.wrap === 2 && (t.adler = Au(t.adler, e, i, r)), - (t.next_in += i), - (t.total_in += i), - i) - ); - }, - GXe = (t, e) => { - let r = t.max_chain_length, - n = t.strstart, - i, - o, - a = t.prev_length, - s = t.nice_match, - c = t.strstart > t.w_size - Xm ? t.strstart - (t.w_size - Xm) : 0, - u = t.window, - h = t.w_mask, - w = t.prev, - M = t.strstart + j2, - k = u[n + a - 1], - O = u[n + a]; - t.prev_length >= t.good_match && (r >>= 2), - s > t.lookahead && (s = t.lookahead); - do - if ( - ((i = e), - !( - u[i + a] !== O || - u[i + a - 1] !== k || - u[i] !== u[n] || - u[++i] !== u[n + 1] - )) - ) { - (n += 2), i++; - do; - while ( - u[++n] === u[++i] && - u[++n] === u[++i] && - u[++n] === u[++i] && - u[++n] === u[++i] && - u[++n] === u[++i] && - u[++n] === u[++i] && - u[++n] === u[++i] && - u[++n] === u[++i] && - n < M - ); - if (((o = j2 - (M - n)), (n = M - j2), o > a)) { - if (((t.match_start = e), (a = o), o >= s)) break; - (k = u[n + a - 1]), (O = u[n + a]); - } - } - while ((e = w[e & h]) > c && --r !== 0); - return a <= t.lookahead ? a : t.lookahead; - }, - eT = (t) => { - let e = t.w_size, - r, - n, - i, - o, - a; - do { - if ( - ((o = t.window_size - t.lookahead - t.strstart), - t.strstart >= e + (e - Xm)) - ) { - t.window.set(t.window.subarray(e, e + e), 0), - (t.match_start -= e), - (t.strstart -= e), - (t.block_start -= e), - (n = t.hash_size), - (r = n); - do (i = t.head[--r]), (t.head[r] = i >= e ? i - e : 0); - while (--n); - (n = e), (r = n); - do (i = t.prev[--r]), (t.prev[r] = i >= e ? i - e : 0); - while (--n); - o += e; - } - if (t.strm.avail_in === 0) break; - if ( - ((n = Nsr(t.strm, t.window, t.strstart + t.lookahead, o)), - (t.lookahead += n), - t.lookahead + t.insert >= ui) - ) - for ( - a = t.strstart - t.insert, - t.ins_h = t.window[a], - t.ins_h = V2(t, t.ins_h, t.window[a + 1]); - t.insert && - ((t.ins_h = V2(t, t.ins_h, t.window[a + ui - 1])), - (t.prev[a & t.w_mask] = t.head[t.ins_h]), - (t.head[t.ins_h] = a), - a++, - t.insert--, - !(t.lookahead + t.insert < ui)); - - ); - } while (t.lookahead < Xm && t.strm.avail_in !== 0); - }, - Dsr = (t, e) => { - let r = 65535; - for (r > t.pending_buf_size - 5 && (r = t.pending_buf_size - 5); ; ) { - if (t.lookahead <= 1) { - if ((eT(t), t.lookahead === 0 && e === rT)) return $s; - if (t.lookahead === 0) break; - } - (t.strstart += t.lookahead), (t.lookahead = 0); - let n = t.block_start + r; - if ( - ((t.strstart === 0 || t.strstart >= n) && - ((t.lookahead = t.strstart - n), - (t.strstart = n), - ic(t, !1), - t.strm.avail_out === 0)) || - (t.strstart - t.block_start >= t.w_size - Xm && - (ic(t, !1), t.strm.avail_out === 0)) - ) - return $s; - } - return ( - (t.insert = 0), - e === H2 - ? (ic(t, !0), t.strm.avail_out === 0 ? QM : EC) - : (t.strstart > t.block_start && (ic(t, !1), t.strm.avail_out === 0), - $s) - ); - }, - _we = (t, e) => { - let r, n; - for (;;) { - if (t.lookahead < Xm) { - if ((eT(t), t.lookahead < Xm && e === rT)) return $s; - if (t.lookahead === 0) break; - } - if ( - ((r = 0), - t.lookahead >= ui && - ((t.ins_h = V2(t, t.ins_h, t.window[t.strstart + ui - 1])), - (r = t.prev[t.strstart & t.w_mask] = t.head[t.ins_h]), - (t.head[t.ins_h] = t.strstart)), - r !== 0 && - t.strstart - r <= t.w_size - Xm && - (t.match_length = GXe(t, r)), - t.match_length >= ui) - ) - if ( - ((n = K2(t, t.strstart - t.match_start, t.match_length - ui)), - (t.lookahead -= t.match_length), - t.match_length <= t.max_lazy_match && t.lookahead >= ui) - ) { - t.match_length--; - do - t.strstart++, - (t.ins_h = V2(t, t.ins_h, t.window[t.strstart + ui - 1])), - (r = t.prev[t.strstart & t.w_mask] = t.head[t.ins_h]), - (t.head[t.ins_h] = t.strstart); - while (--t.match_length !== 0); - t.strstart++; - } else - (t.strstart += t.match_length), - (t.match_length = 0), - (t.ins_h = t.window[t.strstart]), - (t.ins_h = V2(t, t.ins_h, t.window[t.strstart + 1])); - else (n = K2(t, 0, t.window[t.strstart])), t.lookahead--, t.strstart++; - if (n && (ic(t, !1), t.strm.avail_out === 0)) return $s; - } - return ( - (t.insert = t.strstart < ui - 1 ? t.strstart : ui - 1), - e === H2 - ? (ic(t, !0), t.strm.avail_out === 0 ? QM : EC) - : t.last_lit && (ic(t, !1), t.strm.avail_out === 0) - ? $s - : oj - ); - }, - wC = (t, e) => { - let r, n, i; - for (;;) { - if (t.lookahead < Xm) { - if ((eT(t), t.lookahead < Xm && e === rT)) return $s; - if (t.lookahead === 0) break; - } - if ( - ((r = 0), - t.lookahead >= ui && - ((t.ins_h = V2(t, t.ins_h, t.window[t.strstart + ui - 1])), - (r = t.prev[t.strstart & t.w_mask] = t.head[t.ins_h]), - (t.head[t.ins_h] = t.strstart)), - (t.prev_length = t.match_length), - (t.prev_match = t.match_start), - (t.match_length = ui - 1), - r !== 0 && - t.prev_length < t.max_lazy_match && - t.strstart - r <= t.w_size - Xm && - ((t.match_length = GXe(t, r)), - t.match_length <= 5 && - (t.strategy === vsr || - (t.match_length === ui && t.strstart - t.match_start > 4096)) && - (t.match_length = ui - 1)), - t.prev_length >= ui && t.match_length <= t.prev_length) - ) { - (i = t.strstart + t.lookahead - ui), - (n = K2(t, t.strstart - 1 - t.prev_match, t.prev_length - ui)), - (t.lookahead -= t.prev_length - 1), - (t.prev_length -= 2); - do - ++t.strstart <= i && - ((t.ins_h = V2(t, t.ins_h, t.window[t.strstart + ui - 1])), - (r = t.prev[t.strstart & t.w_mask] = t.head[t.ins_h]), - (t.head[t.ins_h] = t.strstart)); - while (--t.prev_length !== 0); - if ( - ((t.match_available = 0), - (t.match_length = ui - 1), - t.strstart++, - n && (ic(t, !1), t.strm.avail_out === 0)) - ) - return $s; - } else if (t.match_available) { - if ( - ((n = K2(t, 0, t.window[t.strstart - 1])), - n && ic(t, !1), - t.strstart++, - t.lookahead--, - t.strm.avail_out === 0) - ) - return $s; - } else (t.match_available = 1), t.strstart++, t.lookahead--; - } - return ( - t.match_available && - ((n = K2(t, 0, t.window[t.strstart - 1])), (t.match_available = 0)), - (t.insert = t.strstart < ui - 1 ? t.strstart : ui - 1), - e === H2 - ? (ic(t, !0), t.strm.avail_out === 0 ? QM : EC) - : t.last_lit && (ic(t, !1), t.strm.avail_out === 0) - ? $s - : oj - ); - }, - Fsr = (t, e) => { - let r, - n, - i, - o, - a = t.window; - for (;;) { - if (t.lookahead <= j2) { - if ((eT(t), t.lookahead <= j2 && e === rT)) return $s; - if (t.lookahead === 0) break; - } - if ( - ((t.match_length = 0), - t.lookahead >= ui && - t.strstart > 0 && - ((i = t.strstart - 1), - (n = a[i]), - n === a[++i] && n === a[++i] && n === a[++i])) - ) { - o = t.strstart + j2; - do; - while ( - n === a[++i] && - n === a[++i] && - n === a[++i] && - n === a[++i] && - n === a[++i] && - n === a[++i] && - n === a[++i] && - n === a[++i] && - i < o - ); - (t.match_length = j2 - (o - i)), - t.match_length > t.lookahead && (t.match_length = t.lookahead); - } - if ( - (t.match_length >= ui - ? ((r = K2(t, 1, t.match_length - ui)), - (t.lookahead -= t.match_length), - (t.strstart += t.match_length), - (t.match_length = 0)) - : ((r = K2(t, 0, t.window[t.strstart])), - t.lookahead--, - t.strstart++), - r && (ic(t, !1), t.strm.avail_out === 0)) - ) - return $s; - } - return ( - (t.insert = 0), - e === H2 - ? (ic(t, !0), t.strm.avail_out === 0 ? QM : EC) - : t.last_lit && (ic(t, !1), t.strm.avail_out === 0) - ? $s - : oj - ); - }, - Lsr = (t, e) => { - let r; - for (;;) { - if (t.lookahead === 0 && (eT(t), t.lookahead === 0)) { - if (e === rT) return $s; - break; - } - if ( - ((t.match_length = 0), - (r = K2(t, 0, t.window[t.strstart])), - t.lookahead--, - t.strstart++, - r && (ic(t, !1), t.strm.avail_out === 0)) - ) - return $s; - } - return ( - (t.insert = 0), - e === H2 - ? (ic(t, !0), t.strm.avail_out === 0 ? QM : EC) - : t.last_lit && (ic(t, !1), t.strm.avail_out === 0) - ? $s - : oj - ); - }; - function Pv(t, e, r, n, i) { - (this.good_length = t), - (this.max_lazy = e), - (this.nice_length = r), - (this.max_chain = n), - (this.func = i); - } - var Wz = [ - new Pv(0, 0, 0, 0, Dsr), - new Pv(4, 4, 8, 4, _we), - new Pv(4, 5, 16, 8, _we), - new Pv(4, 6, 32, 32, _we), - new Pv(4, 4, 16, 16, wC), - new Pv(8, 16, 32, 32, wC), - new Pv(8, 16, 128, 128, wC), - new Pv(8, 32, 128, 256, wC), - new Pv(32, 128, 258, 1024, wC), - new Pv(32, 258, 258, 4096, wC), - ], - qsr = (t) => { - (t.window_size = 2 * t.w_size), - z2(t.head), - (t.max_lazy_match = Wz[t.level].max_lazy), - (t.good_match = Wz[t.level].good_length), - (t.nice_match = Wz[t.level].nice_length), - (t.max_chain_length = Wz[t.level].max_chain), - (t.strstart = 0), - (t.block_start = 0), - (t.lookahead = 0), - (t.insert = 0), - (t.match_length = t.prev_length = ui - 1), - (t.match_available = 0), - (t.ins_h = 0); - }; - function zsr() { - (this.strm = null), - (this.status = 0), - (this.pending_buf = null), - (this.pending_buf_size = 0), - (this.pending_out = 0), - (this.pending = 0), - (this.wrap = 0), - (this.gzhead = null), - (this.gzindex = 0), - (this.method = yQ), - (this.last_flush = -1), - (this.w_size = 0), - (this.w_bits = 0), - (this.w_mask = 0), - (this.window = null), - (this.window_size = 0), - (this.prev = null), - (this.head = null), - (this.ins_h = 0), - (this.hash_size = 0), - (this.hash_bits = 0), - (this.hash_mask = 0), - (this.hash_shift = 0), - (this.block_start = 0), - (this.match_length = 0), - (this.prev_match = 0), - (this.match_available = 0), - (this.strstart = 0), - (this.match_start = 0), - (this.lookahead = 0), - (this.prev_length = 0), - (this.max_chain_length = 0), - (this.max_lazy_match = 0), - (this.level = 0), - (this.strategy = 0), - (this.good_match = 0), - (this.nice_match = 0), - (this.dyn_ltree = new Uint16Array(Osr * 2)), - (this.dyn_dtree = new Uint16Array((2 * ksr + 1) * 2)), - (this.bl_tree = new Uint16Array((2 * Psr + 1) * 2)), - z2(this.dyn_ltree), - z2(this.dyn_dtree), - z2(this.bl_tree), - (this.l_desc = null), - (this.d_desc = null), - (this.bl_desc = null), - (this.bl_count = new Uint16Array(Bsr + 1)), - (this.heap = new Uint16Array(2 * Iwe + 1)), - z2(this.heap), - (this.heap_len = 0), - (this.heap_max = 0), - (this.depth = new Uint16Array(2 * Iwe + 1)), - z2(this.depth), - (this.l_buf = 0), - (this.lit_bufsize = 0), - (this.last_lit = 0), - (this.d_buf = 0), - (this.opt_len = 0), - (this.static_len = 0), - (this.matches = 0), - (this.insert = 0), - (this.bi_buf = 0), - (this.bi_valid = 0); - } - var JXe = (t) => { - if (!t || !t.state) return U2(t, gy); - (t.total_in = t.total_out = 0), (t.data_type = xsr); - let e = t.state; - return ( - (e.pending = 0), - (e.pending_out = 0), - e.wrap < 0 && (e.wrap = -e.wrap), - (e.status = e.wrap ? mQ : XM), - (t.adler = e.wrap === 2 ? 0 : 1), - (e.last_flush = rT), - lsr(e), - Bv - ); - }, - $Xe = (t) => { - let e = JXe(t); - return e === Bv && qsr(t.state), e; - }, - jsr = (t, e) => - !t || !t.state || t.state.wrap !== 2 ? gy : ((t.state.gzhead = e), Bv), - ZXe = (t, e, r, n, i, o) => { - if (!t) return gy; - let a = 1; - if ( - (e === gsr && (e = 6), - n < 0 ? ((a = 0), (n = -n)) : n > 15 && ((a = 2), (n -= 16)), - i < 1 || - i > Ssr || - r !== yQ || - n < 8 || - n > 15 || - e < 0 || - e > 9 || - o < 0 || - o > wsr) - ) - return U2(t, gy); - n === 8 && (n = 9); - let s = new zsr(); - return ( - (t.state = s), - (s.strm = t), - (s.wrap = a), - (s.gzhead = null), - (s.w_bits = n), - (s.w_size = 1 << s.w_bits), - (s.w_mask = s.w_size - 1), - (s.hash_bits = i + 7), - (s.hash_size = 1 << s.hash_bits), - (s.hash_mask = s.hash_size - 1), - (s.hash_shift = ~~((s.hash_bits + ui - 1) / ui)), - (s.window = new Uint8Array(s.w_size * 2)), - (s.head = new Uint16Array(s.hash_size)), - (s.prev = new Uint16Array(s.w_size)), - (s.lit_bufsize = 1 << (i + 6)), - (s.pending_buf_size = s.lit_bufsize * 4), - (s.pending_buf = new Uint8Array(s.pending_buf_size)), - (s.d_buf = 1 * s.lit_bufsize), - (s.l_buf = (1 + 2) * s.lit_bufsize), - (s.level = e), - (s.strategy = o), - (s.method = r), - $Xe(t) - ); - }, - Usr = (t, e) => ZXe(t, e, yQ, Asr, Esr, _sr), - Ksr = (t, e) => { - let r, n; - if (!t || !t.state || e > QZe || e < 0) return t ? U2(t, gy) : gy; - let i = t.state; - if ( - !t.output || - (!t.input && t.avail_in !== 0) || - (i.status === Vz && e !== H2) - ) - return U2(t, t.avail_out === 0 ? wwe : gy); - i.strm = t; - let o = i.last_flush; - if (((i.last_flush = e), i.status === mQ)) - if (i.wrap === 2) - (t.adler = 0), - Ci(i, 31), - Ci(i, 139), - Ci(i, 8), - i.gzhead - ? (Ci( - i, - (i.gzhead.text ? 1 : 0) + - (i.gzhead.hcrc ? 2 : 0) + - (i.gzhead.extra ? 4 : 0) + - (i.gzhead.name ? 8 : 0) + - (i.gzhead.comment ? 16 : 0) - ), - Ci(i, i.gzhead.time & 255), - Ci(i, (i.gzhead.time >> 8) & 255), - Ci(i, (i.gzhead.time >> 16) & 255), - Ci(i, (i.gzhead.time >> 24) & 255), - Ci( - i, - i.level === 9 ? 2 : i.strategy >= nQ || i.level < 2 ? 4 : 0 - ), - Ci(i, i.gzhead.os & 255), - i.gzhead.extra && - i.gzhead.extra.length && - (Ci(i, i.gzhead.extra.length & 255), - Ci(i, (i.gzhead.extra.length >> 8) & 255)), - i.gzhead.hcrc && - (t.adler = Au(t.adler, i.pending_buf, i.pending, 0)), - (i.gzindex = 0), - (i.status = Cwe)) - : (Ci(i, 0), - Ci(i, 0), - Ci(i, 0), - Ci(i, 0), - Ci(i, 0), - Ci( - i, - i.level === 9 ? 2 : i.strategy >= nQ || i.level < 2 ? 4 : 0 - ), - Ci(i, Csr), - (i.status = XM)); - else { - let a = (yQ + ((i.w_bits - 8) << 4)) << 8, - s = -1; - i.strategy >= nQ || i.level < 2 - ? (s = 0) - : i.level < 6 - ? (s = 1) - : i.level === 6 - ? (s = 2) - : (s = 3), - (a |= s << 6), - i.strstart !== 0 && (a |= Isr), - (a += 31 - (a % 31)), - (i.status = XM), - Hz(i, a), - i.strstart !== 0 && (Hz(i, t.adler >>> 16), Hz(i, t.adler & 65535)), - (t.adler = 1); - } - if (i.status === Cwe) - if (i.gzhead.extra) { - for ( - r = i.pending; - i.gzindex < (i.gzhead.extra.length & 65535) && - !( - i.pending === i.pending_buf_size && - (i.gzhead.hcrc && - i.pending > r && - (t.adler = Au(t.adler, i.pending_buf, i.pending - r, r)), - q2(t), - (r = i.pending), - i.pending === i.pending_buf_size) - ); - - ) - Ci(i, i.gzhead.extra[i.gzindex] & 255), i.gzindex++; - i.gzhead.hcrc && - i.pending > r && - (t.adler = Au(t.adler, i.pending_buf, i.pending - r, r)), - i.gzindex === i.gzhead.extra.length && - ((i.gzindex = 0), (i.status = cQ)); - } else i.status = cQ; - if (i.status === cQ) - if (i.gzhead.name) { - r = i.pending; - do { - if ( - i.pending === i.pending_buf_size && - (i.gzhead.hcrc && - i.pending > r && - (t.adler = Au(t.adler, i.pending_buf, i.pending - r, r)), - q2(t), - (r = i.pending), - i.pending === i.pending_buf_size) - ) { - n = 1; - break; - } - i.gzindex < i.gzhead.name.length - ? (n = i.gzhead.name.charCodeAt(i.gzindex++) & 255) - : (n = 0), - Ci(i, n); - } while (n !== 0); - i.gzhead.hcrc && - i.pending > r && - (t.adler = Au(t.adler, i.pending_buf, i.pending - r, r)), - n === 0 && ((i.gzindex = 0), (i.status = lQ)); - } else i.status = lQ; - if (i.status === lQ) - if (i.gzhead.comment) { - r = i.pending; - do { - if ( - i.pending === i.pending_buf_size && - (i.gzhead.hcrc && - i.pending > r && - (t.adler = Au(t.adler, i.pending_buf, i.pending - r, r)), - q2(t), - (r = i.pending), - i.pending === i.pending_buf_size) - ) { - n = 1; - break; - } - i.gzindex < i.gzhead.comment.length - ? (n = i.gzhead.comment.charCodeAt(i.gzindex++) & 255) - : (n = 0), - Ci(i, n); - } while (n !== 0); - i.gzhead.hcrc && - i.pending > r && - (t.adler = Au(t.adler, i.pending_buf, i.pending - r, r)), - n === 0 && (i.status = fQ); - } else i.status = fQ; - if ( - (i.status === fQ && - (i.gzhead.hcrc - ? (i.pending + 2 > i.pending_buf_size && q2(t), - i.pending + 2 <= i.pending_buf_size && - (Ci(i, t.adler & 255), - Ci(i, (t.adler >> 8) & 255), - (t.adler = 0), - (i.status = XM))) - : (i.status = XM)), - i.pending !== 0) - ) { - if ((q2(t), t.avail_out === 0)) return (i.last_flush = -1), Bv; - } else if (t.avail_in === 0 && tXe(e) <= tXe(o) && e !== H2) - return U2(t, wwe); - if (i.status === Vz && t.avail_in !== 0) return U2(t, wwe); - if ( - t.avail_in !== 0 || - i.lookahead !== 0 || - (e !== rT && i.status !== Vz) - ) { - let a = - i.strategy === nQ - ? Lsr(i, e) - : i.strategy === bsr - ? Fsr(i, e) - : Wz[i.level].func(i, e); - if (((a === QM || a === EC) && (i.status = Vz), a === $s || a === QM)) - return t.avail_out === 0 && (i.last_flush = -1), Bv; - if ( - a === oj && - (e === psr - ? hsr(i) - : e !== QZe && - (fsr(i, 0, 0, !1), - e === ysr && - (z2(i.head), - i.lookahead === 0 && - ((i.strstart = 0), (i.block_start = 0), (i.insert = 0)))), - q2(t), - t.avail_out === 0) - ) - return (i.last_flush = -1), Bv; - } - return e !== H2 - ? Bv - : i.wrap <= 0 - ? eXe - : (i.wrap === 2 - ? (Ci(i, t.adler & 255), - Ci(i, (t.adler >> 8) & 255), - Ci(i, (t.adler >> 16) & 255), - Ci(i, (t.adler >> 24) & 255), - Ci(i, t.total_in & 255), - Ci(i, (t.total_in >> 8) & 255), - Ci(i, (t.total_in >> 16) & 255), - Ci(i, (t.total_in >> 24) & 255)) - : (Hz(i, t.adler >>> 16), Hz(i, t.adler & 65535)), - q2(t), - i.wrap > 0 && (i.wrap = -i.wrap), - i.pending !== 0 ? Bv : eXe); - }, - Hsr = (t) => { - if (!t || !t.state) return gy; - let e = t.state.status; - return e !== mQ && - e !== Cwe && - e !== cQ && - e !== lQ && - e !== fQ && - e !== XM && - e !== Vz - ? U2(t, gy) - : ((t.state = null), e === XM ? U2(t, msr) : Bv); - }, - Vsr = (t, e) => { - let r = e.length; - if (!t || !t.state) return gy; - let n = t.state, - i = n.wrap; - if (i === 2 || (i === 1 && n.status !== mQ) || n.lookahead) return gy; - if ( - (i === 1 && (t.adler = ej(t.adler, e, r, 0)), - (n.wrap = 0), - r >= n.w_size) - ) { - i === 0 && - (z2(n.head), (n.strstart = 0), (n.block_start = 0), (n.insert = 0)); - let c = new Uint8Array(n.w_size); - c.set(e.subarray(r - n.w_size, r), 0), (e = c), (r = n.w_size); - } - let o = t.avail_in, - a = t.next_in, - s = t.input; - for ( - t.avail_in = r, t.next_in = 0, t.input = e, eT(n); - n.lookahead >= ui; - - ) { - let c = n.strstart, - u = n.lookahead - (ui - 1); - do - (n.ins_h = V2(n, n.ins_h, n.window[c + ui - 1])), - (n.prev[c & n.w_mask] = n.head[n.ins_h]), - (n.head[n.ins_h] = c), - c++; - while (--u); - (n.strstart = c), (n.lookahead = ui - 1), eT(n); - } - return ( - (n.strstart += n.lookahead), - (n.block_start = n.strstart), - (n.insert = n.lookahead), - (n.lookahead = 0), - (n.match_length = n.prev_length = ui - 1), - (n.match_available = 0), - (t.next_in = a), - (t.input = s), - (t.avail_in = o), - (n.wrap = i), - Bv - ); - }, - Wsr = Usr, - Gsr = ZXe, - Jsr = $Xe, - $sr = JXe, - Zsr = jsr, - Xsr = Ksr, - Ysr = Hsr, - Qsr = Vsr, - eur = "pako deflate (from Nodeca project)", - Jz = { - deflateInit: Wsr, - deflateInit2: Gsr, - deflateReset: Jsr, - deflateResetKeep: $sr, - deflateSetHeader: Zsr, - deflate: Xsr, - deflateEnd: Ysr, - deflateSetDictionary: Qsr, - deflateInfo: eur, - }, - tur = (t, e) => Object.prototype.hasOwnProperty.call(t, e), - rur = function (t) { - let e = Array.prototype.slice.call(arguments, 1); - for (; e.length; ) { - let r = e.shift(); - if (!!r) { - if (typeof r != "object") - throw new TypeError(r + "must be non-object"); - for (let n in r) tur(r, n) && (t[n] = r[n]); - } - } - return t; - }, - nur = (t) => { - let e = 0; - for (let n = 0, i = t.length; n < i; n++) e += t[n].length; - let r = new Uint8Array(e); - for (let n = 0, i = 0, o = t.length; n < o; n++) { - let a = t[n]; - r.set(a, i), (i += a.length); - } - return r; - }, - gQ = { assign: rur, flattenChunks: nur }, - XXe = !0; - try { - String.fromCharCode.apply(null, new Uint8Array(1)); - } catch { - XXe = !1; - } - var tj = new Uint8Array(256); - for (let t = 0; t < 256; t++) - tj[t] = - t >= 252 - ? 6 - : t >= 248 - ? 5 - : t >= 240 - ? 4 - : t >= 224 - ? 3 - : t >= 192 - ? 2 - : 1; - tj[254] = tj[254] = 1; - var iur = (t) => { - if (typeof TextEncoder == "function" && TextEncoder.prototype.encode) - return new TextEncoder().encode(t); - let e, - r, - n, - i, - o, - a = t.length, - s = 0; - for (i = 0; i < a; i++) - (r = t.charCodeAt(i)), - (r & 64512) === 55296 && - i + 1 < a && - ((n = t.charCodeAt(i + 1)), - (n & 64512) === 56320 && - ((r = 65536 + ((r - 55296) << 10) + (n - 56320)), i++)), - (s += r < 128 ? 1 : r < 2048 ? 2 : r < 65536 ? 3 : 4); - for (e = new Uint8Array(s), o = 0, i = 0; o < s; i++) - (r = t.charCodeAt(i)), - (r & 64512) === 55296 && - i + 1 < a && - ((n = t.charCodeAt(i + 1)), - (n & 64512) === 56320 && - ((r = 65536 + ((r - 55296) << 10) + (n - 56320)), i++)), - r < 128 - ? (e[o++] = r) - : r < 2048 - ? ((e[o++] = 192 | (r >>> 6)), (e[o++] = 128 | (r & 63))) - : r < 65536 - ? ((e[o++] = 224 | (r >>> 12)), - (e[o++] = 128 | ((r >>> 6) & 63)), - (e[o++] = 128 | (r & 63))) - : ((e[o++] = 240 | (r >>> 18)), - (e[o++] = 128 | ((r >>> 12) & 63)), - (e[o++] = 128 | ((r >>> 6) & 63)), - (e[o++] = 128 | (r & 63))); - return e; - }, - our = (t, e) => { - if (e < 65534 && t.subarray && XXe) - return String.fromCharCode.apply( - null, - t.length === e ? t : t.subarray(0, e) - ); - let r = ""; - for (let n = 0; n < e; n++) r += String.fromCharCode(t[n]); - return r; - }, - aur = (t, e) => { - let r = e || t.length; - if (typeof TextDecoder == "function" && TextDecoder.prototype.decode) - return new TextDecoder().decode(t.subarray(0, e)); - let n, - i, - o = new Array(r * 2); - for (i = 0, n = 0; n < r; ) { - let a = t[n++]; - if (a < 128) { - o[i++] = a; - continue; - } - let s = tj[a]; - if (s > 4) { - (o[i++] = 65533), (n += s - 1); - continue; - } - for (a &= s === 2 ? 31 : s === 3 ? 15 : 7; s > 1 && n < r; ) - (a = (a << 6) | (t[n++] & 63)), s--; - if (s > 1) { - o[i++] = 65533; - continue; - } - a < 65536 - ? (o[i++] = a) - : ((a -= 65536), - (o[i++] = 55296 | ((a >> 10) & 1023)), - (o[i++] = 56320 | (a & 1023))); - } - return our(o, i); - }, - sur = (t, e) => { - (e = e || t.length), e > t.length && (e = t.length); - let r = e - 1; - for (; r >= 0 && (t[r] & 192) === 128; ) r--; - return r < 0 || r === 0 ? e : r + tj[t[r]] > e ? r : e; - }, - rj = { string2buf: iur, buf2string: aur, utf8border: sur }; - function uur() { - (this.input = null), - (this.next_in = 0), - (this.avail_in = 0), - (this.total_in = 0), - (this.output = null), - (this.next_out = 0), - (this.avail_out = 0), - (this.total_out = 0), - (this.msg = ""), - (this.state = null), - (this.data_type = 2), - (this.adler = 0); - } - var YXe = uur, - QXe = Object.prototype.toString, - { - Z_NO_FLUSH: cur, - Z_SYNC_FLUSH: lur, - Z_FULL_FLUSH: fur, - Z_FINISH: dur, - Z_OK: hQ, - Z_STREAM_END: hur, - Z_DEFAULT_COMPRESSION: pur, - Z_DEFAULT_STRATEGY: yur, - Z_DEFLATED: mur, - } = AC; - function aj(t) { - this.options = gQ.assign( - { - level: pur, - method: mur, - chunkSize: 16384, - windowBits: 15, - memLevel: 8, - strategy: yur, - }, - t || {} - ); - let e = this.options; - e.raw && e.windowBits > 0 - ? (e.windowBits = -e.windowBits) - : e.gzip && e.windowBits > 0 && e.windowBits < 16 && (e.windowBits += 16), - (this.err = 0), - (this.msg = ""), - (this.ended = !1), - (this.chunks = []), - (this.strm = new YXe()), - (this.strm.avail_out = 0); - let r = Jz.deflateInit2( - this.strm, - e.level, - e.method, - e.windowBits, - e.memLevel, - e.strategy - ); - if (r !== hQ) throw new Error(YM[r]); - if ((e.header && Jz.deflateSetHeader(this.strm, e.header), e.dictionary)) { - let n; - if ( - (typeof e.dictionary == "string" - ? (n = rj.string2buf(e.dictionary)) - : QXe.call(e.dictionary) === "[object ArrayBuffer]" - ? (n = new Uint8Array(e.dictionary)) - : (n = e.dictionary), - (r = Jz.deflateSetDictionary(this.strm, n)), - r !== hQ) - ) - throw new Error(YM[r]); - this._dict_set = !0; - } - } - aj.prototype.push = function (t, e) { - let r = this.strm, - n = this.options.chunkSize, - i, - o; - if (this.ended) return !1; - for ( - e === ~~e ? (o = e) : (o = e === !0 ? dur : cur), - typeof t == "string" - ? (r.input = rj.string2buf(t)) - : QXe.call(t) === "[object ArrayBuffer]" - ? (r.input = new Uint8Array(t)) - : (r.input = t), - r.next_in = 0, - r.avail_in = r.input.length; - ; - - ) { - if ( - (r.avail_out === 0 && - ((r.output = new Uint8Array(n)), (r.next_out = 0), (r.avail_out = n)), - (o === lur || o === fur) && r.avail_out <= 6) - ) { - this.onData(r.output.subarray(0, r.next_out)), (r.avail_out = 0); - continue; - } - if (((i = Jz.deflate(r, o)), i === hur)) - return ( - r.next_out > 0 && this.onData(r.output.subarray(0, r.next_out)), - (i = Jz.deflateEnd(this.strm)), - this.onEnd(i), - (this.ended = !0), - i === hQ - ); - if (r.avail_out === 0) { - this.onData(r.output); - continue; - } - if (o > 0 && r.next_out > 0) { - this.onData(r.output.subarray(0, r.next_out)), (r.avail_out = 0); - continue; - } - if (r.avail_in === 0) break; - } - return !0; - }; - aj.prototype.onData = function (t) { - this.chunks.push(t); - }; - aj.prototype.onEnd = function (t) { - t === hQ && (this.result = gQ.flattenChunks(this.chunks)), - (this.chunks = []), - (this.err = t), - (this.msg = this.strm.msg); - }; - function Lwe(t, e) { - let r = new aj(e); - if ((r.push(t, !0), r.err)) throw r.msg || YM[r.err]; - return r.result; - } - function gur(t, e) { - return (e = e || {}), (e.raw = !0), Lwe(t, e); - } - function vur(t, e) { - return (e = e || {}), (e.gzip = !0), Lwe(t, e); - } - var bur = aj, - wur = Lwe, - _ur = gur, - xur = vur, - Sur = AC, - Aur = { - Deflate: bur, - deflate: wur, - deflateRaw: _ur, - gzip: xur, - constants: Sur, - }, - iQ = 30, - Eur = 12, - Mur = function (e, r) { - let n, - i, - o, - a, - s, - c, - u, - h, - w, - M, - k, - O, - D, - F, - N, - q, - z, - H, - Z, - $, - ue, - te, - ne, - A, - l = e.state; - (n = e.next_in), - (ne = e.input), - (i = n + (e.avail_in - 5)), - (o = e.next_out), - (A = e.output), - (a = o - (r - e.avail_out)), - (s = o + (e.avail_out - 257)), - (c = l.dmax), - (u = l.wsize), - (h = l.whave), - (w = l.wnext), - (M = l.window), - (k = l.hold), - (O = l.bits), - (D = l.lencode), - (F = l.distcode), - (N = (1 << l.lenbits) - 1), - (q = (1 << l.distbits) - 1); - e: do { - O < 15 && - ((k += ne[n++] << O), (O += 8), (k += ne[n++] << O), (O += 8)), - (z = D[k & N]); - t: for (;;) { - if ( - ((H = z >>> 24), - (k >>>= H), - (O -= H), - (H = (z >>> 16) & 255), - H === 0) - ) - A[o++] = z & 65535; - else if (H & 16) { - (Z = z & 65535), - (H &= 15), - H && - (O < H && ((k += ne[n++] << O), (O += 8)), - (Z += k & ((1 << H) - 1)), - (k >>>= H), - (O -= H)), - O < 15 && - ((k += ne[n++] << O), (O += 8), (k += ne[n++] << O), (O += 8)), - (z = F[k & q]); - r: for (;;) { - if ( - ((H = z >>> 24), - (k >>>= H), - (O -= H), - (H = (z >>> 16) & 255), - H & 16) - ) { - if ( - (($ = z & 65535), - (H &= 15), - O < H && - ((k += ne[n++] << O), - (O += 8), - O < H && ((k += ne[n++] << O), (O += 8))), - ($ += k & ((1 << H) - 1)), - $ > c) - ) { - (e.msg = "invalid distance too far back"), (l.mode = iQ); - break e; - } - if (((k >>>= H), (O -= H), (H = o - a), $ > H)) { - if (((H = $ - H), H > h && l.sane)) { - (e.msg = "invalid distance too far back"), (l.mode = iQ); - break e; - } - if (((ue = 0), (te = M), w === 0)) { - if (((ue += u - H), H < Z)) { - Z -= H; - do A[o++] = M[ue++]; - while (--H); - (ue = o - $), (te = A); - } - } else if (w < H) { - if (((ue += u + w - H), (H -= w), H < Z)) { - Z -= H; - do A[o++] = M[ue++]; - while (--H); - if (((ue = 0), w < Z)) { - (H = w), (Z -= H); - do A[o++] = M[ue++]; - while (--H); - (ue = o - $), (te = A); - } - } - } else if (((ue += w - H), H < Z)) { - Z -= H; - do A[o++] = M[ue++]; - while (--H); - (ue = o - $), (te = A); - } - for (; Z > 2; ) - (A[o++] = te[ue++]), - (A[o++] = te[ue++]), - (A[o++] = te[ue++]), - (Z -= 3); - Z && ((A[o++] = te[ue++]), Z > 1 && (A[o++] = te[ue++])); - } else { - ue = o - $; - do - (A[o++] = A[ue++]), - (A[o++] = A[ue++]), - (A[o++] = A[ue++]), - (Z -= 3); - while (Z > 2); - Z && ((A[o++] = A[ue++]), Z > 1 && (A[o++] = A[ue++])); - } - } else if ((H & 64) === 0) { - z = F[(z & 65535) + (k & ((1 << H) - 1))]; - continue r; - } else { - (e.msg = "invalid distance code"), (l.mode = iQ); - break e; - } - break; - } - } else if ((H & 64) === 0) { - z = D[(z & 65535) + (k & ((1 << H) - 1))]; - continue t; - } else if (H & 32) { - l.mode = Eur; - break e; - } else { - (e.msg = "invalid literal/length code"), (l.mode = iQ); - break e; - } - break; - } - } while (n < i && o < s); - (Z = O >> 3), - (n -= Z), - (O -= Z << 3), - (k &= (1 << O) - 1), - (e.next_in = n), - (e.next_out = o), - (e.avail_in = n < i ? 5 + (i - n) : 5 - (n - i)), - (e.avail_out = o < s ? 257 + (s - o) : 257 - (o - s)), - (l.hold = k), - (l.bits = O); - }, - _C = 15, - rXe = 852, - nXe = 592, - iXe = 0, - xwe = 1, - oXe = 2, - Tur = new Uint16Array([ - 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, - 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0, - ]), - kur = new Uint8Array([ - 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, - 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78, - ]), - Pur = new Uint16Array([ - 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, - 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0, 0, - ]), - Our = new Uint8Array([ - 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, - 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 64, 64, - ]), - Bur = (t, e, r, n, i, o, a, s) => { - let c = s.bits, - u = 0, - h = 0, - w = 0, - M = 0, - k = 0, - O = 0, - D = 0, - F = 0, - N = 0, - q = 0, - z, - H, - Z, - $, - ue, - te = null, - ne = 0, - A, - l = new Uint16Array(_C + 1), - p = new Uint16Array(_C + 1), - y = null, - d = 0, - v, - _, - S; - for (u = 0; u <= _C; u++) l[u] = 0; - for (h = 0; h < n; h++) l[e[r + h]]++; - for (k = c, M = _C; M >= 1 && l[M] === 0; M--); - if ((k > M && (k = M), M === 0)) - return ( - (i[o++] = (1 << 24) | (64 << 16) | 0), - (i[o++] = (1 << 24) | (64 << 16) | 0), - (s.bits = 1), - 0 - ); - for (w = 1; w < M && l[w] === 0; w++); - for (k < w && (k = w), F = 1, u = 1; u <= _C; u++) - if (((F <<= 1), (F -= l[u]), F < 0)) return -1; - if (F > 0 && (t === iXe || M !== 1)) return -1; - for (p[1] = 0, u = 1; u < _C; u++) p[u + 1] = p[u] + l[u]; - for (h = 0; h < n; h++) e[r + h] !== 0 && (a[p[e[r + h]]++] = h); - if ( - (t === iXe - ? ((te = y = a), (A = 19)) - : t === xwe - ? ((te = Tur), (ne -= 257), (y = kur), (d -= 257), (A = 256)) - : ((te = Pur), (y = Our), (A = -1)), - (q = 0), - (h = 0), - (u = w), - (ue = o), - (O = k), - (D = 0), - (Z = -1), - (N = 1 << k), - ($ = N - 1), - (t === xwe && N > rXe) || (t === oXe && N > nXe)) - ) - return 1; - for (;;) { - (v = u - D), - a[h] < A - ? ((_ = 0), (S = a[h])) - : a[h] > A - ? ((_ = y[d + a[h]]), (S = te[ne + a[h]])) - : ((_ = 32 + 64), (S = 0)), - (z = 1 << (u - D)), - (H = 1 << O), - (w = H); - do (H -= z), (i[ue + (q >> D) + H] = (v << 24) | (_ << 16) | S | 0); - while (H !== 0); - for (z = 1 << (u - 1); q & z; ) z >>= 1; - if ((z !== 0 ? ((q &= z - 1), (q += z)) : (q = 0), h++, --l[u] === 0)) { - if (u === M) break; - u = e[r + a[h]]; - } - if (u > k && (q & $) !== Z) { - for ( - D === 0 && (D = k), ue += w, O = u - D, F = 1 << O; - O + D < M && ((F -= l[O + D]), !(F <= 0)); - - ) - O++, (F <<= 1); - if (((N += 1 << O), (t === xwe && N > rXe) || (t === oXe && N > nXe))) - return 1; - (Z = q & $), (i[Z] = (k << 24) | (O << 16) | (ue - o) | 0); - } - } - return ( - q !== 0 && (i[ue + q] = ((u - D) << 24) | (64 << 16) | 0), - (s.bits = k), - 0 - ); - }, - $z = Bur, - Iur = 0, - eYe = 1, - tYe = 2, - { - Z_FINISH: aXe, - Z_BLOCK: Cur, - Z_TREES: oQ, - Z_OK: tT, - Z_STREAM_END: Rur, - Z_NEED_DICT: Nur, - Z_STREAM_ERROR: vy, - Z_DATA_ERROR: rYe, - Z_MEM_ERROR: nYe, - Z_BUF_ERROR: Dur, - Z_DEFLATED: sXe, - } = AC, - iYe = 1, - uXe = 2, - cXe = 3, - lXe = 4, - fXe = 5, - dXe = 6, - hXe = 7, - pXe = 8, - yXe = 9, - mXe = 10, - pQ = 11, - X_ = 12, - Swe = 13, - gXe = 14, - Awe = 15, - vXe = 16, - bXe = 17, - wXe = 18, - _Xe = 19, - aQ = 20, - sQ = 21, - xXe = 22, - SXe = 23, - AXe = 24, - EXe = 25, - MXe = 26, - Ewe = 27, - TXe = 28, - kXe = 29, - ia = 30, - oYe = 31, - Fur = 32, - Lur = 852, - qur = 592, - zur = 15, - jur = zur, - PXe = (t) => - ((t >>> 24) & 255) + - ((t >>> 8) & 65280) + - ((t & 65280) << 8) + - ((t & 255) << 24); - function Uur() { - (this.mode = 0), - (this.last = !1), - (this.wrap = 0), - (this.havedict = !1), - (this.flags = 0), - (this.dmax = 0), - (this.check = 0), - (this.total = 0), - (this.head = null), - (this.wbits = 0), - (this.wsize = 0), - (this.whave = 0), - (this.wnext = 0), - (this.window = null), - (this.hold = 0), - (this.bits = 0), - (this.length = 0), - (this.offset = 0), - (this.extra = 0), - (this.lencode = null), - (this.distcode = null), - (this.lenbits = 0), - (this.distbits = 0), - (this.ncode = 0), - (this.nlen = 0), - (this.ndist = 0), - (this.have = 0), - (this.next = null), - (this.lens = new Uint16Array(320)), - (this.work = new Uint16Array(288)), - (this.lendyn = null), - (this.distdyn = null), - (this.sane = 0), - (this.back = 0), - (this.was = 0); - } - var aYe = (t) => { - if (!t || !t.state) return vy; - let e = t.state; - return ( - (t.total_in = t.total_out = e.total = 0), - (t.msg = ""), - e.wrap && (t.adler = e.wrap & 1), - (e.mode = iYe), - (e.last = 0), - (e.havedict = 0), - (e.dmax = 32768), - (e.head = null), - (e.hold = 0), - (e.bits = 0), - (e.lencode = e.lendyn = new Int32Array(Lur)), - (e.distcode = e.distdyn = new Int32Array(qur)), - (e.sane = 1), - (e.back = -1), - tT - ); - }, - sYe = (t) => { - if (!t || !t.state) return vy; - let e = t.state; - return (e.wsize = 0), (e.whave = 0), (e.wnext = 0), aYe(t); - }, - uYe = (t, e) => { - let r; - if (!t || !t.state) return vy; - let n = t.state; - return ( - e < 0 ? ((r = 0), (e = -e)) : ((r = (e >> 4) + 1), e < 48 && (e &= 15)), - e && (e < 8 || e > 15) - ? vy - : (n.window !== null && n.wbits !== e && (n.window = null), - (n.wrap = r), - (n.wbits = e), - sYe(t)) - ); - }, - cYe = (t, e) => { - if (!t) return vy; - let r = new Uur(); - (t.state = r), (r.window = null); - let n = uYe(t, e); - return n !== tT && (t.state = null), n; - }, - Kur = (t) => cYe(t, jur), - OXe = !0, - Mwe, - Twe, - Hur = (t) => { - if (OXe) { - (Mwe = new Int32Array(512)), (Twe = new Int32Array(32)); - let e = 0; - for (; e < 144; ) t.lens[e++] = 8; - for (; e < 256; ) t.lens[e++] = 9; - for (; e < 280; ) t.lens[e++] = 7; - for (; e < 288; ) t.lens[e++] = 8; - for ( - $z(eYe, t.lens, 0, 288, Mwe, 0, t.work, { bits: 9 }), e = 0; - e < 32; - - ) - t.lens[e++] = 5; - $z(tYe, t.lens, 0, 32, Twe, 0, t.work, { bits: 5 }), (OXe = !1); - } - (t.lencode = Mwe), (t.lenbits = 9), (t.distcode = Twe), (t.distbits = 5); - }, - lYe = (t, e, r, n) => { - let i, - o = t.state; - return ( - o.window === null && - ((o.wsize = 1 << o.wbits), - (o.wnext = 0), - (o.whave = 0), - (o.window = new Uint8Array(o.wsize))), - n >= o.wsize - ? (o.window.set(e.subarray(r - o.wsize, r), 0), - (o.wnext = 0), - (o.whave = o.wsize)) - : ((i = o.wsize - o.wnext), - i > n && (i = n), - o.window.set(e.subarray(r - n, r - n + i), o.wnext), - (n -= i), - n - ? (o.window.set(e.subarray(r - n, r), 0), - (o.wnext = n), - (o.whave = o.wsize)) - : ((o.wnext += i), - o.wnext === o.wsize && (o.wnext = 0), - o.whave < o.wsize && (o.whave += i))), - 0 - ); - }, - Vur = (t, e) => { - let r, - n, - i, - o, - a, - s, - c, - u, - h, - w, - M, - k, - O, - D, - F = 0, - N, - q, - z, - H, - Z, - $, - ue, - te, - ne = new Uint8Array(4), - A, - l, - p = new Uint8Array([ - 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15, - ]); - if (!t || !t.state || !t.output || (!t.input && t.avail_in !== 0)) - return vy; - (r = t.state), - r.mode === X_ && (r.mode = Swe), - (a = t.next_out), - (i = t.output), - (c = t.avail_out), - (o = t.next_in), - (n = t.input), - (s = t.avail_in), - (u = r.hold), - (h = r.bits), - (w = s), - (M = c), - (te = tT); - e: for (;;) - switch (r.mode) { - case iYe: - if (r.wrap === 0) { - r.mode = Swe; - break; - } - for (; h < 16; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - if (r.wrap & 2 && u === 35615) { - (r.check = 0), - (ne[0] = u & 255), - (ne[1] = (u >>> 8) & 255), - (r.check = Au(r.check, ne, 2, 0)), - (u = 0), - (h = 0), - (r.mode = uXe); - break; - } - if ( - ((r.flags = 0), - r.head && (r.head.done = !1), - !(r.wrap & 1) || (((u & 255) << 8) + (u >> 8)) % 31) - ) { - (t.msg = "incorrect header check"), (r.mode = ia); - break; - } - if ((u & 15) !== sXe) { - (t.msg = "unknown compression method"), (r.mode = ia); - break; - } - if (((u >>>= 4), (h -= 4), (ue = (u & 15) + 8), r.wbits === 0)) - r.wbits = ue; - else if (ue > r.wbits) { - (t.msg = "invalid window size"), (r.mode = ia); - break; - } - (r.dmax = 1 << r.wbits), - (t.adler = r.check = 1), - (r.mode = u & 512 ? mXe : X_), - (u = 0), - (h = 0); - break; - case uXe: - for (; h < 16; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - if (((r.flags = u), (r.flags & 255) !== sXe)) { - (t.msg = "unknown compression method"), (r.mode = ia); - break; - } - if (r.flags & 57344) { - (t.msg = "unknown header flags set"), (r.mode = ia); - break; - } - r.head && (r.head.text = (u >> 8) & 1), - r.flags & 512 && - ((ne[0] = u & 255), - (ne[1] = (u >>> 8) & 255), - (r.check = Au(r.check, ne, 2, 0))), - (u = 0), - (h = 0), - (r.mode = cXe); - case cXe: - for (; h < 32; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - r.head && (r.head.time = u), - r.flags & 512 && - ((ne[0] = u & 255), - (ne[1] = (u >>> 8) & 255), - (ne[2] = (u >>> 16) & 255), - (ne[3] = (u >>> 24) & 255), - (r.check = Au(r.check, ne, 4, 0))), - (u = 0), - (h = 0), - (r.mode = lXe); - case lXe: - for (; h < 16; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - r.head && ((r.head.xflags = u & 255), (r.head.os = u >> 8)), - r.flags & 512 && - ((ne[0] = u & 255), - (ne[1] = (u >>> 8) & 255), - (r.check = Au(r.check, ne, 2, 0))), - (u = 0), - (h = 0), - (r.mode = fXe); - case fXe: - if (r.flags & 1024) { - for (; h < 16; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - (r.length = u), - r.head && (r.head.extra_len = u), - r.flags & 512 && - ((ne[0] = u & 255), - (ne[1] = (u >>> 8) & 255), - (r.check = Au(r.check, ne, 2, 0))), - (u = 0), - (h = 0); - } else r.head && (r.head.extra = null); - r.mode = dXe; - case dXe: - if ( - r.flags & 1024 && - ((k = r.length), - k > s && (k = s), - k && - (r.head && - ((ue = r.head.extra_len - r.length), - r.head.extra || - (r.head.extra = new Uint8Array(r.head.extra_len)), - r.head.extra.set(n.subarray(o, o + k), ue)), - r.flags & 512 && (r.check = Au(r.check, n, k, o)), - (s -= k), - (o += k), - (r.length -= k)), - r.length) - ) - break e; - (r.length = 0), (r.mode = hXe); - case hXe: - if (r.flags & 2048) { - if (s === 0) break e; - k = 0; - do - (ue = n[o + k++]), - r.head && - ue && - r.length < 65536 && - (r.head.name += String.fromCharCode(ue)); - while (ue && k < s); - if ( - (r.flags & 512 && (r.check = Au(r.check, n, k, o)), - (s -= k), - (o += k), - ue) - ) - break e; - } else r.head && (r.head.name = null); - (r.length = 0), (r.mode = pXe); - case pXe: - if (r.flags & 4096) { - if (s === 0) break e; - k = 0; - do - (ue = n[o + k++]), - r.head && - ue && - r.length < 65536 && - (r.head.comment += String.fromCharCode(ue)); - while (ue && k < s); - if ( - (r.flags & 512 && (r.check = Au(r.check, n, k, o)), - (s -= k), - (o += k), - ue) - ) - break e; - } else r.head && (r.head.comment = null); - r.mode = yXe; - case yXe: - if (r.flags & 512) { - for (; h < 16; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - if (u !== (r.check & 65535)) { - (t.msg = "header crc mismatch"), (r.mode = ia); - break; - } - (u = 0), (h = 0); - } - r.head && ((r.head.hcrc = (r.flags >> 9) & 1), (r.head.done = !0)), - (t.adler = r.check = 0), - (r.mode = X_); - break; - case mXe: - for (; h < 32; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - (t.adler = r.check = PXe(u)), (u = 0), (h = 0), (r.mode = pQ); - case pQ: - if (r.havedict === 0) - return ( - (t.next_out = a), - (t.avail_out = c), - (t.next_in = o), - (t.avail_in = s), - (r.hold = u), - (r.bits = h), - Nur - ); - (t.adler = r.check = 1), (r.mode = X_); - case X_: - if (e === Cur || e === oQ) break e; - case Swe: - if (r.last) { - (u >>>= h & 7), (h -= h & 7), (r.mode = Ewe); - break; - } - for (; h < 3; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - switch (((r.last = u & 1), (u >>>= 1), (h -= 1), u & 3)) { - case 0: - r.mode = gXe; - break; - case 1: - if ((Hur(r), (r.mode = aQ), e === oQ)) { - (u >>>= 2), (h -= 2); - break e; - } - break; - case 2: - r.mode = bXe; - break; - case 3: - (t.msg = "invalid block type"), (r.mode = ia); - } - (u >>>= 2), (h -= 2); - break; - case gXe: - for (u >>>= h & 7, h -= h & 7; h < 32; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - if ((u & 65535) !== ((u >>> 16) ^ 65535)) { - (t.msg = "invalid stored block lengths"), (r.mode = ia); - break; - } - if ( - ((r.length = u & 65535), - (u = 0), - (h = 0), - (r.mode = Awe), - e === oQ) - ) - break e; - case Awe: - r.mode = vXe; - case vXe: - if (((k = r.length), k)) { - if ((k > s && (k = s), k > c && (k = c), k === 0)) break e; - i.set(n.subarray(o, o + k), a), - (s -= k), - (o += k), - (c -= k), - (a += k), - (r.length -= k); - break; - } - r.mode = X_; - break; - case bXe: - for (; h < 14; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - if ( - ((r.nlen = (u & 31) + 257), - (u >>>= 5), - (h -= 5), - (r.ndist = (u & 31) + 1), - (u >>>= 5), - (h -= 5), - (r.ncode = (u & 15) + 4), - (u >>>= 4), - (h -= 4), - r.nlen > 286 || r.ndist > 30) - ) { - (t.msg = "too many length or distance symbols"), (r.mode = ia); - break; - } - (r.have = 0), (r.mode = wXe); - case wXe: - for (; r.have < r.ncode; ) { - for (; h < 3; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - (r.lens[p[r.have++]] = u & 7), (u >>>= 3), (h -= 3); - } - for (; r.have < 19; ) r.lens[p[r.have++]] = 0; - if ( - ((r.lencode = r.lendyn), - (r.lenbits = 7), - (A = { bits: r.lenbits }), - (te = $z(Iur, r.lens, 0, 19, r.lencode, 0, r.work, A)), - (r.lenbits = A.bits), - te) - ) { - (t.msg = "invalid code lengths set"), (r.mode = ia); - break; - } - (r.have = 0), (r.mode = _Xe); - case _Xe: - for (; r.have < r.nlen + r.ndist; ) { - for ( - ; - (F = r.lencode[u & ((1 << r.lenbits) - 1)]), - (N = F >>> 24), - (q = (F >>> 16) & 255), - (z = F & 65535), - !(N <= h); - - ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - if (z < 16) (u >>>= N), (h -= N), (r.lens[r.have++] = z); - else { - if (z === 16) { - for (l = N + 2; h < l; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - if (((u >>>= N), (h -= N), r.have === 0)) { - (t.msg = "invalid bit length repeat"), (r.mode = ia); - break; - } - (ue = r.lens[r.have - 1]), - (k = 3 + (u & 3)), - (u >>>= 2), - (h -= 2); - } else if (z === 17) { - for (l = N + 3; h < l; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - (u >>>= N), - (h -= N), - (ue = 0), - (k = 3 + (u & 7)), - (u >>>= 3), - (h -= 3); - } else { - for (l = N + 7; h < l; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - (u >>>= N), - (h -= N), - (ue = 0), - (k = 11 + (u & 127)), - (u >>>= 7), - (h -= 7); - } - if (r.have + k > r.nlen + r.ndist) { - (t.msg = "invalid bit length repeat"), (r.mode = ia); - break; - } - for (; k--; ) r.lens[r.have++] = ue; - } - } - if (r.mode === ia) break; - if (r.lens[256] === 0) { - (t.msg = "invalid code -- missing end-of-block"), (r.mode = ia); - break; - } - if ( - ((r.lenbits = 9), - (A = { bits: r.lenbits }), - (te = $z(eYe, r.lens, 0, r.nlen, r.lencode, 0, r.work, A)), - (r.lenbits = A.bits), - te) - ) { - (t.msg = "invalid literal/lengths set"), (r.mode = ia); - break; - } - if ( - ((r.distbits = 6), - (r.distcode = r.distdyn), - (A = { bits: r.distbits }), - (te = $z(tYe, r.lens, r.nlen, r.ndist, r.distcode, 0, r.work, A)), - (r.distbits = A.bits), - te) - ) { - (t.msg = "invalid distances set"), (r.mode = ia); - break; - } - if (((r.mode = aQ), e === oQ)) break e; - case aQ: - r.mode = sQ; - case sQ: - if (s >= 6 && c >= 258) { - (t.next_out = a), - (t.avail_out = c), - (t.next_in = o), - (t.avail_in = s), - (r.hold = u), - (r.bits = h), - Mur(t, M), - (a = t.next_out), - (i = t.output), - (c = t.avail_out), - (o = t.next_in), - (n = t.input), - (s = t.avail_in), - (u = r.hold), - (h = r.bits), - r.mode === X_ && (r.back = -1); - break; - } - for ( - r.back = 0; - (F = r.lencode[u & ((1 << r.lenbits) - 1)]), - (N = F >>> 24), - (q = (F >>> 16) & 255), - (z = F & 65535), - !(N <= h); - - ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - if (q && (q & 240) === 0) { - for ( - H = N, Z = q, $ = z; - (F = r.lencode[$ + ((u & ((1 << (H + Z)) - 1)) >> H)]), - (N = F >>> 24), - (q = (F >>> 16) & 255), - (z = F & 65535), - !(H + N <= h); - - ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - (u >>>= H), (h -= H), (r.back += H); - } - if ( - ((u >>>= N), (h -= N), (r.back += N), (r.length = z), q === 0) - ) { - r.mode = MXe; - break; - } - if (q & 32) { - (r.back = -1), (r.mode = X_); - break; - } - if (q & 64) { - (t.msg = "invalid literal/length code"), (r.mode = ia); - break; - } - (r.extra = q & 15), (r.mode = xXe); - case xXe: - if (r.extra) { - for (l = r.extra; h < l; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - (r.length += u & ((1 << r.extra) - 1)), - (u >>>= r.extra), - (h -= r.extra), - (r.back += r.extra); - } - (r.was = r.length), (r.mode = SXe); - case SXe: - for ( - ; - (F = r.distcode[u & ((1 << r.distbits) - 1)]), - (N = F >>> 24), - (q = (F >>> 16) & 255), - (z = F & 65535), - !(N <= h); - - ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - if ((q & 240) === 0) { - for ( - H = N, Z = q, $ = z; - (F = r.distcode[$ + ((u & ((1 << (H + Z)) - 1)) >> H)]), - (N = F >>> 24), - (q = (F >>> 16) & 255), - (z = F & 65535), - !(H + N <= h); - - ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - (u >>>= H), (h -= H), (r.back += H); - } - if (((u >>>= N), (h -= N), (r.back += N), q & 64)) { - (t.msg = "invalid distance code"), (r.mode = ia); - break; - } - (r.offset = z), (r.extra = q & 15), (r.mode = AXe); - case AXe: - if (r.extra) { - for (l = r.extra; h < l; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - (r.offset += u & ((1 << r.extra) - 1)), - (u >>>= r.extra), - (h -= r.extra), - (r.back += r.extra); - } - if (r.offset > r.dmax) { - (t.msg = "invalid distance too far back"), (r.mode = ia); - break; - } - r.mode = EXe; - case EXe: - if (c === 0) break e; - if (((k = M - c), r.offset > k)) { - if (((k = r.offset - k), k > r.whave && r.sane)) { - (t.msg = "invalid distance too far back"), (r.mode = ia); - break; - } - k > r.wnext - ? ((k -= r.wnext), (O = r.wsize - k)) - : (O = r.wnext - k), - k > r.length && (k = r.length), - (D = r.window); - } else (D = i), (O = a - r.offset), (k = r.length); - k > c && (k = c), (c -= k), (r.length -= k); - do i[a++] = D[O++]; - while (--k); - r.length === 0 && (r.mode = sQ); - break; - case MXe: - if (c === 0) break e; - (i[a++] = r.length), c--, (r.mode = sQ); - break; - case Ewe: - if (r.wrap) { - for (; h < 32; ) { - if (s === 0) break e; - s--, (u |= n[o++] << h), (h += 8); - } - if ( - ((M -= c), - (t.total_out += M), - (r.total += M), - M && - (t.adler = r.check = - r.flags - ? Au(r.check, i, M, a - M) - : ej(r.check, i, M, a - M)), - (M = c), - (r.flags ? u : PXe(u)) !== r.check) - ) { - (t.msg = "incorrect data check"), (r.mode = ia); - break; - } - (u = 0), (h = 0); - } - r.mode = TXe; - case TXe: - if (r.wrap && r.flags) { - for (; h < 32; ) { - if (s === 0) break e; - s--, (u += n[o++] << h), (h += 8); - } - if (u !== (r.total & 4294967295)) { - (t.msg = "incorrect length check"), (r.mode = ia); - break; - } - (u = 0), (h = 0); - } - r.mode = kXe; - case kXe: - te = Rur; - break e; - case ia: - te = rYe; - break e; - case oYe: - return nYe; - case Fur: - default: - return vy; - } - return ( - (t.next_out = a), - (t.avail_out = c), - (t.next_in = o), - (t.avail_in = s), - (r.hold = u), - (r.bits = h), - (r.wsize || - (M !== t.avail_out && r.mode < ia && (r.mode < Ewe || e !== aXe))) && - lYe(t, t.output, t.next_out, M - t.avail_out), - (w -= t.avail_in), - (M -= t.avail_out), - (t.total_in += w), - (t.total_out += M), - (r.total += M), - r.wrap && - M && - (t.adler = r.check = - r.flags - ? Au(r.check, i, M, t.next_out - M) - : ej(r.check, i, M, t.next_out - M)), - (t.data_type = - r.bits + - (r.last ? 64 : 0) + - (r.mode === X_ ? 128 : 0) + - (r.mode === aQ || r.mode === Awe ? 256 : 0)), - ((w === 0 && M === 0) || e === aXe) && te === tT && (te = Dur), - te - ); - }, - Wur = (t) => { - if (!t || !t.state) return vy; - let e = t.state; - return e.window && (e.window = null), (t.state = null), tT; - }, - Gur = (t, e) => { - if (!t || !t.state) return vy; - let r = t.state; - return (r.wrap & 2) === 0 ? vy : ((r.head = e), (e.done = !1), tT); - }, - Jur = (t, e) => { - let r = e.length, - n, - i, - o; - return !t || !t.state || ((n = t.state), n.wrap !== 0 && n.mode !== pQ) - ? vy - : n.mode === pQ && ((i = 1), (i = ej(i, e, r, 0)), i !== n.check) - ? rYe - : ((o = lYe(t, e, r, r)), - o ? ((n.mode = oYe), nYe) : ((n.havedict = 1), tT)); - }, - $ur = sYe, - Zur = uYe, - Xur = aYe, - Yur = Kur, - Qur = cYe, - ecr = Vur, - tcr = Wur, - rcr = Gur, - ncr = Jur, - icr = "pako inflate (from Nodeca project)", - Q_ = { - inflateReset: $ur, - inflateReset2: Zur, - inflateResetKeep: Xur, - inflateInit: Yur, - inflateInit2: Qur, - inflate: ecr, - inflateEnd: tcr, - inflateGetHeader: rcr, - inflateSetDictionary: ncr, - inflateInfo: icr, - }; - function ocr() { - (this.text = 0), - (this.time = 0), - (this.xflags = 0), - (this.os = 0), - (this.extra = null), - (this.extra_len = 0), - (this.name = ""), - (this.comment = ""), - (this.hcrc = 0), - (this.done = !1); - } - var acr = ocr, - fYe = Object.prototype.toString, - { - Z_NO_FLUSH: scr, - Z_FINISH: ucr, - Z_OK: nj, - Z_STREAM_END: kwe, - Z_NEED_DICT: Pwe, - Z_STREAM_ERROR: ccr, - Z_DATA_ERROR: BXe, - Z_MEM_ERROR: lcr, - } = AC; - function sj(t) { - this.options = gQ.assign( - { chunkSize: 1024 * 64, windowBits: 15, to: "" }, - t || {} - ); - let e = this.options; - e.raw && - e.windowBits >= 0 && - e.windowBits < 16 && - ((e.windowBits = -e.windowBits), - e.windowBits === 0 && (e.windowBits = -15)), - e.windowBits >= 0 && - e.windowBits < 16 && - !(t && t.windowBits) && - (e.windowBits += 32), - e.windowBits > 15 && - e.windowBits < 48 && - (e.windowBits & 15) === 0 && - (e.windowBits |= 15), - (this.err = 0), - (this.msg = ""), - (this.ended = !1), - (this.chunks = []), - (this.strm = new YXe()), - (this.strm.avail_out = 0); - let r = Q_.inflateInit2(this.strm, e.windowBits); - if (r !== nj) throw new Error(YM[r]); - if ( - ((this.header = new acr()), - Q_.inflateGetHeader(this.strm, this.header), - e.dictionary && - (typeof e.dictionary == "string" - ? (e.dictionary = rj.string2buf(e.dictionary)) - : fYe.call(e.dictionary) === "[object ArrayBuffer]" && - (e.dictionary = new Uint8Array(e.dictionary)), - e.raw && - ((r = Q_.inflateSetDictionary(this.strm, e.dictionary)), r !== nj))) - ) - throw new Error(YM[r]); - } - sj.prototype.push = function (t, e) { - let r = this.strm, - n = this.options.chunkSize, - i = this.options.dictionary, - o, - a, - s; - if (this.ended) return !1; - for ( - e === ~~e ? (a = e) : (a = e === !0 ? ucr : scr), - fYe.call(t) === "[object ArrayBuffer]" - ? (r.input = new Uint8Array(t)) - : (r.input = t), - r.next_in = 0, - r.avail_in = r.input.length; - ; - - ) { - for ( - r.avail_out === 0 && - ((r.output = new Uint8Array(n)), (r.next_out = 0), (r.avail_out = n)), - o = Q_.inflate(r, a), - o === Pwe && - i && - ((o = Q_.inflateSetDictionary(r, i)), - o === nj ? (o = Q_.inflate(r, a)) : o === BXe && (o = Pwe)); - r.avail_in > 0 && o === kwe && r.state.wrap > 0 && t[r.next_in] !== 0; - - ) - Q_.inflateReset(r), (o = Q_.inflate(r, a)); - switch (o) { - case ccr: - case BXe: - case Pwe: - case lcr: - return this.onEnd(o), (this.ended = !0), !1; - } - if (((s = r.avail_out), r.next_out && (r.avail_out === 0 || o === kwe))) - if (this.options.to === "string") { - let c = rj.utf8border(r.output, r.next_out), - u = r.next_out - c, - h = rj.buf2string(r.output, c); - (r.next_out = u), - (r.avail_out = n - u), - u && r.output.set(r.output.subarray(c, c + u), 0), - this.onData(h); - } else - this.onData( - r.output.length === r.next_out - ? r.output - : r.output.subarray(0, r.next_out) - ); - if (!(o === nj && s === 0)) { - if (o === kwe) - return ( - (o = Q_.inflateEnd(this.strm)), this.onEnd(o), (this.ended = !0), !0 - ); - if (r.avail_in === 0) break; - } - } - return !0; - }; - sj.prototype.onData = function (t) { - this.chunks.push(t); - }; - sj.prototype.onEnd = function (t) { - t === nj && - (this.options.to === "string" - ? (this.result = this.chunks.join("")) - : (this.result = gQ.flattenChunks(this.chunks))), - (this.chunks = []), - (this.err = t), - (this.msg = this.strm.msg); - }; - function qwe(t, e) { - let r = new sj(e); - if ((r.push(t), r.err)) throw r.msg || YM[r.err]; - return r.result; - } - function fcr(t, e) { - return (e = e || {}), (e.raw = !0), qwe(t, e); - } - var dcr = sj, - hcr = qwe, - pcr = fcr, - ycr = qwe, - mcr = AC, - gcr = { - Inflate: dcr, - inflate: hcr, - inflateRaw: pcr, - ungzip: ycr, - constants: mcr, - }, - { Deflate: jdn, deflate: Udn, deflateRaw: Kdn, gzip: Hdn } = Aur, - { Inflate: Vdn, inflate: vcr, inflateRaw: Wdn, ungzip: Gdn } = gcr; - var dYe = vcr; - var V_e = qe(lI()), - NQ = qe(Dr()); - var Wlr = Object.freeze({ - __proto__: null, - encode: function (t) { - return t.reduce((e, r) => e + r.toString(16).padStart(2, "0"), "0x"); - }, - decode: function (t) { - t.indexOf("0x") === 0 && (t = t.substr(2)), - t.length % 2 == 1 && (t = "0" + t); - let e = t.match(/.{2}/g); - return e === null - ? Ki.Buffer.from([]) - : Ki.Buffer.from(e.map((r) => parseInt(r, 16))); - }, - }); - function eet(t) { - return new TextDecoder("utf-8").decode(t); - } - function tet(t) { - return new TextEncoder().encode(t); - } - var Glr = Object.freeze({ __proto__: null, decode: eet, encode: tet }); - function ret(t) { - return X2.default.encode(t); - } - var Jlr = Object.freeze({ - __proto__: null, - encode: ret, - decode: function (t) { - return X2.default.decode(t); - }, - }); - function net(t) { - return Ki.Buffer.from(uT.toByteArray(t)); - } - var $lr = Object.freeze({ - __proto__: null, - encode: function (t) { - return uT.fromByteArray(t); - }, - decode: net, - }), - Zlr = Object.freeze({ - __proto__: null, - hex: Wlr, - utf8: Glr, - bs58: Jlr, - base64: $lr, - }); - function iet(t) { - let e = new Map(); - return ( - t.errors && - t.errors.forEach((r) => { - var n; - let i = (n = r.msg) !== null && n !== void 0 ? n : r.name; - e.set(r.code, i); - }), - e - ); - } - function Xlr(t, ...e) { - if (t.args.length != e.length) throw new Error("Invalid argument length"); - let r = {}, - n = 0; - return ( - t.args.forEach((i) => { - (r[i.name] = e[n]), (n += 1); - }), - r - ); - } - function W_e(t, e = {}) { - t.forEach((r) => { - if ("accounts" in r) W_e(r.accounts, e[r.name]); - else if (e[r.name] === void 0) - throw new Error(`Invalid arguments: ${r.name} not provided.`); - }); - } - function Iv(t) { - return t instanceof Bn.PublicKey ? t : new Bn.PublicKey(t); - } - var d_e = class extends TypeError { - constructor(e, r) { - let n, - { message: i, ...o } = e, - { path: a } = e; - super(a.length === 0 ? i : "At path: " + a.join(".") + " -- " + i), - (this.value = void 0), - (this.key = void 0), - (this.type = void 0), - (this.refinement = void 0), - (this.path = void 0), - (this.branch = void 0), - (this.failures = void 0), - Object.assign(this, o), - (this.name = this.constructor.name), - (this.failures = () => { - var s; - return (s = n) != null ? s : (n = [e, ...r()]); - }); - } - }; - function BC(t) { - return typeof t == "object" && t != null; - } - function Y2(t) { - return typeof t == "string" ? JSON.stringify(t) : "" + t; - } - function Ylr(t, e, r, n) { - if (t === !0) return; - t === !1 ? (t = {}) : typeof t == "string" && (t = { message: t }); - let { path: i, branch: o } = e, - { type: a } = r, - { - refinement: s, - message: c = "Expected a value of type `" + - a + - "`" + - (s ? " with refinement `" + s + "`" : "") + - ", but received: `" + - Y2(n) + - "`", - } = t; - return { - value: n, - type: a, - refinement: s, - key: i[i.length - 1], - path: i, - branch: o, - ...t, - message: c, - }; - } - function* UQe(t, e, r, n) { - var i; - (BC((i = t)) && typeof i[Symbol.iterator] == "function") || (t = [t]); - for (let o of t) { - let a = Ylr(o, e, r, n); - a && (yield a); - } - } - function* G_e(t, e, r) { - r === void 0 && (r = {}); - let { path: n = [], branch: i = [t], coerce: o = !1, mask: a = !1 } = r, - s = { path: n, branch: i }; - if ( - o && - ((t = e.coercer(t, s)), - a && e.type !== "type" && BC(e.schema) && BC(t) && !Array.isArray(t)) - ) - for (let u in t) e.schema[u] === void 0 && delete t[u]; - let c = !0; - for (let u of e.validator(t, s)) (c = !1), yield [u, void 0]; - for (let [u, h, w] of e.entries(t, s)) { - let M = G_e(h, w, { - path: u === void 0 ? n : [...n, u], - branch: u === void 0 ? i : [...i, h], - coerce: o, - mask: a, - }); - for (let k of M) - k[0] - ? ((c = !1), yield [k[0], void 0]) - : o && - ((h = k[1]), - u === void 0 - ? (t = h) - : t instanceof Map - ? t.set(u, h) - : t instanceof Set - ? t.add(h) - : BC(t) && (t[u] = h)); - } - if (c) for (let u of e.refiner(t, s)) (c = !1), yield [u, void 0]; - c && (yield [void 0, t]); - } - var Cv = class { - constructor(e) { - (this.TYPE = void 0), - (this.type = void 0), - (this.schema = void 0), - (this.coercer = void 0), - (this.validator = void 0), - (this.refiner = void 0), - (this.entries = void 0); - let { - type: r, - schema: n, - validator: i, - refiner: o, - coercer: a = (c) => c, - entries: s = function* () {}, - } = e; - (this.type = r), - (this.schema = n), - (this.entries = s), - (this.coercer = a), - (this.validator = i ? (c, u) => UQe(i(c, u), u, this, c) : () => []), - (this.refiner = o ? (c, u) => UQe(o(c, u), u, this, c) : () => []); - } - assert(e) { - return (function (r, n) { - let i = xj(r, n); - if (i[0]) throw i[0]; - })(e, this); - } - create(e) { - return J_e(e, this); - } - is(e) { - return oet(e, this); - } - mask(e) { - return (function (r, n) { - let i = xj(r, n, { coerce: !0, mask: !0 }); - if (i[0]) throw i[0]; - return i[1]; - })(e, this); - } - validate(e, r) { - return r === void 0 && (r = {}), xj(e, this, r); - } - }; - function J_e(t, e) { - let r = xj(t, e, { coerce: !0 }); - if (r[0]) throw r[0]; - return r[1]; - } - function oet(t, e) { - return !xj(t, e)[0]; - } - function xj(t, e, r) { - r === void 0 && (r = {}); - let n = G_e(t, e, r), - i = (function (o) { - let { done: a, value: s } = o.next(); - return a ? void 0 : s; - })(n); - return i[0] - ? [ - new d_e(i[0], function* () { - for (let o of n) o[0] && (yield o[0]); - }), - void 0, - ] - : [void 0, i[1]]; - } - function Oj(t, e) { - return new Cv({ type: t, schema: null, validator: e }); - } - function c_e(t) { - return new Cv({ - type: "array", - schema: t, - *entries(e) { - if (t && Array.isArray(e)) - for (let [r, n] of e.entries()) yield [r, n, t]; - }, - coercer: (e) => (Array.isArray(e) ? e.slice() : e), - validator: (e) => - Array.isArray(e) || "Expected an array value, but received: " + Y2(e), - }); - } - function KQe(t) { - let e = Y2(t), - r = typeof t; - return new Cv({ - type: "literal", - schema: r === "string" || r === "number" || r === "boolean" ? t : null, - validator: (n) => - n === t || "Expected the literal `" + e + "`, but received: " + Y2(n), - }); - } - function OQ(t) { - return new Cv({ - ...t, - validator: (e, r) => e === null || t.validator(e, r), - refiner: (e, r) => e === null || t.refiner(e, r), - }); - } - function BQ() { - return Oj( - "number", - (t) => - (typeof t == "number" && !isNaN(t)) || - "Expected a number, but received: " + Y2(t) - ); - } - function CQ(t) { - return new Cv({ - ...t, - validator: (e, r) => e === void 0 || t.validator(e, r), - refiner: (e, r) => e === void 0 || t.refiner(e, r), - }); - } - function oT() { - return Oj( - "string", - (t) => typeof t == "string" || "Expected a string, but received: " + Y2(t) - ); - } - function Z2(t) { - let e = Object.keys(t); - return new Cv({ - type: "type", - schema: t, - *entries(r) { - if (BC(r)) for (let n of e) yield [n, r[n], t[n]]; - }, - validator: (r) => BC(r) || "Expected an object, but received: " + Y2(r), - }); - } - function aet(t) { - let e = t.map((r) => r.type).join(" | "); - return new Cv({ - type: "union", - schema: null, - coercer: (r, n) => - ( - t.find((i) => { - let [o] = i.validate(r, { coerce: !0 }); - return !o; - }) || $_e() - ).coercer(r, n), - validator(r, n) { - let i = []; - for (let o of t) { - let [...a] = G_e(r, o, n), - [s] = a; - if (!s[0]) return []; - for (let [c] of a) c && i.push(c); - } - return [ - "Expected the value to satisfy a union of `" + - e + - "`, but received: " + - Y2(r), - ...i, - ]; - }, - }); - } - function $_e() { - return Oj("unknown", () => !0); - } - async function set(t, e, r) { - if (e.length <= 99) return await HQe(t, e, r); - { - let n = (function (i, o) { - return Array.apply(0, new Array(Math.ceil(i.length / o))).map((a, s) => - i.slice(s * o, (s + 1) * o) - ); - })(e, 99); - return (await Promise.all(n.map((i) => HQe(t, i, r)))).flat(); - } - } - async function HQe(t, e, r) { - let n = r ?? t.commitment; - return (await t.getMultipleAccountsInfo(e, n)).map((i, o) => - i === null ? null : { publicKey: e[o], account: i } - ); - } - async function uet(t, e, r, n, i) { - r && r.length > 0 && e.sign(...r); - let o = e._compile(), - a = o.serialize(), - s = e._serialize(a).toString("base64"), - c = { encoding: "base64", commitment: n ?? t.commitment }; - if (i) { - let w = (Array.isArray(i) ? i : o.nonProgramIds()).map((M) => - M.toBase58() - ); - c.accounts = { encoding: "base64", addresses: w }; - } - r && (c.sigVerify = !0); - let u = [s, c], - h = J_e(await t._rpcRequest("simulateTransaction", u), tfr); - if ("error" in h) { - let w; - if ( - "data" in h.error && - ((w = h.error.data.logs), w && Array.isArray(w)) - ) { - let M = ` - `, - k = M + w.join(M); - console.error(h.error.message, k); - } - throw new Bn.SendTransactionError( - "failed to simulate transaction: " + h.error.message, - w - ); - } - return h.result; - } - function Qlr(t) { - return (function (e, r, n) { - return new Cv({ - ...e, - coercer: (i, o) => - oet(i, r) ? e.coercer(n(i, o), o) : e.coercer(i, o), - }); - })(cet(t), efr, (e) => - "error" in e ? e : { ...e, result: J_e(e.result, t) } - ); - } - var efr = cet($_e()); - function cet(t) { - return aet([ - Z2({ jsonrpc: KQe("2.0"), id: oT(), result: t }), - Z2({ - jsonrpc: KQe("2.0"), - id: oT(), - error: Z2({ - code: $_e(), - message: oT(), - data: CQ(Oj("any", () => !0)), - }), - }), - ]); - } - var tfr = - ((VQe = Z2({ - err: OQ(aet([Z2({}), oT()])), - logs: OQ(c_e(oT())), - accounts: CQ( - OQ( - c_e( - OQ( - Z2({ - executable: Oj("boolean", (t) => typeof t == "boolean"), - owner: oT(), - lamports: BQ(), - data: c_e(oT()), - rentEpoch: CQ(BQ()), - }) - ) - ) - ) - ), - unitsConsumed: CQ(BQ()), - })), - Qlr(Z2({ context: Z2({ slot: BQ() }), value: VQe }))), - VQe, - rfr = Object.freeze({ - __proto__: null, - invoke: async function (t, e, r, n) { - (t = Iv(t)), n || (n = Ej()); - let i = new Bn.Transaction(); - if ( - (i.add( - new Bn.TransactionInstruction({ - programId: t, - keys: e ?? [], - data: r, - }) - ), - n.sendAndConfirm === void 0) - ) - throw new Error( - "This function requires 'Provider.sendAndConfirm' to be implemented." - ); - return await n.sendAndConfirm(i, []); - }, - getMultipleAccounts: set, - simulateTransaction: uet, - }), - h_e = class { - constructor(e, r, n) { - (this.connection = e), - (this.wallet = r), - (this.opts = n), - (this.publicKey = r.publicKey); - } - static defaultOptions() { - return { preflightCommitment: "processed", commitment: "processed" }; - } - static local(e, r) { - throw new Error("Provider local is not available on browser."); - } - static env() { - throw new Error("Provider env is not available on browser."); - } - async sendAndConfirm(e, r, n) { - var i; - n === void 0 && (n = this.opts), - (e.feePayer = this.wallet.publicKey), - (e.recentBlockhash = ( - await this.connection.getRecentBlockhash(n.preflightCommitment) - ).blockhash), - (e = await this.wallet.signTransaction(e)), - (r ?? []).forEach((a) => { - e.partialSign(a); - }); - let o = e.serialize(); - try { - return await WQe(this.connection, o, n); - } catch (a) { - if (a instanceof DQ) { - let s = await this.connection.getTransaction(ret(e.signature), { - commitment: "confirmed", - }); - if (s) { - let c = - (i = s.meta) === null || i === void 0 ? void 0 : i.logMessages; - throw c ? new Bn.SendTransactionError(a.message, c) : a; - } - throw a; - } - throw a; - } - } - async sendAll(e, r) { - r === void 0 && (r = this.opts); - let n = await this.connection.getRecentBlockhash(r.preflightCommitment), - i = e.map((s) => { - var c; - let u = s.tx, - h = (c = s.signers) !== null && c !== void 0 ? c : []; - return ( - (u.feePayer = this.wallet.publicKey), - (u.recentBlockhash = n.blockhash), - h.forEach((w) => { - u.partialSign(w); - }), - u - ); - }), - o = await this.wallet.signAllTransactions(i), - a = []; - for (let s = 0; s < i.length; s += 1) { - let c = o[s].serialize(); - a.push(await WQe(this.connection, c, r)); - } - return a; - } - async simulate(e, r, n, i) { - (e.feePayer = this.wallet.publicKey), - (e.recentBlockhash = ( - await this.connection.getLatestBlockhash( - n ?? this.connection.commitment - ) - ).blockhash), - (e = await this.wallet.signTransaction(e)); - let o = await uet(this.connection, e, r, n, i); - if (o.value.err) throw new p_e(o.value); - return o.value; - } - }, - p_e = class extends Error { - constructor(e, r) { - super(r), (this.simulationResponse = e); - } - }; - async function WQe(t, e, r) { - let n = r && { - skipPreflight: r.skipPreflight, - preflightCommitment: r.preflightCommitment || r.commitment, - }, - i = await t.sendRawTransaction(e, n), - o = (await t.confirmTransaction(i, r && r.commitment)).value; - if (o.err) - throw new DQ(`Raw transaction ${i} failed (${JSON.stringify(o)})`); - return i; - } - var DQ = class extends Error { - constructor(e) { - super(e); - } - }; - function Ej() { - return GQe === null ? h_e.local() : GQe; - } - var GQe = null, - nfr = new Set(["anchor-deprecated-state", "debug-logs"]), - fet = new Map(); - function GQ(t) { - return fet.get(t) !== void 0; - } - var ifr = Object.freeze({ - __proto__: null, - set: function (t) { - if (!nfr.has(t)) throw new Error("Invalid feature"); - fet.set(t, !0); - }, - isSet: GQ, - }), - IC = class extends Error { - constructor(e) { - super(e), (this.name = "IdlError"); - } - }, - cT = class { - constructor(e) { - this.stack = e; - } - static parse(e) { - var r; - let n = /^Program (\w*) invoke/, - i = /^Program \w* success/, - o = []; - for (let a = 0; a < e.length; a++) { - if (i.exec(e[a])) { - o.pop(); - continue; - } - let s = (r = n.exec(e[a])) === null || r === void 0 ? void 0 : r[1]; - s && o.push(new Bn.PublicKey(s)); - } - return new cT(o); - } - }, - aT = class extends Error { - constructor(e, r, n, i, o, a) { - super( - n - .join( - ` -` - ) - .replace("Program log: ", "") - ), - (this.errorLogs = n), - (this.logs = i), - (this.error = { - errorCode: e, - errorMessage: r, - comparedValues: a, - origin: o, - }), - (this._programErrorStack = cT.parse(i)); - } - static parse(e) { - if (!e) return null; - let r = e.findIndex((u) => u.startsWith("Program log: AnchorError")); - if (r === -1) return null; - let n = e[r], - i = [n], - o; - if (r + 1 < e.length) { - if (e[r + 1] === "Program log: Left:") { - let u = /^Program log: (.*)$/, - h = u.exec(e[r + 2])[1], - w = u.exec(e[r + 4])[1]; - (o = [new Bn.PublicKey(h), new Bn.PublicKey(w)]), - i.push(...e.slice(r + 1, r + 5)); - } else if (e[r + 1].startsWith("Program log: Left:")) { - let u = /^Program log: (Left|Right): (.*)$/, - h = u.exec(e[r + 1])[2], - w = u.exec(e[r + 2])[2]; - i.push(...e.slice(r + 1, r + 3)), (o = [h, w]); - } - } - let a = - /^Program log: AnchorError occurred\. Error Code: (.*)\. Error Number: (\d*)\. Error Message: (.*)\./.exec( - n - ), - s = - /^Program log: AnchorError thrown in (.*):(\d*)\. Error Code: (.*)\. Error Number: (\d*)\. Error Message: (.*)\./.exec( - n - ), - c = - /^Program log: AnchorError caused by account: (.*)\. Error Code: (.*)\. Error Number: (\d*)\. Error Message: (.*)\./.exec( - n - ); - if (a) { - let [u, h, w] = a.slice(1, 4), - M = { code: u, number: parseInt(h) }; - return new aT(M, w, i, e, void 0, o); - } - if (s) { - let [u, h, w, M, k] = s.slice(1, 6), - O = { code: w, number: parseInt(M) }, - D = { file: u, line: parseInt(h) }; - return new aT(O, k, i, e, D, o); - } - if (c) { - let [u, h, w, M] = c.slice(1, 5), - k = u, - O = { code: h, number: parseInt(w) }; - return new aT(O, M, i, e, k, o); - } - return null; - } - get program() { - return this._programErrorStack.stack[ - this._programErrorStack.stack.length - 1 - ]; - } - get programErrorStack() { - return this._programErrorStack.stack; - } - toString() { - return this.message; - } - }, - CC = class extends Error { - constructor(e, r, n) { - super(), - (this.code = e), - (this.msg = r), - (this.logs = n), - n && (this._programErrorStack = cT.parse(n)); - } - static parse(e, r) { - let n = e.toString(), - i, - o; - if (n.includes("custom program error:")) { - let s = n.split("custom program error: "); - if (s.length !== 2) return null; - i = s[1]; - } else { - let s = n.match(/"Custom":([0-9]+)}/g); - if (!s || s.length > 1) return null; - i = s[0].match(/([0-9]+)/g)[0]; - } - try { - o = parseInt(i); - } catch { - return null; - } - let a = r.get(o); - return a !== void 0 - ? new CC(o, a, e.logs) - : ((a = ofr.get(o)), a !== void 0 ? new CC(o, a, e.logs) : null); - } - get program() { - var e; - return (e = this._programErrorStack) === null || e === void 0 - ? void 0 - : e.stack[this._programErrorStack.stack.length - 1]; - } - get programErrorStack() { - var e; - return (e = this._programErrorStack) === null || e === void 0 - ? void 0 - : e.stack; - } - toString() { - return this.msg; - } - }; - function det(t, e) { - GQ("debug-logs") && console.log("Translating error:", t); - let r = aT.parse(t.logs); - if (r) return r; - let n = CC.parse(t, e); - if (n) return n; - if (t.logs) { - let i = { - get: function (o, a) { - return a === "programErrorStack" - ? o.programErrorStack.stack - : a === "program" - ? o.programErrorStack.stack[t.programErrorStack.stack.length - 1] - : Reflect.get(...arguments); - }, - }; - return (t.programErrorStack = cT.parse(t.logs)), new Proxy(t, i); - } - return t; - } - var _r = { - InstructionMissing: 100, - InstructionFallbackNotFound: 101, - InstructionDidNotDeserialize: 102, - InstructionDidNotSerialize: 103, - IdlInstructionStub: 1e3, - IdlInstructionInvalidProgram: 1001, - ConstraintMut: 2e3, - ConstraintHasOne: 2001, - ConstraintSigner: 2002, - ConstraintRaw: 2003, - ConstraintOwner: 2004, - ConstraintRentExempt: 2005, - ConstraintSeeds: 2006, - ConstraintExecutable: 2007, - ConstraintState: 2008, - ConstraintAssociated: 2009, - ConstraintAssociatedInit: 2010, - ConstraintClose: 2011, - ConstraintAddress: 2012, - ConstraintZero: 2013, - ConstraintTokenMint: 2014, - ConstraintTokenOwner: 2015, - ConstraintMintMintAuthority: 2016, - ConstraintMintFreezeAuthority: 2017, - ConstraintMintDecimals: 2018, - ConstraintSpace: 2019, - RequireViolated: 2500, - RequireEqViolated: 2501, - RequireKeysEqViolated: 2502, - RequireNeqViolated: 2503, - RequireKeysNeqViolated: 2504, - RequireGtViolated: 2505, - RequireGteViolated: 2506, - AccountDiscriminatorAlreadySet: 3e3, - AccountDiscriminatorNotFound: 3001, - AccountDiscriminatorMismatch: 3002, - AccountDidNotDeserialize: 3003, - AccountDidNotSerialize: 3004, - AccountNotEnoughKeys: 3005, - AccountNotMutable: 3006, - AccountOwnedByWrongProgram: 3007, - InvalidProgramId: 3008, - InvalidProgramExecutable: 3009, - AccountNotSigner: 3010, - AccountNotSystemOwned: 3011, - AccountNotInitialized: 3012, - AccountNotProgramData: 3013, - AccountNotAssociatedTokenAccount: 3014, - AccountSysvarMismatch: 3015, - AccountReallocExceedsLimit: 3016, - AccountDuplicateReallocs: 3017, - StateInvalidAddress: 4e3, - DeclaredProgramIdMismatch: 4100, - Deprecated: 5e3, - }, - ofr = new Map([ - [_r.InstructionMissing, "8 byte instruction identifier not provided"], - [_r.InstructionFallbackNotFound, "Fallback functions are not supported"], - [ - _r.InstructionDidNotDeserialize, - "The program could not deserialize the given instruction", - ], - [ - _r.InstructionDidNotSerialize, - "The program could not serialize the given instruction", - ], - [ - _r.IdlInstructionStub, - "The program was compiled without idl instructions", - ], - [ - _r.IdlInstructionInvalidProgram, - "The transaction was given an invalid program for the IDL instruction", - ], - [_r.ConstraintMut, "A mut constraint was violated"], - [_r.ConstraintHasOne, "A has_one constraint was violated"], - [_r.ConstraintSigner, "A signer constraint was violated"], - [_r.ConstraintRaw, "A raw constraint was violated"], - [_r.ConstraintOwner, "An owner constraint was violated"], - [_r.ConstraintRentExempt, "A rent exemption constraint was violated"], - [_r.ConstraintSeeds, "A seeds constraint was violated"], - [_r.ConstraintExecutable, "An executable constraint was violated"], - [_r.ConstraintState, "A state constraint was violated"], - [_r.ConstraintAssociated, "An associated constraint was violated"], - [ - _r.ConstraintAssociatedInit, - "An associated init constraint was violated", - ], - [_r.ConstraintClose, "A close constraint was violated"], - [_r.ConstraintAddress, "An address constraint was violated"], - [_r.ConstraintZero, "Expected zero account discriminant"], - [_r.ConstraintTokenMint, "A token mint constraint was violated"], - [_r.ConstraintTokenOwner, "A token owner constraint was violated"], - [ - _r.ConstraintMintMintAuthority, - "A mint mint authority constraint was violated", - ], - [ - _r.ConstraintMintFreezeAuthority, - "A mint freeze authority constraint was violated", - ], - [_r.ConstraintMintDecimals, "A mint decimals constraint was violated"], - [_r.ConstraintSpace, "A space constraint was violated"], - [_r.RequireViolated, "A require expression was violated"], - [_r.RequireEqViolated, "A require_eq expression was violated"], - [_r.RequireKeysEqViolated, "A require_keys_eq expression was violated"], - [_r.RequireNeqViolated, "A require_neq expression was violated"], - [_r.RequireKeysNeqViolated, "A require_keys_neq expression was violated"], - [_r.RequireGtViolated, "A require_gt expression was violated"], - [_r.RequireGteViolated, "A require_gte expression was violated"], - [ - _r.AccountDiscriminatorAlreadySet, - "The account discriminator was already set on this account", - ], - [ - _r.AccountDiscriminatorNotFound, - "No 8 byte discriminator was found on the account", - ], - [ - _r.AccountDiscriminatorMismatch, - "8 byte discriminator did not match what was expected", - ], - [_r.AccountDidNotDeserialize, "Failed to deserialize the account"], - [_r.AccountDidNotSerialize, "Failed to serialize the account"], - [ - _r.AccountNotEnoughKeys, - "Not enough account keys given to the instruction", - ], - [_r.AccountNotMutable, "The given account is not mutable"], - [ - _r.AccountOwnedByWrongProgram, - "The given account is owned by a different program than expected", - ], - [_r.InvalidProgramId, "Program ID was not as expected"], - [_r.InvalidProgramExecutable, "Program account is not executable"], - [_r.AccountNotSigner, "The given account did not sign"], - [ - _r.AccountNotSystemOwned, - "The given account is not owned by the system program", - ], - [ - _r.AccountNotInitialized, - "The program expected this account to be already initialized", - ], - [ - _r.AccountNotProgramData, - "The given account is not a program data account", - ], - [ - _r.AccountNotAssociatedTokenAccount, - "The given account is not the associated token account", - ], - [ - _r.AccountSysvarMismatch, - "The given public key does not match the required sysvar", - ], - [ - _r.AccountReallocExceedsLimit, - "The account reallocation exceeds the MAX_PERMITTED_DATA_INCREASE limit", - ], - [ - _r.AccountDuplicateReallocs, - "The account was duplicated for more than one reallocation", - ], - [ - _r.StateInvalidAddress, - "The given state account does not have the correct address", - ], - [ - _r.DeclaredProgramIdMismatch, - "The declared program id does not match the actual program id", - ], - [ - _r.Deprecated, - "The API being used is deprecated and should no longer be used", - ], - ]); - var FQ = function () { - return ( - (FQ = - Object.assign || - function (t) { - for (var e, r = 1, n = arguments.length; r < n; r++) - for (var i in (e = arguments[r])) - Object.prototype.hasOwnProperty.call(e, i) && (t[i] = e[i]); - return t; - }), - FQ.apply(this, arguments) - ); - }; - function afr(t) { - return t.toLowerCase(); - } - var sfr = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g], - ufr = /[^A-Z0-9]+/gi; - function JQe(t, e, r) { - return e instanceof RegExp - ? t.replace(e, r) - : e.reduce(function (n, i) { - return n.replace(i, r); - }, t); - } - function cfr(t, e) { - return ( - e === void 0 && (e = {}), - (function (r, n) { - n === void 0 && (n = {}); - for ( - var i = n.splitRegexp, - o = i === void 0 ? sfr : i, - a = n.stripRegexp, - s = a === void 0 ? ufr : a, - c = n.transform, - u = c === void 0 ? afr : c, - h = n.delimiter, - w = h === void 0 ? " " : h, - M = JQe(JQe(r, o, "$1\0$2"), s, "\0"), - k = 0, - O = M.length; - M.charAt(k) === "\0"; - - ) - k++; - for (; M.charAt(O - 1) === "\0"; ) O--; - return M.slice(k, O).split("\0").map(u).join(w); - })(t, FQ({ delimiter: "." }, e)) - ); - } - var Hc = class { - static fieldLayout(e, r) { - let n = e.name !== void 0 ? (0, Zs.default)(e.name) : void 0; - switch (e.type) { - case "bool": - return fr.bool(n); - case "u8": - return fr.u8(n); - case "i8": - return fr.i8(n); - case "u16": - return fr.u16(n); - case "i16": - return fr.i16(n); - case "u32": - return fr.u32(n); - case "i32": - return fr.i32(n); - case "f32": - return fr.f32(n); - case "u64": - return fr.u64(n); - case "i64": - return fr.i64(n); - case "f64": - return fr.f64(n); - case "u128": - return fr.u128(n); - case "i128": - return fr.i128(n); - case "bytes": - return fr.vecU8(n); - case "string": - return fr.str(n); - case "publicKey": - return fr.publicKey(n); - default: - if ("vec" in e.type) - return fr.vec( - Hc.fieldLayout({ name: void 0, type: e.type.vec }, r), - n - ); - if ("option" in e.type) - return fr.option( - Hc.fieldLayout({ name: void 0, type: e.type.option }, r), - n - ); - if ("defined" in e.type) { - let i = e.type.defined; - if (r === void 0) throw new IC("User defined types not provided"); - let o = r.filter((a) => a.name === i); - if (o.length !== 1) - throw new IC(`Type not found: ${JSON.stringify(e)}`); - return Hc.typeDefLayout(o[0], r, n); - } - if ("array" in e.type) { - let i = e.type.array[0], - o = e.type.array[1], - a = Hc.fieldLayout({ name: void 0, type: i }, r); - return fr.array(a, o, n); - } - throw new Error(`Not yet implemented: ${e}`); - } - } - static typeDefLayout(e, r = [], n) { - if (e.type.kind === "struct") { - let i = e.type.fields.map((o) => Hc.fieldLayout(o, r)); - return fr.struct(i, n); - } - if (e.type.kind === "enum") { - let i = e.type.variants.map((o) => { - let a = (0, Zs.default)(o.name); - if (o.fields === void 0) return fr.struct([], a); - let s = o.fields.map((c) => { - if (!c.hasOwnProperty("name")) - throw new Error("Tuple enum variants not yet implemented."); - return Hc.fieldLayout(c, r); - }); - return fr.struct(s, a); - }); - return n !== void 0 ? fr.rustEnum(i).replicate(n) : fr.rustEnum(i, n); - } - throw new Error(`Unknown type kint: ${e}`); - } - }, - Mj = class { - constructor(e) { - (this.idl = e), (this.ixLayout = Mj.parseIxLayout(e)); - let r = new Map(); - e.instructions.forEach((n) => { - let i = l_e("global", n.name); - r.set(X2.default.encode(i), { - layout: this.ixLayout.get(n.name), - name: n.name, - }); - }), - e.state && - e.state.methods.map((n) => { - let i = l_e("state", n.name); - r.set(X2.default.encode(i), { - layout: this.ixLayout.get(n.name), - name: n.name, - }); - }), - (this.sighashLayouts = r); - } - encode(e, r) { - return this._encode("global", e, r); - } - encodeState(e, r) { - return this._encode("state", e, r); - } - _encode(e, r, n) { - let i = Ki.Buffer.alloc(1e3), - o = (0, Zs.default)(r), - a = this.ixLayout.get(o); - if (!a) throw new Error(`Unknown method: ${o}`); - let s = a.encode(n, i), - c = i.slice(0, s); - return Ki.Buffer.concat([l_e(e, r), c]); - } - static parseIxLayout(e) { - let r = (e.state ? e.state.methods : []) - .map((n) => { - let i = n.args.map((a) => { - var s, c; - return Hc.fieldLayout( - a, - Array.from([ - ...((s = e.accounts) !== null && s !== void 0 ? s : []), - ...((c = e.types) !== null && c !== void 0 ? c : []), - ]) - ); - }), - o = (0, Zs.default)(n.name); - return [o, fr.struct(i, o)]; - }) - .concat( - e.instructions.map((n) => { - let i = n.args.map((a) => { - var s, c; - return Hc.fieldLayout( - a, - Array.from([ - ...((s = e.accounts) !== null && s !== void 0 ? s : []), - ...((c = e.types) !== null && c !== void 0 ? c : []), - ]) - ); - }), - o = (0, Zs.default)(n.name); - return [o, fr.struct(i, o)]; - }) - ); - return new Map(r); - } - decode(e, r = "hex") { - typeof e == "string" && - (e = r === "hex" ? Ki.Buffer.from(e, "hex") : X2.default.decode(e)); - let n = X2.default.encode(e.slice(0, 8)), - i = e.slice(8), - o = this.sighashLayouts.get(n); - return o ? { data: o.layout.decode(i), name: o.name } : null; - } - format(e, r) { - return eg.format(e, r, this.idl); - } - }, - eg = class { - static format(e, r, n) { - let i = n.instructions.filter((s) => e.name === s.name)[0]; - if (i === void 0) - return console.error("Invalid instruction given"), null; - let o = i.args.map((s) => ({ - name: s.name, - type: eg.formatIdlType(s.type), - data: eg.formatIdlData(s, e.data[s.name], n.types), - })), - a = eg.flattenIdlAccounts(i.accounts); - return { - args: o, - accounts: r.map((s, c) => - c < a.length ? { name: a[c].name, ...s } : { name: void 0, ...s } - ), - }; - } - static formatIdlType(e) { - if (typeof e == "string") return e; - if ("vec" in e) return `Vec<${this.formatIdlType(e.vec)}>`; - if ("option" in e) return `Option<${this.formatIdlType(e.option)}>`; - if ("defined" in e) return e.defined; - if ("array" in e) return `Array<${e.array[0]}; ${e.array[1]}>`; - throw new Error(`Unknown IDL type: ${e}`); - } - static formatIdlData(e, r, n) { - if (typeof e.type == "string") return r.toString(); - if (e.type.hasOwnProperty("vec")) - return ( - "[" + - r - .map((i) => this.formatIdlData({ name: "", type: e.type.vec }, i)) - .join(", ") + - "]" - ); - if (e.type.hasOwnProperty("option")) - return r === null - ? "null" - : this.formatIdlData({ name: "", type: e.type.option }, r, n); - if (e.type.hasOwnProperty("defined")) { - if (n === void 0) throw new Error("User defined types not provided"); - let i = n.filter((o) => o.name === e.type.defined); - if (i.length !== 1) - throw new Error(`Type not found: ${e.type.defined}`); - return eg.formatIdlDataDefined(i[0], r, n); - } - return "unknown"; - } - static formatIdlDataDefined(e, r, n) { - if (e.type.kind === "struct") { - let i = e.type; - return ( - "{ " + - Object.keys(r) - .map((o) => { - let a = i.fields.filter((s) => s.name === o)[0]; - if (a === void 0) throw new Error("Unable to find type"); - return o + ": " + eg.formatIdlData(a, r[o], n); - }) - .join(", ") + - " }" - ); - } - if (e.type.variants.length === 0) return "{}"; - if (e.type.variants[0].name) { - let i = e.type.variants, - o = Object.keys(r)[0], - a = r[o], - s = Object.keys(a) - .map((u) => { - var h; - let w = a[u], - M = - (h = i[o]) === null || h === void 0 - ? void 0 - : h.filter((k) => k.name === u)[0]; - if (M === void 0) throw new Error("Unable to find variant"); - return u + ": " + eg.formatIdlData(M, w, n); - }) - .join(", "), - c = (0, Zs.default)(o, { pascalCase: !0 }); - return s.length === 0 ? c : `${c} { ${s} }`; - } - return "Tuple formatting not yet implemented"; - } - static flattenIdlAccounts(e, r) { - return e - .map((n) => { - let i = (function (o) { - let a = o.replace(/([A-Z])/g, " $1"); - return a.charAt(0).toUpperCase() + a.slice(1); - })(n.name); - if (n.hasOwnProperty("accounts")) { - let o = r ? `${r} > ${i}` : i; - return eg.flattenIdlAccounts(n.accounts, o); - } - return { ...n, name: r ? `${r} > ${i}` : i }; - }) - .flat(); - } - }; - function l_e(t, e) { - var r; - let n = `${t}:${ - (r === void 0 && (r = {}), cfr(e, FQ({ delimiter: "_" }, r))) - }`; - return Ki.Buffer.from(eA.sha256.digest(n)).slice(0, 8); - } - function Z_e(t, e) { - if (e.type.kind === "enum") { - let r = e.type.variants.map((n) => - n.fields === void 0 - ? 0 - : n.fields - .map((i) => { - if (typeof i != "object" || !("name" in i)) - throw new Error("Tuple enum variants not yet implemented."); - return Sj(t, i.type); - }) - .reduce((i, o) => i + o) - ); - return Math.max(...r) + 1; - } - return e.type.fields === void 0 - ? 0 - : e.type.fields.map((r) => Sj(t, r.type)).reduce((r, n) => r + n, 0); - } - function Sj(t, e) { - var r, n; - switch (e) { - case "bool": - case "u8": - case "i8": - case "bytes": - case "string": - return 1; - case "i16": - case "u16": - return 2; - case "u32": - case "i32": - case "f32": - return 4; - case "u64": - case "i64": - case "f64": - return 8; - case "u128": - case "i128": - return 16; - case "publicKey": - return 32; - default: - if ("vec" in e) return 1; - if ("option" in e) return 1 + Sj(t, e.option); - if ("coption" in e) return 4 + Sj(t, e.coption); - if ("defined" in e) { - let i = - (n = - (r = t.types) === null || r === void 0 - ? void 0 - : r.filter((o) => o.name === e.defined)) !== null && - n !== void 0 - ? n - : []; - if (i.length !== 1) - throw new IC(`Type not found: ${JSON.stringify(e)}`); - return Z_e(t, i[0]); - } - if ("array" in e) { - let i = e.array[0], - o = e.array[1]; - return Sj(t, i) * o; - } - throw new Error(`Invalid type ${JSON.stringify(e)}`); - } - } - var sT = class { - constructor(e) { - if (e.accounts === void 0) - return void (this.accountLayouts = new Map()); - let r = e.accounts.map((n) => [n.name, Hc.typeDefLayout(n, e.types)]); - (this.accountLayouts = new Map(r)), (this.idl = e); - } - async encode(e, r) { - let n = Ki.Buffer.alloc(1e3), - i = this.accountLayouts.get(e); - if (!i) throw new Error(`Unknown account: ${e}`); - let o = i.encode(r, n), - a = n.slice(0, o), - s = sT.accountDiscriminator(e); - return Ki.Buffer.concat([s, a]); - } - decode(e, r) { - if (sT.accountDiscriminator(e).compare(r.slice(0, 8))) - throw new Error("Invalid account discriminator"); - return this.decodeUnchecked(e, r); - } - decodeUnchecked(e, r) { - let n = r.slice(8), - i = this.accountLayouts.get(e); - if (!i) throw new Error(`Unknown account: ${e}`); - return i.decode(n); - } - memcmp(e, r) { - let n = sT.accountDiscriminator(e); - return { - offset: 0, - bytes: X2.default.encode(r ? Ki.Buffer.concat([n, r]) : n), - }; - } - size(e) { - var r; - return 8 + ((r = Z_e(this.idl, e)) !== null && r !== void 0 ? r : 0); - } - static accountDiscriminator(e) { - return Ki.Buffer.from( - eA.sha256.digest(`account:${(0, Zs.default)(e, { pascalCase: !0 })}`) - ).slice(0, 8); - } - }, - y_e = class { - constructor(e) { - if (e.events === void 0) return void (this.layouts = new Map()); - let r = e.events.map((n) => { - let i = { - name: n.name, - type: { - kind: "struct", - fields: n.fields.map((o) => ({ name: o.name, type: o.type })), - }, - }; - return [n.name, Hc.typeDefLayout(i, e.types)]; - }); - (this.layouts = new Map(r)), - (this.discriminators = new Map( - e.events === void 0 - ? [] - : e.events.map((n) => [uT.fromByteArray(lfr(n.name)), n.name]) - )); - } - decode(e) { - let r; - try { - r = Ki.Buffer.from(uT.toByteArray(e)); - } catch { - return null; - } - let n = uT.fromByteArray(r.slice(0, 8)), - i = this.discriminators.get(n); - if (i === void 0) return null; - let o = this.layouts.get(i); - if (!o) throw new Error(`Unknown event: ${i}`); - return { data: o.decode(r.slice(8)), name: i }; - } - }; - function lfr(t) { - return Ki.Buffer.from(eA.sha256.digest(`event:${t}`)).slice(0, 8); - } - var m_e = class { - constructor(e) { - if (e.state === void 0) throw new Error("Idl state not defined."); - this.layout = Hc.typeDefLayout(e.state.struct, e.types); - } - async encode(e, r) { - let n = Ki.Buffer.alloc(1e3), - i = this.layout.encode(r, n), - o = await het(e), - a = n.slice(0, i); - return Ki.Buffer.concat([o, a]); - } - decode(e) { - let r = e.slice(8); - return this.layout.decode(r); - } - }; - async function het(t) { - let e = GQ("anchor-deprecated-state") ? "account" : "state"; - return Ki.Buffer.from(eA.sha256.digest(`${e}:${t}`)).slice(0, 8); - } - var g_e = class { - constructor(e) { - if (e.types === void 0) return void (this.typeLayouts = new Map()); - let r = e.types.map((n) => [n.name, Hc.typeDefLayout(n, e.types)]); - (this.typeLayouts = new Map(r)), (this.idl = e); - } - encode(e, r) { - let n = Ki.Buffer.alloc(1e3), - i = this.typeLayouts.get(e); - if (!i) throw new Error(`Unknown type: ${e}`); - let o = i.encode(r, n); - return n.slice(0, o); - } - decode(e, r) { - let n = this.typeLayouts.get(e); - if (!n) throw new Error(`Unknown type: ${e}`); - return n.decode(r); - } - }, - Tj = class { - constructor(e) { - (this.instruction = new Mj(e)), - (this.accounts = new sT(e)), - (this.events = new y_e(e)), - e.state && (this.state = new m_e(e)), - (this.types = new g_e(e)); - } - }, - ffr = - typeof globalThis < "u" - ? globalThis - : typeof window < "u" || typeof window < "u" - ? window - : typeof self < "u" - ? self - : {}; - function dfr(t) { - return t && - t.__esModule && - Object.prototype.hasOwnProperty.call(t, "default") - ? t.default - : t; - } - var Vc = class { - constructor(e, r) { - if (!Number.isInteger(e)) - throw new TypeError("span must be an integer"); - (this.span = e), (this.property = r); - } - makeDestinationObject() { - return {}; - } - decode(e, r) { - throw new Error("Layout is abstract"); - } - encode(e, r, n) { - throw new Error("Layout is abstract"); - } - getSpan(e, r) { - if (0 > this.span) throw new RangeError("indeterminate span"); - return this.span; - } - replicate(e) { - let r = Object.create(this.constructor.prototype); - return Object.assign(r, this), (r.property = e), r; - } - fromArray(e) {} - }, - JQ = Vc, - nx = class extends Vc { - isCount() { - throw new Error("ExternalLayout is abstract"); - } - }, - LQ = class extends nx { - constructor(e, r, n) { - if (!(e instanceof Vc)) throw new TypeError("layout must be a Layout"); - if (r === void 0) r = 0; - else if (!Number.isInteger(r)) - throw new TypeError("offset must be integer or undefined"); - super(e.span, n || e.property), (this.layout = e), (this.offset = r); - } - isCount() { - return this.layout instanceof RC || this.layout instanceof qQ; - } - decode(e, r) { - return r === void 0 && (r = 0), this.layout.decode(e, r + this.offset); - } - encode(e, r, n) { - return ( - n === void 0 && (n = 0), this.layout.encode(e, r, n + this.offset) - ); - } - }, - RC = class extends Vc { - constructor(e, r) { - if ((super(e, r), 6 < this.span)) - throw new RangeError("span must not exceed 6 bytes"); - } - decode(e, r) { - return r === void 0 && (r = 0), e.readUIntLE(r, this.span); - } - encode(e, r, n) { - return ( - n === void 0 && (n = 0), r.writeUIntLE(e, n, this.span), this.span - ); - } - }, - qQ = class extends Vc { - constructor(e, r) { - if ((super(e, r), 6 < this.span)) - throw new RangeError("span must not exceed 6 bytes"); - } - decode(e, r) { - return r === void 0 && (r = 0), e.readUIntBE(r, this.span); - } - encode(e, r, n) { - return ( - n === void 0 && (n = 0), r.writeUIntBE(e, n, this.span), this.span - ); - } - }, - v_e = Math.pow(2, 32); - function pet(t) { - let e = Math.floor(t / v_e); - return { hi32: e, lo32: t - e * v_e }; - } - function yet(t, e) { - return t * v_e + e; - } - var b_e = class extends Vc { - constructor(e) { - super(8, e); - } - decode(e, r) { - r === void 0 && (r = 0); - let n = e.readUInt32LE(r); - return yet(e.readUInt32LE(r + 4), n); - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = pet(e); - return r.writeUInt32LE(i.lo32, n), r.writeUInt32LE(i.hi32, n + 4), 8; - } - }, - w_e = class extends Vc { - constructor(e) { - super(8, e); - } - decode(e, r) { - r === void 0 && (r = 0); - let n = e.readUInt32LE(r); - return yet(e.readInt32LE(r + 4), n); - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = pet(e); - return r.writeUInt32LE(i.lo32, n), r.writeInt32LE(i.hi32, n + 4), 8; - } - }, - __e = class extends Vc { - constructor(e, r, n) { - if (!Array.isArray(e) || !e.reduce((o, a) => o && a instanceof Vc, !0)) - throw new TypeError("fields must be array of Layout instances"); - typeof r == "boolean" && n === void 0 && ((n = r), (r = void 0)); - for (let o of e) - if (0 > o.span && o.property === void 0) - throw new Error( - "fields cannot contain unnamed variable-length layout" - ); - let i = -1; - try { - i = e.reduce((o, a) => o + a.getSpan(), 0); - } catch {} - super(i, r), (this.fields = e), (this.decodePrefixes = !!n); - } - getSpan(e, r) { - if (0 <= this.span) return this.span; - r === void 0 && (r = 0); - let n = 0; - try { - n = this.fields.reduce((i, o) => { - let a = o.getSpan(e, r); - return (r += a), i + a; - }, 0); - } catch { - throw new RangeError("indeterminate span"); - } - return n; - } - decode(e, r) { - r === void 0 && (r = 0); - let n = this.makeDestinationObject(); - for (let i of this.fields) - if ( - (i.property !== void 0 && (n[i.property] = i.decode(e, r)), - (r += i.getSpan(e, r)), - this.decodePrefixes && e.length === r) - ) - break; - return n; - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = n, - o = 0, - a = 0; - for (let s of this.fields) { - let c = s.span; - if (((a = 0 < c ? c : 0), s.property !== void 0)) { - let u = e[s.property]; - u !== void 0 && - ((a = s.encode(u, r, n)), 0 > c && (c = s.getSpan(r, n))); - } - (o = n), (n += c); - } - return o + a - i; - } - fromArray(e) { - let r = this.makeDestinationObject(); - for (let n of this.fields) - n.property !== void 0 && 0 < e.length && (r[n.property] = e.shift()); - return r; - } - layoutFor(e) { - if (typeof e != "string") - throw new TypeError("property must be string"); - for (let r of this.fields) if (r.property === e) return r; - } - offsetOf(e) { - if (typeof e != "string") - throw new TypeError("property must be string"); - let r = 0; - for (let n of this.fields) { - if (n.property === e) return r; - 0 > n.span ? (r = -1) : 0 <= r && (r += n.span); - } - } - }, - zQ = class { - constructor(e) { - this.property = e; - } - decode() { - throw new Error("UnionDiscriminator is abstract"); - } - encode() { - throw new Error("UnionDiscriminator is abstract"); - } - }, - jQ = class extends zQ { - constructor(e, r) { - if (!(e instanceof nx && e.isCount())) - throw new TypeError( - "layout must be an unsigned integer ExternalLayout" - ); - super(r || e.property || "variant"), (this.layout = e); - } - decode(e, r) { - return this.layout.decode(e, r); - } - encode(e, r, n) { - return this.layout.encode(e, r, n); - } - }, - UQ = class extends Vc { - constructor(e, r, n) { - let i = e instanceof RC || e instanceof qQ; - if (i) e = new jQ(new LQ(e)); - else if (e instanceof nx && e.isCount()) e = new jQ(e); - else if (!(e instanceof zQ)) - throw new TypeError( - "discr must be a UnionDiscriminator or an unsigned integer layout" - ); - if ((r === void 0 && (r = null), !(r === null || r instanceof Vc))) - throw new TypeError("defaultLayout must be null or a Layout"); - if (r !== null) { - if (0 > r.span) - throw new Error("defaultLayout must have constant span"); - r.property === void 0 && (r = r.replicate("content")); - } - let o = -1; - r && ((o = r.span), 0 <= o && i && (o += e.layout.span)), - super(o, n), - (this.discriminator = e), - (this.usesPrefixDiscriminator = i), - (this.defaultLayout = r), - (this.registry = {}); - let a = this.defaultGetSourceVariant.bind(this); - (this.getSourceVariant = function (s) { - return a(s); - }), - (this.configGetSourceVariant = function (s) { - a = s.bind(this); - }); - } - getSpan(e, r) { - if (0 <= this.span) return this.span; - r === void 0 && (r = 0); - let n = this.getVariant(e, r); - if (!n) - throw new Error("unable to determine span for unrecognized variant"); - return n.getSpan(e, r); - } - defaultGetSourceVariant(e) { - if (e.hasOwnProperty(this.discriminator.property)) { - if ( - this.defaultLayout && - e.hasOwnProperty(this.defaultLayout.property) - ) - return; - let r = this.registry[e[this.discriminator.property]]; - if (r && (!r.layout || e.hasOwnProperty(r.property))) return r; - } else - for (let r in this.registry) { - let n = this.registry[r]; - if (e.hasOwnProperty(n.property)) return n; - } - throw new Error("unable to infer src variant"); - } - decode(e, r) { - let n; - r === void 0 && (r = 0); - let i = this.discriminator, - o = i.decode(e, r), - a = this.registry[o]; - if (a === void 0) { - let s = 0; - (a = this.defaultLayout), - this.usesPrefixDiscriminator && (s = i.layout.span), - (n = this.makeDestinationObject()), - (n[i.property] = o), - (n[a.property] = this.defaultLayout.decode(e, r + s)); - } else n = a.decode(e, r); - return n; - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = this.getSourceVariant(e); - if (i === void 0) { - let o = this.discriminator, - a = this.defaultLayout, - s = 0; - return ( - this.usesPrefixDiscriminator && (s = o.layout.span), - o.encode(e[o.property], r, n), - s + a.encode(e[a.property], r, n + s) - ); - } - return i.encode(e, r, n); - } - addVariant(e, r, n) { - let i = new x_e(this, e, r, n); - return (this.registry[e] = i), i; - } - getVariant(e, r) { - let n = e; - return ( - Buffer.isBuffer(e) && - (r === void 0 && (r = 0), (n = this.discriminator.decode(e, r))), - this.registry[n] - ); - } - }, - x_e = class extends Vc { - constructor(e, r, n, i) { - if (!(e instanceof UQ)) throw new TypeError("union must be a Union"); - if (!Number.isInteger(r) || 0 > r) - throw new TypeError("variant must be a (non-negative) integer"); - if ( - (typeof n == "string" && i === void 0 && ((i = n), (n = null)), n) - ) { - if (!(n instanceof Vc)) - throw new TypeError("layout must be a Layout"); - if ( - e.defaultLayout !== null && - 0 <= n.span && - n.span > e.defaultLayout.span - ) - throw new Error("variant span exceeds span of containing union"); - if (typeof i != "string") - throw new TypeError("variant must have a String property"); - } - let o = e.span; - 0 > e.span && - ((o = n ? n.span : 0), - 0 <= o && - e.usesPrefixDiscriminator && - (o += e.discriminator.layout.span)), - super(o, i), - (this.union = e), - (this.variant = r), - (this.layout = n || null); - } - getSpan(e, r) { - if (0 <= this.span) return this.span; - r === void 0 && (r = 0); - let n = 0; - return ( - this.union.usesPrefixDiscriminator && - (n = this.union.discriminator.layout.span), - n + this.layout.getSpan(e, r + n) - ); - } - decode(e, r) { - let n = this.makeDestinationObject(); - if ((r === void 0 && (r = 0), this !== this.union.getVariant(e, r))) - throw new Error("variant mismatch"); - let i = 0; - return ( - this.union.usesPrefixDiscriminator && - (i = this.union.discriminator.layout.span), - this.layout - ? (n[this.property] = this.layout.decode(e, r + i)) - : this.property - ? (n[this.property] = !0) - : this.union.usesPrefixDiscriminator && - (n[this.union.discriminator.property] = this.variant), - n - ); - } - encode(e, r, n) { - n === void 0 && (n = 0); - let i = 0; - if ( - (this.union.usesPrefixDiscriminator && - (i = this.union.discriminator.layout.span), - this.layout && !e.hasOwnProperty(this.property)) - ) - throw new TypeError("variant lacks property " + this.property); - this.union.discriminator.encode(this.variant, r, n); - let o = i; - if ( - this.layout && - (this.layout.encode(e[this.property], r, n + i), - (o += this.layout.getSpan(r, n + i)), - 0 <= this.union.span && o > this.union.span) - ) - throw new Error("encoded variant overruns containing union"); - return o; - } - fromArray(e) { - if (this.layout) return this.layout.fromArray(e); - } - }, - S_e = class extends Vc { - constructor(e, r) { - if ( - !((e instanceof nx && e.isCount()) || (Number.isInteger(e) && 0 <= e)) - ) - throw new TypeError( - "length must be positive integer or an unsigned integer ExternalLayout" - ); - let n = -1; - e instanceof nx || (n = e), super(n, r), (this.length = e); - } - getSpan(e, r) { - let n = this.span; - return 0 > n && (n = this.length.decode(e, r)), n; - } - decode(e, r) { - r === void 0 && (r = 0); - let n = this.span; - return 0 > n && (n = this.length.decode(e, r)), e.slice(r, r + n); - } - encode(e, r, n) { - let i = this.length; - if ( - (this.length instanceof nx && (i = e.length), - !Buffer.isBuffer(e) || i !== e.length) - ) - throw new TypeError( - ((o = "Blob.encode"), - ((a = this).property ? o + "[" + a.property + "]" : o) + - " requires (length " + - i + - ") Buffer as src") - ); - var o, a; - if (n + i > r.length) throw new RangeError("encoding overruns Buffer"); - return ( - r.write(e.toString("hex"), n, i, "hex"), - this.length instanceof nx && this.length.encode(i, r, n), - i - ); - } - }, - hfr = (t, e, r) => new LQ(t, e, r), - Kc = (t) => new RC(1, t), - rx = (t) => new RC(4, t), - tx = (t) => new b_e(t), - ex = (t) => new w_e(t), - Nn = (t, e, r) => new __e(t, e, r), - met = (t, e, r) => new UQ(t, e, r), - dT = (t, e) => new S_e(t, e), - A_e = class { - constructor(e) {} - encode(e, r) { - switch ((0, Zs.default)(e)) { - case "initializeMint": - return (function ({ - decimals: n, - mintAuthority: i, - freezeAuthority: o, - }) { - return rs({ - initializeMint: { - decimals: n, - mintAuthority: i.toBuffer(), - freezeAuthorityOption: !!o, - freezeAuthority: (o || Bn.PublicKey.default).toBuffer(), - }, - }); - })(r); - case "initializeAccount": - return rs({ initializeAccount: {} }); - case "initializeMultisig": - return (function ({ m: n }) { - return rs({ initializeMultisig: { m: n } }); - })(r); - case "transfer": - return (function ({ amount: n }) { - return rs({ transfer: { amount: n } }); - })(r); - case "approve": - return (function ({ amount: n }) { - return rs({ approve: { amount: n } }); - })(r); - case "revoke": - return rs({ revoke: {} }); - case "setAuthority": - return (function ({ authorityType: n, newAuthority: i }) { - return rs({ - setAuthority: { authorityType: n, newAuthority: i }, - }); - })(r); - case "mintTo": - return (function ({ amount: n }) { - return rs({ mintTo: { amount: n } }); - })(r); - case "burn": - return (function ({ amount: n }) { - return rs({ burn: { amount: n } }); - })(r); - case "closeAccount": - return rs({ closeAccount: {} }); - case "freezeAccount": - return rs({ freezeAccount: {} }); - case "thawAccount": - return rs({ thawAccount: {} }); - case "transferChecked": - return (function ({ amount: n, decimals: i }) { - return rs({ transferChecked: { amount: n, decimals: i } }); - })(r); - case "approvedChecked": - return (function ({ amount: n, decimals: i }) { - return rs({ approveChecked: { amount: n, decimals: i } }); - })(r); - case "mintToChecked": - return (function ({ amount: n, decimals: i }) { - return rs({ mintToChecked: { amount: n, decimals: i } }); - })(r); - case "burnChecked": - return (function ({ amount: n, decimals: i }) { - return rs({ burnChecked: { amount: n, decimals: i } }); - })(r); - case "intializeAccount2": - return (function ({ authority: n }) { - return rs({ initilaizeAccount2: { authority: n } }); - })(r); - case "syncNative": - return rs({ syncNative: {} }); - case "initializeAccount3": - return (function ({ authority: n }) { - return rs({ initializeAccount3: { authority: n } }); - })(r); - case "initializeMultisig2": - return (function ({ m: n }) { - return rs({ initializeMultisig2: { m: n } }); - })(r); - case "initializeMint2": - return (function ({ - decimals: n, - mintAuthority: i, - freezeAuthority: o, - }) { - return rs({ - encodeInitializeMint2: { - decimals: n, - mintAuthority: i, - freezeAuthority: o, - }, - }); - })(r); - default: - throw new Error(`Invalid instruction: ${e}`); - } - } - encodeState(e, r) { - throw new Error("SPL token does not have state"); - } - }, - ga = met(Kc("instruction")); - function PC(t) { - return dT(32, t); - } - function rs(t) { - let e = Buffer.alloc(pfr), - r = ga.encode(t, e); - return e.slice(0, r); - } - ga.addVariant( - 0, - Nn([ - Kc("decimals"), - dT(32, "mintAuthority"), - Kc("freezeAuthorityOption"), - PC("freezeAuthority"), - ]), - "initializeMint" - ), - ga.addVariant(1, Nn([]), "initializeAccount"), - ga.addVariant(2, Nn([Kc("m")]), "initializeMultisig"), - ga.addVariant(3, Nn([tx("amount")]), "transfer"), - ga.addVariant(4, Nn([tx("amount")]), "approve"), - ga.addVariant(5, Nn([]), "revoke"), - ga.addVariant( - 6, - Nn([Kc("authorityType"), Kc("newAuthorityOption"), PC("newAuthority")]), - "setAuthority" - ), - ga.addVariant(7, Nn([tx("amount")]), "mintTo"), - ga.addVariant(8, Nn([tx("amount")]), "burn"), - ga.addVariant(9, Nn([]), "closeAccount"), - ga.addVariant(10, Nn([]), "freezeAccount"), - ga.addVariant(11, Nn([]), "thawAccount"), - ga.addVariant(12, Nn([tx("amount"), Kc("decimals")]), "transferChecked"), - ga.addVariant(13, Nn([tx("amount"), Kc("decimals")]), "approvedChecked"), - ga.addVariant(14, Nn([tx("amount"), Kc("decimals")]), "mintToChecked"), - ga.addVariant(15, Nn([tx("amount"), Kc("decimals")]), "burnedChecked"), - ga.addVariant(16, Nn([PC("authority")]), "InitializeAccount2"), - ga.addVariant(17, Nn([]), "syncNative"), - ga.addVariant(18, Nn([PC("authority")]), "initializeAccount3"), - ga.addVariant(19, Nn([Kc("m")]), "initializeMultisig2"), - ga.addVariant( - 20, - Nn([ - Kc("decimals"), - PC("mintAuthority"), - Kc("freezeAuthorityOption"), - PC("freezeAuthority"), - ]), - "initializeMint2" - ); - var pfr = Math.max(...Object.values(ga.registry).map((t) => t.span)), - E_e = class { - constructor(e) {} - encode(e, r) { - throw new Error("SPL token does not have state"); - } - decode(e) { - throw new Error("SPL token does not have state"); - } - }; - function RQ(t) { - return new kj( - dT(8), - (e) => Pj.fromBuffer(e), - (e) => e.toBuffer(), - t - ); - } - function OC(t) { - return new kj( - dT(32), - (e) => new Bn.PublicKey(e), - (e) => e.toBuffer(), - t - ); - } - function Aj(t, e) { - return new M_e(t, e); - } - var kj = class extends JQ { - constructor(e, r, n, i) { - super(e.span, i), - (this.layout = e), - (this.decoder = r), - (this.encoder = n); - } - decode(e, r) { - return this.decoder(this.layout.decode(e, r)); - } - encode(e, r, n) { - return this.layout.encode(this.encoder(e), r, n); - } - getSpan(e, r) { - return this.layout.getSpan(e, r); - } - }, - M_e = class extends JQ { - constructor(e, r) { - super(-1, r), (this.layout = e), (this.discriminator = rx()); - } - encode(e, r, n = 0) { - return e == null - ? this.layout.span + this.discriminator.encode(0, r, n) - : (this.discriminator.encode(1, r, n), - this.layout.encode(e, r, n + 4) + 4); - } - decode(e, r = 0) { - let n = this.discriminator.decode(e, r); - if (n === 0) return null; - if (n === 1) return this.layout.decode(e, r + 4); - throw new Error("Invalid coption " + this.layout.property); - } - getSpan(e, r = 0) { - return this.layout.getSpan(e, r + 4) + 4; - } - }; - function yfr(t) { - if (t === 0) return !1; - if (t === 1) return !0; - throw new Error("Invalid bool: " + t); - } - function mfr(t) { - return t ? 1 : 0; - } - var Pj = class extends WQ.default { - toBuffer() { - let e = super.toArray().reverse(), - r = Buffer.from(e); - if (r.length === 8) return r; - if (r.length >= 8) throw new Error("u64 too large"); - let n = Buffer.alloc(8); - return r.copy(n), n; - } - static fromBuffer(e) { - if (e.length !== 8) - throw new Error(`Invalid buffer length: ${e.length}`); - return new Pj( - [...e] - .reverse() - .map((r) => `00${r.toString(16)}`.slice(-2)) - .join(""), - 16 - ); - } - }, - T_e = class { - constructor(e) { - this.idl = e; - } - async encode(e, r) { - switch (e) { - case "token": { - let n = Buffer.alloc(165), - i = XQe.encode(r, n); - return n.slice(0, i); - } - case "mint": { - let n = Buffer.alloc(82), - i = $Qe.encode(r, n); - return n.slice(0, i); - } - default: - throw new Error(`Invalid account name: ${e}`); - } - } - decode(e, r) { - return this.decodeUnchecked(e, r); - } - decodeUnchecked(e, r) { - switch (e) { - case "token": - return (function (n) { - return XQe.decode(n); - })(r); - case "mint": - return (function (n) { - return $Qe.decode(n); - })(r); - default: - throw new Error(`Invalid account name: ${e}`); - } - } - memcmp(e, r) { - switch (e) { - case "token": - return { dataSize: 165 }; - case "mint": - return { dataSize: 82 }; - default: - throw new Error(`Invalid account name: ${e}`); - } - } - size(e) { - var r; - return (r = Z_e(this.idl, e)) !== null && r !== void 0 ? r : 0; - } - }, - $Qe = Nn([ - Aj(OC(), "mintAuthority"), - RQ("supply"), - Kc("decimals"), - ((ZQe = "isInitialized"), new kj(Kc(), yfr, mfr, ZQe)), - Aj(OC(), "freezeAuthority"), - ]), - ZQe, - XQe = Nn([ - OC("mint"), - OC("authority"), - RQ("amount"), - Aj(OC(), "delegate"), - Kc("state"), - Aj(RQ(), "isNative"), - RQ("delegatedAmount"), - Aj(OC(), "closeAuthority"), - ]), - k_e = class { - constructor(e) {} - decode(e) { - throw new Error("SPL token program does not have events"); - } - }, - P_e = class { - constructor(e) {} - encode(e, r) { - throw new Error("SPL token does not have user-defined types"); - } - decode(e, r) { - throw new Error("SPL token does not have user-defined types"); - } - }, - O_e = class { - constructor(e) { - (this.instruction = new A_e(e)), - (this.accounts = new T_e(e)), - (this.events = new k_e(e)), - (this.state = new E_e(e)), - (this.types = new P_e(e)); - } - }; - var B_e = class extends JQ { - constructor(e) { - super(-1, e), - (this.property = e), - (this.layout = Nn( - [rx("length"), rx("lengthPadding"), dT(hfr(rx(), -8), "chars")], - this.property - )); - } - encode(e, r, n = 0) { - if (e == null) return this.layout.span; - let i = { chars: Buffer.from(e, "utf8") }; - return this.layout.encode(i, r, n); - } - decode(e, r = 0) { - return this.layout.decode(e, r).chars.toString(); - } - getSpan(e, r = 0) { - return ( - rx().span + - rx().span + - new WQ.default(new Uint8Array(e).slice(r, r + 4), 10, "le").toNumber() - ); - } - }; - function IQ(t) { - return new B_e(t); - } - function _y(t) { - return dT(32, t); - } - var Hp = met(rx("instruction")); - Hp.addVariant( - 0, - Nn([ex("lamports"), ex("space"), _y("owner")]), - "createAccount" - ), - Hp.addVariant(1, Nn([_y("owner")]), "assign"), - Hp.addVariant(2, Nn([ex("lamports")]), "transfer"), - Hp.addVariant( - 3, - Nn([_y("base"), IQ("seed"), ex("lamports"), ex("space"), _y("owner")]), - "createAccountWithSeed" - ), - Hp.addVariant(4, Nn([_y("authorized")]), "advanceNonceAccount"), - Hp.addVariant(5, Nn([ex("lamports")]), "withdrawNonceAccount"), - Hp.addVariant(6, Nn([_y("authorized")]), "initializeNonceAccount"), - Hp.addVariant(7, Nn([_y("authorized")]), "authorizeNonceAccount"), - Hp.addVariant(8, Nn([ex("space")]), "allocate"), - Hp.addVariant( - 9, - Nn([_y("base"), IQ("seed"), ex("space"), _y("owner")]), - "allocateWithSeed" - ), - Hp.addVariant( - 10, - Nn([_y("base"), IQ("seed"), _y("owner")]), - "assignWithSeed" - ), - Hp.addVariant( - 11, - Nn([ex("lamports"), IQ("seed"), _y("owner")]), - "transferWithSeed" - ); - var yhn = Math.max(...Object.values(Hp.registry).map((t) => t.span)); - var I_e = class extends JQ { - constructor(e, r, n, i) { - super(e.span, i), - (this.layout = e), - (this.decoder = r), - (this.encoder = n); - } - decode(e, r) { - return this.decoder(this.layout.decode(e, r)); - } - encode(e, r, n) { - return this.layout.encode(this.encoder(e), r, n); - } - getSpan(e, r) { - return this.layout.getSpan(e, r); - } - }; - function YQe(t) { - return new I_e( - dT(32), - (e) => new Bn.PublicKey(e), - (e) => e.toBuffer(), - t - ); - } - var mhn = Nn([ - rx("version"), - rx("state"), - YQe("authorizedPubkey"), - YQe("nonce"), - Nn([tx("lamportsPerSignature")], "feeCalculator"), - ]); - var gfr = Object.freeze({ - __proto__: null, - hash: function (t) { - return (0, eA.sha256)(t); - }, - }); - function get(t, e, r) { - let n = Ki.Buffer.concat([t.toBuffer(), Ki.Buffer.from(e), r.toBuffer()]), - i = eA.sha256.digest(n); - return new Bn.PublicKey(Ki.Buffer.from(i)); - } - function vet(t, e) { - let r = Ki.Buffer.alloc(0); - t.forEach(function (o) { - if (o.length > 32) throw new TypeError("Max seed length exceeded"); - r = Ki.Buffer.concat([r, vfr(o)]); - }), - (r = Ki.Buffer.concat([ - r, - e.toBuffer(), - Ki.Buffer.from("ProgramDerivedAddress"), - ])); - let n = (0, eA.sha256)(new Uint8Array(r)), - i = new WQ.default(n, 16).toArray(void 0, 32); - if (Bn.PublicKey.isOnCurve(new Uint8Array(i))) - throw new Error("Invalid seeds, address must fall off the curve"); - return new Bn.PublicKey(i); - } - function X_e(t, e) { - let r, - n = 255; - for (; n != 0; ) { - try { - r = vet(t.concat(Ki.Buffer.from([n])), e); - } catch (i) { - if (i instanceof TypeError) throw i; - n--; - continue; - } - return [r, n]; - } - throw new Error("Unable to find a viable program address nonce"); - } - var vfr = (t) => - t instanceof Ki.Buffer - ? t - : t instanceof Uint8Array - ? Ki.Buffer.from(t.buffer, t.byteOffset, t.byteLength) - : Ki.Buffer.from(t); - async function bet(t, ...e) { - let r = [Ki.Buffer.from([97, 110, 99, 104, 111, 114])]; - e.forEach((i) => { - r.push(i instanceof Ki.Buffer ? i : Iv(i).toBuffer()); - }); - let [n] = await Bn.PublicKey.findProgramAddress(r, Iv(t)); - return n; - } - var bfr = Object.freeze({ - __proto__: null, - createWithSeedSync: get, - createProgramAddressSync: vet, - findProgramAddressSync: X_e, - associated: bet, - }), - C_e = new Bn.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"), - R_e = new Bn.PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"), - wfr = Object.freeze({ - __proto__: null, - TOKEN_PROGRAM_ID: C_e, - ASSOCIATED_PROGRAM_ID: R_e, - associatedAddress: async function ({ mint: t, owner: e }) { - return ( - await Bn.PublicKey.findProgramAddress( - [e.toBuffer(), C_e.toBuffer(), t.toBuffer()], - R_e - ) - )[0]; - }, - }), - N_e = { exports: {} }; - (function (t, e) { - var r = typeof self < "u" ? self : ffr, - n = (function () { - function o() { - (this.fetch = !1), (this.DOMException = r.DOMException); - } - return (o.prototype = r), new o(); - })(); - (function (o) { - (function (a) { - var s = "URLSearchParams" in o, - c = "Symbol" in o && "iterator" in Symbol, - u = - "FileReader" in o && - "Blob" in o && - (function () { - try { - return new Blob(), !0; - } catch { - return !1; - } - })(), - h = "FormData" in o, - w = "ArrayBuffer" in o; - if (w) - var M = [ - "[object Int8Array]", - "[object Uint8Array]", - "[object Uint8ClampedArray]", - "[object Int16Array]", - "[object Uint16Array]", - "[object Int32Array]", - "[object Uint32Array]", - "[object Float32Array]", - "[object Float64Array]", - ], - k = - ArrayBuffer.isView || - function (y) { - return y && M.indexOf(Object.prototype.toString.call(y)) > -1; - }; - function O(y) { - if ( - (typeof y != "string" && (y = String(y)), - /[^a-z0-9\-#$%&'*+.^_`|~]/i.test(y)) - ) - throw new TypeError("Invalid character in header field name"); - return y.toLowerCase(); - } - function D(y) { - return typeof y != "string" && (y = String(y)), y; - } - function F(y) { - var d = { - next: function () { - var v = y.shift(); - return { done: v === void 0, value: v }; - }, - }; - return ( - c && - (d[Symbol.iterator] = function () { - return d; - }), - d - ); - } - function N(y) { - (this.map = {}), - y instanceof N - ? y.forEach(function (d, v) { - this.append(v, d); - }, this) - : Array.isArray(y) - ? y.forEach(function (d) { - this.append(d[0], d[1]); - }, this) - : y && - Object.getOwnPropertyNames(y).forEach(function (d) { - this.append(d, y[d]); - }, this); - } - function q(y) { - if (y.bodyUsed) return Promise.reject(new TypeError("Already read")); - y.bodyUsed = !0; - } - function z(y) { - return new Promise(function (d, v) { - (y.onload = function () { - d(y.result); - }), - (y.onerror = function () { - v(y.error); - }); - }); - } - function H(y) { - var d = new FileReader(), - v = z(d); - return d.readAsArrayBuffer(y), v; - } - function Z(y) { - if (y.slice) return y.slice(0); - var d = new Uint8Array(y.byteLength); - return d.set(new Uint8Array(y)), d.buffer; - } - function $() { - return ( - (this.bodyUsed = !1), - (this._initBody = function (y) { - var d; - (this._bodyInit = y), - y - ? typeof y == "string" - ? (this._bodyText = y) - : u && Blob.prototype.isPrototypeOf(y) - ? (this._bodyBlob = y) - : h && FormData.prototype.isPrototypeOf(y) - ? (this._bodyFormData = y) - : s && URLSearchParams.prototype.isPrototypeOf(y) - ? (this._bodyText = y.toString()) - : w && u && (d = y) && DataView.prototype.isPrototypeOf(d) - ? ((this._bodyArrayBuffer = Z(y.buffer)), - (this._bodyInit = new Blob([this._bodyArrayBuffer]))) - : w && (ArrayBuffer.prototype.isPrototypeOf(y) || k(y)) - ? (this._bodyArrayBuffer = Z(y)) - : (this._bodyText = y = Object.prototype.toString.call(y)) - : (this._bodyText = ""), - this.headers.get("content-type") || - (typeof y == "string" - ? this.headers.set( - "content-type", - "text/plain;charset=UTF-8" - ) - : this._bodyBlob && this._bodyBlob.type - ? this.headers.set("content-type", this._bodyBlob.type) - : s && - URLSearchParams.prototype.isPrototypeOf(y) && - this.headers.set( - "content-type", - "application/x-www-form-urlencoded;charset=UTF-8" - )); - }), - u && - ((this.blob = function () { - var y = q(this); - if (y) return y; - if (this._bodyBlob) return Promise.resolve(this._bodyBlob); - if (this._bodyArrayBuffer) - return Promise.resolve(new Blob([this._bodyArrayBuffer])); - if (this._bodyFormData) - throw new Error("could not read FormData body as blob"); - return Promise.resolve(new Blob([this._bodyText])); - }), - (this.arrayBuffer = function () { - return this._bodyArrayBuffer - ? q(this) || Promise.resolve(this._bodyArrayBuffer) - : this.blob().then(H); - })), - (this.text = function () { - var y = q(this); - if (y) return y; - if (this._bodyBlob) - return (function (d) { - var v = new FileReader(), - _ = z(v); - return v.readAsText(d), _; - })(this._bodyBlob); - if (this._bodyArrayBuffer) - return Promise.resolve( - (function (d) { - for ( - var v = new Uint8Array(d), _ = new Array(v.length), S = 0; - S < v.length; - S++ - ) - _[S] = String.fromCharCode(v[S]); - return _.join(""); - })(this._bodyArrayBuffer) - ); - if (this._bodyFormData) - throw new Error("could not read FormData body as text"); - return Promise.resolve(this._bodyText); - }), - h && - (this.formData = function () { - return this.text().then(ne); - }), - (this.json = function () { - return this.text().then(JSON.parse); - }), - this - ); - } - (N.prototype.append = function (y, d) { - (y = O(y)), (d = D(d)); - var v = this.map[y]; - this.map[y] = v ? v + ", " + d : d; - }), - (N.prototype.delete = function (y) { - delete this.map[O(y)]; - }), - (N.prototype.get = function (y) { - return (y = O(y)), this.has(y) ? this.map[y] : null; - }), - (N.prototype.has = function (y) { - return this.map.hasOwnProperty(O(y)); - }), - (N.prototype.set = function (y, d) { - this.map[O(y)] = D(d); - }), - (N.prototype.forEach = function (y, d) { - for (var v in this.map) - this.map.hasOwnProperty(v) && y.call(d, this.map[v], v, this); - }), - (N.prototype.keys = function () { - var y = []; - return ( - this.forEach(function (d, v) { - y.push(v); - }), - F(y) - ); - }), - (N.prototype.values = function () { - var y = []; - return ( - this.forEach(function (d) { - y.push(d); - }), - F(y) - ); - }), - (N.prototype.entries = function () { - var y = []; - return ( - this.forEach(function (d, v) { - y.push([v, d]); - }), - F(y) - ); - }), - c && (N.prototype[Symbol.iterator] = N.prototype.entries); - var ue = ["DELETE", "GET", "HEAD", "OPTIONS", "POST", "PUT"]; - function te(y, d) { - var v, - _, - S = (d = d || {}).body; - if (y instanceof te) { - if (y.bodyUsed) throw new TypeError("Already read"); - (this.url = y.url), - (this.credentials = y.credentials), - d.headers || (this.headers = new N(y.headers)), - (this.method = y.method), - (this.mode = y.mode), - (this.signal = y.signal), - S || - y._bodyInit == null || - ((S = y._bodyInit), (y.bodyUsed = !0)); - } else this.url = String(y); - if ( - ((this.credentials = - d.credentials || this.credentials || "same-origin"), - (!d.headers && this.headers) || (this.headers = new N(d.headers)), - (this.method = - ((v = d.method || this.method || "GET"), - (_ = v.toUpperCase()), - ue.indexOf(_) > -1 ? _ : v)), - (this.mode = d.mode || this.mode || null), - (this.signal = d.signal || this.signal), - (this.referrer = null), - (this.method === "GET" || this.method === "HEAD") && S) - ) - throw new TypeError("Body not allowed for GET or HEAD requests"); - this._initBody(S); - } - function ne(y) { - var d = new FormData(); - return ( - y - .trim() - .split("&") - .forEach(function (v) { - if (v) { - var _ = v.split("="), - S = _.shift().replace(/\+/g, " "), - b = _.join("=").replace(/\+/g, " "); - d.append(decodeURIComponent(S), decodeURIComponent(b)); - } - }), - d - ); - } - function A(y, d) { - d || (d = {}), - (this.type = "default"), - (this.status = d.status === void 0 ? 200 : d.status), - (this.ok = this.status >= 200 && this.status < 300), - (this.statusText = "statusText" in d ? d.statusText : "OK"), - (this.headers = new N(d.headers)), - (this.url = d.url || ""), - this._initBody(y); - } - (te.prototype.clone = function () { - return new te(this, { body: this._bodyInit }); - }), - $.call(te.prototype), - $.call(A.prototype), - (A.prototype.clone = function () { - return new A(this._bodyInit, { - status: this.status, - statusText: this.statusText, - headers: new N(this.headers), - url: this.url, - }); - }), - (A.error = function () { - var y = new A(null, { status: 0, statusText: "" }); - return (y.type = "error"), y; - }); - var l = [301, 302, 303, 307, 308]; - (A.redirect = function (y, d) { - if (l.indexOf(d) === -1) throw new RangeError("Invalid status code"); - return new A(null, { status: d, headers: { location: y } }); - }), - (a.DOMException = o.DOMException); - try { - new a.DOMException(); - } catch { - (a.DOMException = function (d, v) { - (this.message = d), (this.name = v); - var _ = Error(d); - this.stack = _.stack; - }), - (a.DOMException.prototype = Object.create(Error.prototype)), - (a.DOMException.prototype.constructor = a.DOMException); - } - function p(y, d) { - return new Promise(function (v, _) { - var S = new te(y, d); - if (S.signal && S.signal.aborted) - return _(new a.DOMException("Aborted", "AbortError")); - var b = new XMLHttpRequest(); - function f() { - b.abort(); - } - (b.onload = function () { - var x, - C, - E = { - status: b.status, - statusText: b.statusText, - headers: - ((x = b.getAllResponseHeaders() || ""), - (C = new N()), - x - .replace(/\r?\n[\t ]+/g, " ") - .split(/\r?\n/) - .forEach(function (G) { - var L = G.split(":"), - ee = L.shift().trim(); - if (ee) { - var ge = L.join(":").trim(); - C.append(ee, ge); - } - }), - C), - }; - E.url = - "responseURL" in b - ? b.responseURL - : E.headers.get("X-Request-URL"); - var B = "response" in b ? b.response : b.responseText; - v(new A(B, E)); - }), - (b.onerror = function () { - _(new TypeError("Network request failed")); - }), - (b.ontimeout = function () { - _(new TypeError("Network request failed")); - }), - (b.onabort = function () { - _(new a.DOMException("Aborted", "AbortError")); - }), - b.open(S.method, S.url, !0), - S.credentials === "include" - ? (b.withCredentials = !0) - : S.credentials === "omit" && (b.withCredentials = !1), - "responseType" in b && u && (b.responseType = "blob"), - S.headers.forEach(function (x, C) { - b.setRequestHeader(C, x); - }), - S.signal && - (S.signal.addEventListener("abort", f), - (b.onreadystatechange = function () { - b.readyState === 4 && - S.signal.removeEventListener("abort", f); - })), - b.send(S._bodyInit === void 0 ? null : S._bodyInit); - }); - } - (p.polyfill = !0), - o.fetch || - ((o.fetch = p), - (o.Headers = N), - (o.Request = te), - (o.Response = A)), - (a.Headers = N), - (a.Request = te), - (a.Response = A), - (a.fetch = p), - Object.defineProperty(a, "__esModule", { value: !0 }); - })({}); - })(n), - (n.fetch.ponyfill = !0), - delete n.fetch.polyfill; - var i = n; - ((e = i.fetch).default = i.fetch), - (e.fetch = i.fetch), - (e.Headers = i.Headers), - (e.Request = i.Request), - (e.Response = i.Response), - (t.exports = e); - })(N_e, N_e.exports); - var _fr = dfr(N_e.exports); - async function QQe(t, e) { - let r = await t.getAccountInfo(e); - if (r === null) throw new Error("program account not found"); - let { program: n } = D_e(r.data), - i = await t.getAccountInfo(n.programdataAddress); - if (i === null) throw new Error("program data account not found"); - let { programData: o } = D_e(i.data); - return o; - } - var xfr = fr.rustEnum( - [ - fr.struct([], "uninitialized"), - fr.struct([fr.option(fr.publicKey(), "authorityAddress")], "buffer"), - fr.struct([fr.publicKey("programdataAddress")], "program"), - fr.struct( - [fr.u64("slot"), fr.option(fr.publicKey(), "upgradeAuthorityAddress")], - "programData" - ), - ], - void 0, - fr.u32() - ); - function D_e(t) { - return xfr.decode(t); - } - var Sfr = Object.freeze({ - __proto__: null, - verifiedBuild: async function (t, e, r = 5) { - let n = `https://api.apr.dev/api/v0/program/${e.toString()}/latest?limit=${r}`, - [i, o] = await Promise.all([QQe(t, e), _fr(n)]), - a = (await o.json()).filter( - (c) => - !c.aborted && c.state === "Built" && c.verified === "Verified" - ); - if (a.length === 0) return null; - let s = a[0]; - return i.slot.toNumber() !== s.verified_slot ? null : s; - }, - fetchData: QQe, - decodeUpgradeableLoaderState: D_e, - }), - ghn = Object.freeze({ - __proto__: null, - sha256: gfr, - rpc: rfr, - publicKey: bfr, - bytes: Zlr, - token: wfr, - features: ifr, - registry: Sfr, - }), - Afr = fr.struct([fr.publicKey("authority"), fr.vecU8("data")]); - function $Q(t, e) { - var r, n; - let i = {}, - o = t.args ? t.args.length : 0; - if (e.length > o) { - if (e.length !== o + 1) - throw new Error( - `provided too many arguments ${e} to instruction ${ - t?.name - } expecting: ${ - (n = - (r = t.args) === null || r === void 0 - ? void 0 - : r.map((a) => a.name)) !== null && n !== void 0 - ? n - : [] - }` - ); - i = e.pop(); - } - return [e, i]; - } - var Q2 = class { - static build(e, r, n) { - if (e.name === "_inner") throw new IC("the _inner name is reserved"); - let i = (...o) => { - let [a, s] = $Q(e, [...o]); - W_e(e.accounts, s.accounts); - let c = i.accounts(s.accounts); - return ( - s.remainingAccounts !== void 0 && c.push(...s.remainingAccounts), - GQ("debug-logs") && console.log("Outgoing account metas:", c), - new Bn.TransactionInstruction({ - keys: c, - programId: n, - data: r(e.name, Xlr(e, ...a)), - }) - ); - }; - return (i.accounts = (o) => Q2.accountsArray(o, e.accounts, e.name)), i; - } - static accountsArray(e, r, n) { - return e - ? r - .map((i) => { - if (("accounts" in i ? i.accounts : void 0) !== void 0) { - let o = e[i.name]; - return Q2.accountsArray(o, i.accounts, n).flat(); - } - { - let o = i, - a; - try { - a = Iv(e[i.name]); - } catch { - throw new Error( - `Wrong input type for account "${ - i.name - }" in the instruction accounts object${ - n !== void 0 ? ' for instruction "' + n + '"' : "" - }. Expected PublicKey or string.` - ); - } - return { - pubkey: a, - isWritable: o.isMut, - isSigner: o.isSigner, - }; - } - }) - .flat() - : []; - } - }, - KQ = class { - static build(e, r, n, i) { - return async (...o) => { - var a; - let s = r(...o), - [, c] = $Q(e, [...o]); - if (i.sendAndConfirm === void 0) - throw new Error( - "This function requires 'Provider.sendAndConfirm' to be implemented." - ); - try { - return await i.sendAndConfirm( - s, - (a = c.signers) !== null && a !== void 0 ? a : [], - c.options - ); - } catch (u) { - throw det(u, n); - } - }; - } - }, - HQ = class { - static build(e, r) { - return (...n) => { - var i, o, a; - let [, s] = $Q(e, [...n]), - c = new Bn.Transaction(); - if (s.preInstructions && s.instructions) - throw new Error("instructions is deprecated, use preInstructions"); - return ( - (i = s.preInstructions) === null || - i === void 0 || - i.forEach((u) => c.add(u)), - (o = s.instructions) === null || - o === void 0 || - o.forEach((u) => c.add(u)), - c.add(r(...n)), - (a = s.postInstructions) === null || - a === void 0 || - a.forEach((u) => c.add(u)), - c - ); - }; - } - }, - F_e = class { - constructor(e, r, n = Ej(), i = new Tj(e)) { - (this.provider = n), - (this.coder = i), - (this._idl = e), - (this._programId = r), - (this._address = f_e(r)), - (this._sub = null); - let [o, a, s] = (() => { - var c; - let u = {}, - h = {}, - w = {}; - return ( - (c = e.state) === null || - c === void 0 || - c.methods.forEach((M) => { - let k = Q2.build( - M, - (N, q) => i.instruction.encodeState(N, q), - r - ); - k.accounts = (N) => - (function (z, H, Z, $) { - if (Z.name === "new") { - let [ue] = X_e([], z); - if (H.wallet === void 0) - throw new Error( - "This function requires the Provider interface implementor to have a 'wallet' field." - ); - return [ - { - pubkey: H.wallet.publicKey, - isWritable: !1, - isSigner: !0, - }, - { pubkey: f_e(z), isWritable: !0, isSigner: !1 }, - { pubkey: ue, isWritable: !1, isSigner: !1 }, - { - pubkey: Bn.SystemProgram.programId, - isWritable: !1, - isSigner: !1, - }, - { pubkey: z, isWritable: !1, isSigner: !1 }, - ]; - } - return ( - W_e(Z.accounts, $), - [{ pubkey: f_e(z), isWritable: !0, isSigner: !1 }] - ); - })(r, n, M, N).concat( - Q2.accountsArray(N, M.accounts, M.name) - ); - let O = HQ.build(M, k), - D = KQ.build(M, O, iet(e), n), - F = (0, Zs.default)(M.name); - (u[F] = k), (h[F] = O), (w[F] = D); - }), - [u, h, w] - ); - })(); - (this.instruction = o), (this.transaction = a), (this.rpc = s); - } - get programId() { - return this._programId; - } - async fetch() { - let e = this.address(), - r = await this.provider.connection.getAccountInfo(e); - if (r === null) - throw new Error(`Account does not exist ${e.toString()}`); - let n = this._idl.state; - if (!n) throw new Error("State is not specified in IDL."); - if ((await het(n.struct.name)).compare(r.data.slice(0, 8))) - throw new Error("Invalid account discriminator"); - return this.coder.state.decode(r.data); - } - address() { - return this._address; - } - subscribe(e) { - if (this._sub !== null) return this._sub.ee; - let r = new V_e.default(), - n = this.provider.connection.onAccountChange( - this.address(), - (i) => { - let o = this.coder.state.decode(i.data); - r.emit("change", o); - }, - e - ); - return (this._sub = { ee: r, listener: n }), r; - } - unsubscribe() { - this._sub !== null && - this.provider.connection - .removeAccountChangeListener(this._sub.listener) - .then(async () => { - this._sub = null; - }) - .catch(console.error); - } - }; - function f_e(t) { - let [e] = X_e([], t); - return get(e, "unversioned", t); - } - var L_e = class { - constructor(e, r, n, i, o) { - (this._idlAccount = r), - (this._programId = n), - (this._provider = i ?? Ej()), - (this._coder = o ?? new Tj(e)), - (this._size = this._coder.accounts.size(r)); - } - get size() { - return this._size; - } - get programId() { - return this._programId; - } - get provider() { - return this._provider; - } - get coder() { - return this._coder; - } - async fetchNullable(e, r) { - let n = await this.getAccountInfo(e, r); - return n === null - ? null - : this._coder.accounts.decode(this._idlAccount.name, n.data); - } - async fetch(e, r) { - let n = await this.fetchNullable(e, r); - if (n === null) - throw new Error(`Account does not exist ${e.toString()}`); - return n; - } - async fetchMultiple(e, r) { - return ( - await set( - this._provider.connection, - e.map((n) => Iv(n)), - r - ) - ).map((n) => - n == null - ? null - : this._coder.accounts.decode( - this._idlAccount.name, - n?.account.data - ) - ); - } - async all(e) { - return ( - await this._provider.connection.getProgramAccounts(this._programId, { - commitment: this._provider.connection.commitment, - filters: [ - { - memcmp: this.coder.accounts.memcmp( - this._idlAccount.name, - e instanceof Buffer ? e : void 0 - ), - }, - ...(Array.isArray(e) ? e : []), - ], - }) - ).map(({ pubkey: r, account: n }) => ({ - publicKey: r, - account: this._coder.accounts.decode(this._idlAccount.name, n.data), - })); - } - subscribe(e, r) { - let n = _j.get(e.toString()); - if (n) return n.ee; - let i = new V_e.default(); - e = Iv(e); - let o = this._provider.connection.onAccountChange( - e, - (a) => { - let s = this._coder.accounts.decode(this._idlAccount.name, a.data); - i.emit("change", s); - }, - r - ); - return _j.set(e.toString(), { ee: i, listener: o }), i; - } - async unsubscribe(e) { - let r = _j.get(e.toString()); - r - ? _j && - (await this._provider.connection - .removeAccountChangeListener(r.listener) - .then(() => { - _j.delete(e.toString()); - }) - .catch(console.error)) - : console.warn("Address is not subscribed"); - } - async createInstruction(e, r) { - let n = this.size; - if (this._provider.wallet === void 0) - throw new Error( - "This function requires the Provider interface implementor to have a 'wallet' field." - ); - return Bn.SystemProgram.createAccount({ - fromPubkey: this._provider.wallet.publicKey, - newAccountPubkey: e.publicKey, - space: r ?? n, - lamports: - await this._provider.connection.getMinimumBalanceForRentExemption( - r ?? n - ), - programId: this._programId, - }); - } - async associated(...e) { - let r = await this.associatedAddress(...e); - return await this.fetch(r); - } - async associatedAddress(...e) { - return await bet(this._programId, ...e); - } - async getAccountInfo(e, r) { - return await this._provider.connection.getAccountInfo(Iv(e), r); - } - }, - _j = new Map(), - Efr = 13, - Mfr = 14, - q_e = class { - constructor(e, r, n) { - (this._programId = e), - (this._provider = r), - (this._eventParser = new VQ(e, n)), - (this._eventCallbacks = new Map()), - (this._eventListeners = new Map()), - (this._listenerIdCount = 0); - } - addEventListener(e, r) { - var n; - let i = this._listenerIdCount; - return ( - (this._listenerIdCount += 1), - e in this._eventCallbacks || this._eventListeners.set(e, []), - this._eventListeners.set( - e, - ((n = this._eventListeners.get(e)) !== null && n !== void 0 - ? n - : [] - ).concat(i) - ), - this._eventCallbacks.set(i, [e, r]), - this._onLogsSubscriptionId !== void 0 || - (this._onLogsSubscriptionId = this._provider.connection.onLogs( - this._programId, - (o, a) => { - if (!o.err) - for (let s of this._eventParser.parseLogs(o.logs)) { - let c = this._eventListeners.get(s.name); - c && - c.forEach((u) => { - let h = this._eventCallbacks.get(u); - if (h) { - let [, w] = h; - w(s.data, a.slot, o.signature); - } - }); - } - } - )), - i - ); - } - async removeEventListener(e) { - let r = this._eventCallbacks.get(e); - if (!r) throw new Error(`Event listener ${e} doesn't exist!`); - let [n] = r, - i = this._eventListeners.get(n); - if (!i) throw new Error(`Event listeners don't exist for ${n}!`); - this._eventCallbacks.delete(e), - (i = i.filter((o) => o !== e)), - i.length === 0 && this._eventListeners.delete(n), - this._eventCallbacks.size == 0 && - (NQ.ok(this._eventListeners.size === 0), - this._onLogsSubscriptionId !== void 0 && - (await this._provider.connection.removeOnLogsListener( - this._onLogsSubscriptionId - ), - (this._onLogsSubscriptionId = void 0))); - } - }, - VQ = class { - constructor(e, r) { - (this.coder = r), (this.programId = e); - } - *parseLogs(e) { - let r = new j_e(e), - n = new z_e(), - i = r.next(); - for (; i !== null; ) { - let [o, a, s] = this.handleLog(n, i); - o && (yield o), a && n.push(a), s && n.pop(), (i = r.next()); - } - } - handleLog(e, r) { - return e.stack.length > 0 && e.program() === this.programId.toString() - ? this.handleProgramLog(r) - : [null, ...this.handleSystemLog(r)]; - } - handleProgramLog(e) { - if (e.startsWith("Program log: ") || e.startsWith("Program data: ")) { - let r = e.startsWith("Program log: ") ? e.slice(Efr) : e.slice(Mfr); - return [this.coder.events.decode(r), null, !1]; - } - return [null, ...this.handleSystemLog(e)]; - } - handleSystemLog(e) { - let r = e.split(":")[0]; - return r.match(/^Program (.*) success/g) !== null - ? [null, !0] - : r.startsWith(`Program ${this.programId.toString()} invoke`) - ? [this.programId.toString(), !1] - : r.includes("invoke") - ? ["cpi", !1] - : [null, !1]; - } - }, - z_e = class { - constructor() { - this.stack = []; - } - program() { - return NQ.ok(this.stack.length > 0), this.stack[this.stack.length - 1]; - } - push(e) { - this.stack.push(e); - } - pop() { - NQ.ok(this.stack.length > 0), this.stack.pop(); - } - }, - j_e = class { - constructor(e) { - this.logs = e; - } - next() { - if (this.logs.length === 0) return null; - let e = this.logs[0]; - return (this.logs = this.logs.slice(1)), e; - } - }, - vhn = new Bn.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"); - function Tfr() { - return new O_e(kfr); - } - var kfr = { - version: "0.1.0", - name: "spl_token", - instructions: [ - { - name: "initializeMint", - accounts: [ - { name: "mint", isMut: !0, isSigner: !1 }, - { name: "rent", isMut: !1, isSigner: !1 }, - ], - args: [ - { name: "decimals", type: "u8" }, - { name: "mintAuthority", type: "publicKey" }, - { name: "freezeAuthority", type: { coption: "publicKey" } }, - ], - }, - { - name: "initializeAccount", - accounts: [ - { name: "account", isMut: !0, isSigner: !1 }, - { name: "mint", isMut: !1, isSigner: !1 }, - { name: "authority", isMut: !1, isSigner: !1 }, - { name: "rent", isMut: !1, isSigner: !1 }, - ], - args: [], - }, - { - name: "initializeMultisig", - accounts: [ - { name: "account", isMut: !0, isSigner: !1 }, - { name: "rent", isMut: !1, isSigner: !1 }, - ], - args: [{ name: "m", type: "u8" }], - }, - { - name: "transfer", - accounts: [ - { name: "source", isMut: !0, isSigner: !1 }, - { name: "destination", isMut: !0, isSigner: !1 }, - { name: "authority", isMut: !1, isSigner: !0 }, - ], - args: [{ name: "amount", type: "u64" }], - }, - { - name: "approve", - accounts: [ - { name: "source", isMut: !0, isSigner: !1 }, - { name: "delegate", isMut: !1, isSigner: !1 }, - { name: "authority", isMut: !1, isSigner: !0 }, - ], - args: [{ name: "amount", type: "u64" }], - }, - { - name: "revoke", - accounts: [ - { name: "source", isMut: !0, isSigner: !1 }, - { name: "authority", isMut: !1, isSigner: !0 }, - ], - args: [], - }, - { - name: "setAuthority", - accounts: [ - { name: "mint", isMut: !0, isSigner: !1 }, - { name: "authority", isMut: !1, isSigner: !0 }, - ], - args: [ - { name: "authorityType", type: "u8" }, - { name: "newAuthority", type: { coption: "publicKey" } }, - ], - }, - { - name: "mintTo", - accounts: [ - { name: "mint", isMut: !0, isSigner: !1 }, - { name: "to", isMut: !0, isSigner: !1 }, - { name: "authority", isMut: !1, isSigner: !0 }, - ], - args: [{ name: "amount", type: "u64" }], - }, - { - name: "burn", - accounts: [ - { name: "source", isMut: !0, isSigner: !1 }, - { name: "mint", isMut: !0, isSigner: !1 }, - { name: "authority", isMut: !1, isSigner: !0 }, - ], - args: [{ name: "amount", type: "u64" }], - }, - { - name: "closeAccount", - accounts: [ - { name: "account", isMut: !0, isSigner: !1 }, - { name: "destination", isMut: !0, isSigner: !1 }, - { name: "authority", isMut: !1, isSigner: !1 }, - ], - args: [], - }, - { - name: "freezeAccount", - accounts: [ - { name: "account", isMut: !0, isSigner: !1 }, - { name: "mint", isMut: !1, isSigner: !1 }, - { name: "authority", isMut: !1, isSigner: !0 }, - ], - args: [], - }, - { - name: "thawAccount", - accounts: [ - { name: "account", isMut: !0, isSigner: !1 }, - { name: "mint", isMut: !1, isSigner: !1 }, - { name: "authority", isMut: !1, isSigner: !0 }, - ], - args: [], - }, - { - name: "transferChecked", - accounts: [ - { name: "source", isMut: !0, isSigner: !1 }, - { name: "mint", isMut: !1, isSigner: !1 }, - { name: "destination", isMut: !0, isSigner: !1 }, - { name: "authority", isMut: !1, isSigner: !0 }, - ], - args: [ - { name: "amount", type: "u64" }, - { name: "decimals", type: "u8" }, - ], - }, - { - name: "approveChecked", - accounts: [ - { name: "source", isMut: !0, isSigner: !1 }, - { name: "mint", isMut: !1, isSigner: !1 }, - { name: "delegate", isMut: !1, isSigner: !1 }, - { name: "authority", isMut: !1, isSigner: !0 }, - ], - args: [ - { name: "amount", type: "u64" }, - { name: "decimals", type: "u8" }, - ], - }, - { - name: "mintToChecked", - accounts: [ - { name: "mint", isMut: !0, isSigner: !1 }, - { name: "to", isMut: !0, isSigner: !1 }, - { name: "authority", isMut: !1, isSigner: !0 }, - ], - args: [ - { name: "amount", type: "u64" }, - { name: "decimals", type: "u8" }, - ], - }, - { - name: "burnChecked", - accounts: [ - { name: "source", isMut: !0, isSigner: !1 }, - { name: "mint", isMut: !0, isSigner: !1 }, - { name: "authority", isMut: !1, isSigner: !0 }, - ], - args: [ - { name: "amount", type: "u64" }, - { name: "decimals", type: "u8" }, - ], - }, - { - name: "initializeAccount2", - accounts: [ - { name: "account", isMut: !0, isSigner: !1 }, - { name: "mint", isMut: !1, isSigner: !1 }, - { name: "rent", isMut: !1, isSigner: !1 }, - ], - args: [{ name: "authority", type: "publicKey" }], - }, - { - name: "syncNative", - accounts: [{ name: "account", isMut: !0, isSigner: !1 }], - args: [], - }, - { - name: "initializeAccount3", - accounts: [ - { name: "account", isMut: !0, isSigner: !1 }, - { name: "mint", isMut: !1, isSigner: !1 }, - ], - args: [{ name: "authority", type: "publicKey" }], - }, - { - name: "initializeMultisig2", - accounts: [{ name: "account", isMut: !0, isSigner: !1 }], - args: [{ name: "m", type: "u8" }], - }, - { - name: "initializeMint2", - accounts: [{ name: "mint", isMut: !0, isSigner: !1 }], - args: [ - { name: "decimals", type: "u8" }, - { name: "mintAuthority", type: "publicKey" }, - { name: "freezeAuthority", type: { coption: "publicKey" } }, - ], - }, - ], - accounts: [ - { - name: "mint", - type: { - kind: "struct", - fields: [ - { name: "mintAuthority", type: { coption: "publicKey" } }, - { name: "supply", type: "u64" }, - { name: "decimals", type: "u8" }, - { name: "isInitialized", type: "bool" }, - { name: "freezeAuthority", type: { coption: "publicKey" } }, - ], - }, - }, - { - name: "token", - type: { - kind: "struct", - fields: [ - { name: "mint", type: "publicKey" }, - { name: "authority", type: "publicKey" }, - { name: "amount", type: "u64" }, - { name: "delegate", type: { coption: "publicKey" } }, - { name: "state", type: "u8" }, - { name: "isNative", type: { coption: "u64" } }, - { name: "delegatedAmount", type: "u64" }, - { name: "closeAuthority", type: { coption: "publicKey" } }, - ], - }, - }, - ], - }, - lT = class { - constructor(e, r, n, i, o, a) { - (this._args = e), - (this._accounts = r), - (this._provider = n), - (this._programId = i), - (this._idlIx = o), - (this._accountStore = new U_e(n, a)); - } - async resolve() { - for (let e = 0; e < this._idlIx.accounts.length; e += 1) { - let r = this._idlIx.accounts[e], - n = (0, Zs.default)(r.name); - if (!r.isSigner || this._accounts[n]) - Reflect.has(lT.CONST_ACCOUNTS, n) && - !this._accounts[n] && - (this._accounts[n] = lT.CONST_ACCOUNTS[n]); - else { - if (this._provider.wallet === void 0) - throw new Error( - "This function requires the Provider interface implementor to have a 'wallet' field." - ); - this._accounts[n] = this._provider.wallet.publicKey; - } - } - for (let e = 0; e < this._idlIx.accounts.length; e += 1) { - let r = this._idlIx.accounts[e], - n = (0, Zs.default)(r.name); - r.pda && - r.pda.seeds.length > 0 && - !this._accounts[n] && - (await this.autoPopulatePda(r)); - } - } - async autoPopulatePda(e) { - if (!e.pda || !e.pda.seeds) throw new Error("Must have seeds"); - let r = await Promise.all(e.pda.seeds.map((o) => this.toBuffer(o))), - n = await this.parseProgramId(e), - [i] = await Bn.PublicKey.findProgramAddress(r, n); - this._accounts[(0, Zs.default)(e.name)] = i; - } - async parseProgramId(e) { - var r; - if (!(!((r = e.pda) === null || r === void 0) && r.programId)) - return this._programId; - switch (e.pda.programId.kind) { - case "const": - return new Bn.PublicKey(this.toBufferConst(e.pda.programId.value)); - case "arg": - return this.argValue(e.pda.programId); - case "account": - return await this.accountValue(e.pda.programId); - default: - throw new Error( - `Unexpected program seed kind: ${e.pda.programId.kind}` - ); - } - } - async toBuffer(e) { - switch (e.kind) { - case "const": - return this.toBufferConst(e); - case "arg": - return await this.toBufferArg(e); - case "account": - return await this.toBufferAccount(e); - default: - throw new Error(`Unexpected seed kind: ${e.kind}`); - } - } - toBufferConst(e) { - return this.toBufferValue(e.type, e.value); - } - async toBufferArg(e) { - let r = this.argValue(e); - return this.toBufferValue(e.type, r); - } - argValue(e) { - let r = (0, Zs.default)(e.path.split(".")[0]), - n = this._idlIx.args.findIndex((i) => i.name === r); - if (n === -1) throw new Error(`Unable to find argument for seed: ${r}`); - return this._args[n]; - } - async toBufferAccount(e) { - let r = await this.accountValue(e); - return this.toBufferValue(e.type, r); - } - async accountValue(e) { - let r = e.path.split("."), - n = r[0], - i = this._accounts[(0, Zs.default)(n)]; - if (r.length === 1) return i; - let o = await this._accountStore.fetchAccount(e.account, i); - return this.parseAccountValue(o, r.slice(1)); - } - parseAccountValue(e, r) { - let n; - for (; r.length > 0; ) (n = e[(0, Zs.default)(r[0])]), (r = r.slice(1)); - return n; - } - toBufferValue(e, r) { - switch (e) { - case "u8": - return Buffer.from([r]); - case "u16": - let n = Buffer.alloc(2); - return n.writeUInt16LE(r), n; - case "u32": - let i = Buffer.alloc(4); - return i.writeUInt32LE(r), i; - case "u64": - let o = Buffer.alloc(8); - return o.writeBigUInt64LE(BigInt(r)), o; - case "string": - return Buffer.from(tet(r)); - case "publicKey": - return r.toBuffer(); - default: - if (e.array) return Buffer.from(r); - throw new Error(`Unexpected seed type: ${e}`); - } - } - }; - lT.CONST_ACCOUNTS = { - associatedTokenProgram: R_e, - rent: Bn.SYSVAR_RENT_PUBKEY, - systemProgram: Bn.SystemProgram.programId, - tokenProgram: C_e, - }; - var U_e = class { - constructor(e, r) { - (this._provider = e), (this._accounts = r), (this._cache = new Map()); - } - async fetchAccount(e, r) { - let n = r.toString(); - if (!this._cache.has(n)) - if (e === "TokenAccount") { - let i = await this._provider.connection.getAccountInfo(r); - if (i === null) throw new Error(`invalid account info for ${n}`); - let o = Tfr().accounts.decode("token", i.data); - this._cache.set(n, o); - } else { - let i = this._accounts[(0, Zs.default)(e)].fetch(r); - this._cache.set(n, i); - } - return this._cache.get(n); - } - }, - K_e = class { - static build(e, r, n, i, o, a, s, c, u) { - return (...h) => new H_e(h, i, o, a, s, c, e, r, n, u); - } - }, - H_e = class { - constructor(e, r, n, i, o, a, s, c, u, h) { - (this._args = e), - (this._ixFn = r), - (this._txFn = n), - (this._rpcFn = i), - (this._simulateFn = o), - (this._viewFn = a), - (this._accounts = {}), - (this._remainingAccounts = []), - (this._signers = []), - (this._preInstructions = []), - (this._postInstructions = []), - (this._autoResolveAccounts = !0), - (this._accountsResolver = new lT(e, this._accounts, s, c, u, h)); - } - async pubkeys() { - return ( - this._autoResolveAccounts && (await this._accountsResolver.resolve()), - this._accounts - ); - } - accounts(e) { - return ( - (this._autoResolveAccounts = !0), - Object.assign(this._accounts, e), - this - ); - } - accountsStrict(e) { - return ( - (this._autoResolveAccounts = !1), - Object.assign(this._accounts, e), - this - ); - } - signers(e) { - return (this._signers = this._signers.concat(e)), this; - } - remainingAccounts(e) { - return ( - (this._remainingAccounts = this._remainingAccounts.concat(e)), this - ); - } - preInstructions(e) { - return (this._preInstructions = this._preInstructions.concat(e)), this; - } - postInstructions(e) { - return ( - (this._postInstructions = this._postInstructions.concat(e)), this - ); - } - async rpc(e) { - return ( - this._autoResolveAccounts && (await this._accountsResolver.resolve()), - this._rpcFn(...this._args, { - accounts: this._accounts, - signers: this._signers, - remainingAccounts: this._remainingAccounts, - preInstructions: this._preInstructions, - postInstructions: this._postInstructions, - options: e, - }) - ); - } - async view(e) { - if ( - (this._autoResolveAccounts && - (await this._accountsResolver.resolve()), - !this._viewFn) - ) - throw new Error("Method does not support views"); - return this._viewFn(...this._args, { - accounts: this._accounts, - signers: this._signers, - remainingAccounts: this._remainingAccounts, - preInstructions: this._preInstructions, - postInstructions: this._postInstructions, - options: e, - }); - } - async simulate(e) { - return ( - this._autoResolveAccounts && (await this._accountsResolver.resolve()), - this._simulateFn(...this._args, { - accounts: this._accounts, - signers: this._signers, - remainingAccounts: this._remainingAccounts, - preInstructions: this._preInstructions, - postInstructions: this._postInstructions, - options: e, - }) - ); - } - async instruction() { - return ( - this._autoResolveAccounts && (await this._accountsResolver.resolve()), - this._ixFn(...this._args, { - accounts: this._accounts, - signers: this._signers, - remainingAccounts: this._remainingAccounts, - preInstructions: this._preInstructions, - postInstructions: this._postInstructions, - }) - ); - } - async transaction() { - return ( - this._autoResolveAccounts && (await this._accountsResolver.resolve()), - this._txFn(...this._args, { - accounts: this._accounts, - signers: this._signers, - remainingAccounts: this._remainingAccounts, - preInstructions: this._preInstructions, - postInstructions: this._postInstructions, - }) - ); - } - }, - fT = class { - constructor(e, r, n, i) { - (r = Iv(r)), - n || (n = Ej()), - (this._idl = e), - (this._provider = n), - (this._programId = r), - (this._coder = i ?? new Tj(e)), - (this._events = new q_e(this._programId, n, this._coder)); - let [o, a, s, c, u, h, w, M] = class { - static build(k, O, D, F) { - let N = {}, - q = {}, - z = {}, - H = {}, - Z = {}, - $ = {}, - ue = iet(k), - te = k.accounts - ? class { - static build(A, l, p, y) { - var d; - let v = {}; - return ( - (d = A.accounts) === null || - d === void 0 || - d.forEach((_) => { - let S = (0, Zs.default)(_.name); - v[S] = new L_e(A, _, p, y, l); - }), - v - ); - } - }.build(k, O, D, F) - : {}, - ne = class { - static build(A, l, p, y) { - if (A.state !== void 0) return new F_e(A, p, y, l); - } - }.build(k, O, D, F); - return ( - k.instructions.forEach((A) => { - let l = Q2.build(A, (b, f) => O.instruction.encode(b, f), D), - p = HQ.build(A, l), - y = KQ.build(A, p, ue, F), - d = class { - static build(b, f, x, C, E, B, G) { - return async (...L) => { - var ee; - let ge = f(...L), - [, fe] = $Q(b, [...L]), - V; - if (C.simulate === void 0) - throw new Error( - "This function requires 'Provider.simulate' to be implemented." - ); - try { - V = await C.simulate( - ge, - fe.signers, - (ee = fe.options) === null || ee === void 0 - ? void 0 - : ee.commitment - ); - } catch (le) { - throw det(le, x); - } - if (V === void 0) - throw new Error("Unable to simulate transaction"); - let ye = V.logs; - if (!ye) throw new Error("Simulated logs not found"); - let ae = []; - if (G.events) { - let le = new VQ(B, E); - for (let Me of le.parseLogs(ye)) ae.push(Me); - } - return { events: ae, raw: ye }; - }; - } - }.build(A, p, ue, F, O, D, k), - v = class { - static build(b, f, x, C) { - let E = f.accounts.find((G) => G.isMut), - B = !!f.returns; - if (!E && B) - return async (...G) => { - var L, ee; - let ge = await x(...G), - fe = `Program return: ${b} `, - V = ge.raw.find((le) => le.startsWith(fe)); - if (!V) throw new Error("View expected return log"); - let ye = net(V.slice(fe.length)), - ae = f.returns; - if (!ae) throw new Error("View expected return type"); - return Hc.fieldLayout( - { type: ae }, - Array.from([ - ...((L = C.accounts) !== null && L !== void 0 - ? L - : []), - ...((ee = C.types) !== null && ee !== void 0 - ? ee - : []), - ]) - ).decode(ye); - }; - } - }.build(D, A, d, k), - _ = K_e.build(F, D, A, l, p, y, d, v, te), - S = (0, Zs.default)(A.name); - (q[S] = l), - (z[S] = p), - (N[S] = y), - (H[S] = d), - (Z[S] = _), - v && ($[S] = v); - }), - [N, q, z, te, H, Z, ne, $] - ); - } - }.build(e, this._coder, r, n); - (this.rpc = o), - (this.instruction = a), - (this.transaction = s), - (this.account = c), - (this.simulate = u), - (this.methods = h), - (this.state = w), - (this.views = M); - } - get programId() { - return this._programId; - } - get idl() { - return this._idl; - } - get coder() { - return this._coder; - } - get provider() { - return this._provider; - } - static async at(e, r) { - let n = Iv(e), - i = await fT.fetchIdl(n, r); - if (!i) throw new Error(`IDL not found for program: ${e.toString()}`); - return new fT(i, n, r); - } - static async fetchIdl(e, r) { - r = r ?? Ej(); - let n = Iv(e), - i = await (async function (u) { - let h = (await Bn.PublicKey.findProgramAddress([], u))[0]; - return await Bn.PublicKey.createWithSeed(h, "anchor:idl", u); - })(n), - o = await r.connection.getAccountInfo(i); - if (!o) return null; - let a = ((s = o.data.slice(8)), Afr.decode(s)); - var s; - let c = dYe(a.data); - return JSON.parse(eet(c)); - } - addEventListener(e, r) { - return this._events.addEventListener(e, r); - } - async removeEventListener(e) { - return await this._events.removeEventListener(e); - } - }; - var bhn = new Bn.PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"); - var whn = new Bn.PublicKey("11111111111111111111111111111111"); - m(); - g(); - m(); - g(); - m(); - g(); - m(); - g(); - var Pfr = ["api.mainnet-beta.solana.com", "ssc-dao.genesysgo.net"], - Ofr = ["api.devnet.solana.com", "psytrbhymqlkfrhudd.dev.genesysgo.net"], - Bfr = ["api.testnet.solana.com"], - Ifr = ["localhost", "127.0.0.1"], - wet = (t) => Cfr(t.rpcEndpoint), - Cfr = (t) => { - let e = new URL(t).hostname; - return Pfr.includes(e) - ? "mainnet-beta" - : Ofr.includes(e) - ? "devnet" - : Bfr.includes(e) - ? "testnet" - : Ifr.includes(e) - ? "localnet" - : "custom"; - }; - m(); - g(); - m(); - g(); - m(); - g(); - m(); - g(); - function Go(t, e, r) { - return ( - e in t - ? Object.defineProperty(t, e, { - value: r, - enumerable: !0, - configurable: !0, - writable: !0, - }) - : (t[e] = r), - t - ); - } - m(); - g(); - var Rfr = qe(Rp(), 1); - var Eu = BigInt(0), - bi = BigInt(1), - NC = BigInt(2), - _et = BigInt( - "7237005577332262213973186563042994240857116359379907606001950938285454250989" - ), - aa = Object.freeze({ - a: BigInt(-1), - d: BigInt( - "37095705934669439343138083508754565189542113879843219016388785533085940283555" - ), - P: BigInt( - "57896044618658097711785492504343953926634992332820282019728792003956564819949" - ), - l: _et, - n: _et, - h: BigInt(8), - Gx: BigInt( - "15112221349535400772501151409588531511454012693041857206046113283949847762202" - ), - Gy: BigInt( - "46316835694926478169428394003475163141307993866256225615783033603165251855960" - ), - }); - var Met = BigInt( - "0x10000000000000000000000000000000000000000000000000000000000000000" - ), - Bj = BigInt( - "19681161376707505956807079304988542015446066515923890162744021073123829784752" - ), - Phn = BigInt( - "6853475219497561581579357271197624642482790079785650197046958215289687604742" - ), - Nfr = BigInt( - "25063068953384623474111414158702152701244531502492656460079210482610430750235" - ), - Dfr = BigInt( - "54469307008909316920995813868745141605393597292927456921205312896311721017578" - ), - Ffr = BigInt( - "1159843021668779879193775521855586647937357759715417654439879720876111806838" - ), - Lfr = BigInt( - "40440834346308536858101042469323190826248399146238708352240133220865137265952" - ), - vi = class { - constructor(e, r, n, i) { - (this.x = e), (this.y = r), (this.z = n), (this.t = i); - } - static fromAffine(e) { - if (!(e instanceof va)) - throw new TypeError("ExtendedPoint#fromAffine: expected Point"); - return e.equals(va.ZERO) - ? vi.ZERO - : new vi(e.x, e.y, bi, Rt(e.x * e.y)); - } - static toAffineBatch(e) { - let r = jfr(e.map((n) => n.z)); - return e.map((n, i) => n.toAffine(r[i])); - } - static normalizeZ(e) { - return this.toAffineBatch(e).map(this.fromAffine); - } - equals(e) { - xet(e); - let { x: r, y: n, z: i } = this, - { x: o, y: a, z: s } = e, - c = Rt(r * s), - u = Rt(o * i), - h = Rt(n * s), - w = Rt(a * i); - return c === u && h === w; - } - negate() { - return new vi(Rt(-this.x), this.y, this.z, Rt(-this.t)); - } - double() { - let { x: e, y: r, z: n } = this, - { a: i } = aa, - o = Rt(e * e), - a = Rt(r * r), - s = Rt(NC * Rt(n * n)), - c = Rt(i * o), - u = e + r, - h = Rt(Rt(u * u) - o - a), - w = c + a, - M = w - s, - k = c - a, - O = Rt(h * M), - D = Rt(w * k), - F = Rt(h * k), - N = Rt(M * w); - return new vi(O, D, N, F); - } - add(e) { - xet(e); - let { x: r, y: n, z: i, t: o } = this, - { x: a, y: s, z: c, t: u } = e, - h = Rt((n - r) * (s + a)), - w = Rt((n + r) * (s - a)), - M = Rt(w - h); - if (M === Eu) return this.double(); - let k = Rt(i * NC * u), - O = Rt(o * NC * c), - D = O + k, - F = w + h, - N = O - k, - q = Rt(D * M), - z = Rt(F * N), - H = Rt(D * N), - Z = Rt(M * F); - return new vi(q, z, Z, H); - } - subtract(e) { - return this.add(e.negate()); - } - precomputeWindow(e) { - let r = 1 + 256 / e, - n = [], - i = this, - o = i; - for (let a = 0; a < r; a++) { - (o = i), n.push(o); - for (let s = 1; s < 2 ** (e - 1); s++) (o = o.add(i)), n.push(o); - i = o.double(); - } - return n; - } - wNAF(e, r) { - !r && this.equals(vi.BASE) && (r = va.BASE); - let n = (r && r._WINDOW_SIZE) || 1; - if (256 % n) - throw new Error( - "Point#wNAF: Invalid precomputation window, must be power of 2" - ); - let i = r && txe.get(r); - i || - ((i = this.precomputeWindow(n)), - r && n !== 1 && ((i = vi.normalizeZ(i)), txe.set(r, i))); - let o = vi.ZERO, - a = vi.ZERO, - s = 1 + 256 / n, - c = 2 ** (n - 1), - u = BigInt(2 ** n - 1), - h = 2 ** n, - w = BigInt(n); - for (let M = 0; M < s; M++) { - let k = M * c, - O = Number(e & u); - if (((e >>= w), O > c && ((O -= h), (e += bi)), O === 0)) { - let D = i[k]; - M % 2 && (D = D.negate()), (a = a.add(D)); - } else { - let D = i[k + Math.abs(O) - 1]; - O < 0 && (D = D.negate()), (o = o.add(D)); - } - } - return vi.normalizeZ([o, a])[0]; - } - multiply(e, r) { - return this.wNAF(XQ(e, aa.l), r); - } - multiplyUnsafe(e) { - let r = XQ(e, aa.l, !1), - n = vi.BASE, - i = vi.ZERO; - if (r === Eu) return i; - if (this.equals(i) || r === bi) return this; - if (this.equals(n)) return this.wNAF(r); - let o = i, - a = this; - for (; r > Eu; ) r & bi && (o = o.add(a)), (a = a.double()), (r >>= bi); - return o; - } - isSmallOrder() { - return this.multiplyUnsafe(aa.h).equals(vi.ZERO); - } - isTorsionFree() { - return this.multiplyUnsafe(aa.l).equals(vi.ZERO); - } - toAffine(e = QQ(this.z)) { - let { x: r, y: n, z: i } = this, - o = Rt(r * e), - a = Rt(n * e); - if (Rt(i * e) !== bi) throw new Error("invZ was invalid"); - return new va(o, a); - } - fromRistrettoBytes() { - Q_e(); - } - toRistrettoBytes() { - Q_e(); - } - fromRistrettoHash() { - Q_e(); - } - }; - vi.BASE = new vi(aa.Gx, aa.Gy, bi, Rt(aa.Gx * aa.Gy)); - vi.ZERO = new vi(Eu, bi, bi, Eu); - function xet(t) { - if (!(t instanceof vi)) throw new TypeError("ExtendedPoint expected"); - } - function Y_e(t) { - if (!(t instanceof Dh)) throw new TypeError("RistrettoPoint expected"); - } - function Q_e() { - throw new Error("Legacy method: switch to RistrettoPoint"); - } - var Dh = class { - constructor(e) { - this.ep = e; - } - static calcElligatorRistrettoMap(e) { - let { d: r } = aa, - n = Rt(Bj * e * e), - i = Rt((n + bi) * Ffr), - o = BigInt(-1), - a = Rt((o - r * n) * Rt(n + r)), - { isValid: s, value: c } = nxe(i, a), - u = Rt(c * e); - rA(u) || (u = Rt(-u)), s || (c = u), s || (o = n); - let h = Rt(o * (n - bi) * Lfr - a), - w = c * c, - M = Rt((c + c) * a), - k = Rt(h * Nfr), - O = Rt(bi - w), - D = Rt(bi + w); - return new vi(Rt(M * D), Rt(O * k), Rt(k * D), Rt(M * O)); - } - static hashToCurve(e) { - e = nA(e, 64); - let r = exe(e.slice(0, 32)), - n = this.calcElligatorRistrettoMap(r), - i = exe(e.slice(32, 64)), - o = this.calcElligatorRistrettoMap(i); - return new Dh(n.add(o)); - } - static fromHex(e) { - e = nA(e, 32); - let { a: r, d: n } = aa, - i = - "RistrettoPoint.fromHex: the hex is not valid encoding of RistrettoPoint", - o = exe(e); - if (!Kfr(Cj(o), e) || rA(o)) throw new Error(i); - let a = Rt(o * o), - s = Rt(bi + r * a), - c = Rt(bi - r * a), - u = Rt(s * s), - h = Rt(c * c), - w = Rt(r * n * u - h), - { isValid: M, value: k } = Eet(Rt(w * h)), - O = Rt(k * c), - D = Rt(k * O * w), - F = Rt((o + o) * O); - rA(F) && (F = Rt(-F)); - let N = Rt(s * D), - q = Rt(F * N); - if (!M || rA(q) || N === Eu) throw new Error(i); - return new Dh(new vi(F, N, bi, q)); - } - toRawBytes() { - let { x: e, y: r, z: n, t: i } = this.ep, - o = Rt(Rt(n + r) * Rt(n - r)), - a = Rt(e * r), - s = Rt(a * a), - { value: c } = Eet(Rt(o * s)), - u = Rt(c * o), - h = Rt(c * a), - w = Rt(u * h * i), - M; - if (rA(i * w)) { - let O = Rt(r * Bj), - D = Rt(e * Bj); - (e = O), (r = D), (M = Rt(u * Dfr)); - } else M = h; - rA(e * w) && (r = Rt(-r)); - let k = Rt((n - r) * M); - return rA(k) && (k = Rt(-k)), Cj(k); - } - toHex() { - return Rj(this.toRawBytes()); - } - toString() { - return this.toHex(); - } - equals(e) { - Y_e(e); - let r = this.ep, - n = e.ep, - i = Rt(r.x * n.y) === Rt(r.y * n.x), - o = Rt(r.y * n.y) === Rt(r.x * n.x); - return i || o; - } - add(e) { - return Y_e(e), new Dh(this.ep.add(e.ep)); - } - subtract(e) { - return Y_e(e), new Dh(this.ep.subtract(e.ep)); - } - multiply(e) { - return new Dh(this.ep.multiply(e)); - } - multiplyUnsafe(e) { - return new Dh(this.ep.multiplyUnsafe(e)); - } - }; - Dh.BASE = new Dh(vi.BASE); - Dh.ZERO = new Dh(vi.ZERO); - var txe = new WeakMap(), - va = class { - constructor(e, r) { - (this.x = e), (this.y = r); - } - _setWindowSize(e) { - (this._WINDOW_SIZE = e), txe.delete(this); - } - static fromHex(e, r = !0) { - let { d: n, P: i } = aa; - e = nA(e, 32); - let o = e.slice(); - o[31] = e[31] & -129; - let a = Nj(o); - if (r && a >= i) throw new Error("Expected 0 < hex < P"); - if (!r && a >= Met) throw new Error("Expected 0 < hex < 2**256"); - let s = Rt(a * a), - c = Rt(s - bi), - u = Rt(n * s + bi), - { isValid: h, value: w } = nxe(c, u); - if (!h) throw new Error("Point.fromHex: invalid y coordinate"); - let M = (w & bi) === bi; - return ((e[31] & 128) !== 0) !== M && (w = Rt(-w)), new va(w, a); - } - static async fromPrivateKey(e) { - return (await Oet(e)).point; - } - toRawBytes() { - let e = Cj(this.y); - return (e[31] |= this.x & bi ? 128 : 0), e; - } - toHex() { - return Rj(this.toRawBytes()); - } - toX25519() { - let { y: e } = this, - r = Rt((bi + e) * QQ(bi - e)); - return Cj(r); - } - isTorsionFree() { - return vi.fromAffine(this).isTorsionFree(); - } - equals(e) { - return this.x === e.x && this.y === e.y; - } - negate() { - return new va(Rt(-this.x), this.y); - } - add(e) { - return vi.fromAffine(this).add(vi.fromAffine(e)).toAffine(); - } - subtract(e) { - return this.add(e.negate()); - } - multiply(e) { - return vi.fromAffine(this).multiply(e, this).toAffine(); - } - }; - va.BASE = new va(aa.Gx, aa.Gy); - va.ZERO = new va(Eu, bi); - var pT = class { - constructor(e, r) { - (this.r = e), (this.s = r), this.assertValidity(); - } - static fromHex(e) { - let r = nA(e, 64), - n = va.fromHex(r.slice(0, 32), !1), - i = Nj(r.slice(32, 64)); - return new pT(n, i); - } - assertValidity() { - let { r: e, s: r } = this; - if (!(e instanceof va)) throw new Error("Expected Point instance"); - return XQ(r, aa.l, !1), this; - } - toRawBytes() { - let e = new Uint8Array(64); - return e.set(this.r.toRawBytes()), e.set(Cj(this.s), 32), e; - } - toHex() { - return Rj(this.toRawBytes()); - } - }; - function Aet(...t) { - if (!t.every((n) => n instanceof Uint8Array)) - throw new Error("Expected Uint8Array list"); - if (t.length === 1) return t[0]; - let e = t.reduce((n, i) => n + i.length, 0), - r = new Uint8Array(e); - for (let n = 0, i = 0; n < t.length; n++) { - let o = t[n]; - r.set(o, i), (i += o.length); - } - return r; - } - var qfr = Array.from({ length: 256 }, (t, e) => - e.toString(16).padStart(2, "0") - ); - function Rj(t) { - if (!(t instanceof Uint8Array)) throw new Error("Uint8Array expected"); - let e = ""; - for (let r = 0; r < t.length; r++) e += qfr[t[r]]; - return e; - } - function rxe(t) { - if (typeof t != "string") - throw new TypeError("hexToBytes: expected string, got " + typeof t); - if (t.length % 2) - throw new Error("hexToBytes: received invalid unpadded hex"); - let e = new Uint8Array(t.length / 2); - for (let r = 0; r < e.length; r++) { - let n = r * 2, - i = t.slice(n, n + 2), - o = Number.parseInt(i, 16); - if (Number.isNaN(o) || o < 0) throw new Error("Invalid byte sequence"); - e[r] = o; - } - return e; - } - function Tet(t) { - let r = t.toString(16).padStart(64, "0"); - return rxe(r); - } - function Cj(t) { - return Tet(t).reverse(); - } - function rA(t) { - return (Rt(t) & bi) === bi; - } - function Nj(t) { - if (!(t instanceof Uint8Array)) throw new Error("Expected Uint8Array"); - return BigInt("0x" + Rj(Uint8Array.from(t).reverse())); - } - var zfr = BigInt( - "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff" - ); - function exe(t) { - return Rt(Nj(t) & zfr); - } - function Rt(t, e = aa.P) { - let r = t % e; - return r >= Eu ? r : e + r; - } - function QQ(t, e = aa.P) { - if (t === Eu || e <= Eu) - throw new Error( - `invert: expected positive integers, got n=${t} mod=${e}` - ); - let r = Rt(t, e), - n = e, - i = Eu, - o = bi, - a = bi, - s = Eu; - for (; r !== Eu; ) { - let u = n / r, - h = n % r, - w = i - a * u, - M = o - s * u; - (n = r), (r = h), (i = a), (o = s), (a = w), (s = M); - } - if (n !== bi) throw new Error("invert: does not exist"); - return Rt(i, e); - } - function jfr(t, e = aa.P) { - let r = new Array(t.length), - n = t.reduce( - (o, a, s) => (a === Eu ? o : ((r[s] = o), Rt(o * a, e))), - bi - ), - i = QQ(n, e); - return ( - t.reduceRight( - (o, a, s) => (a === Eu ? o : ((r[s] = Rt(o * r[s], e)), Rt(o * a, e))), - i - ), - r - ); - } - function Rv(t, e) { - let { P: r } = aa, - n = t; - for (; e-- > Eu; ) (n *= n), (n %= r); - return n; - } - function Ufr(t) { - let { P: e } = aa, - r = BigInt(5), - n = BigInt(10), - i = BigInt(20), - o = BigInt(40), - a = BigInt(80), - c = (((t * t) % e) * t) % e, - u = (Rv(c, NC) * c) % e, - h = (Rv(u, bi) * t) % e, - w = (Rv(h, r) * h) % e, - M = (Rv(w, n) * w) % e, - k = (Rv(M, i) * M) % e, - O = (Rv(k, o) * k) % e, - D = (Rv(O, a) * O) % e, - F = (Rv(D, a) * O) % e, - N = (Rv(F, n) * w) % e; - return { pow_p_5_8: (Rv(N, NC) * t) % e, b2: c }; - } - function nxe(t, e) { - let r = Rt(e * e * e), - n = Rt(r * r * e), - i = Ufr(t * n).pow_p_5_8, - o = Rt(t * r * i), - a = Rt(e * o * o), - s = o, - c = Rt(o * Bj), - u = a === t, - h = a === Rt(-t), - w = a === Rt(-t * Bj); - return ( - u && (o = s), - (h || w) && (o = c), - rA(o) && (o = Rt(-o)), - { isValid: u || h, value: o } - ); - } - function Eet(t) { - return nxe(bi, t); - } - function ZQ(t) { - return Rt(Nj(t), aa.l); - } - function Kfr(t, e) { - if (t.length !== e.length) return !1; - for (let r = 0; r < t.length; r++) if (t[r] !== e[r]) return !1; - return !0; - } - function nA(t, e) { - let r = t instanceof Uint8Array ? Uint8Array.from(t) : rxe(t); - if (typeof e == "number" && r.length !== e) - throw new Error(`Expected ${e} bytes`); - return r; - } - function XQ(t, e, r = !0) { - if (!e) throw new TypeError("Specify max value"); - if ( - (typeof t == "number" && Number.isSafeInteger(t) && (t = BigInt(t)), - typeof t == "bigint" && t < e) - ) { - if (r) { - if (Eu < t) return t; - } else if (Eu <= t) return t; - } - throw new TypeError("Expected valid scalar: 0 < scalar < max"); - } - function Hfr(t) { - return (t[0] &= 248), (t[31] &= 127), (t[31] |= 64), t; - } - function ket(t) { - if ( - ((t = - typeof t == "bigint" || typeof t == "number" ? Tet(XQ(t, Met)) : nA(t)), - t.length !== 32) - ) - throw new Error("Expected 32 bytes"); - return t; - } - function Pet(t) { - let e = Hfr(t.slice(0, 32)), - r = t.slice(32, 64), - n = ZQ(e), - i = va.BASE.multiply(n), - o = i.toRawBytes(); - return { head: e, prefix: r, scalar: n, point: i, pointBytes: o }; - } - var Ij; - function YQ(...t) { - if (typeof Ij != "function") - throw new Error("utils.sha512Sync must be set to use sync methods"); - return Ij(...t); - } - async function Oet(t) { - return Pet(await oxe.sha512(ket(t))); - } - function ixe(t) { - return Pet(YQ(ket(t))); - } - function Vfr(t) { - return ixe(t).pointBytes; - } - function Wfr(t, e) { - t = nA(t); - let { prefix: r, scalar: n, pointBytes: i } = ixe(e), - o = ZQ(YQ(r, t)), - a = va.BASE.multiply(o), - s = ZQ(YQ(a.toRawBytes(), i, t)), - c = Rt(o + s * n, aa.l); - return new pT(a, c).toRawBytes(); - } - function Gfr(t, e, r) { - (e = nA(e)), r instanceof va || (r = va.fromHex(r, !1)); - let { r: n, s: i } = t instanceof pT ? t.assertValidity() : pT.fromHex(t), - o = vi.BASE.multiplyUnsafe(i); - return { r: n, s: i, SB: o, pub: r, msg: e }; - } - function Jfr(t, e, r, n) { - let i = ZQ(n), - o = vi.fromAffine(t).multiplyUnsafe(i); - return vi - .fromAffine(e) - .add(o) - .subtract(r) - .multiplyUnsafe(aa.h) - .equals(vi.ZERO); - } - function $fr(t, e, r) { - let { r: n, SB: i, msg: o, pub: a } = Gfr(t, e, r), - s = YQ(n.toRawBytes(), a.toRawBytes(), o); - return Jfr(a, n, i, s); - } - var eee = { - getExtendedPublicKey: ixe, - getPublicKey: Vfr, - sign: Wfr, - verify: $fr, - }; - va.BASE._setWindowSize(8); - var tA = { - node: Rfr, - web: typeof self == "object" && "crypto" in self ? self.crypto : void 0, - }, - oxe = { - bytesToHex: Rj, - hexToBytes: rxe, - concatBytes: Aet, - getExtendedPublicKey: Oet, - mod: Rt, - invert: QQ, - TORSION_SUBGROUP: [ - "0100000000000000000000000000000000000000000000000000000000000000", - "c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac037a", - "0000000000000000000000000000000000000000000000000000000000000080", - "26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc05", - "ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f", - "26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc85", - "0000000000000000000000000000000000000000000000000000000000000000", - "c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac03fa", - ], - hashToPrivateScalar: (t) => { - if (((t = nA(t)), t.length < 40 || t.length > 1024)) - throw new Error( - "Expected 40-1024 bytes of private key as per FIPS 186" - ); - return Rt(Nj(t), aa.l - bi) + bi; - }, - randomBytes: (t = 32) => { - if (tA.web) return tA.web.getRandomValues(new Uint8Array(t)); - if (tA.node) { - let { randomBytes: e } = tA.node; - return new Uint8Array(e(t).buffer); - } else - throw new Error("The environment doesn't have randomBytes function"); - }, - randomPrivateKey: () => oxe.randomBytes(32), - sha512: async (...t) => { - let e = Aet(...t); - if (tA.web) { - let r = await tA.web.subtle.digest("SHA-512", e.buffer); - return new Uint8Array(r); - } else { - if (tA.node) - return Uint8Array.from( - tA.node.createHash("sha512").update(e).digest() - ); - throw new Error("The environment doesn't have sha512 function"); - } - }, - precompute(t = 8, e = va.BASE) { - let r = e.equals(va.BASE) ? e : new va(e.x, e.y); - return r._setWindowSize(t), r.multiply(NC), r; - }, - sha512Sync: void 0, - }; - Object.defineProperties(oxe, { - sha512Sync: { - configurable: !1, - get() { - return Ij; - }, - set(t) { - Ij || (Ij = t); - }, - }, - }); - m(); - g(); - m(); - g(); - var Mu = class extends Error { - constructor(e) { - var r, n, i, o, a, s, c, u; - super(e.problem), - Go(this, "name", "MetaplexError"), - (this.key = `metaplex.errors.${e.key}`), - (this.title = e.title), - (this.problem = Iet( - e.problem, - (r = e.options) === null || r === void 0 ? void 0 : r.problem, - (n = e.options) === null || n === void 0 ? void 0 : n.problemPrefix, - (i = e.options) === null || i === void 0 ? void 0 : i.problemSuffix - )), - (this.solution = Iet( - e.solution, - (o = e.options) === null || o === void 0 ? void 0 : o.solution, - (a = e.options) === null || a === void 0 - ? void 0 - : a.solutionPrefix, - (s = e.options) === null || s === void 0 ? void 0 : s.solutionSuffix - )), - (this.source = e.source), - (this.sourceDetails = e.sourceDetails), - (this.cause = - (c = e.options) === null || c === void 0 ? void 0 : c.cause), - (this.logs = - (u = e.options) === null || u === void 0 ? void 0 : u.logs), - (this.message = this.toString(!1)); - } - getCapitalizedSource() { - return this.source === "sdk" || this.source === "rpc" - ? this.source.toUpperCase() - : this.source[0].toUpperCase() + this.source.slice(1); - } - getFullSource() { - let e = this.getCapitalizedSource(), - r = this.sourceDetails ? ` > ${this.sourceDetails}` : ""; - return e + r; - } - toString(e = !0) { - let r = - this.logs != null - ? ` - -[ Logs: ${this.logs.join(" |$> ")} ]` - : "", - n = this.cause - ? ` - -Caused By: ${this.cause}` - : ""; - return ( - (e ? `[${this.name}] ` : "") + - `${this.title} ->> Source: ${this.getFullSource()} ->> Problem: ${this.problem} ->> Solution: ${this.solution}` + - n + - r + - ` -` - ); - } - }, - Iet = (t, e, r, n) => [r, e ?? t, n].filter((i) => !!i).join(" "); - var _s = class extends Mu { - constructor(e) { - super({ ...e, key: `sdk.${e.key}`, source: "sdk" }); - } - }, - tee = class extends _s { - constructor(e, r) { - super({ - options: r, - key: "operation_handler_missing", - title: "Operation Handler Missing", - problem: `No operation handler was registered for the [${e}] operation.`, - solution: - 'Did you forget to register it? You may do this by using: "metaplex.register(operation, operationHandler)".', - }); - } - }, - DC = class extends _s { - constructor(e, r) { - super({ - options: r, - key: "driver_not_provided", - title: "Driver Not Provided", - problem: `The SDK tried to access the driver [${e}] but was not provided.`, - solution: - 'Make sure the driver is registered by using the "setDriver(myDriver)" method.', - }); - } - }, - ree = class extends _s { - constructor(e, r, n) { - super({ - options: n, - key: "unexpected_currency", - title: "Unexpected Currency", - problem: `Expected currency [${r}] but got [${e}].`, - solution: - "Ensure the provided Amount or Currency is of the expected type.", - }), - (this.actual = e), - (this.expected = r); - } - }, - nee = class extends _s { - constructor(e, r, n, i) { - let o = n ? ` [${n}]` : ""; - super({ - options: i, - key: "currency_mismatch", - title: "Currency Mismatch", - problem: `The SDK tried to execute an operation${o} on two different currencies: ${e.symbol} and ${r.symbol}.`, - solution: - "Provide both amounts in the same currency to perform this operation.", - }), - (this.left = e), - (this.right = r), - (this.operation = n); - } - }, - iee = class extends _s { - constructor(e) { - super({ - options: e, - key: "invalid_json_variable", - title: "Invalid JSON Variable", - problem: - "The provided JSON variable could not be parsed into a string.", - solution: - 'Ensure the variable can be parsed as a JSON string using "JSON.stringify(myVariable)".', - }); - } - }, - oee = class extends _s { - constructor(e) { - super({ - options: e, - key: "invalid_json_string", - title: "Invalid JSON String", - problem: - "The provided string could not be parsed into a JSON variable.", - solution: "Ensure the provided string uses a valid JSON syntax.", - }); - } - }, - FC = class extends _s { - constructor(e, r) { - super({ - options: r, - key: "operation_unauthorized_for_guests", - title: "Operation Unauthorized For Guests", - problem: `Trying to access the [${e}] operation as a guest.`, - solution: - 'Ensure your wallet is connected using the identity driver. For instance, by using "metaplex.use(walletAdapterIdentity(wallet))" or "metaplex.use(keypairIdentity(keypair))".', - }); - } - }; - var aee = class extends _s { - constructor(e, r, n) { - super({ - options: n, - key: "account_not_found", - title: "Account Not Found", - problem: - (r - ? `The account of type [${r}] was not found` - : "No account was found") + - ` at the provided address [${e.toBase58()}].`, - solution: - "Ensure the provided address is correct and that an account exists at this address.", - }); - } - }, - see = class extends _s { - constructor(e, r, n) { - super({ - options: n, - key: "unexpected_account", - title: "Unexpected Account", - problem: `The account at the provided address [${e.toBase58()}] is not of the expected type [${r}].`, - solution: `Ensure the provided address is correct and that it holds an account of type [${r}].`, - }); - } - }; - var xy = class extends _s { - constructor(e, r, n) { - super({ - options: n, - key: "expected_signer", - title: "Expected Signer", - problem: `Expected variable [${e}] to be of type [Signer] but got [${r}].`, - solution: - "Please check that you are providing the variable as a signer. Note that, it may be allowed to provide a non-signer variable for certain use cases but not this one.", - }); - } - }, - uee = class extends _s { - constructor(e, r, n) { - let i = typeof e == "string", - o = i ? e : e.toBase58(); - super({ - options: n, - key: "program_not_recognized", - title: "Program Not Recognized", - problem: `The provided program ${ - i ? "name" : "address" - } [${o}] is not recognized in the [${r}] cluster.`, - solution: - 'Did you forget to register this program? If so, you may use "metaplex.programs().register(myProgram)" to fix this.', - }), - (this.nameOrAddress = e), - (this.cluster = r); - } - }, - cee = class extends _s { - constructor(e, r) { - super({ - options: r, - key: "missing_gpa_builder", - title: 'Missing "getProgramAccount" Builder', - problem: `The program [${e.name}] does not have a registered "getProgramAccount" builder.`, - solution: - 'When registering a program, make sure you provide a "gpaResolver" before trying to access its "getProgramAccount" builder.', - }), - (this.program = e); - } - }, - Nv = class extends _s { - constructor(e, r, n) { - super({ - options: n, - key: "no_instructions_to_send", - title: "No Instructions To Send", - problem: `The input provided to the [${e}] resulted in a Transaction containing no Instructions.`, - solution: - r ?? - "Ensure that the provided input has an effect on the operation. This typically happens when trying to update an account with the same data it already contains.", - }); - } - }, - lee = class extends _s { - constructor(e, r) { - super({ - options: r, - key: "failed_to_serialize_data", - title: "Failed To Serialize Data", - problem: `The received data could not be serialized as a [${e}].`, - solution: - "Ensure the data is of the expected type so it can be serialized.", - }); - } - }, - fee = class extends _s { - constructor(e, r) { - super({ - options: r, - key: "missing_input_data", - title: "Missing Input Data", - problem: - "Some parameters are missing from the provided input object.", - solution: - "Please provide the following missing parameters: [" + - e.join(", ") + - "].", - }); - } - }, - dee = class extends _s { - constructor(e, r) { - super({ - options: r, - key: "failed_to_deserialize_data", - title: "Failed To Deserialize Data", - problem: `The received serialized data could not be deserialized to a [${e}].`, - solution: - "Ensure the serialized data is not corrupted and complies with the expected type.", - }); - } - }, - iA = class extends _s { - constructor(e) { - super({ - options: e, - key: "not_yet_implemented", - title: "Not Yet Implemented", - problem: "This feature is not yet implemented.", - solution: "Please check back later.", - }); - } - }, - hee = class extends _s { - constructor(e, r) { - super({ - options: r, - key: "unreachable_case", - title: `The Case '${e}' in a Switch or If Statement went Unhandled.`, - problem: - "The developer is not handling that case yet or is missing a `break` or `return` statement.", - solution: - "Check your inputs or file an issue to have all cases handled properly.", - }); - } - }; - m(); - g(); - var kr = (t) => - typeof t == "object" && - "publicKey" in t && - ("secretKey" in t || "signTransaction" in t), - axe = (t) => kr(t) && "secretKey" in t && t.secretKey != null, - pee = (t) => kr(t) && !axe(t), - Cet = (t) => - t.reduce( - (e, r) => { - var n; - let i = e.all.findIndex(({ publicKey: c }) => c.equals(r.publicKey)), - o = (n = e.all[i]) !== null && n !== void 0 ? n : null, - a = o ? pee(o) : !1, - s = pee(r); - if (!o) e.all.push(r), s ? e.identities.push(r) : e.keypairs.push(r); - else if (a && !s) { - let c = e.identities.findIndex(({ publicKey: u }) => - u.equals(r.publicKey) - ); - e.all.splice(i, 1), - e.identities.splice(c, 1), - e.all.push(r), - e.keypairs.push(r); - } - return e; - }, - { all: [], keypairs: [], identities: [] } - ); - var yee = class { - constructor() { - Go(this, "_driver", null); - } - driver() { - if (!this._driver) throw new DC("IdentityDriver"); - return this._driver; - } - setDriver(e) { - this._driver = e; - } - get publicKey() { - return this.driver().publicKey; - } - get secretKey() { - return this.driver().secretKey; - } - signMessage(e) { - return this.driver().signMessage(e); - } - signTransaction(e) { - return this.driver().signTransaction(e); - } - signAllTransactions(e) { - return this.driver().signAllTransactions(e); - } - verifyMessage(e, r) { - return eee.verify(e, r, this.publicKey.toBytes()); - } - equals(e) { - return kr(e) && (e = e.publicKey), this.publicKey.equals(e); - } - hasSecretKey() { - return this.secretKey != null; - } - }; - var Ret = () => ({ - install(t) { - let e = new yee(); - t.identity = () => e; - }, - }); - m(); - g(); - m(); - g(); - var Xet = qe(Det(), 1); - m(); - g(); - var uxe = qe(Qr(), 1); - m(); - g(); - var Vet = qe(Het(), 1), - Wc = (t) => t.replace(/\u0000/g, ""), - qC = (t, e) => t.padEnd(e, "\0"); - var Wet = (t, e) => - t.reduce((r, n, i) => { - let o = Math.floor(i / e); - return r[o] || (r[o] = []), r[o].push(n), r; - }, []), - gee = (t, e, r) => - t.map((n, i) => { - var o; - return r(n, (o = e?.[i]) !== null && o !== void 0 ? o : null, i); - }), - Get = ( - t = 20, - e = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" - ) => { - let r = "", - n = e.length; - for (var i = 0; i < t; i++) r += e.charAt(Math.floor(Math.random() * n)); - return r; - }, - Jet = (t) => Vet.default.getType(t), - $et = (t) => { - let e = t.lastIndexOf("."); - return e < 0 ? null : t.slice(e + 1); - }, - vee = (t, e, r) => { - let n = (o) => vee(o, e, r); - if (t && Array.isArray(t)) - t.forEach((o, a) => { - e(n, o, a, t); - }); - else if (t && typeof t == "object") { - var i; - let o = Object.keys(t); - (!((i = r?.sortObjectKeys) !== null && i !== void 0) || i) && o.sort(), - o.forEach((a) => { - let s = t[a]; - e(n, s, a, t); - }); - } - }, - sxe = (t) => - Object.keys(t).reduce( - (e, r) => (t[r] !== void 0 && (e[r] = t[r]), e), - {} - ); - var cxe = (t, e, r = {}) => { - var n, i, o, a, s; - return { - buffer: Yfr(t), - fileName: e, - displayName: (n = r.displayName) !== null && n !== void 0 ? n : e, - uniqueName: (i = r.uniqueName) !== null && i !== void 0 ? i : Get(), - contentType: (o = r.contentType) !== null && o !== void 0 ? o : Jet(e), - extension: (a = r.extension) !== null && a !== void 0 ? a : $et(e), - tags: (s = r.tags) !== null && s !== void 0 ? s : [], - }; - }; - var Zet = (t, e = "inline.json", r = {}) => { - let n; - try { - n = JSON.stringify(t); - } catch (i) { - throw new iee({ cause: i }); - } - return cxe(n, e, r); - }, - Yfr = (t) => - t instanceof ArrayBuffer - ? uxe.Buffer.from(new Uint8Array(t)) - : uxe.Buffer.from(t), - bee = (...t) => t.reduce((e, r) => e + r.buffer.byteLength, 0); - var lxe = (t) => - t != null && - typeof t == "object" && - "buffer" in t && - "fileName" in t && - "displayName" in t && - "uniqueName" in t && - "contentType" in t && - "extension" in t && - "tags" in t; - var wee = class { - constructor() { - Go(this, "_driver", null); - } - driver() { - if (!this._driver) throw new DC("StorageDriver"); - return this._driver; - } - setDriver(e) { - this._driver = e; - } - getUploadPriceForBytes(e) { - return this.driver().getUploadPrice(e); - } - getUploadPriceForFile(e) { - return this.getUploadPriceForFiles([e]); - } - getUploadPriceForFiles(e) { - return this.getUploadPriceForBytes(bee(...e)); - } - upload(e) { - return this.driver().upload(e); - } - uploadAll(e) { - let r = this.driver(); - return r.uploadAll - ? r.uploadAll(e) - : Promise.all(e.map((n) => this.driver().upload(n))); - } - uploadJson(e) { - return this.upload(Zet(e)); - } - async download(e, r) { - let n = this.driver(); - if (n.download) return n.download(e, r); - let o = await (await (0, Xet.default)(e, r)).arrayBuffer(); - return cxe(o, e); - } - async downloadJson(e, r) { - let n = await this.download(e, r); - try { - return JSON.parse(n.buffer.toString()); - } catch (i) { - throw new oee({ cause: i }); - } - } - }; - var Yet = () => ({ - install(t) { - let e = new wee(); - t.storage = () => e; - }, - }); - m(); - g(); - m(); - g(); - m(); - g(); - var _ee = class extends Mu { - constructor(e) { - super({ ...e, key: `rpc.${e.key}`, source: "rpc" }); - } - }, - yT = class extends _ee { - constructor(e, r) { - super({ - key: "failed_to_send_transaction", - title: "Failed to Send Transaction", - problem: - "The transaction could not be sent successfully to the network.", - solution: "Check the error below for more information.", - options: { ...r, logs: e.logs, cause: e }, - }); - } - asSendTransactionError() { - return this.cause; - } - get error() { - return this.asSendTransactionError().message; - } - get errorLogs() { - var e; - return (e = this.asSendTransactionError().logs) !== null && e !== void 0 - ? e - : []; - } - }, - Dj = class extends _ee { - constructor(e, r) { - super({ - key: "failed_to_confirm_transaction", - title: "Failed to Confirm Transaction", - problem: "The transaction could not be confirmed.", - solution: "Check the error below for more information.", - options: { ...r, cause: e }, - }); - } - }, - xee = class extends Dj { - constructor(e) { - let r = (n) => { - if (!n) return "Unknown error"; - if (typeof n == "string") return n; - try { - return JSON.stringify(n); - } catch { - return "Unknown error"; - } - }; - super(new Error(r(e.value.err))), (this.response = e); - } - get error() { - var e; - return (e = this.response.value.err) !== null && e !== void 0 - ? e - : "Unknown error"; - } - }; - m(); - g(); - var Qfr = qe(Le(), 1), - dxe = qe(Ho(), 1); - m(); - g(); - var Qet = qe(Ho(), 1); - m(); - g(); - var See = class extends Error { - constructor(e) { - super(e), - (this.name = "AssertionError"), - Error.captureStackTrace && - Error.captureStackTrace(this, this.constructor); - } - }; - function ba(t, e) { - if (!t) throw new See(e ?? "Assertion failed"); - } - ba.equal = function (e, r, n) { - if (e !== r) throw new See((n ?? "") + ` ${e} !== ${r}`); - }; - function fxe(t, e, r) { - let n = e.filter((i) => t?.[i] === void 0); - if (n.length > 0) throw r(n); - } - var Sr = (t, e) => new Qet.default(t, e), - ett = (t) => (t === null ? null : Sr(t)); - var zC = { symbol: "SOL", decimals: 9 }; - var ci = (t, e) => ({ basisPoints: Sr(t), currency: e }), - Xi = (t) => ci(t, zC); - var Jo = (t, e = 0, r = "Token") => ( - typeof t != "number" && (t = Sr(t).toNumber()), - { - basisPoints: Sr(t * Math.pow(10, e)), - currency: { symbol: r, decimals: e, namespace: "spl-token" }, - } - ); - var ttt = (t, e) => ( - "currency" in t && (t = t.currency), - "currency" in e && (e = e.currency), - t.symbol === e.symbol && - t.decimals === e.decimals && - t.namespace === e.namespace - ); - function edr(t, e) { - if (("currency" in t && (t = t.currency), !ttt(t, e))) throw new ree(t, e); - } - function jC(t) { - edr(t, zC); - } - function Aee(t, e, r) { - if ( - ("currency" in t && (t = t.currency), - "currency" in e && (e = e.currency), - !ttt(t, e)) - ) - throw new nee(t, e, r); - } - var hxe = (t, e) => ( - Aee(t, e, "add"), ci(t.basisPoints.add(e.basisPoints), t.currency) - ), - rtt = (t, e) => ( - Aee(t, e, "subtract"), ci(t.basisPoints.sub(e.basisPoints), t.currency) - ), - pxe = (t, e) => ci(t.basisPoints.muln(e), t.currency); - var yxe = (t) => { - if (t.currency.decimals === 0) - return `${t.currency.symbol} ${t.basisPoints.toString()}`; - let e = new dxe.default(10).pow(new dxe.default(t.currency.decimals)), - r = t.basisPoints, - { div: n, mod: i } = r.divmod(e), - o = `${n.toString()}.${i.abs().toString(10, t.currency.decimals)}`; - return `${t.currency.symbol} ${o}`; - }; - m(); - g(); - var ntt = (t) => t instanceof Error && "logs" in t; - m(); - g(); - var Eee = class extends Mu { - constructor(e, r) { - super({ - ...r, - key: `program.${r.key}`, - title: `${e.name} > ${r.title}`, - source: "program", - sourceDetails: `${e.name} [${e.address.toBase58()}]`, - }), - (this.program = e); - } - }, - Mee = class extends Eee { - constructor(e, r, n) { - let i = r.code ? ` of code [${r.code}]` : ""; - super(e, { - key: "parsed_program_error", - title: r.message, - problem: `The program [${ - e.name - }] at address [${e.address.toBase58()}] raised an error${i} that translates to "${ - r.message - }".`, - solution: "Check the error message provided by the program.", - options: { ...n, logs: r.logs, cause: r }, - }); - } - }, - Fj = class extends Eee { - constructor(e, r, n) { - let i = r.code ? ` of code [${r.code}]` : ""; - super(e, { - key: "unknown_program_error", - title: "Unknown Program Error", - problem: `The program [${ - e.name - }] at address [${e.address.toBase58()}] raised an error${i} that is not recognized by the programs registered by the SDK.`, - solution: - 'Unfortunately, you will need to check the unparsed error below to investigate what went wrong. To get more helpful error messages, ensure the program that failed is registered by the SDK and provides an "errorResolver" method.', - options: { ...n, logs: r.logs, cause: r }, - }); - } - }; - var Tee = class { - constructor(e) { - this.metaplex = e; - } - async prepareTransaction(e, r) { - let n; - return ( - !("records" in e) && e.recentBlockhash && e.lastValidBlockHeight - ? (n = { - blockhash: e.recentBlockhash, - lastValidBlockHeight: e.lastValidBlockHeight, - }) - : (n = await this.getLatestBlockhash()), - "records" in e && - ((r = [...e.getSigners(), ...r]), (e = e.toTransaction(n))), - { transaction: e, signers: r, blockhashWithExpiryBlockHeight: n } - ); - } - async signTransaction(e, r) { - let { keypairs: n, identities: i } = Cet(r); - n.length > 0 && e.partialSign(...n); - for (let o = 0; o < i.length; o++) await i[o].signTransaction(e); - return e; - } - async sendTransaction(e, r = {}, n = []) { - let i = await this.prepareTransaction(e, n); - (e = i.transaction), (n = i.signers); - let o = this.getDefaultFeePayer(); - !e.feePayer && o && ((e.feePayer = o.publicKey), (n = [o, ...n])), - (e = await this.signTransaction(e, n)); - let a = e.serialize(); - try { - return await this.metaplex.connection.sendRawTransaction(a, r); - } catch (s) { - throw this.parseProgramError(s, e); - } - } - async confirmTransaction(e, r, n) { - let i; - try { - i = await this.metaplex.connection.confirmTransaction( - { signature: e, ...r }, - n - ); - } catch (o) { - throw new Dj(o); - } - if (i.value.err) throw new xee(i); - return i; - } - async sendAndConfirmTransaction(e, r, n = []) { - let i = await this.prepareTransaction(e, n), - { blockhashWithExpiryBlockHeight: o } = i; - (e = i.transaction), (n = i.signers); - let a = await this.sendTransaction(e, r, n), - s = await this.confirmTransaction(a, o, r?.commitment); - return { signature: a, confirmResponse: s, ...o }; - } - async getAccount(e, r) { - let n = await this.metaplex.connection.getAccountInfo(e, r); - return this.getUnparsedMaybeAccount(e, n); - } - async accountExists(e, r) { - return (await this.metaplex.connection.getBalance(e, r)) > 0; - } - async getMultipleAccounts(e, r) { - let n = await this.metaplex.connection.getMultipleAccountsInfo(e, r); - return gee(e, n, (i, o) => this.getUnparsedMaybeAccount(i, o)); - } - async getProgramAccounts(e, r) { - return (await this.metaplex.connection.getProgramAccounts(e, r)).map( - ({ pubkey: i, account: o }) => ({ - ...o, - publicKey: i, - lamports: Xi(o.lamports), - }) - ); - } - async airdrop(e, r, n) { - jC(r); - let i = await this.metaplex.connection.requestAirdrop( - e, - r.basisPoints.toNumber() - ), - o = await this.getLatestBlockhash(), - a = await this.confirmTransaction(i, o, n); - return { signature: i, confirmResponse: a, ...o }; - } - async getBalance(e, r) { - let n = await this.metaplex.connection.getBalance(e, r); - return Xi(n); - } - async getRent(e, r) { - let n = await this.metaplex.connection.getMinimumBalanceForRentExemption( - e, - r - ); - return Xi(n); - } - async getLatestBlockhash(e = "finalized") { - return this.metaplex.connection.getLatestBlockhash(e); - } - getSolanaExporerUrl(e) { - let r = ""; - switch (this.metaplex.cluster) { - case "devnet": - r = "?cluster=devnet"; - break; - case "testnet": - r = "?cluster=testnet"; - break; - case "localnet": - case "custom": - r = `?cluster=custom&customUrl=${encodeURIComponent( - this.metaplex.connection.rpcEndpoint - )}`; - break; - } - return `https://explorer.solana.com/tx/${e}${r}`; - } - setDefaultFeePayer(e) { - return (this.defaultFeePayer = e), this; - } - getDefaultFeePayer() { - return this.defaultFeePayer - ? this.defaultFeePayer - : this.metaplex.identity(); - } - getUnparsedMaybeAccount(e, r) { - return r - ? { ...r, publicKey: e, exists: !0, lamports: Xi(r.lamports) } - : { publicKey: e, exists: !1 }; - } - parseProgramError(e, r) { - var n, i, o, a, s; - if (!ntt(e)) return new yT(e); - let c = /Error processing Instruction (\d+):/, - u = - (n = - (i = e.message.match(c)) === null || i === void 0 - ? void 0 - : i[1]) !== null && n !== void 0 - ? n - : null; - if (!u) return new yT(e); - let h = parseInt(u, 10), - w = - (o = - (a = r.instructions) === null || - a === void 0 || - (s = a[h]) === null || - s === void 0 - ? void 0 - : s.programId) !== null && o !== void 0 - ? o - : null; - if (!w) return new yT(e); - let M; - try { - M = this.metaplex.programs().get(w); - } catch { - return new yT(e); - } - if (!M.errorResolver) return new Fj(M, e); - let k = M.errorResolver(e); - return k ? new Mee(M, k) : new Fj(M, e); - } - }; - var itt = () => ({ - install(t) { - let e = new Tee(t); - t.rpc = () => e; - }, - }); - m(); - g(); - m(); - g(); - m(); - g(); - var ott = qe(lI(), 1), - kee = class { - constructor(e) { - Go(this, "cancelationError", null), - (this.signal = e), - (this.eventEmitter = new ott.default.EventEmitter()), - (this.abortListener = (r) => { - (this.cancelationError = r), - this.eventEmitter.emit("cancel", r), - this.close(); - }), - this.signal.addEventListener("abort", this.abortListener); - } - async run(e, r = !0) { - try { - return await Promise.resolve(e(this.getScope())); - } finally { - r && this.close(); - } - } - getScope() { - return { - signal: this.signal, - isCanceled: () => this.isCanceled(), - getCancelationError: () => this.cancelationError, - throwIfCanceled: () => { - if (this.isCanceled()) throw this.getCancelationError(); - }, - }; - } - isCanceled() { - return this.signal.aborted; - } - getCancelationError() { - return this.cancelationError; - } - onCancel(e) { - return this.eventEmitter.on("cancel", e), this; - } - close() { - this.signal.removeEventListener("abort", this.abortListener), - this.eventEmitter.removeAllListeners(); - } - }; - var Pee = class { - constructor(e) { - Go(this, "operationHandlers", new Map()), (this.metaplex = e); - } - register(e, r) { - return this.operationHandlers.set(e.key, r), this; - } - get(e) { - let r = this.operationHandlers.get(e.key); - if (!r) throw new tee(e.key); - return r; - } - async execute(e, r = {}) { - var n; - let i = this.get(e), - o = - (n = r.signal) !== null && n !== void 0 - ? n - : new AbortController().signal; - return new kee(o).run((a) => - i.handle(e, this.metaplex, this.getOperationScope(r, a)) - ); - } - getOperationScope(e, r) { - var n; - !!e.commitment && - !e.confirmOptions && - (e.confirmOptions = { commitment: e.commitment }); - let i = - (n = e.payer) !== null && n !== void 0 - ? n - : this.metaplex.rpc().getDefaultFeePayer(); - return { ...e, ...r, payer: i }; - } - }; - var att = () => ({ - install(t) { - let e = new Pee(t); - t.operations = () => e; - }, - }); - m(); - g(); - m(); - g(); - var Oee = class { - constructor(e) { - Go(this, "programs", []), (this.metaplex = e); - } - register(e) { - this.programs.unshift(e); - } - all(e = []) { - return [...e, ...this.programs]; - } - allForCluster(e, r = []) { - return this.all(r).filter((n) => { - var i, o; - return (i = - (o = n.clusterFilter) === null || o === void 0 - ? void 0 - : o.call(n, e)) !== null && i !== void 0 - ? i - : !0; - }); - } - allForCurrentCluster(e = []) { - return this.allForCluster(this.metaplex.cluster, e); - } - get(e, r = []) { - let n = this.allForCurrentCluster(r), - i = - typeof e == "string" - ? n.find((o) => o.name === e) - : n.find((o) => o.address.equals(e)); - if (!i) throw new uee(e, this.metaplex.cluster); - return i; - } - getGpaBuilder(e, r = []) { - let n = this.get(e, r); - if (!n.gpaResolver) throw new cee(n); - return n.gpaResolver(this.metaplex); - } - }; - var stt = () => ({ - install(t) { - let e = new Oee(t); - t.programs = () => e; - }, - }); - m(); - g(); - m(); - g(); - var tdr = 5e3, - Bee = class { - constructor(e) { - Go(this, "cachedRentPerEmptyAccount", null), - Go(this, "cachedRentPerByte", null), - (this.metaplex = e); - } - async estimate(e, r = 1, n = 1, i = !0) { - let o = await this.estimateRent(e, r, i), - a = this.estimateTransactionFee(n); - return hxe(o, a); - } - async estimateRent(e, r = 1, n = !0) { - if ( - !n || - this.cachedRentPerEmptyAccount === null || - this.cachedRentPerByte === null - ) { - let a = await this.metaplex.rpc().getRent(0), - s = await this.metaplex.rpc().getRent(1); - (this.cachedRentPerEmptyAccount = a), - (this.cachedRentPerByte = rtt(s, a)); - } - let i = pxe(this.cachedRentPerEmptyAccount, r), - o = pxe(this.cachedRentPerByte, e); - return hxe(i, o); - } - estimateTransactionFee(e = 1) { - return Xi(e * tdr); - } - }; - var utt = () => ({ - install(t) { - let e = new Bee(t); - t.utils = () => e; - }, - }); - m(); - g(); - m(); - g(); - var ctt = qe(Le(), 1); - var Iee = class { - constructor(e) { - this.publicKey = e ?? ctt.PublicKey.default; - } - async signMessage() { - throw new FC("signMessage"); - } - async signTransaction() { - throw new FC("signTransaction"); - } - async signAllTransactions() { - throw new FC("signAllTransactions"); - } - }; - var ltt = (t) => ({ - install(e) { - e.identity().setDriver(new Iee(t)); - }, - }); - m(); - g(); - m(); - g(); - var kOr = qe(hbt(), 1), - Toe = qe(Sy(), 1), - mbt = qe(Le(), 1); - m(); - g(); - var MN = class extends Mu { - constructor(e) { - super({ - ...e, - key: `plugin.bundlr.${e.key}`, - title: `Bundlr > ${e.title}`, - source: "plugin", - sourceDetails: "Bundlr", - }); - } - }, - xoe = class extends MN { - constructor(e) { - super({ - options: e, - key: "failed_to_initialize_bundlr", - title: "Failed to Initialize Bundlr", - problem: "Bundlr could not be initialized.", - solution: - "This could happen for a variety of reasons. Check the underlying error below for more information.", - }); - } - }, - Soe = class extends MN { - constructor(e, r) { - super({ - options: r, - key: "failed_to_connect_to_bundlr_address", - title: "Failed to Connect to Bundlr Address", - problem: `Bundlr could not connect to the provided address [${e}].`, - solution: - 'Ensure the provided address is valid. Some valid addresses include: "https://node1.bundlr.network" for mainnet and "https://devnet.bundlr.network" for devnet', - }); - } - }, - Aoe = class extends MN { - constructor(e, r) { - super({ - options: r, - key: "asset_upload_failed", - title: "Asset Upload Failed", - problem: `The asset could not be uploaded to the Bundlr network and returned the following status code [${e}].`, - solution: - "Check the provided status code for more information. For now, this is all we get from Bundlr's API but we'll improve this error message as we get more information.", - }); - } - }, - Eoe = class extends MN { - constructor(e, r) { - super({ - options: r, - key: "bundlr_withdraw_error", - title: "Bundlr Withdraw Error", - problem: `The balance could not be withdrawn from the Bundlr network and returned the following status code [${e}].`, - solution: - "Check the provided status code for more information. For now, this is all we get from Bundlr's API but we'll improve this error message as we get more information.", - }); - } - }; - m(); - g(); - var Moe = class { - constructor(e) { - (this.keypair = e), - (this.publicKey = e.publicKey), - (this.secretKey = e.secretKey); - } - async signMessage(e) { - return eee.sign(e, this.secretKey.slice(0, 32)); - } - async signTransaction(e) { - return e.partialSign(this.keypair), e; - } - async signAllTransactions(e) { - return Promise.all(e.map((r) => this.signTransaction(r))); - } - }; - function POr(t) { - return t && typeof t == "object" && "default" in t && "default" in t.default - ? t.default - : t; - } - var pbt = POr(kOr), - koe = class { - constructor(e, r = {}) { - Go(this, "_bundlr", null), - (this._metaplex = e), - (this._options = { providerUrl: e.connection.rpcEndpoint, ...r }); - } - async getUploadPrice(e) { - var r; - let i = await (await this.bundlr()).getPrice(e); - return XTe( - i.multipliedBy( - (r = this._options.priceMultiplier) !== null && r !== void 0 - ? r - : 1.5 - ) - ); - } - async upload(e) { - let [r] = await this.uploadAll([e]); - return r; - } - async uploadAll(e) { - let r = await this.bundlr(), - n = await this.getUploadPrice(bee(...e)); - await this.fund(n); - let i = e.map(async (o) => { - let { status: a, data: s } = await r.uploader.upload(o.buffer, { - tags: OOr(o), - }); - if (a >= 300) throw new Aoe(a); - return `https://arweave.net/${s.id}`; - }); - return await Promise.all(i); - } - async getBalance() { - let r = await (await this.bundlr()).getLoadedBalance(); - return XTe(r); - } - async fund(e, r = !1) { - let n = await this.bundlr(), - i = ybt(e); - if (!r) { - let o = await n.getLoadedBalance(); - i = i.isGreaterThan(o) ? i.minus(o) : new Toe.default(0); - } - i.isLessThanOrEqualTo(0) || (await n.fund(i)); - } - async withdrawAll() { - let r = await (await this.bundlr()).getLoadedBalance(), - n = new Toe.default(5e3); - if (r.isLessThan(n)) return; - let i = r.minus(n); - await this.withdraw(XTe(i)); - } - async withdraw(e) { - let r = await this.bundlr(), - { status: n } = await r.withdrawBalance(ybt(e)); - if (n >= 300) throw new Eoe(n); - } - async bundlr() { - return this._bundlr - ? this._bundlr - : (this._bundlr = await this.initBundlr()); - } - async initBundlr() { - var e, r, n, i; - let o = "solana", - a = - (e = - (r = this._options) === null || r === void 0 - ? void 0 - : r.address) !== null && e !== void 0 - ? e - : "https://node1.bundlr.network", - s = { - timeout: this._options.timeout, - providerUrl: this._options.providerUrl, - }, - c = - (n = this._options.identity) !== null && n !== void 0 - ? n - : this._metaplex.identity(), - u = - typeof window > "u" || - ((i = window.process) === null || i === void 0 - ? void 0 - : i.hasOwnProperty("type")), - h; - if (u && axe(c)) h = this.initNodeBundlr(a, o, c, s); - else { - let w; - pee(c) - ? (w = c) - : (w = new Moe(mbt.Keypair.fromSecretKey(c.secretKey))), - (h = await this.initWebBundlr(a, o, w, s)); - } - try { - await h.utils.getBundlerAddress(o); - } catch (w) { - throw new Soe(a, { cause: w }); - } - return h; - } - initNodeBundlr(e, r, n, i) { - return new pbt.default(e, r, n.secretKey, i); - } - async initWebBundlr(e, r, n, i) { - let o = { - publicKey: n.publicKey, - signMessage: (s) => n.signMessage(s), - signTransaction: (s) => n.signTransaction(s), - signAllTransactions: (s) => n.signAllTransactions(s), - sendTransaction: (s, c, u = {}) => { - let { signers: h = [], ...w } = u; - return this._metaplex.rpc().sendTransaction(s, w, [n, ...h]); - }, - }, - a = new pbt.WebBundlr(e, r, o, i); - try { - await a.ready(); - } catch (s) { - throw new xoe({ cause: s }); - } - return a; - } - }; - var XTe = (t) => Xi(Sr(t.decimalPlaces(0).toString())), - ybt = (t) => new Toe.default(t.basisPoints.toString()), - OOr = (t) => - t.contentType - ? [{ name: "Content-Type", value: t.contentType }, ...t.tags] - : t.tags; - var gbt = (t = {}) => ({ - install(e) { - e.storage().setDriver(new koe(e, t)); - }, - }); - m(); - g(); - var xbt = qe(Le(), 1); - m(); - g(); - m(); - g(); - m(); - g(); - var DH = qe(Le(), 1); - m(); - g(); - var ot = (t) => { - let e = (r) => ({ key: t, input: r }); - return (e.key = t), e; - }, - go = (t, e) => - t.cluster === "mainnet-beta" ? { ...e, commitment: "finalized" } : e; - m(); - g(); - var vbt = qe(Le(), 1), - ct = class { - constructor(e = {}) { - Go(this, "records", []), - Go(this, "feePayer", void 0), - Go(this, "context", {}), - (this.transactionOptions = e); - } - static make(e) { - return new ct(e); - } - prepend(...e) { - let r = e.flatMap((n) => - n instanceof ct ? n.getInstructionsWithSigners() : [n] - ); - return (this.records = [...r, ...this.records]), this; - } - append(...e) { - let r = e.flatMap((n) => - n instanceof ct ? n.getInstructionsWithSigners() : [n] - ); - return (this.records = [...this.records, ...r]), this; - } - add(...e) { - return this.append(...e); - } - splitUsingKey(e, r = !0) { - let n = new ct(this.transactionOptions), - i = new ct(this.transactionOptions), - o = this.records.findIndex((a) => a.key === e); - return ( - o > -1 - ? ((o += r ? 1 : 0), - n.add(...this.records.slice(0, o)), - n.add(...this.records.slice(o))) - : n.add(this), - [n, i] - ); - } - splitBeforeKey(e) { - return this.splitUsingKey(e, !1); - } - splitAfterKey(e) { - return this.splitUsingKey(e, !0); - } - getInstructionsWithSigners() { - return this.records; - } - getInstructions() { - return this.records.map((e) => e.instruction); - } - getInstructionCount() { - return this.records.length; - } - isEmpty() { - return this.getInstructionCount() === 0; - } - getSigners() { - let e = this.feePayer == null ? [] : [this.feePayer], - r = this.records.flatMap((n) => n.signers); - return [...e, ...r]; - } - setTransactionOptions(e) { - return (this.transactionOptions = e), this; - } - getTransactionOptions() { - return this.transactionOptions; - } - setFeePayer(e) { - return (this.feePayer = e), this; - } - getFeePayer() { - return this.feePayer; - } - setContext(e) { - return (this.context = e), this; - } - getContext() { - return this.context; - } - when(e, r) { - return e ? r(this) : this; - } - unless(e, r) { - return this.when(!e, r); - } - toTransaction(e, r = {}) { - var n; - r = { ...this.getTransactionOptions(), ...r }; - let i = new vbt.Transaction({ - feePayer: - (n = this.getFeePayer()) === null || n === void 0 - ? void 0 - : n.publicKey, - signatures: r.signatures, - blockhash: e.blockhash, - lastValidBlockHeight: e.lastValidBlockHeight, - }); - return i.add(...this.getInstructions()), i; - } - async sendAndConfirm(e, r) { - return { - response: await e.rpc().sendAndConfirmTransaction(this, r), - ...this.getContext(), - }; - } - }; - var BOr = "CreateAccountOperation", - Poe = ot(BOr), - bbt = { - async handle(t, e, r) { - let n = await YTe(e, t.input, r); - return r.throwIfCanceled(), n.sendAndConfirm(e, r.confirmOptions); - }, - }, - YTe = async (t, e, r = {}) => { - var n, i; - let { payer: o = t.rpc().getDefaultFeePayer() } = r, - { - space: a, - newAccount: s = DH.Keypair.generate(), - program: c = DH.SystemProgram.programId, - } = e, - u = - (n = e.lamports) !== null && n !== void 0 - ? n - : await t.rpc().getRent(a); - return ( - jC(u), - ct - .make() - .setFeePayer(o) - .setContext({ newAccount: s, lamports: u }) - .add({ - instruction: DH.SystemProgram.createAccount({ - fromPubkey: o.publicKey, - newAccountPubkey: s.publicKey, - space: a, - lamports: u.basisPoints.toNumber(), - programId: c, - }), - signers: [o, s], - key: - (i = e.instructionKey) !== null && i !== void 0 - ? i - : "createAccount", - }) - ); - }; - m(); - g(); - var wbt = qe(Le(), 1); - var IOr = "TransferSolOperation", - Ooe = ot(IOr), - _bt = { - async handle(t, e, r) { - return QTe(e, t.input, r).sendAndConfirm(e, r.confirmOptions); - }, - }, - QTe = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - from: a = t.identity(), - to: s, - amount: c, - basePubkey: u, - seed: h, - } = e; - return ( - jC(c), - ct - .make() - .setFeePayer(o) - .add({ - instruction: wbt.SystemProgram.transfer({ - fromPubkey: a.publicKey, - toPubkey: s, - lamports: c.basisPoints.toNumber(), - ...(u ? { basePubkey: u, seed: h } : {}), - programId: t.programs().getSystem(i).address, - }), - signers: [a], - key: - (n = e.instructionKey) !== null && n !== void 0 - ? n - : "transferSol", - }) - ); - }; - var Boe = class { - constructor(e) { - this.metaplex = e; - } - createAccount(e, r) { - return YTe(this.metaplex, e, r); - } - transferSol(e, r) { - return QTe(this.metaplex, e, r); - } - }; - var Ioe = class { - constructor(e) { - this.metaplex = e; - } - builders() { - return new Boe(this.metaplex); - } - createAccount(e, r) { - return this.metaplex.operations().execute(Poe(e), r); - } - transferSol(e, r) { - return this.metaplex.operations().execute(Ooe(e), r); - } - }; - var Sbt = () => ({ - install(t) { - let e = { name: "SystemProgram", address: xbt.SystemProgram.programId }; - t.programs().register(e), - (t.programs().getSystem = function (n) { - return this.get(e.name, n); - }); - let r = t.operations(); - r.register(Poe, bbt), - r.register(Ooe, _bt), - (t.system = function () { - return new Ioe(this); - }); - }, - }); - m(); - g(); - m(); - g(); - m(); - g(); - var TN = qe(Le(), 1), - Ha = new TN.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"), - S_n = new TN.PublicKey("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"), - Coe = new TN.PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"), - A_n = new TN.PublicKey("So11111111111111111111111111111111111111112"), - E_n = new TN.PublicKey("9pan9bMn5HatX4EJdBwg9VgCa7Uz5HL8N1m5D3NdXejP"); - m(); - g(); - m(); - g(); - var BE = (t) => { - let e = t.decode.bind(t), - r = t.encode.bind(t); - return { decode: e, encode: r }; - }; - m(); - g(); - var e6e = qe(Sn(), 1), - IE = qe(uY(), 1); - var Roe = (t) => (e) => { - let r = (0, e6e.blob)(t, e), - { encode: n, decode: i } = BE(r), - o = r; - return ( - (o.decode = (a, s) => { - let c = i(a, s); - return (0, IE.toBigIntLE)(Buffer.from(c)); - }), - (o.encode = (a, s, c) => { - let u = (0, IE.toBufferLE)(a, t); - return n(u, s, c); - }), - o - ); - }, - Noe = (t) => (e) => { - let r = (0, e6e.blob)(t, e), - { encode: n, decode: i } = BE(r), - o = r; - return ( - (o.decode = (a, s) => { - let c = i(a, s); - return (0, IE.toBigIntBE)(Buffer.from(c)); - }), - (o.encode = (a, s, c) => { - let u = (0, IE.toBufferBE)(a, t); - return n(u, s, c); - }), - o - ); - }, - dl = Roe(8), - P_n = Noe(8), - COr = Roe(16), - O_n = Noe(16), - B_n = Roe(24), - I_n = Noe(24), - C_n = Roe(32), - R_n = Noe(32); - m(); - g(); - var Abt = qe(Sy(), 1); - var L_n = new Abt.default("1e+18"); - m(); - g(); - var Ebt = qe(Sn(), 1); - var Mbt = (t) => { - let e = (0, Ebt.u8)(t), - { encode: r, decode: n } = BE(e), - i = e; - return ( - (i.decode = (o, a) => !!n(o, a)), - (i.encode = (o, a, s) => { - let c = Number(o); - return r(c, a, s); - }), - i - ); - }; - m(); - g(); - var Tbt = qe(Sn(), 1), - kbt = qe(Le(), 1); - var hl = (t) => { - let e = (0, Tbt.blob)(32, t), - { encode: r, decode: n } = BE(e), - i = e; - return ( - (i.decode = (o, a) => { - let s = n(o, a); - return new kbt.PublicKey(s); - }), - (i.encode = (o, a, s) => { - let c = o.toBuffer(); - return r(c, a, s); - }), - i - ); - }; - m(); - g(); - var Fu; - (function (t) { - (t[(t.InitializeMint = 0)] = "InitializeMint"), - (t[(t.InitializeAccount = 1)] = "InitializeAccount"), - (t[(t.InitializeMultisig = 2)] = "InitializeMultisig"), - (t[(t.Transfer = 3)] = "Transfer"), - (t[(t.Approve = 4)] = "Approve"), - (t[(t.Revoke = 5)] = "Revoke"), - (t[(t.SetAuthority = 6)] = "SetAuthority"), - (t[(t.MintTo = 7)] = "MintTo"), - (t[(t.Burn = 8)] = "Burn"), - (t[(t.CloseAccount = 9)] = "CloseAccount"), - (t[(t.FreezeAccount = 10)] = "FreezeAccount"), - (t[(t.ThawAccount = 11)] = "ThawAccount"), - (t[(t.TransferChecked = 12)] = "TransferChecked"), - (t[(t.ApproveChecked = 13)] = "ApproveChecked"), - (t[(t.MintToChecked = 14)] = "MintToChecked"), - (t[(t.BurnChecked = 15)] = "BurnChecked"), - (t[(t.InitializeAccount2 = 16)] = "InitializeAccount2"), - (t[(t.SyncNative = 17)] = "SyncNative"), - (t[(t.InitializeAccount3 = 18)] = "InitializeAccount3"), - (t[(t.InitializeMultisig2 = 19)] = "InitializeMultisig2"), - (t[(t.InitializeMint2 = 20)] = "InitializeMint2"), - (t[(t.GetAccountDataSize = 21)] = "GetAccountDataSize"), - (t[(t.InitializeImmutableOwner = 22)] = "InitializeImmutableOwner"), - (t[(t.AmountToUiAmount = 23)] = "AmountToUiAmount"), - (t[(t.UiAmountToAmount = 24)] = "UiAmountToAmount"), - (t[(t.InitializeMintCloseAuthority = 25)] = - "InitializeMintCloseAuthority"), - (t[(t.TransferFeeExtension = 26)] = "TransferFeeExtension"), - (t[(t.ConfidentialTransferExtension = 27)] = - "ConfidentialTransferExtension"), - (t[(t.DefaultAccountStateExtension = 28)] = - "DefaultAccountStateExtension"), - (t[(t.Reallocate = 29)] = "Reallocate"), - (t[(t.MemoTransferExtension = 30)] = "MemoTransferExtension"), - (t[(t.CreateNativeMint = 31)] = "CreateNativeMint"), - (t[(t.InitializeNonTransferableMint = 32)] = - "InitializeNonTransferableMint"), - (t[(t.InterestBearingMintExtension = 33)] = - "InterestBearingMintExtension"); - })(Fu || (Fu = {})); - m(); - g(); - var Doe = qe(Sn(), 1); - var Obt = qe(Le(), 1); - m(); - g(); - function rm(t, e, r) { - if (r.length) { - t.push({ pubkey: e, isSigner: !1, isWritable: !1 }); - for (let n of r) - t.push({ pubkey: n.publicKey, isSigner: !0, isWritable: !1 }); - } else t.push({ pubkey: e, isSigner: !0, isWritable: !1 }); - return t; - } - var Pbt = (0, Doe.struct)([(0, Doe.u8)("instruction"), dl("amount")]); - function Bbt(t, e, r, n, i = [], o = Ha) { - let a = rm( - [ - { pubkey: t, isSigner: !1, isWritable: !0 }, - { pubkey: e, isSigner: !1, isWritable: !1 }, - ], - r, - i - ), - s = Buffer.alloc(Pbt.span); - return ( - Pbt.encode({ instruction: Fu.Approve, amount: BigInt(n) }, s), - new Obt.TransactionInstruction({ keys: a, programId: o, data: s }) - ); - } - m(); - g(); - var CE = qe(Sn(), 1); - var Ibt; - (function (t) { - (t[(t.Uninitialized = 0)] = "Uninitialized"), - (t[(t.Initialized = 1)] = "Initialized"), - (t[(t.Frozen = 2)] = "Frozen"); - })(Ibt || (Ibt = {})); - var Foe = (0, CE.struct)([ - hl("mint"), - hl("owner"), - dl("amount"), - (0, CE.u32)("delegateOption"), - hl("delegate"), - (0, CE.u8)("state"), - (0, CE.u32)("isNativeOption"), - dl("isNative"), - dl("delegatedAmount"), - (0, CE.u32)("closeAuthorityOption"), - hl("closeAuthority"), - ]), - Loe = Foe.span; - m(); - g(); - var C6 = qe(Sn(), 1); - var ROr = qe(Le(), 1); - var qoe = (0, C6.struct)([ - (0, C6.u32)("mintAuthorityOption"), - hl("mintAuthority"), - dl("supply"), - (0, C6.u8)("decimals"), - Mbt("isInitialized"), - (0, C6.u32)("freezeAuthorityOption"), - hl("freezeAuthority"), - ]), - t6e = qoe.span; - m(); - g(); - var zoe = qe(Sn(), 1), - joe = qe(Le(), 1); - var Cbt = (0, zoe.struct)([(0, zoe.u8)("instruction")]); - function Rbt(t, e, r, n = Ha) { - let i = [ - { pubkey: t, isSigner: !1, isWritable: !0 }, - { pubkey: e, isSigner: !1, isWritable: !1 }, - { pubkey: r, isSigner: !1, isWritable: !1 }, - { pubkey: joe.SYSVAR_RENT_PUBKEY, isSigner: !1, isWritable: !1 }, - ], - o = Buffer.alloc(Cbt.span); - return ( - Cbt.encode({ instruction: Fu.InitializeAccount }, o), - new joe.TransactionInstruction({ keys: i, programId: n, data: o }) - ); - } - m(); - g(); - var Uoe = qe(Le(), 1); - function Nbt(t, e, r, n, i = Ha, o = Coe) { - let a = [ - { pubkey: t, isSigner: !0, isWritable: !0 }, - { pubkey: e, isSigner: !1, isWritable: !0 }, - { pubkey: r, isSigner: !1, isWritable: !1 }, - { pubkey: n, isSigner: !1, isWritable: !1 }, - { pubkey: Uoe.SystemProgram.programId, isSigner: !1, isWritable: !1 }, - { pubkey: i, isSigner: !1, isWritable: !1 }, - ]; - return new Uoe.TransactionInstruction({ - keys: a, - programId: o, - data: Buffer.alloc(0), - }); - } - m(); - g(); - var Koe = qe(Sn(), 1), - Fbt = qe(Le(), 1); - var Dbt = (0, Koe.struct)([(0, Koe.u8)("instruction")]); - function Lbt(t, e, r, n = [], i = Ha) { - let o = rm( - [ - { pubkey: t, isSigner: !1, isWritable: !0 }, - { pubkey: e, isSigner: !1, isWritable: !1 }, - ], - r, - n - ), - a = Buffer.alloc(Dbt.span); - return ( - Dbt.encode({ instruction: Fu.FreezeAccount }, a), - new Fbt.TransactionInstruction({ keys: o, programId: i, data: a }) - ); - } - m(); - g(); - var Hoe = qe(Sn(), 1); - var zbt = qe(Le(), 1); - var qbt = (0, Hoe.struct)([(0, Hoe.u8)("instruction"), dl("amount")]); - function jbt(t, e, r, n, i = [], o = Ha) { - let a = rm( - [ - { pubkey: t, isSigner: !1, isWritable: !0 }, - { pubkey: e, isSigner: !1, isWritable: !0 }, - ], - r, - i - ), - s = Buffer.alloc(qbt.span); - return ( - qbt.encode({ instruction: Fu.MintTo, amount: BigInt(n) }, s), - new zbt.TransactionInstruction({ keys: a, programId: o, data: s }) - ); - } - m(); - g(); - var Voe = qe(Sn(), 1), - Kbt = qe(Le(), 1); - var Ubt = (0, Voe.struct)([(0, Voe.u8)("instruction")]); - function Hbt(t, e, r = [], n = Ha) { - let i = rm([{ pubkey: t, isSigner: !1, isWritable: !0 }], e, r), - o = Buffer.alloc(Ubt.span); - return ( - Ubt.encode({ instruction: Fu.Revoke }, o), - new Kbt.TransactionInstruction({ keys: i, programId: n, data: o }) - ); - } - m(); - g(); - var Woe = qe(Sn(), 1), - Wbt = qe(Le(), 1); - var Vbt = (0, Woe.struct)([(0, Woe.u8)("instruction")]); - function Gbt(t, e, r, n = [], i = Ha) { - let o = rm( - [ - { pubkey: t, isSigner: !1, isWritable: !0 }, - { pubkey: e, isSigner: !1, isWritable: !1 }, - ], - r, - n - ), - a = Buffer.alloc(Vbt.span); - return ( - Vbt.encode({ instruction: Fu.ThawAccount }, a), - new Wbt.TransactionInstruction({ keys: o, programId: i, data: a }) - ); - } - m(); - g(); - var Goe = qe(Sn(), 1); - var $bt = qe(Le(), 1); - var Jbt = (0, Goe.struct)([(0, Goe.u8)("instruction"), dl("amount")]); - function Zbt(t, e, r, n, i = [], o = Ha) { - let a = rm( - [ - { pubkey: t, isSigner: !1, isWritable: !0 }, - { pubkey: e, isSigner: !1, isWritable: !0 }, - ], - r, - i - ), - s = Buffer.alloc(Jbt.span); - return ( - Jbt.encode({ instruction: Fu.Transfer, amount: BigInt(n) }, s), - new $bt.TransactionInstruction({ keys: a, programId: o, data: s }) - ); - } - m(); - g(); - var kN = qe(Sn(), 1); - var PN = qe(Le(), 1); - var Xbt = (0, kN.struct)([ - (0, kN.u8)("instruction"), - (0, kN.u8)("decimals"), - hl("mintAuthority"), - (0, kN.u8)("freezeAuthorityOption"), - hl("freezeAuthority"), - ]); - function Ybt(t, e, r, n, i = Ha) { - let o = [ - { pubkey: t, isSigner: !1, isWritable: !0 }, - { pubkey: PN.SYSVAR_RENT_PUBKEY, isSigner: !1, isWritable: !1 }, - ], - a = Buffer.alloc(Xbt.span); - return ( - Xbt.encode( - { - instruction: Fu.InitializeMint, - decimals: e, - mintAuthority: r, - freezeAuthorityOption: n ? 1 : 0, - freezeAuthority: n || new PN.PublicKey(0), - }, - a - ), - new PN.TransactionInstruction({ keys: o, programId: i, data: a }) - ); - } - var r6e = { name: "TokenProgram", address: Ha }, - FH = { name: "AssociatedTokenProgram", address: Coe }; - m(); - g(); - m(); - g(); - m(); - g(); - var Qbt = qe(Le(), 1); - var NOr = "CreateMintOperation", - Joe = ot(NOr), - e1t = { - async handle(t, e, r) { - let n = await n6e(e, t.input, r); - r.throwIfCanceled(); - let i = go(e, r.confirmOptions), - o = await n.sendAndConfirm(e, i); - r.throwIfCanceled(); - let a = await e - .tokens() - .findMintByAddress({ address: o.mintSigner.publicKey }, r); - return { ...o, mint: a }; - }, - }, - n6e = async (t, e, r = {}) => { - var n, i; - let { programs: o, payer: a = t.rpc().getDefaultFeePayer() } = r, - { - decimals: s = 0, - mint: c = Qbt.Keypair.generate(), - mintAuthority: u = t.identity().publicKey, - freezeAuthority: h = u, - } = e, - w = t.programs().getToken(o); - return ct - .make() - .setFeePayer(a) - .setContext({ mintSigner: c }) - .add( - await t - .system() - .builders() - .createAccount( - { - newAccount: c, - space: t6e, - program: w.address, - instructionKey: - (n = e.createAccountInstructionKey) !== null && n !== void 0 - ? n - : "createAccount", - }, - { payer: a, programs: o } - ) - ) - .add({ - instruction: Ybt(c.publicKey, s, u, h, w.address), - signers: [c], - key: - (i = e.initializeMintInstructionKey) !== null && i !== void 0 - ? i - : "initializeMint", - }); - }; - m(); - g(); - m(); - g(); - var t1t = qe(Le(), 1), - DOr = qe(Le(), 1), - Jt = (t) => - typeof t == "object" && "publicKey" in t - ? t.publicKey - : typeof t == "object" && "address" in t - ? t.address - : new t1t.PublicKey(t); - var FOr = "CreateTokenOperation", - $oe = ot(FOr), - r1t = { - async handle(t, e, r) { - let n = await i6e(e, t.input, r); - r.throwIfCanceled(); - let i = go(e, r.confirmOptions), - o = await n.sendAndConfirm(e, i); - r.throwIfCanceled(); - let a = await e - .tokens() - .findTokenByAddress({ address: o.tokenAddress }, r); - return { ...o, token: a }; - }, - }, - i6e = async (t, e, r = {}) => { - var n, i; - let { programs: o, payer: a = t.rpc().getDefaultFeePayer() } = r, - { mint: s, owner: c = t.identity().publicKey, token: u } = e, - h = t.programs().getToken(o), - w = t.programs().getAssociatedToken(o), - M = u === void 0, - k = ct.make().setFeePayer(a); - if (M) { - var O; - let D = t - .tokens() - .pdas() - .associatedTokenAccount({ mint: s, owner: c, programs: o }); - return k.setContext({ tokenAddress: D }).add({ - instruction: Nbt(a.publicKey, D, c, s, h.address, w.address), - signers: [a], - key: - (O = e.createAssociatedTokenAccountInstructionKey) !== null && - O !== void 0 - ? O - : "createAssociatedTokenAccount", - }); - } - return k - .setFeePayer(a) - .setContext({ tokenAddress: u.publicKey }) - .add( - await t - .system() - .builders() - .createAccount( - { - newAccount: u, - space: Loe, - program: h.address, - instructionKey: - (n = e.createAccountInstructionKey) !== null && n !== void 0 - ? n - : "createAccount", - }, - { payer: a, programs: o } - ) - ) - .add({ - instruction: Rbt(u.publicKey, s, c, h.address), - signers: [u], - key: - (i = e.initializeTokenInstructionKey) !== null && i !== void 0 - ? i - : "initializeToken", - }); - }, - n1t = async (t, e, r = {}) => { - let { programs: n, payer: i = t.rpc().getDefaultFeePayer() } = r, - { - mint: o, - owner: a = t.identity().publicKey, - token: s, - tokenExists: c = !0, - tokenVariable: u = "token", - } = e, - h = - s ?? - t - .tokens() - .pdas() - .associatedTokenAccount({ mint: o, owner: a, programs: n }), - w = Jt(h), - M = ct.make().setFeePayer(i).setContext({ tokenAddress: w }); - if (c) return M; - if (s && !kr(s)) - throw new xy(u, "PublicKey", { - problemSuffix: `The provided "${u}" account at address [${w}] does not exist. Therefore, it needs to be created and passed as a Signer.`, - solution: `If you want to create the "${u}" account, then please pass it as a Signer. Alternatively, you can pass the owner account as a PublicKey instead to use (or create) an associated token account.`, - }); - return M.add( - await t - .tokens() - .builders() - .createToken( - { ...e, mint: o, owner: a, token: s }, - { programs: n, payer: i } - ) - ); - }; - m(); - g(); - var i1t = qe(Le(), 1); - m(); - g(); - var Zoe = class extends Mu { - constructor(e) { - super({ - ...e, - key: `plugin.token.${e.key}`, - title: `Token > ${e.title}`, - source: "plugin", - sourceDetails: "Token", - }); - } - }, - Xoe = class extends Zoe { - constructor(e) { - super({ - options: e, - key: "mint_authority_must_be_signer_to_mint_initial_supply", - title: "Mint Authority Must Be Signer To Mint Initial Supply", - problem: - "You are trying to create a Mint and a Token account and to send an initial supply of token to the newly created Token account. The issue is, you have provided a Mint Authority as a Public Key which means we don't have the rights to send this transaction.", - solution: - 'Please provide the Mint Authority as a Signer when using the "createTokenWithMint" operation , so we can send the initial supply. Alternative, remove the initial supply from the operation for it to succeed.', - }); - } - }, - Yoe = class extends Zoe { - constructor(e, r, n, i) { - super({ - options: i, - key: "token_and_mint_do_not_match", - title: "Token And Mint Do Not Match", - problem: `The provided Token and Mint accounts do not match. That is, the mint address [${r}] stored in the Token account [${e}] do not match the address of the Mint account [${n}]. `, - solution: - "Please provide a Token account that belongs to the provided Mint account.", - }); - } - }; - var LOr = "CreateTokenWithMintOperation", - Qoe = ot(LOr), - o1t = { - async handle(t, e, r) { - let n = await o6e(e, t.input, r); - r.throwIfCanceled(); - let i = go(e, r.confirmOptions), - o = await n.sendAndConfirm(e, i); - r.throwIfCanceled(); - let a = await e.tokens().findTokenWithMintByMint( - { - mint: o.mintSigner.publicKey, - address: o.tokenAddress, - addressType: "token", - }, - r - ); - return { ...o, token: a }; - }, - }, - o6e = async (t, e, r = {}) => { - var n, i, o, a, s; - let { programs: c, payer: u = t.rpc().getDefaultFeePayer() } = r, - { - decimals: h = 0, - initialSupply: w, - mint: M = i1t.Keypair.generate(), - mintAuthority: k = t.identity(), - freezeAuthority: O = t.identity().publicKey, - owner: D = t.identity().publicKey, - token: F, - } = e, - N = await t - .tokens() - .builders() - .createMint( - { - decimals: h, - mint: M, - mintAuthority: Jt(k), - freezeAuthority: O, - createAccountInstructionKey: - (n = e.createMintAccountInstructionKey) !== null && n !== void 0 - ? n - : "createMintAccount", - initializeMintInstructionKey: - (i = e.initializeMintInstructionKey) !== null && i !== void 0 - ? i - : "initializeMint", - }, - { programs: c, payer: u } - ), - q = await t - .tokens() - .builders() - .createToken( - { - mint: M.publicKey, - owner: D, - token: F, - createAssociatedTokenAccountInstructionKey: - (o = e.createAssociatedTokenAccountInstructionKey) !== null && - o !== void 0 - ? o - : "createAssociatedTokenAccount", - createAccountInstructionKey: - (a = e.createTokenAccountInstructionKey) !== null && - a !== void 0 - ? a - : "createTokenAccount", - initializeTokenInstructionKey: - (s = e.initializeTokenInstructionKey) !== null && s !== void 0 - ? s - : "initializeToken", - }, - { payer: u, programs: c } - ), - { tokenAddress: z } = q.getContext(), - H = ct - .make() - .setFeePayer(u) - .setContext({ mintSigner: M, tokenAddress: z }) - .add(N) - .add(q); - if (w) { - var Z; - if (!kr(k)) throw new Xoe(); - H.add( - await t - .tokens() - .builders() - .mint( - { - mintAddress: M.publicKey, - toToken: z, - amount: w, - mintAuthority: k, - mintTokensInstructionKey: - (Z = e.mintTokensInstructionKey) !== null && Z !== void 0 - ? Z - : "mintTokens", - }, - { payer: u, programs: c } - ) - ); - } - return H; - }; - m(); - g(); - var qOr = "MintTokensOperation", - eae = ot(qOr), - a1t = { - async handle(t, e, r) { - let { programs: n, confirmOptions: i } = r, - { - mintAddress: o, - toOwner: a = e.identity().publicKey, - toToken: s, - } = t.input, - c = - s ?? - e - .tokens() - .pdas() - .associatedTokenAccount({ mint: o, owner: a, programs: n }), - u = Jt(c), - h = await e.rpc().accountExists(u); - r.throwIfCanceled(); - let w = await a6e(e, { ...t.input, toTokenExists: h }, r); - return r.throwIfCanceled(), w.sendAndConfirm(e, i); - }, - }, - a6e = async (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - mintAddress: a, - amount: s, - toOwner: c = t.identity().publicKey, - toToken: u, - toTokenExists: h = !0, - mintAuthority: w = t.identity(), - multiSigners: M = [], - } = e, - [k, O] = kr(w) ? [w.publicKey, [w]] : [w, M], - D = t.programs().getToken(i), - F = - u ?? - t - .tokens() - .pdas() - .associatedTokenAccount({ mint: a, owner: c, programs: i }); - return ct - .make() - .add( - await t - .tokens() - .builders() - .createTokenIfMissing( - { - ...e, - mint: a, - owner: c, - token: u, - tokenExists: h, - tokenVariable: "toToken", - }, - { payer: o, programs: i } - ) - ) - .add({ - instruction: jbt(a, Jt(F), k, s.basisPoints.toNumber(), M, D.address), - signers: O, - key: - (n = e.mintTokensInstructionKey) !== null && n !== void 0 - ? n - : "mintTokens", - }); - }; - m(); - g(); - var zOr = "SendTokensOperation", - tae = ot(zOr), - s1t = { - async handle(t, e, r) { - let { - mintAddress: n, - toOwner: i = e.identity().publicKey, - toToken: o, - } = t.input, - a = - o ?? - e.tokens().pdas().associatedTokenAccount({ - mint: n, - owner: i, - programs: r.programs, - }), - s = Jt(a), - c = await e.rpc().accountExists(s); - r.throwIfCanceled(); - let u = await s6e(e, { ...t.input, toTokenExists: c }, r); - return r.throwIfCanceled(), u.sendAndConfirm(e, r.confirmOptions); - }, - }, - s6e = async (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - mintAddress: a, - amount: s, - toOwner: c = t.identity().publicKey, - toToken: u, - toTokenExists: h = !0, - fromOwner: w = t.identity(), - fromToken: M, - fromMultiSigners: k = [], - delegateAuthority: O, - } = e, - [D, F] = kr(w) ? [w.publicKey, [w]] : [w, [O, ...k].filter(kr)], - N = t.programs().getToken(i), - q = - M ?? - t - .tokens() - .pdas() - .associatedTokenAccount({ mint: a, owner: D, programs: i }), - z = - u ?? - t - .tokens() - .pdas() - .associatedTokenAccount({ mint: a, owner: c, programs: i }); - return ct - .make() - .setFeePayer(o) - .add( - await t - .tokens() - .builders() - .createTokenIfMissing( - { - ...e, - mint: a, - owner: c, - token: u, - tokenExists: h, - tokenVariable: "toToken", - }, - { programs: i, payer: o } - ) - ) - .add({ - instruction: Zbt( - q, - Jt(z), - O ? O.publicKey : D, - s.basisPoints.toNumber(), - k, - N.address - ), - signers: F, - key: - (n = e.transferTokensInstructionKey) !== null && n !== void 0 - ? n - : "transferTokens", - }); - }; - m(); - g(); - var jOr = "FreezeTokensOperation", - rae = ot(jOr), - u1t = { - async handle(t, e, r) { - return u6e(e, t.input, r).sendAndConfirm(e, r.confirmOptions); - }, - }, - u6e = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - mintAddress: a, - tokenOwner: s = t.identity().publicKey, - tokenAddress: c, - multiSigners: u = [], - freezeAuthority: h, - } = e, - [w, M] = kr(h) ? [h.publicKey, [h]] : [h, u], - k = t.programs().getToken(i), - O = - c ?? - t - .tokens() - .pdas() - .associatedTokenAccount({ mint: a, owner: s, programs: i }); - return ct - .make() - .setFeePayer(o) - .add({ - instruction: Lbt(O, a, w, u, k.address), - signers: M, - key: - (n = e.instructionKey) !== null && n !== void 0 - ? n - : "freezeTokens", - }); - }; - m(); - g(); - var UOr = "ThawTokensOperation", - nae = ot(UOr), - c1t = { - async handle(t, e, r) { - return c6e(e, t.input, r).sendAndConfirm(e, r.confirmOptions); - }, - }, - c6e = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - mintAddress: a, - tokenOwner: s = t.identity().publicKey, - tokenAddress: c, - multiSigners: u = [], - freezeAuthority: h, - } = e, - [w, M] = kr(h) ? [h.publicKey, [h]] : [h, u], - k = t.programs().getToken(i), - O = - c ?? - t - .tokens() - .pdas() - .associatedTokenAccount({ mint: a, owner: s, programs: i }); - return ct - .make() - .setFeePayer(o) - .add({ - instruction: Gbt(O, a, w, u, k.address), - signers: M, - key: - (n = e.instructionKey) !== null && n !== void 0 ? n : "thawTokens", - }); - }; - m(); - g(); - var KOr = "ApproveTokenDelegateAuthorityOperation", - iae = ot(KOr), - l1t = { - handle: async (t, e, r) => - l6e(e, t.input, r).sendAndConfirm(e, r.confirmOptions), - }, - l6e = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - mintAddress: a, - delegateAuthority: s, - amount: c = Jo(1), - owner: u = t.identity(), - tokenAddress: h, - multiSigners: w = [], - } = e, - [M, k] = kr(u) ? [u.publicKey, [u]] : [u, w], - O = t.programs().getToken(i), - D = - h ?? - t - .tokens() - .pdas() - .associatedTokenAccount({ mint: a, owner: M, programs: i }); - return ct - .make() - .setFeePayer(o) - .add({ - instruction: Bbt(D, s, M, c.basisPoints.toNumber(), w, O.address), - signers: k, - key: - (n = e.instructionKey) !== null && n !== void 0 - ? n - : "approveDelegateAuthority", - }); - }; - m(); - g(); - var HOr = "RevokeTokenDelegateAuthorityOperation", - oae = ot(HOr), - f1t = { - handle: async (t, e, r) => - f6e(e, t.input, r).sendAndConfirm(e, r.confirmOptions), - }, - f6e = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - mintAddress: a, - owner: s = t.identity(), - tokenAddress: c, - multiSigners: u = [], - } = e, - [h, w] = kr(s) ? [s.publicKey, [s]] : [s, u], - M = t.programs().getToken(i), - k = - c ?? - t - .tokens() - .pdas() - .associatedTokenAccount({ mint: a, owner: h, programs: i }); - return ct - .make() - .setFeePayer(o) - .add({ - instruction: Hbt(k, h, u, M.address), - signers: w, - key: - (n = e.instructionKey) !== null && n !== void 0 - ? n - : "revokeDelegateAuthority", - }); - }; - var aae = class { - constructor(e) { - this.metaplex = e; - } - createMint(e, r) { - return n6e(this.metaplex, e, r); - } - createToken(e, r) { - return i6e(this.metaplex, e, r); - } - createTokenIfMissing(e, r) { - return n1t(this.metaplex, e, r); - } - createTokenWithMint(e, r) { - return o6e(this.metaplex, e, r); - } - mint(e, r) { - return a6e(this.metaplex, e, r); - } - send(e, r) { - return s6e(this.metaplex, e, r); - } - freeze(e, r) { - return u6e(this.metaplex, e, r); - } - thaw(e, r) { - return c6e(this.metaplex, e, r); - } - approveDelegateAuthority(e, r) { - return l6e(this.metaplex, e, r); - } - revokeDelegateAuthority(e, r) { - return f6e(this.metaplex, e, r); - } - }; - m(); - g(); - m(); - g(); - var d6e = qe(Le(), 1), - Br = class extends d6e.PublicKey { - constructor(e, r) { - super(e), (this.bump = r); - } - static find(e, r) { - let [n, i] = d6e.PublicKey.findProgramAddressSync(r, e); - return new Br(n, i); - } - }; - var sae = class { - constructor(e) { - this.metaplex = e; - } - associatedTokenAccount({ mint: e, owner: r, programs: n }) { - let i = this.metaplex.programs().getToken(n), - o = this.metaplex.programs().getAssociatedToken(n); - return Br.find(o.address, [ - r.toBuffer(), - i.address.toBuffer(), - e.toBuffer(), - ]); - } - }; - m(); - g(); - m(); - g(); - m(); - g(); - m(); - g(); - var Lx = qe(Wt(), 1); - var Ps = (t, e, r) => ({ - description: t.description, - serialize: (n) => t.serialize(r(n)), - deserialize: (n, i) => { - let [o, a] = t.deserialize(n, i); - return [e(o), a]; - }, - }), - Di = (t) => ({ - description: t.description, - serialize: (e) => { - let r = Lx.isFixableBeet(t) ? t.toFixedFromValue(e) : t, - n = new Lx.BeetWriter(r.byteSize); - return n.write(r, e), n.buffer; - }, - deserialize: (e, r) => { - let n = Lx.isFixableBeet(t) ? t.toFixedFromData(e, r ?? 0) : t, - i = new Lx.BeetReader(e, r ?? 0); - return [i.read(n), i.offset]; - }, - }), - WN = (t, e) => ({ - description: e ?? t.name, - serialize: (r) => t.fromArgs(r).serialize()[0], - deserialize: (r, n) => t.deserialize(r, n), - }), - z1t = (t, e) => { - try { - return e.serialize(t); - } catch (r) { - throw new lee(e.description, { cause: r }); - } - }, - j1t = (t, e) => { - try { - return e.deserialize(t); - } catch (r) { - throw new dee(e.description, { cause: r }); - } - }; - function GN(t, e) { - if ("exists" in t && !t.exists) return t; - try { - let r = e.deserialize(t.data)[0]; - return { ...t, data: r }; - } catch (r) { - throw new see(t.publicKey, e.description, { cause: r }); - } - } - function Lu(t) { - function e(r) { - if ("exists" in r && !r.exists) return r; - let n = WN(t); - return GN(r, n); - } - return e; - } - function wc(t) { - let e = Lu(t); - return (r, n) => ("exists" in r && $b(r, t.name, n), e(r)); - } - function $b(t, e, r) { - if (!t.exists) throw new aee(t.publicKey, e, { solution: r }); - } - var wae = (t) => { - let { executable: e, owner: r, lamports: n, rentEpoch: i } = t; - return { executable: e, owner: r, lamports: n, rentEpoch: i }; - }; - var U1t = { - name: "MintAccount", - deserialize: (t, e) => { - let r = qoe.getSpan(t, e); - return [qoe.decode(t, e), r]; - }, - fromArgs() { - throw new iA(); - }, - }, - M2n = Lu(U1t), - Zb = wc(U1t), - K1t = { - name: "TokenAccount", - deserialize: (t, e) => { - let r = Foe.getSpan(t, e); - return [Foe.decode(t, e), r]; - }, - fromArgs() { - throw new iA(); - }, - }, - T2n = Lu(K1t), - Xb = wc(K1t); - m(); - g(); - m(); - g(); - var H1t = qe(Le(), 1), - jH = new H1t.PublicKey("So11111111111111111111111111111111111111112"); - var Yb = (t) => { - let e = t.publicKey.equals(jH), - r = { - symbol: e ? "SOL" : "Token", - decimals: t.data.decimals, - namespace: "spl-token", - }; - return { - model: "mint", - address: t.publicKey, - mintAuthorityAddress: t.data.mintAuthorityOption - ? t.data.mintAuthority - : null, - freezeAuthorityAddress: t.data.freezeAuthorityOption - ? t.data.freezeAuthority - : null, - decimals: t.data.decimals, - supply: ci(t.data.supply.toString(), r), - isWrappedSol: e, - currency: r, - }; - }; - var ZBr = "FindMintByAddressOperation", - _ae = ot(ZBr), - V1t = { - handle: async (t, e, r) => { - let { commitment: n } = r, - { address: i } = t.input, - o = Zb(await e.rpc().getAccount(i, n)); - return Yb(o); - }, - }; - m(); - g(); - m(); - g(); - var UH = (t) => { - let e = Br.find(FH.address, [ - t.data.owner.toBuffer(), - t.owner.toBuffer(), - t.data.mint.toBuffer(), - ]), - r = e.equals(t.publicKey); - return { - model: "token", - address: r ? e : t.publicKey, - isAssociatedToken: r, - mintAddress: t.data.mint, - ownerAddress: t.data.owner, - amount: Jo(t.data.amount.toString()), - closeAuthorityAddress: t.data.closeAuthorityOption - ? t.data.closeAuthority - : null, - delegateAddress: t.data.delegateOption ? t.data.delegate : null, - delegateAmount: Jo(t.data.delegatedAmount.toString()), - state: t.data.state, - }; - }; - var xae = (t, e) => { - let r = UH(t); - return { - ...r, - model: "tokenWithMint", - mint: e, - amount: ci(r.amount.basisPoints, e.currency), - delegateAmount: ci(r.delegateAmount.basisPoints, e.currency), - }; - }; - var XBr = "FindTokenByAddressOperation", - Sae = ot(XBr), - W1t = { - handle: async (t, e, r) => { - let { commitment: n } = r, - { address: i } = t.input, - o = Xb(await e.rpc().getAccount(i, n)); - return UH(o); - }, - }; - m(); - g(); - var YBr = "FindTokenWithMintByAddressOperation", - Aae = ot(YBr), - G1t = { - handle: async (t, e, r) => { - let { commitment: n } = r, - { address: i } = t.input, - o = Xb(await e.rpc().getAccount(i, n)), - a = Zb(await e.rpc().getAccount(o.data.mint, n)); - return xae(o, Yb(a)); - }, - }; - m(); - g(); - var QBr = "FindTokenWithMintByMintOperation", - Eae = ot(QBr), - J1t = { - handle: async (t, e, r) => { - let { commitment: n, programs: i } = r, - { mint: o, address: a, addressType: s } = t.input, - c = - s === "owner" - ? e - .tokens() - .pdas() - .associatedTokenAccount({ mint: o, owner: a, programs: i }) - : a, - u = await e.rpc().getMultipleAccounts([o, c], n), - h = Zb(u[0]), - w = Xb(u[1]); - if (!w.data.mint.equals(o)) throw new Yoe(c, w.data.mint, o); - return xae(w, Yb(h)); - }, - }; - var Mae = class { - constructor(e) { - this.metaplex = e; - } - builders() { - return new aae(this.metaplex); - } - pdas() { - return new sae(this.metaplex); - } - findMintByAddress(e, r) { - return this.metaplex.operations().execute(_ae(e), r); - } - findTokenByAddress(e, r) { - return this.metaplex.operations().execute(Sae(e), r); - } - findTokenWithMintByAddress(e, r) { - return this.metaplex.operations().execute(Aae(e), r); - } - findTokenWithMintByMint(e, r) { - return this.metaplex.operations().execute(Eae(e), r); - } - createMint(e = {}, r) { - return this.metaplex.operations().execute(Joe(e), r); - } - createToken(e, r) { - return this.metaplex.operations().execute($oe(e), r); - } - createTokenWithMint(e = {}, r) { - return this.metaplex.operations().execute(Qoe(e), r); - } - mint(e, r) { - return this.metaplex.operations().execute(eae(e), r); - } - send(e, r) { - return this.metaplex.operations().execute(tae(e), r); - } - freeze(e, r) { - return this.metaplex.operations().execute(rae(e), r); - } - thaw(e, r) { - return this.metaplex.operations().execute(nae(e), r); - } - approveDelegateAuthority(e, r) { - return this.metaplex.operations().execute(iae(e), r); - } - revokeDelegateAuthority(e, r) { - return this.metaplex.operations().execute(oae(e), r); - } - }; - var $1t = () => ({ - install(t) { - t.programs().register(r6e), - (t.programs().getToken = function (r) { - return this.get(r6e.name, r); - }), - t.programs().register(FH), - (t.programs().getAssociatedToken = function (r) { - return this.get(FH.name, r); - }); - let e = t.operations(); - e.register(iae, l1t), - e.register(Joe, e1t), - e.register($oe, r1t), - e.register(Qoe, o1t), - e.register(_ae, V1t), - e.register(Sae, W1t), - e.register(Aae, G1t), - e.register(Eae, J1t), - e.register(rae, u1t), - e.register(eae, a1t), - e.register(oae, f1t), - e.register(tae, s1t), - e.register(nae, c1t), - (t.tokens = function () { - return new Mae(this); - }); - }, - }); - m(); - g(); - var Nue = qe(hs(), 1); - m(); - g(); - m(); - g(); - var $At = (t) => - typeof t == "object" && "mintAddress" in t ? t.mintAddress : Jt(t); - m(); - g(); - m(); - g(); - var rEt = qe(hs(), 1), - oPe = qe(Le(), 1); - m(); - g(); - m(); - g(); - var ZAt = (t) => typeof t == "object" && t.model === "sft"; - function XAt(t) { - ba(ZAt(t), "Expected Sft model"); - } - var tV = (t, e) => { - let { address: r, mintAddress: n, ...i } = t; - ba( - n.equals(e.address), - "The provided mint does not match the mint address in the metadata" - ); - let o = { ...e.currency, symbol: t.symbol || "Token" }; - return { - ...i, - model: "sft", - address: n, - metadataAddress: r, - mint: { ...e, currency: o, supply: ci(e.supply.basisPoints, o) }, - }; - }, - YAt = (t) => ZAt(t) && "token" in t; - var Ise = (t, e, r) => { - let n = tV(t, e), - { currency: i } = n.mint; - return { - ...n, - token: { - ...r, - amount: ci(r.amount.basisPoints, i), - delegateAmount: ci(r.delegateAmount.basisPoints, i), - }, - }; - }; - var Cqr = (t) => typeof t == "object" && t.model === "nft"; - var QAt = (t, e, r) => ({ ...tV(t, e), model: "nft", edition: r }), - eEt = (t) => Cqr(t) && "token" in t; - function Cse(t) { - ba(eEt(t), "Expected Nft model with token"); - } - function A9(t) { - ba(eEt(t) || YAt(t), "Expected Nft or Sft model with token"); - } - var tEt = (t, e, r, n) => ({ ...Ise(t, e, n), model: "nft", edition: r }); - var Rqr = "CreateNftOperation", - Rse = ot(Rqr), - nEt = { - handle: async (t, e, r) => { - let { - useNewMint: n = oPe.Keypair.generate(), - useExistingMint: i, - tokenOwner: o = e.identity().publicKey, - tokenAddress: a, - } = t.input, - s = i ?? n.publicKey, - c = a - ? Jt(a) - : e.tokens().pdas().associatedTokenAccount({ - mint: s, - owner: o, - programs: r.programs, - }), - h = (await e.rpc().getAccount(c)).exists, - w = await aPe( - e, - { ...t.input, useNewMint: n, tokenOwner: o, tokenExists: h }, - r - ); - r.throwIfCanceled(); - let M = go(e, r.confirmOptions), - k = await w.sendAndConfirm(e, M); - r.throwIfCanceled(); - let O = await e - .nfts() - .findByMint( - { mintAddress: k.mintAddress, tokenAddress: k.tokenAddress }, - r - ); - return r.throwIfCanceled(), Cse(O), { ...k, nft: O }; - }, - }, - aPe = async (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - useNewMint: a = oPe.Keypair.generate(), - updateAuthority: s = t.identity(), - mintAuthority: c = t.identity(), - tokenOwner: u = t.identity().publicKey, - } = e, - h = t.programs().getTokenMetadata(i), - w = await t - .nfts() - .builders() - .createSft( - { - ...e, - updateAuthority: s, - mintAuthority: c, - freezeAuthority: c.publicKey, - useNewMint: a, - tokenOwner: u, - tokenAmount: Jo(1), - decimals: 0, - }, - { programs: i, payer: o } - ), - { - mintAddress: M, - metadataAddress: k, - tokenAddress: O, - } = w.getContext(), - D = t.nfts().pdas().masterEdition({ mint: M, programs: i }); - return ct - .make() - .setFeePayer(o) - .setContext({ - mintAddress: M, - metadataAddress: k, - masterEditionAddress: D, - tokenAddress: O, - }) - .add(w) - .add({ - instruction: (0, rEt.createCreateMasterEditionV3Instruction)( - { - edition: D, - mint: M, - updateAuthority: s.publicKey, - mintAuthority: c.publicKey, - payer: o.publicKey, - metadata: k, - }, - { - createMasterEditionArgs: { - maxSupply: e.maxSupply === void 0 ? 0 : e.maxSupply, - }, - }, - h.address - ), - signers: [o, c, s], - key: - (n = e.createMasterEditionInstructionKey) !== null && n !== void 0 - ? n - : "createMasterEdition", - }); - }; - m(); - g(); - var iEt = qe(hs(), 1), - sPe = qe(Le(), 1); - var Nqr = "CreateSftOperation", - Nse = ot(Nqr), - oEt = { - handle: async (t, e, r) => { - var n; - let { - useNewMint: i = sPe.Keypair.generate(), - useExistingMint: o, - tokenOwner: a, - tokenAddress: s, - } = t.input, - c = o ?? i.publicKey, - u = a - ? e.tokens().pdas().associatedTokenAccount({ - mint: c, - owner: a, - programs: r.programs, - }) - : null, - h = s ? Jt(s) : u, - w; - !!o && !!h ? (w = (await e.rpc().getAccount(h)).exists) : (w = !1); - let M = await uPe(e, { ...t.input, useNewMint: i, tokenExists: w }, r); - r.throwIfCanceled(); - let k = go(e, r.confirmOptions), - O = await M.sendAndConfirm(e, k); - r.throwIfCanceled(); - let D = await e.nfts().findByMint( - { - mintAddress: O.mintAddress, - tokenAddress: - (n = O.tokenAddress) !== null && n !== void 0 ? n : void 0, - }, - r - ); - return r.throwIfCanceled(), XAt(D), { ...O, sft: D }; - }, - }, - uPe = async (t, e, r = {}) => { - var n, i, o, a, s; - let { programs: c, payer: u = t.rpc().getDefaultFeePayer() } = r, - { - useNewMint: h = sPe.Keypair.generate(), - updateAuthority: w = t.identity(), - mintAuthority: M = t.identity(), - } = e, - k = await Dqr(t, e, { programs: c, payer: u }, h), - { mintAddress: O, tokenAddress: D } = k.getContext(), - F = t.programs().getTokenMetadata(c), - N = t.nfts().pdas().metadata({ mint: O, programs: c }), - q = - (n = e.creators) !== null && n !== void 0 - ? n - : [{ address: w.publicKey, authority: w, share: 100 }], - z = - q.length > 0 - ? q.map(($) => ({ ...$, verified: $.address.equals(w.publicKey) })) - : null, - H = (0, iEt.createCreateMetadataAccountV3Instruction)( - { - metadata: N, - mint: O, - mintAuthority: M.publicKey, - payer: u.publicKey, - updateAuthority: w.publicKey, - }, - { - createMetadataAccountArgsV3: { - data: { - name: e.name, - symbol: (i = e.symbol) !== null && i !== void 0 ? i : "", - uri: e.uri, - sellerFeeBasisPoints: e.sellerFeeBasisPoints, - creators: z, - collection: e.collection - ? { key: e.collection, verified: !1 } - : null, - uses: (o = e.uses) !== null && o !== void 0 ? o : null, - }, - isMutable: (a = e.isMutable) !== null && a !== void 0 ? a : !0, - collectionDetails: e.isCollection - ? { __kind: "V1", size: 0 } - : null, - }, - }, - F.address - ); - H.keys[4].isSigner = !0; - let Z = q - .filter(($) => !!$.authority && !$.address.equals(w.publicKey)) - .map(($) => - t - .nfts() - .builders() - .verifyCreator( - { mintAddress: O, creator: $.authority }, - { programs: c, payer: u } - ) - ); - return ct - .make() - .setFeePayer(u) - .setContext({ mintAddress: O, metadataAddress: N, tokenAddress: D }) - .add(k) - .add({ - instruction: H, - signers: [u, M, w], - key: - (s = e.createMetadataInstructionKey) !== null && s !== void 0 - ? s - : "createMetadata", - }) - .add(...Z) - .when(!!e.collection && !!e.collectionAuthority, ($) => { - var ue, te; - return $.add( - t - .nfts() - .builders() - .verifyCollection( - { - mintAddress: O, - collectionMintAddress: e.collection, - collectionAuthority: e.collectionAuthority, - isDelegated: - (ue = e.collectionAuthorityIsDelegated) !== null && - ue !== void 0 - ? ue - : !1, - isSizedCollection: - (te = e.collectionIsSized) !== null && te !== void 0 - ? te - : !0, - }, - { payer: u, programs: c } - ) - ); - }); - }, - Dqr = async (t, e, r, n) => { - var i; - let { programs: o, payer: a = t.rpc().getDefaultFeePayer() } = r, - { - mintAuthority: s = t.identity(), - freezeAuthority: c = t.identity().publicKey, - tokenExists: u = !1, - } = e, - h = (i = e.useExistingMint) !== null && i !== void 0 ? i : n.publicKey, - w = e.tokenOwner - ? t.tokens().pdas().associatedTokenAccount({ - mint: h, - owner: e.tokenOwner, - programs: o, - }) - : null, - M = e.tokenAddress ? Jt(e.tokenAddress) : w, - k = ct - .make() - .setFeePayer(a) - .setContext({ mintAddress: h, tokenAddress: M }); - if (!e.useExistingMint) { - var O; - k.add( - await t - .tokens() - .builders() - .createMint( - { - decimals: (O = e.decimals) !== null && O !== void 0 ? O : 0, - mint: n, - mintAuthority: s.publicKey, - freezeAuthority: c, - createAccountInstructionKey: e.createMintAccountInstructionKey, - initializeMintInstructionKey: e.initializeMintInstructionKey, - }, - { programs: o, payer: a } - ) - ); - } - let D = !!e.tokenAddress && kr(e.tokenAddress), - F = !!e.tokenOwner; - return ( - !u && - (D || F) && - k.add( - await t.tokens().builders().createToken( - { - mint: h, - owner: e.tokenOwner, - token: e.tokenAddress, - createAssociatedTokenAccountInstructionKey: - e.createAssociatedTokenAccountInstructionKey, - createAccountInstructionKey: e.createTokenAccountInstructionKey, - initializeTokenInstructionKey: e.initializeTokenInstructionKey, - }, - { programs: o, payer: a } - ) - ), - M && - e.tokenAmount && - k.add( - await t.tokens().builders().mint( - { - mintAddress: h, - toToken: M, - toTokenExists: !0, - amount: e.tokenAmount, - mintAuthority: s, - mintTokensInstructionKey: e.mintTokensInstructionKey, - }, - { programs: o, payer: a } - ) - ), - k - ); - }; - m(); - g(); - var cEt = qe(hs(), 1), - hPe = qe(Le(), 1); - m(); - g(); - var xc = qe(hs(), 1); - var Fqr = Lu(xc.Metadata), - p0 = wc(xc.Metadata), - aEt = { - name: "MasterEditionV1 | MasterEditionV2 | Edition", - deserialize: (t, e = 0) => - t?.[0] === xc.Key.MasterEditionV1 - ? xc.MasterEditionV1.deserialize(t, e) - : t?.[0] === xc.Key.MasterEditionV2 - ? xc.MasterEditionV2.deserialize(t, e) - : xc.Edition.deserialize(t, e), - fromArgs() { - throw new iA(); - }, - }, - cPe = Lu(aEt), - Lqr = wc(aEt), - lPe = (t) => "maxSupply" in t.data; - var sEt = { - name: "MasterEditionV1 | MasterEditionV2", - deserialize: (t, e = 0) => - t?.[0] === xc.Key.MasterEditionV1 - ? xc.MasterEditionV1.deserialize(t, e) - : xc.MasterEditionV2.deserialize(t, e), - fromArgs() { - throw new iA(); - }, - }, - qqr = Lu(sEt), - fPe = wc(sEt), - zqr = Lu(xc.Edition), - jqr = wc(xc.Edition); - m(); - g(); - var uEt = (t) => (lPe(t) ? dPe(t) : Uqr(t)); - var dPe = (t) => ({ - model: "nftEdition", - isOriginal: !0, - address: t.publicKey, - supply: Sr(t.data.supply), - maxSupply: ett(t.data.maxSupply), - }); - var Uqr = (t) => ({ - model: "nftEdition", - isOriginal: !1, - address: t.publicKey, - parent: t.data.parent, - number: Sr(t.data.edition), - }); - var Kqr = "PrintNewEditionOperation", - Dse = ot(Kqr), - lEt = { - handle: async (t, e, r) => { - let n = await e.rpc().getAccount( - e.nfts().pdas().masterEdition({ - mint: t.input.originalMint, - programs: r.programs, - }) - ); - r.throwIfCanceled(); - let i = dPe(fPe(n)), - o = await pPe(e, { ...t.input, originalSupply: i.supply }, r); - r.throwIfCanceled(); - let a = go(e, r.confirmOptions), - s = await o.sendAndConfirm(e, a); - r.throwIfCanceled(); - let c = await e.nfts().findByMint( - { - mintAddress: s.mintSigner.publicKey, - tokenAddress: s.tokenAddress, - }, - r - ); - return r.throwIfCanceled(), Cse(c), { ...s, nft: c }; - }, - }, - pPe = async (t, e, r = {}) => { - var n, i; - let { programs: o, payer: a = t.rpc().getDefaultFeePayer() } = r, - { - originalMint: s, - newMint: c = hPe.Keypair.generate(), - newUpdateAuthority: u = t.identity().publicKey, - newOwner: h = t.identity().publicKey, - newTokenAccount: w, - printNewEditionInstructionKey: M = "printNewEdition", - } = e, - k = t.programs().getTokenMetadata(o), - O = t.nfts().pdas().metadata({ mint: s, programs: o }), - D = t.nfts().pdas().masterEdition({ mint: s, programs: o }), - F = Sr(e.originalSupply.addn(1)), - N = t.nfts().pdas().editionMarker({ mint: s, edition: F, programs: o }), - q = hPe.Keypair.generate(), - z = t.nfts().pdas().metadata({ mint: c.publicKey, programs: o }), - H = t.nfts().pdas().edition({ mint: c.publicKey, programs: o }), - Z = { - newMetadata: z, - newEdition: H, - masterEdition: D, - newMint: c.publicKey, - editionMarkPda: N, - newMintAuthority: q.publicKey, - payer: a.publicKey, - newMetadataUpdateAuthority: u, - metadata: O, - }, - $ = await t - .tokens() - .builders() - .createTokenWithMint( - { - decimals: 0, - initialSupply: Jo(1), - mint: c, - mintAuthority: q, - freezeAuthority: q.publicKey, - owner: h, - token: w, - createMintAccountInstructionKey: - e.createMintAccountInstructionKey, - initializeMintInstructionKey: e.initializeMintInstructionKey, - createAssociatedTokenAccountInstructionKey: - e.createAssociatedTokenAccountInstructionKey, - createTokenAccountInstructionKey: - e.createTokenAccountInstructionKey, - initializeTokenInstructionKey: e.initializeTokenInstructionKey, - mintTokensInstructionKey: e.mintTokensInstructionKey, - }, - { payer: a, programs: o } - ), - { tokenAddress: ue } = $.getContext(), - te = - (n = e.originalTokenAccountOwner) !== null && n !== void 0 - ? n - : t.identity(), - ne = - (i = e.originalTokenAccount) !== null && i !== void 0 - ? i - : t.tokens().pdas().associatedTokenAccount({ - mint: s, - owner: te.publicKey, - programs: o, - }); - return ct - .make() - .setFeePayer(a) - .setContext({ - mintSigner: c, - metadataAddress: z, - editionAddress: H, - tokenAddress: ue, - updatedSupply: F, - }) - .add($) - .add({ - instruction: (0, - cEt.createMintNewEditionFromMasterEditionViaTokenInstruction)( - { ...Z, tokenAccountOwner: te.publicKey, tokenAccount: ne }, - { mintNewEditionFromMasterEditionViaTokenArgs: { edition: F } }, - k.address - ), - signers: [c, q, a, te], - key: M, - }); - }; - m(); - g(); - var WEt = qe(hs(), 1), - GEt = qe(Jse(), 1); - var JEt = "UpdateNftOperation", - $se = ot(JEt), - $Et = { - handle: async (t, e, r) => { - let n = MPe(e, t.input, r); - if (n.isEmpty()) throw new Nv(JEt); - return n.sendAndConfirm(e, r.confirmOptions); - }, - }, - MPe = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { nftOrSft: a, updateAuthority: s = t.identity() } = e, - c = t.programs().getTokenMetadata(i), - u = VEt(a), - h = VEt(a, e), - w = !(0, GEt.default)(h, u), - M = !!a.collection && !!a.collection.verified && e.collection === null, - k = - !!a.collection && - !!a.collection.verified && - !!e.collection && - !e.collection.equals(a.collection.address), - O = M || k, - F = ((n = e.creators) !== null && n !== void 0 ? n : a.creators) - .filter((N) => { - var q; - let z = a.creators.find(({ address: Z }) => Z.equals(N.address)), - H = (q = z?.verified) !== null && q !== void 0 ? q : !1; - return !!N.authority && !H; - }) - .map((N) => - t - .nfts() - .builders() - .verifyCreator( - { mintAddress: a.address, creator: N.authority }, - { payer: o, programs: i } - ) - ); - return ct - .make() - .when(O, (N) => { - var q, z; - return N.add( - t - .nfts() - .builders() - .unverifyCollection( - { - mintAddress: a.address, - collectionMintAddress: - (q = a.collection) === null || q === void 0 - ? void 0 - : q.address, - collectionAuthority: s, - isSizedCollection: - (z = e.oldCollectionIsSized) !== null && z !== void 0 - ? z - : !0, - }, - { programs: i, payer: o } - ) - ); - }) - .when(w, (N) => { - var q; - return N.add({ - instruction: (0, WEt.createUpdateMetadataAccountV2Instruction)( - { - metadata: t - .nfts() - .pdas() - .metadata({ mint: a.address, programs: i }), - updateAuthority: s.publicKey, - }, - { updateMetadataAccountArgsV2: h }, - c.address - ), - signers: [s], - key: - (q = e.updateMetadataInstructionKey) !== null && q !== void 0 - ? q - : "updateMetadata", - }); - }) - .add(...F) - .when(!!e.collection && !!e.collectionAuthority, (N) => { - var q, z; - return N.add( - t - .nfts() - .builders() - .verifyCollection( - { - mintAddress: a.address, - collectionMintAddress: e.collection, - collectionAuthority: e.collectionAuthority, - isDelegated: - (q = e.collectionAuthorityIsDelegated) !== null && - q !== void 0 - ? q - : !1, - isSizedCollection: - (z = e.collectionIsSized) !== null && z !== void 0 ? z : !0, - }, - { programs: i, payer: o } - ) - ); - }); - }, - VEt = (t, e = {}) => { - var r, n, i, o, a, s, c; - let u = - e.creators === void 0 - ? t.creators - : e.creators.map((M) => { - var k; - let O = t.creators.find(({ address: D }) => - D.equals(M.address) - ); - return { - ...M, - verified: (k = O?.verified) !== null && k !== void 0 ? k : !1, - }; - }), - h = t.collection - ? { ...t.collection, key: t.collection.address } - : null, - w = e.collection ? { key: e.collection, verified: !1 } : null; - return { - updateAuthority: - (r = e.newUpdateAuthority) !== null && r !== void 0 ? r : null, - primarySaleHappened: - (n = e.primarySaleHappened) !== null && n !== void 0 ? n : null, - isMutable: (i = e.isMutable) !== null && i !== void 0 ? i : null, - data: { - name: (o = e.name) !== null && o !== void 0 ? o : t.name, - symbol: (a = e.symbol) !== null && a !== void 0 ? a : t.symbol, - uri: (s = e.uri) !== null && s !== void 0 ? s : t.uri, - sellerFeeBasisPoints: - (c = e.sellerFeeBasisPoints) !== null && c !== void 0 - ? c - : t.sellerFeeBasisPoints, - creators: u.length > 0 ? u : null, - uses: e.uses === void 0 ? t.uses : e.uses, - collection: e.collection === void 0 ? h : w, - }, - }; - }; - m(); - g(); - var ZEt = qe(hs(), 1); - var wjr = "DeleteNftOperation", - Zse = ot(wjr), - XEt = { - handle: async (t, e, r) => - TPe(e, t.input, r).sendAndConfirm(e, r.confirmOptions), - }, - TPe = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - mintAddress: a, - owner: s = t.identity(), - ownerTokenAccount: c, - collection: u, - } = e, - h = t.programs().getToken(i), - w = t.programs().getTokenMetadata(i), - M = t.nfts().pdas().metadata({ mint: a, programs: i }), - k = t.nfts().pdas().masterEdition({ mint: a, programs: i }), - O = - c ?? - t.tokens().pdas().associatedTokenAccount({ - mint: a, - owner: s.publicKey, - programs: i, - }); - return ct - .make() - .setFeePayer(o) - .add({ - instruction: (0, ZEt.createBurnNftInstruction)( - { - metadata: M, - owner: s.publicKey, - mint: a, - tokenAccount: O, - masterEditionAccount: k, - splTokenProgram: h.address, - collectionMetadata: u - ? t.nfts().pdas().metadata({ mint: u, programs: i }) - : void 0, - }, - w.address - ), - signers: [s], - key: - (n = e.instructionKey) !== null && n !== void 0 ? n : "deleteNft", - }); - }; - m(); - g(); - var YEt = qe(hs(), 1); - var _jr = "UseNftOperation", - Xse = ot(_jr), - QEt = { - handle: async (t, e, r) => - kPe(e, t.input, r).sendAndConfirm(e, r.confirmOptions), - }, - kPe = (t, e, r = {}) => { - var n, i; - let { programs: o, payer: a = t.rpc().getDefaultFeePayer() } = r, - { - mintAddress: s, - numberOfUses: c = 1, - owner: u = t.identity(), - useAuthority: h, - } = e, - w = t.programs().getTokenMetadata(o); - if (!kr(u) && !h) - throw new xy("owner", "PublicKey", { - problemSuffix: - "In order to use an NFT you must either provide the owner as a Signer or a delegated use authority as a Signer.", - }); - let M = t.nfts().pdas().metadata({ mint: s, programs: o }), - k = - (n = e.ownerTokenAccount) !== null && n !== void 0 - ? n - : t - .tokens() - .pdas() - .associatedTokenAccount({ mint: s, owner: Jt(u), programs: o }), - O = h - ? t.nfts().pdas().useAuthorityRecord({ - mint: s, - useAuthority: h.publicKey, - programs: o, - }) - : void 0, - D = t.nfts().pdas().burner({ programs: o }); - return ct - .make() - .setFeePayer(a) - .add({ - instruction: (0, YEt.createUtilizeInstruction)( - { - metadata: M, - tokenAccount: k, - useAuthority: h ? h.publicKey : Jt(u), - mint: s, - owner: Jt(u), - useAuthorityRecord: O, - burner: O ? D : void 0, - }, - { utilizeArgs: { numberOfUses: c } }, - w.address - ), - signers: [u, h].filter(kr), - key: - (i = e.instructionKey) !== null && i !== void 0 ? i : "utilizeNft", - }); - }; - m(); - g(); - var e3t = qe(hs(), 1); - var xjr = "ApproveNftUseAuthorityOperation", - Yse = ot(xjr), - t3t = { - handle: async (t, e, r) => - PPe(e, t.input, r).sendAndConfirm(e, r.confirmOptions), - }, - PPe = (t, e, r = {}) => { - var n, i, o; - let { programs: a, payer: s = t.rpc().getDefaultFeePayer() } = r, - { mintAddress: c, user: u, owner: h = t.identity() } = e, - w = t.programs().getSystem(a), - M = t.programs().getToken(a), - k = t.programs().getTokenMetadata(a), - O = t.nfts().pdas().metadata({ mint: c, programs: a }), - D = t - .nfts() - .pdas() - .useAuthorityRecord({ mint: c, useAuthority: u, programs: a }), - F = t.nfts().pdas().burner({ programs: a }), - N = - (n = e.ownerTokenAddress) !== null && n !== void 0 - ? n - : t.tokens().pdas().associatedTokenAccount({ - mint: c, - owner: h.publicKey, - programs: a, - }); - return ct - .make() - .setFeePayer(s) - .add({ - instruction: (0, e3t.createApproveUseAuthorityInstruction)( - { - useAuthorityRecord: D, - owner: h.publicKey, - payer: s.publicKey, - user: u, - ownerTokenAccount: N, - metadata: O, - mint: c, - burner: F, - tokenProgram: M.address, - systemProgram: w.address, - }, - { - approveUseAuthorityArgs: { - numberOfUses: - (i = e.numberOfUses) !== null && i !== void 0 ? i : 1, - }, - }, - k.address - ), - signers: [h, s], - key: - (o = e.instructionKey) !== null && o !== void 0 - ? o - : "approveUseAuthority", - }); - }; - m(); - g(); - var r3t = qe(hs(), 1); - var Sjr = "RevokeNftUseAuthorityOperation", - Qse = ot(Sjr), - n3t = { - handle: async (t, e, r) => - OPe(e, t.input, r).sendAndConfirm(e, r.confirmOptions), - }, - OPe = (t, e, r = {}) => { - var n, i; - let { programs: o, payer: a = t.rpc().getDefaultFeePayer() } = r, - { mintAddress: s, user: c, owner: u = t.identity() } = e, - h = t.programs().getSystem(o), - w = t.programs().getToken(o), - M = t.programs().getTokenMetadata(o), - k = t.nfts().pdas().metadata({ mint: s, programs: o }), - O = t - .nfts() - .pdas() - .useAuthorityRecord({ mint: s, useAuthority: c, programs: o }), - D = - (n = e.ownerTokenAddress) !== null && n !== void 0 - ? n - : t.tokens().pdas().associatedTokenAccount({ - mint: s, - owner: u.publicKey, - programs: o, - }); - return ct - .make() - .setFeePayer(a) - .add({ - instruction: (0, r3t.createRevokeUseAuthorityInstruction)( - { - useAuthorityRecord: O, - owner: u.publicKey, - user: c, - ownerTokenAccount: D, - mint: s, - metadata: k, - tokenProgram: w.address, - systemProgram: h.address, - }, - M.address - ), - signers: [u], - key: - (i = e.instructionKey) !== null && i !== void 0 - ? i - : "revokeUseAuthority", - }); - }; - m(); - g(); - var i3t = qe(hs(), 1); - var Ajr = "VerifyNftCreatorOperation", - eue = ot(Ajr), - o3t = { - handle: async (t, e, r) => - BPe(e, t.input, r).sendAndConfirm(e, r.confirmOptions), - }, - BPe = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { mintAddress: a, creator: s = t.identity() } = e, - c = t.programs().getTokenMetadata(i); - return ct - .make() - .setFeePayer(o) - .add({ - instruction: (0, i3t.createSignMetadataInstruction)( - { - metadata: t.nfts().pdas().metadata({ mint: a, programs: i }), - creator: s.publicKey, - }, - c.address - ), - signers: [s], - key: - (n = e.instructionKey) !== null && n !== void 0 - ? n - : "verifyCreator", - }); - }; - m(); - g(); - var a3t = qe(hs(), 1); - var Ejr = "UnverifyNftCreatorOperation", - tue = ot(Ejr), - s3t = { - handle: async (t, e, r) => - IPe(e, t.input, r).sendAndConfirm(e, r.confirmOptions), - }, - IPe = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { mintAddress: a, creator: s = t.identity() } = e, - c = t.programs().getTokenMetadata(i); - return ct - .make() - .setFeePayer(o) - .add({ - instruction: (0, a3t.createRemoveCreatorVerificationInstruction)( - { - metadata: t.nfts().pdas().metadata({ mint: a, programs: i }), - creator: s.publicKey, - }, - c.address - ), - signers: [s], - key: - (n = e.instructionKey) !== null && n !== void 0 - ? n - : "unverifyCreator", - }); - }; - m(); - g(); - var rue = qe(hs(), 1); - var Mjr = "VerifyNftCollectionOperation", - nue = ot(Mjr), - u3t = { - handle: async (t, e, r) => - CPe(e, t.input, r).sendAndConfirm(e, r.confirmOptions), - }, - CPe = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - mintAddress: a, - collectionMintAddress: s, - isSizedCollection: c = !0, - isDelegated: u = !1, - collectionAuthority: h = t.identity(), - } = e, - w = t.programs().getTokenMetadata(i), - M = { - metadata: t.nfts().pdas().metadata({ mint: a, programs: i }), - collectionAuthority: h.publicKey, - payer: o.publicKey, - collectionMint: s, - collection: t.nfts().pdas().metadata({ mint: s, programs: i }), - collectionMasterEditionAccount: t - .nfts() - .pdas() - .masterEdition({ mint: s, programs: i }), - }, - k = c - ? (0, rue.createVerifySizedCollectionItemInstruction)(M, w.address) - : (0, rue.createVerifyCollectionInstruction)(M, w.address); - return ( - u && - k.keys.push({ - pubkey: t.nfts().pdas().collectionAuthorityRecord({ - mint: s, - collectionAuthority: h.publicKey, - programs: i, - }), - isWritable: !1, - isSigner: !1, - }), - ct - .make() - .setFeePayer(o) - .add({ - instruction: k, - signers: [o, h], - key: - (n = e.instructionKey) !== null && n !== void 0 - ? n - : "verifyCollection", - }) - ); - }; - m(); - g(); - var iue = qe(hs(), 1); - var Tjr = "UnverifyNftCollectionOperation", - oue = ot(Tjr), - c3t = { - handle: async (t, e, r) => - RPe(e, t.input, r).sendAndConfirm(e, r.confirmOptions), - }, - RPe = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - mintAddress: a, - collectionMintAddress: s, - isSizedCollection: c = !0, - isDelegated: u = !1, - collectionAuthority: h = t.identity(), - } = e, - w = t.programs().getTokenMetadata(i), - M = { - metadata: t.nfts().pdas().metadata({ mint: a, programs: i }), - collectionAuthority: h.publicKey, - payer: o.publicKey, - collectionMint: s, - collection: t.nfts().pdas().metadata({ mint: s, programs: i }), - collectionMasterEditionAccount: t - .nfts() - .pdas() - .masterEdition({ mint: s, programs: i }), - collectionAuthorityRecord: u - ? t.nfts().pdas().collectionAuthorityRecord({ - mint: s, - collectionAuthority: h.publicKey, - programs: i, - }) - : void 0, - }, - k = c - ? (0, iue.createUnverifySizedCollectionItemInstruction)(M, w.address) - : (0, iue.createUnverifyCollectionInstruction)(M, w.address); - return ct - .make() - .setFeePayer(o) - .add({ - instruction: k, - signers: [o, h], - key: - (n = e.instructionKey) !== null && n !== void 0 - ? n - : "unverifyCollection", - }); - }; - m(); - g(); - var l3t = qe(hs(), 1); - var kjr = "ApproveNftCollectionAuthorityOperation", - aue = ot(kjr), - f3t = { - handle: async (t, e, r) => - NPe(e, t.input, r).sendAndConfirm(e, r.confirmOptions), - }, - NPe = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - mintAddress: a, - collectionAuthority: s, - updateAuthority: c = t.identity(), - } = e, - u = t.programs().getSystem(i), - h = t.programs().getTokenMetadata(i), - w = t.nfts().pdas().metadata({ mint: a, programs: i }), - M = t.nfts().pdas().collectionAuthorityRecord({ - mint: a, - collectionAuthority: s, - programs: i, - }); - return ct - .make() - .setFeePayer(o) - .add({ - instruction: (0, l3t.createApproveCollectionAuthorityInstruction)( - { - collectionAuthorityRecord: M, - newCollectionAuthority: s, - updateAuthority: c.publicKey, - payer: o.publicKey, - metadata: w, - mint: a, - systemProgram: u.address, - }, - h.address - ), - signers: [o, c], - key: - (n = e.instructionKey) !== null && n !== void 0 - ? n - : "approveCollectionAuthority", - }); - }; - m(); - g(); - var d3t = qe(hs(), 1); - var Pjr = "RevokeNftCollectionAuthorityOperation", - sue = ot(Pjr), - h3t = { - handle: async (t, e, r) => - DPe(e, t.input, r).sendAndConfirm(e, r.confirmOptions), - }, - DPe = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - mintAddress: a, - collectionAuthority: s, - revokeAuthority: c = t.identity(), - } = e, - u = t.programs().getTokenMetadata(i), - h = t.nfts().pdas().metadata({ mint: a, programs: i }), - w = t.nfts().pdas().collectionAuthorityRecord({ - mint: a, - collectionAuthority: s, - programs: i, - }), - M = (0, d3t.createRevokeCollectionAuthorityInstruction)( - { - collectionAuthorityRecord: w, - delegateAuthority: s, - revokeAuthority: c.publicKey, - metadata: h, - mint: a, - }, - u.address - ); - return ( - (M.keys[1].isSigner = !1), - ct - .make() - .setFeePayer(o) - .add({ - instruction: M, - signers: [c], - key: - (n = e.instructionKey) !== null && n !== void 0 - ? n - : "revokeCollectionAuthority", - }) - ); - }; - m(); - g(); - var p3t = qe(hs(), 1); - var Ojr = "MigrateToSizedCollectionNftOperation", - uue = ot(Ojr), - y3t = { - handle: async (t, e, r) => - FPe(e, t.input, r).sendAndConfirm(e, r.confirmOptions), - }, - FPe = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - mintAddress: a, - collectionAuthority: s = t.identity(), - size: c, - isDelegated: u = !1, - } = e, - h = t.programs().getTokenMetadata(i), - w = t.nfts().pdas(); - return ct - .make() - .setFeePayer(o) - .add({ - instruction: (0, p3t.createSetCollectionSizeInstruction)( - { - collectionMetadata: w.metadata({ mint: a, programs: i }), - collectionAuthority: s.publicKey, - collectionMint: a, - collectionAuthorityRecord: u - ? w.collectionAuthorityRecord({ - mint: a, - collectionAuthority: s.publicKey, - programs: i, - }) - : void 0, - }, - { setCollectionSizeArgs: { size: c } }, - h.address - ), - signers: [s], - key: - (n = e.instructionKey) !== null && n !== void 0 - ? n - : "setCollectionSize", - }); - }; - m(); - g(); - var m3t = qe(hs(), 1); - var Bjr = "FreezeDelegatedNftOperation", - cue = ot(Bjr), - g3t = { - async handle(t, e, r) { - return LPe(e, t.input, r).sendAndConfirm(e, r.confirmOptions); - }, - }, - LPe = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - mintAddress: a, - delegateAuthority: s, - tokenOwner: c = t.identity().publicKey, - tokenAddress: u, - } = e, - h = t.programs().getToken(i), - w = t.programs().getTokenMetadata(i), - M = t.nfts().pdas().masterEdition({ mint: a, programs: i }), - k = - u ?? - t - .tokens() - .pdas() - .associatedTokenAccount({ mint: a, owner: c, programs: i }); - return ct - .make() - .setFeePayer(o) - .add({ - instruction: (0, m3t.createFreezeDelegatedAccountInstruction)( - { - delegate: s.publicKey, - tokenAccount: k, - edition: M, - mint: a, - tokenProgram: h.address, - }, - w.address - ), - signers: [s], - key: - (n = e.instructionKey) !== null && n !== void 0 - ? n - : "freezeDelegatedNft", - }); - }; - m(); - g(); - var v3t = qe(hs(), 1); - var Ijr = "ThawDelegatedNftOperation", - lue = ot(Ijr), - b3t = { - async handle(t, e, r) { - return qPe(e, t.input).sendAndConfirm(e, r.confirmOptions); - }, - }, - qPe = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - mintAddress: a, - delegateAuthority: s, - tokenOwner: c = t.identity().publicKey, - tokenAddress: u, - } = e, - h = t.programs().getToken(i), - w = t.programs().getTokenMetadata(i), - M = t.nfts().pdas().masterEdition({ mint: a, programs: i }), - k = - u ?? - t - .tokens() - .pdas() - .associatedTokenAccount({ mint: a, owner: c, programs: i }); - return ct - .make() - .setFeePayer(o) - .add({ - instruction: (0, v3t.createThawDelegatedAccountInstruction)( - { - delegate: s.publicKey, - tokenAccount: k, - edition: M, - mint: a, - tokenProgram: h.address, - }, - w.address - ), - signers: [s], - key: - (n = e.instructionKey) !== null && n !== void 0 - ? n - : "thawDelegatedNft", - }); - }; - var fue = class { - constructor(e) { - this.metaplex = e; - } - create(e, r) { - return aPe(this.metaplex, e, r); - } - createSft(e, r) { - return uPe(this.metaplex, e, r); - } - printNewEdition(e, r) { - return pPe(this.metaplex, e, r); - } - update(e, r) { - return MPe(this.metaplex, e, r); - } - delete(e, r) { - return TPe(this.metaplex, e, r); - } - use(e, r) { - return kPe(this.metaplex, e, r); - } - approveUseAuthority(e, r) { - return PPe(this.metaplex, e, r); - } - revokeUseAuthority(e, r) { - return OPe(this.metaplex, e, r); - } - verifyCreator(e, r) { - return BPe(this.metaplex, e, r); - } - unverifyCreator(e, r) { - return IPe(this.metaplex, e, r); - } - verifyCollection(e, r) { - return CPe(this.metaplex, e, r); - } - unverifyCollection(e, r) { - return RPe(this.metaplex, e, r); - } - approveCollectionAuthority(e, r) { - return NPe(this.metaplex, e, r); - } - revokeCollectionAuthority(e, r) { - return DPe(this.metaplex, e, r); - } - migrateToSizedCollection(e, r) { - return FPe(this.metaplex, e, r); - } - freezeDelegatedNft(e, r) { - return LPe(this.metaplex, e, r); - } - thawDelegatedNft(e, r) { - return qPe(this.metaplex, e, r); - } - }; - m(); - g(); - var y0 = qe(Qr(), 1); - var due = class { - constructor(e) { - this.metaplex = e; - } - metadata({ mint: e, programs: r }) { - let n = this.programId(r); - return Br.find(n, [ - y0.Buffer.from("metadata", "utf8"), - n.toBuffer(), - e.toBuffer(), - ]); - } - masterEdition({ mint: e, programs: r }) { - let n = this.programId(r); - return Br.find(n, [ - y0.Buffer.from("metadata", "utf8"), - n.toBuffer(), - e.toBuffer(), - y0.Buffer.from("edition", "utf8"), - ]); - } - edition(e) { - return this.masterEdition(e); - } - editionMarker({ mint: e, edition: r, programs: n }) { - let i = this.programId(n); - return Br.find(i, [ - y0.Buffer.from("metadata", "utf8"), - i.toBuffer(), - e.toBuffer(), - y0.Buffer.from("edition", "utf8"), - y0.Buffer.from(r.div(Sr(248)).toString()), - ]); - } - collectionAuthorityRecord({ - mint: e, - collectionAuthority: r, - programs: n, - }) { - let i = this.programId(n); - return Br.find(i, [ - y0.Buffer.from("metadata", "utf8"), - i.toBuffer(), - e.toBuffer(), - y0.Buffer.from("collection_authority", "utf8"), - r.toBuffer(), - ]); - } - useAuthorityRecord({ mint: e, useAuthority: r, programs: n }) { - let i = this.programId(n); - return Br.find(i, [ - y0.Buffer.from("metadata", "utf8"), - i.toBuffer(), - e.toBuffer(), - y0.Buffer.from("user", "utf8"), - r.toBuffer(), - ]); - } - burner({ programs: e }) { - let r = this.programId(e); - return Br.find(r, [ - y0.Buffer.from("metadata", "utf8"), - r.toBuffer(), - y0.Buffer.from("burn", "utf8"), - ]); - } - programId(e) { - return this.metaplex.programs().getTokenMetadata(e).address; - } - }; - m(); - g(); - m(); - g(); - var GE = (t, e) => { - var r; - return { - model: "metadata", - address: Br.find(t.owner, [ - Buffer.from("metadata", "utf8"), - t.owner.toBuffer(), - t.data.mint.toBuffer(), - ]), - mintAddress: t.data.mint, - updateAuthorityAddress: t.data.updateAuthority, - json: e ?? null, - jsonLoaded: e !== void 0, - name: Wc(t.data.data.name), - symbol: Wc(t.data.data.symbol), - uri: Wc(t.data.data.uri), - isMutable: t.data.isMutable, - primarySaleHappened: t.data.primarySaleHappened, - sellerFeeBasisPoints: t.data.data.sellerFeeBasisPoints, - editionNonce: t.data.editionNonce, - creators: (r = t.data.data.creators) !== null && r !== void 0 ? r : [], - tokenStandard: t.data.tokenStandard, - collection: t.data.collection - ? { ...t.data.collection, address: t.data.collection.key } - : null, - collectionDetails: t.data.collectionDetails - ? { - version: t.data.collectionDetails.__kind, - size: Sr(t.data.collectionDetails.size), - } - : null, - uses: t.data.uses - ? { - ...t.data.uses, - remaining: Sr(t.data.uses.remaining), - total: Sr(t.data.uses.total), - } - : null, - }; - }; - var Cjr = "FindNftByMintOperation", - hue = ot(Cjr), - w3t = { - handle: async (t, e, r) => { - let { programs: n, commitment: i } = r, - { - mintAddress: o, - tokenAddress: a, - tokenOwner: s, - loadJsonMetadata: c = !0, - } = t.input, - u = s - ? e - .tokens() - .pdas() - .associatedTokenAccount({ mint: o, owner: s, programs: n }) - : void 0, - h = e.nfts().pdas(), - w = [ - o, - h.metadata({ mint: o, programs: n }), - h.masterEdition({ mint: o, programs: n }), - a ?? u, - ].filter((q) => !!q), - M = await e.rpc().getMultipleAccounts(w, i); - r.throwIfCanceled(); - let k = Yb(Zb(M[0])), - O = GE(p0(M[1])), - D = cPe(M[2]), - F = M[3] ? UH(Xb(M[3])) : null; - if (c) - try { - let q = await e.storage().downloadJson(O.uri, r); - O = { ...O, jsonLoaded: !0, json: q }; - } catch { - O = { ...O, jsonLoaded: !0, json: null }; - } - if ( - D.exists && - k.mintAuthorityAddress && - k.mintAuthorityAddress.equals(D.publicKey) - ) { - let q = uEt(D); - return F ? tEt(O, k, q, F) : QAt(O, k, q); - } - return F ? Ise(O, k, F) : tV(O, k); - }, - }; - m(); - g(); - var Rjr = "FindNftByMetadataOperation", - pue = ot(Rjr), - _3t = { - handle: async (t, e, r) => { - let n = p0(await e.rpc().getAccount(t.input.metadata)); - return ( - r.throwIfCanceled(), - e.nfts().findByMint({ ...t.input, mintAddress: n.data.mint }, r) - ); - }, - }; - m(); - g(); - var Njr = "FindNftByTokenOperation", - yue = ot(Njr), - x3t = { - handle: async (t, e, r) => { - let n = Xb(await e.rpc().getAccount(t.input.token)); - return ( - r.throwIfCanceled(), - await e.nfts().findByMint( - { - ...t.input, - mintAddress: n.data.mint, - tokenAddress: t.input.token, - }, - r - ) - ); - }, - }; - m(); - g(); - m(); - g(); - var gue = qe(Qr(), 1), - vue = qe(hs(), 1); - m(); - g(); - var S3t = qe(Qr(), 1), - zPe = qe(Le(), 1), - mue = qe(G6e(), 1), - jPe = qe(Ho(), 1); - m(); - g(); - var JE = class { - constructor(e, r, n = {}) { - var i; - (this.metaplex = e), - (this.chunkSize = (i = n.chunkSize) !== null && i !== void 0 ? i : 100), - (this.commitment = n.commitment), - (this.publicKeys = r); - } - static make(e, r, n = {}) { - return new JE(e, r, n); - } - chunkBy(e) { - return (this.chunkSize = e), this; - } - addPublicKeys(e) { - return this.publicKeys.push(...e), this; - } - getPublicKeys() { - return this.publicKeys; - } - getUniquePublicKeys() { - return this.getPublicKeys(); - } - async getFirst(e) { - let r = this.boundNumber(e ?? 1); - return this.getChunks(this.getPublicKeys().slice(0, r)); - } - async getLast(e) { - let r = this.boundNumber(e ?? 1); - return this.getChunks(this.getPublicKeys().slice(-r)); - } - async getBetween(e, r) { - return ( - (e = this.boundNumber(e)), - (r = this.boundNumber(r)), - ([e, r] = e > r ? [r, e] : [e, r]), - this.getChunks(this.getPublicKeys().slice(e, r)) - ); - } - async getPage(e, r) { - return this.getBetween((e - 1) * r, e * r); - } - async get() { - return this.getChunks(this.getPublicKeys()); - } - async getAndMap(e) { - return (await this.get()).map(e); - } - async getChunks(e) { - let n = Wet(e, this.chunkSize).map((o) => this.getChunk(o)); - return (await Promise.all(n)).flat(); - } - async getChunk(e) { - try { - return await this.metaplex - .rpc() - .getMultipleAccounts(e, this.commitment); - } catch (r) { - throw r; - } - } - boundNumber(e) { - return this.boundIndex(e - 1) + 1; - } - boundIndex(e) { - return ( - (e = e < 0 ? 0 : e), - (e = e >= this.publicKeys.length ? this.publicKeys.length - 1 : e), - e - ); - } - }; - var yf = class { - constructor(e, r) { - Go(this, "config", {}), (this.metaplex = e), (this.programId = r); - } - mergeConfig(e) { - return (this.config = { ...this.config, ...e }), this; - } - slice(e, r) { - return (this.config.dataSlice = { offset: e, length: r }), this; - } - withoutData() { - return this.slice(0, 0); - } - addFilter(...e) { - return ( - this.config.filters || (this.config.filters = []), - this.config.filters.push(...e), - this - ); - } - where(e, r) { - return ( - S3t.Buffer.isBuffer(r) - ? (r = mue.default.encode(r)) - : typeof r == "object" && "toBase58" in r - ? (r = r.toBase58()) - : jPe.default.isBN(r) - ? (r = mue.default.encode(r.toArray())) - : typeof r != "string" && - (r = mue.default.encode(new jPe.default(r, "le").toArray())), - this.addFilter({ memcmp: { offset: e, bytes: r } }) - ); - } - whereSize(e) { - return this.addFilter({ dataSize: e }); - } - sortUsing(e) { - return (this.sortCallback = e), this; - } - async get() { - let e = await this.metaplex - .rpc() - .getProgramAccounts(this.programId, this.config); - return this.sortCallback && e.sort(this.sortCallback), e; - } - async getAndMap(e) { - return (await this.get()).map(e); - } - async getPublicKeys() { - return this.getAndMap((e) => e.publicKey); - } - async getDataAsPublicKeys() { - return this.getAndMap((e) => new zPe.PublicKey(e.data)); - } - async getMultipleAccounts(e, r) { - let n = e ?? ((i) => new zPe.PublicKey(i.data)); - return new JE(this.metaplex, await this.getAndMap(n), r); - } - }; - var HPe = 32, - VPe = 10, - WPe = 200, - UPe = 32 + 1 + 1, - Djr = 1 + 32 + 32, - GPe = Djr + 4, - JPe = GPe + HPe + 4, - $Pe = JPe + VPe + 4, - KPe = $Pe + WPe + 2 + 1 + 4, - ZPe = class extends yf { - constructor(e, r) { - super(e, r ?? vue.PROGRAM_ID); - } - whereKey(e) { - return this.where(0, Sr(e, "le")); - } - }, - k9 = class extends ZPe { - constructor(e, r) { - super(e, r), this.whereKey(vue.Key.MetadataV1); - } - selectUpdatedAuthority() { - return this.slice(1, 32); - } - whereUpdateAuthority(e) { - return this.where(1, e); - } - selectMint() { - return this.slice(33, 32); - } - whereMint(e) { - return this.where(33, e); - } - selectName() { - return this.slice(GPe, HPe); - } - whereName(e) { - return this.where(GPe, gue.Buffer.from(qC(e, HPe))); - } - selectSymbol() { - return this.slice(JPe, VPe); - } - whereSymbol(e) { - return this.where(JPe, gue.Buffer.from(qC(e, VPe))); - } - selectUri() { - return this.slice($Pe, WPe); - } - whereUri(e) { - return this.where($Pe, gue.Buffer.from(qC(e, WPe))); - } - selectCreator(e) { - return this.slice(KPe + (e - 1) * UPe, KPe + e * UPe); - } - whereCreator(e, r) { - return this.where(KPe + (e - 1) * UPe, r); - } - selectFirstCreator() { - return this.selectCreator(1); - } - whereFirstCreator(e) { - return this.whereCreator(1, e); - } - }; - var Fjr = "FindNftsByCreatorOperation", - bue = ot(Fjr), - A3t = { - handle: async (t, e, r) => { - let { programs: n } = r, - { creator: i, position: o = 1 } = t.input, - s = await new k9(e, e.programs().getTokenMetadata(n).address) - .whereCreator(o, i) - .get(); - return ( - r.throwIfCanceled(), - s - .map((c) => { - if (c == null) return null; - try { - return GE(p0(c)); - } catch { - return null; - } - }) - .filter((c) => c !== null) - ); - }, - }; - m(); - g(); - var Ljr = "FindNftsByMintListOperation", - wue = ot(Ljr), - E3t = { - handle: async (t, e, r) => { - let { commitment: n, programs: i } = r, - { mints: o } = t.input, - a = e.nfts().pdas(), - s = o.map((u) => a.metadata({ mint: u, programs: i })), - c = await JE.make(e, s, { commitment: n }).get(); - return ( - r.throwIfCanceled(), - c.map((u) => { - if (!u.exists) return null; - try { - return GE(p0(u)); - } catch { - return null; - } - }) - ); - }, - }; - m(); - g(); - m(); - g(); - var _ue = class extends yf { - constructor(e, r) { - super(e, r ?? Ha), this.whereSize(Loe); - } - selectMint() { - return this.slice(0, 32); - } - whereMint(e) { - return this.where(0, e); - } - selectOwner() { - return this.slice(32, 32); - } - whereOwner(e) { - return this.where(32, e); - } - selectAmount() { - return this.slice(64, 8); - } - whereAmount(e) { - return this.where(64, e); - } - whereDoesntHaveDelegate() { - return this.where(72, 0); - } - whereHasDelegate() { - return this.where(72, 1); - } - whereDelegate(e) { - return this.whereHasDelegate().where(76, e); - } - }; - var qjr = "FindNftsByOwnerOperation", - xue = ot(qjr), - M3t = { - handle: async (t, e, r) => { - let { programs: n } = r, - { owner: i } = t.input, - o = e.programs().getToken(n), - a = await new _ue(e, o.address) - .selectMint() - .whereOwner(i) - .whereAmount(1) - .getDataAsPublicKeys(); - r.throwIfCanceled(); - let s = await e.nfts().findAllByMintList({ mints: a }, r); - return r.throwIfCanceled(), s.filter((c) => c !== null); - }, - }; - m(); - g(); - var zjr = "FindNftsByUpdateAuthorityOperation", - Sue = ot(zjr), - T3t = { - handle: async (t, e, r) => { - let { updateAuthority: n } = t.input, - o = await new k9(e, e.programs().getTokenMetadata(r.programs).address) - .whereUpdateAuthority(n) - .get(); - return ( - r.throwIfCanceled(), - o - .map((a) => { - if (a == null) return null; - try { - return GE(p0(a)); - } catch { - return null; - } - }) - .filter((a) => a !== null) - ); - }, - }; - m(); - g(); - var jjr = "LoadMetadataOperation", - Aue = ot(jjr), - k3t = { - handle: async (t, e, r) => { - let { metadata: n, loadJsonMetadata: i = !0 } = t.input, - o = await e.nfts().findByMint( - { - ...t.input, - mintAddress: n.mintAddress, - loadJsonMetadata: !n.jsonLoaded && i, - }, - r - ); - return ( - !o.jsonLoaded && - n.jsonLoaded && - (o = { ...o, json: n.json, jsonLoaded: !0 }), - o - ); - }, - }; - m(); - g(); - var gMt = qe(mMt(), 1); - var yKr = "UploadMetadataOperation", - Cue = ot(yKr), - vMt = { - handle: async (t, e, r) => { - let n = t.input, - i = mKr(n), - o = await e.storage().uploadAll(i); - r.throwIfCanceled(); - let a = gKr(n, o); - return { - uri: await e.storage().uploadJson(a), - metadata: a, - assetUris: o, - }; - }, - }, - mKr = (t) => { - let e = []; - return ( - vee(t, (r, n) => { - lxe(n) ? e.push(n) : r(n); - }), - e - ); - }, - gKr = (t, e) => { - let r = (0, gMt.default)(t), - n = 0; - return ( - vee(r, (i, o, a, s) => { - lxe(o) && n < e.length && (s[a] = e[n++]), i(o); - }), - r - ); - }; - var Rue = class { - constructor(e) { - this.metaplex = e; - } - builders() { - return new fue(this.metaplex); - } - pdas() { - return new due(this.metaplex); - } - findByMint(e, r) { - return this.metaplex.operations().execute(hue(e), r); - } - findByMetadata(e, r) { - return this.metaplex.operations().execute(pue(e), r); - } - findByToken(e, r) { - return this.metaplex.operations().execute(yue(e), r); - } - findAllByCreator(e, r) { - return this.metaplex.operations().execute(bue(e), r); - } - findAllByMintList(e, r) { - return this.metaplex.operations().execute(wue(e), r); - } - findAllByOwner(e, r) { - return this.metaplex.operations().execute(xue(e), r); - } - findAllByUpdateAuthority(e, r) { - return this.metaplex.operations().execute(Sue(e), r); - } - load(e, r) { - return this.metaplex.operations().execute(Aue(e), r); - } - refresh(e, r, n) { - return this.findByMint( - { - mintAddress: $At(e), - tokenAddress: "token" in e ? e.token.address : void 0, - ...r, - }, - n - ); - } - create(e, r) { - return this.metaplex.operations().execute(Rse(e), r); - } - createSft(e, r) { - return this.metaplex.operations().execute(Nse(e), r); - } - printNewEdition(e, r) { - return this.metaplex.operations().execute(Dse(e), r); - } - uploadMetadata(e, r) { - return this.metaplex.operations().execute(Cue(e), r); - } - update(e, r) { - return this.metaplex.operations().execute($se(e), r); - } - delete(e, r) { - return this.metaplex.operations().execute(Zse(e), r); - } - use(e, r) { - return this.metaplex.operations().execute(Xse(e), r); - } - approveUseAuthority(e, r) { - return this.metaplex.operations().execute(Yse(e), r); - } - revokeUseAuthority(e, r) { - return this.metaplex.operations().execute(Qse(e), r); - } - verifyCreator(e, r) { - return this.metaplex.operations().execute(eue(e), r); - } - unverifyCreator(e, r) { - return this.metaplex.operations().execute(tue(e), r); - } - verifyCollection(e, r) { - return this.metaplex.operations().execute(nue(e), r); - } - unverifyCollection(e, r) { - return this.metaplex.operations().execute(oue(e), r); - } - approveCollectionAuthority(e, r) { - return this.metaplex.operations().execute(aue(e), r); - } - revokeCollectionAuthority(e, r) { - return this.metaplex.operations().execute(sue(e), r); - } - migrateToSizedCollection(e, r) { - return this.metaplex.operations().execute(uue(e), r); - } - freezeDelegatedNft(e, r) { - return this.metaplex.operations().execute(cue(e), r); - } - thawDelegatedNft(e, r) { - return this.metaplex.operations().execute(lue(e), r); - } - send(e, r) { - return this.metaplex.tokens().send({ ...e, amount: Jo(1) }, r); - } - }; - var bMt = () => ({ - install(t) { - let e = { - name: "TokenMetadataProgram", - address: Nue.PROGRAM_ID, - errorResolver: (n) => Nue.cusper.errorFromProgramLogs(n.logs, !1), - }; - t.programs().register(e), - (t.programs().getTokenMetadata = function (n) { - return this.get(e.name, n); - }); - let r = t.operations(); - r.register(aue, f3t), - r.register(Yse, t3t), - r.register(Rse, nEt), - r.register(Nse, oEt), - r.register(Zse, XEt), - r.register(pue, _3t), - r.register(hue, w3t), - r.register(yue, x3t), - r.register(bue, A3t), - r.register(wue, E3t), - r.register(xue, M3t), - r.register(Sue, T3t), - r.register(cue, g3t), - r.register(Aue, k3t), - r.register(uue, y3t), - r.register(Dse, lEt), - r.register(sue, h3t), - r.register(Qse, n3t), - r.register(lue, b3t), - r.register(oue, c3t), - r.register(tue, s3t), - r.register($se, $Et), - r.register(Cue, vMt), - r.register(Xse, QEt), - r.register(nue, u3t), - r.register(eue, o3t), - (t.nfts = function () { - return new Rue(this); - }); - }, - }); - m(); - g(); - m(); - g(); - m(); - g(); - m(); - g(); - var Cce = qe(hm(), 1), - D6t = qe(Le(), 1); - m(); - g(); - var T6t = qe(hm(), 1); - function LOe(t) { - let e = t.slice(713, 713 + 4); - return Sr(e, "le"); - } - function k6t(t) { - let e = 713 + 4, - r = [], - n = LOe(t).toNumber(); - for (let i = 0; i < n; i++) { - let [o] = T6t.configLineBeet.deserialize(t, e + i * 240); - r.push({ name: Wc(o.name), uri: Wc(o.uri) }); - } - return r; - } - function P6t(t) { - if (t.hiddenSettings != null) return 713; - let e = Sr(t.itemsAvailable).toNumber(); - return Math.ceil(713 + 4 + e * 240 + 8 + 2 * (e / 8 + 1)); - } - var O6t = (t) => t.toBase58().slice(0, 6); - m(); - g(); - var qOe = qe(Qr(), 1); - m(); - g(); - var R6t = qe(hm(), 1); - m(); - g(); - var B6t = qe(Le(), 1); - var I6t = [51, 173, 177, 113, 25, 241, 109, 189], - C6t = I6t.length, - dGr = C6t + B6t.PublicKey.default.toBytes().byteLength, - Oce = class extends yf { - whereDiscriminator(e) { - return this.where(0, Buffer.from(e)); - } - candyMachineAccounts() { - return this.whereDiscriminator(I6t); - } - candyMachineAccountsForWallet(e) { - return this.candyMachineAccounts().where(dGr, e.toBase58()); - } - candyMachineAccountsForAuthority(e) { - return this.candyMachineAccounts().where(C6t, e.toBase58()); - } - }; - var Qx = { - publicKey: R6t.PROGRAM_ID, - accounts(t) { - return new Oce(t, this.publicKey); - }, - }; - var Bce = (t, e = Qx.publicKey) => - Br.find(e, [qOe.Buffer.from("candy_machine", "utf8"), t.toBuffer()]), - x0 = (t, e = Qx.publicKey) => - Br.find(e, [qOe.Buffer.from("collection", "utf8"), t.toBuffer()]); - m(); - g(); - var kV = qe(hm(), 1); - m(); - g(); - var zOe = qe(Ho(), 1); - var _p = (t) => { - if (typeof t == "string" || hGr(t)) { - let e = new Date(t), - r = Math.floor(e.getTime() / 1e3); - return new zOe.default(r); - } - return new zOe.default(t); - }, - oh = () => _p(new Date(Date.now())), - Y9 = (t) => (t === null ? null : _p(t)); - var hGr = (t) => Object.prototype.toString.call(t) === "[object Date]", - jOe = ( - t, - e = "en-US", - r = { - month: "short", - day: "numeric", - year: "numeric", - hour: "numeric", - minute: "numeric", - } - ) => new Date(t.toNumber() * 1e3).toLocaleDateString(e, r); - var Ice = (t, e, r, n) => { - ba( - n === null || - (t.data.tokenMint !== null && n.address.equals(t.data.tokenMint)) - ); - let i = Sr(t.data.data.itemsAvailable), - o = Sr(t.data.itemsRedeemed), - { endSettings: a } = t.data.data, - { hiddenSettings: s } = t.data.data, - { whitelistMintSettings: c } = t.data.data, - { gatekeeper: u } = t.data.data, - h = e.data, - w = s ? Sr(0) : LOe(h), - M = s ? [] : k6t(h); - return { - model: "candyMachineV2", - address: t.publicKey, - programAddress: t.owner, - version: t.owner.equals(Qx.publicKey) ? 2 : 1, - authorityAddress: t.data.authority, - walletAddress: t.data.wallet, - tokenMintAddress: t.data.tokenMint, - collectionMintAddress: r && r.exists ? r.data.mint : null, - uuid: t.data.data.uuid, - price: ci(t.data.data.price, n ? n.currency : zC), - symbol: Wc(t.data.data.symbol), - sellerFeeBasisPoints: t.data.data.sellerFeeBasisPoints, - isMutable: t.data.data.isMutable, - retainAuthority: t.data.data.retainAuthority, - goLiveDate: Y9(t.data.data.goLiveDate), - maxEditionSupply: Sr(t.data.data.maxSupply), - items: M, - itemsAvailable: i, - itemsMinted: o, - itemsRemaining: Sr(i.sub(o)), - itemsLoaded: w, - isFullyLoaded: i.lte(w), - endSettings: a - ? a.endSettingType === kV.EndSettingType.Date - ? { endSettingType: kV.EndSettingType.Date, date: _p(a.number) } - : { endSettingType: kV.EndSettingType.Amount, number: Sr(a.number) } - : null, - hiddenSettings: s, - whitelistMintSettings: c - ? { - ...c, - discountPrice: c.discountPrice ? Xi(c.discountPrice) : null, - } - : null, - gatekeeper: u ? { ...u, network: u.gatekeeperNetwork } : null, - creators: t.data.data.creators, - }; - }, - N6t = (t) => ({ - wallet: t.walletAddress, - tokenMint: t.tokenMintAddress, - ...t, - }), - PV = (t, e) => { - var r, n; - let { endSettings: i } = e, - { whitelistMintSettings: o } = e, - { gatekeeper: a } = e; - return { - wallet: e.wallet, - tokenMint: e.tokenMint, - data: { - ...e, - uuid: O6t(t), - price: e.price.basisPoints, - maxSupply: e.maxEditionSupply, - endSettings: i - ? { - ...i, - number: - i.endSettingType === kV.EndSettingType.Date - ? i.date - : i.number, - } - : null, - whitelistMintSettings: o - ? { - ...o, - discountPrice: - (r = - (n = o.discountPrice) === null || n === void 0 - ? void 0 - : n.basisPoints) !== null && r !== void 0 - ? r - : null, - } - : null, - gatekeeper: a ? { ...a, gatekeeperNetwork: a.network } : null, - }, - }; - }; - var pGr = "CreateCandyMachineV2Operation", - Rce = ot(pGr), - F6t = { - async handle(t, e, r) { - let n = await UOe(e, t.input, r); - r.throwIfCanceled(); - let i = go(e, r.confirmOptions), - o = await n.sendAndConfirm(e, i); - r.throwIfCanceled(); - let a = await e - .candyMachinesV2() - .findByAddress({ address: o.candyMachineSigner.publicKey }, r); - return { ...o, candyMachine: a }; - }, - }, - UOe = async (t, e, r = {}) => { - var n, i, o, a, s, c, u, h, w, M, k, O, D, F, N, q, z; - let { programs: H, payer: Z = t.rpc().getDefaultFeePayer() } = r, - $ = - (n = e.candyMachine) !== null && n !== void 0 - ? n - : D6t.Keypair.generate(), - ue = (i = e.authority) !== null && i !== void 0 ? i : t.identity(), - te = (o = e.collection) !== null && o !== void 0 ? o : null, - { - data: ne, - wallet: A, - tokenMint: l, - } = PV($.publicKey, { - ...e, - wallet: - (a = e.wallet) !== null && a !== void 0 - ? a - : t.identity().publicKey, - tokenMint: (s = e.tokenMint) !== null && s !== void 0 ? s : null, - symbol: (c = e.symbol) !== null && c !== void 0 ? c : "", - maxEditionSupply: - (u = e.maxEditionSupply) !== null && u !== void 0 ? u : Sr(0), - isMutable: (h = e.isMutable) !== null && h !== void 0 ? h : !0, - retainAuthority: - (w = e.retainAuthority) !== null && w !== void 0 ? w : !0, - goLiveDate: (M = e.goLiveDate) !== null && M !== void 0 ? M : null, - endSettings: (k = e.endSettings) !== null && k !== void 0 ? k : null, - creators: - (O = e.creators) !== null && O !== void 0 - ? O - : [{ address: t.identity().publicKey, share: 100, verified: !1 }], - hiddenSettings: - (D = e.hiddenSettings) !== null && D !== void 0 ? D : null, - whitelistMintSettings: - (F = e.whitelistMintSettings) !== null && F !== void 0 ? F : null, - gatekeeper: (N = e.gatekeeper) !== null && N !== void 0 ? N : null, - }), - p = (0, Cce.createInitializeCandyMachineInstruction)( - { - candyMachine: $.publicKey, - wallet: A, - authority: Jt(ue), - payer: Z.publicKey, - }, - { data: ne } - ); - return ( - l - ? p.keys.push({ pubkey: l, isWritable: !1, isSigner: !1 }) - : Aee(e.price, zC), - ct - .make() - .setFeePayer(Z) - .setContext({ - candyMachineSigner: $, - wallet: A, - authority: Jt(ue), - creators: ne.creators, - }) - .add( - await t - .system() - .builders() - .createAccount( - { - newAccount: $, - space: P6t(ne), - program: Qx.publicKey, - instructionKey: - (q = e.createAccountInstructionKey) !== null && q !== void 0 - ? q - : "createAccount", - }, - { payer: Z, programs: H } - ) - ) - .add({ - instruction: p, - signers: [$, Z], - key: - (z = e.initializeCandyMachineInstructionKey) !== null && - z !== void 0 - ? z - : "initializeCandyMachine", - }) - .when(!!te, (y) => { - var d; - if (!kr(ue)) - throw new xy("authority", "PublicKey", { - problemSuffix: - "You are trying to create a Candy Machine with a Collection NFT. In order for the Collection NFT to be set successfully, you must provide the authority as a Signer.", - solution: - 'Please provide the "authority" parameter as a Signer if you want to set the Collection NFT upon creation. Alternatively, you may remove the "collection" parameter to create a Candy Machine without an associated Collection NFT.', - }); - let v = te, - _ = t.nfts().pdas().metadata({ mint: v, programs: H }), - S = t.nfts().pdas().masterEdition({ mint: v, programs: H }), - b = x0($.publicKey), - f = t.nfts().pdas().collectionAuthorityRecord({ - mint: v, - collectionAuthority: b, - programs: H, - }); - return y.add({ - instruction: (0, Cce.createSetCollectionInstruction)({ - candyMachine: $.publicKey, - authority: Jt(ue), - collectionPda: b, - payer: Z.publicKey, - metadata: _, - mint: v, - edition: S, - collectionAuthorityRecord: f, - tokenMetadataProgram: t.programs().getTokenMetadata().address, - }), - signers: [ue], - key: - (d = e.setCollectionInstructionKey) !== null && d !== void 0 - ? d - : "setCollection", - }); - }) - ); - }; - m(); - g(); - var L6t = qe(hm(), 1); - var yGr = "DeleteCandyMachineV2Operation", - Nce = ot(yGr), - q6t = { - async handle(t, e, r) { - return KOe(e, t.input, r).sendAndConfirm(e, r.confirmOptions); - }, - }, - KOe = (t, e, r = {}) => { - var n, i; - let { payer: o = t.rpc().getDefaultFeePayer() } = r, - a = (n = e.authority) !== null && n !== void 0 ? n : t.identity(), - { candyMachine: s } = e, - c = (0, L6t.createWithdrawFundsInstruction)({ - candyMachine: s.address, - authority: a.publicKey, - }); - if (s.collectionMintAddress) { - let u = x0(s.address); - c.keys.push({ pubkey: u, isWritable: !0, isSigner: !1 }); - } - return ct - .make() - .setFeePayer(o) - .add({ - instruction: c, - signers: [a], - key: - (i = e.instructionKey) !== null && i !== void 0 - ? i - : "withdrawFunds", - }); - }; - m(); - g(); - var H6t = qe(hm(), 1); - m(); - g(); - var VOe = qe(hm(), 1); - m(); - g(); - var HOe = qe(hm(), 1); - var eS = class extends Mu { - constructor(e) { - super({ - ...e, - key: `plugin.candy_machine_v2.${e.key}`, - title: `Candy Machine V2 > ${e.title}`, - source: "plugin", - sourceDetails: "Candy Machine V2", - }); - } - }, - Dce = class extends eS { - constructor(e, r, n) { - super({ - options: n, - key: "candy_machine_is_full", - title: "Candy Machine Is Full", - problem: `Trying to add asset number ${e.addn( - 1 - )}, but candy machine only can hold ${r} assets.`, - solution: - "Limit number of assets you are adding or create a new Candy Machine that can hold more.", - }); - } - }, - Fce = class extends eS { - constructor(e, r) { - super({ - options: r, - key: "candy_machine_is_empty", - title: "Candy Machine Is Empty", - problem: `You're trying to mint from an empty candy machine. All ${e} items have been minted.`, - solution: "You can no longer mint from this Candy Machine.", - }); - } - }, - Lce = class extends eS { - constructor(e, r, n, i) { - super({ - options: i, - key: "candy_machine_cannot_add_amount", - title: "Candy Machine Cannot Add Amount", - problem: `Trying to add ${r} assets to candy machine that already has ${e} assets and can only hold ${n} assets.`, - solution: - "Limit number of assets you are adding or create a new Candy Machine that can hold more.", - }); - } - }, - qce = class extends eS { - constructor(e, r, n) { - super({ - options: n, - key: "candy_machine_add_item_constraints_violated", - title: "Candy Machine Add Item Constraints Violated", - problem: `Trying to add an asset with name "${r.name}" and uri: "${r.uri}" to candy machine at index ${e} that violates constraints.`, - solution: "Fix the name or URI of this asset and try again.", - }); - } - }, - zce = class extends eS { - constructor(e, r) { - super({ - options: r, - key: "candy_machine_not_live", - title: "Candy Machine Not Live", - problem: - "You're trying to mint from a Candy Machine which is not live yet. " + - (e - ? `It will go live on ${jOe(e)}.` - : "Its live date has not been set yet."), - solution: - 'You need to wait until the Candy Machine is live to mint from it. If this is your Candy Machine, use "metaplex.candyMachinesV2().update(...)" to set the live date. Note that the authority of the Candy Machine can mint regardless of the live date.', - }); - } - }, - jce = class extends eS { - constructor(e, r) { - let n = - e.endSettingType === HOe.EndSettingType.Amount ? "Amount" : "Date", - i = - e.endSettingType === HOe.EndSettingType.Amount - ? `All ${e.number} items have been minted.` - : `It ended on ${jOe(e.date)}.`; - super({ - options: r, - key: "candy_machine_ended", - title: "Candy Machine Ended", - problem: - `The end condition [${n}] of this Candy Machine has been reached. ` + - i, - solution: "You can no longer mint from this Candy Machine.", - }); - } - }, - Uce = class extends eS { - constructor(e, r, n) { - super({ - options: { ...n, cause: r }, - key: "candy_machine_bot_tax", - title: "Candy Machine Bot Tax", - problem: - "The NFT couldn't be fetched after being minted. This is most likely due to a bot tax that occured during minting. When someone tries to mint an NFT from a Candy Machine which cannot be minted from, the program will succeed and charge a small tax to fight against bots.", - solution: `Ensure you can mint from the Candy Machine. You may want to check the transaction logs for more details: [${e}].`, - }); - } - }; - var vGr = (t) => { - ba(t.length <= 32, `Candy Machine name too long: ${t} (max ${32})`); - }, - bGr = (t) => { - ba(t.length <= 200, `Candy Machine URI too long: ${t} (max ${200})`); - }, - z6t = (t, e) => { - if (t.itemsAvailable.lte(t.itemsLoaded)) - throw new Dce(e, t.itemsAvailable); - }, - wGr = (t) => { - if (t.itemsRemaining.isZero()) throw new Fce(t.itemsAvailable); - }, - j6t = (t, e, r) => { - if (e.addn(r).gt(t.itemsAvailable)) throw new Lce(e, r, t.itemsAvailable); - }, - U6t = (t) => { - for (let e = 0; e < t.length; e++) - try { - vGr(t[e].name), bGr(t[e].uri); - } catch (r) { - throw new qce(Sr(e), t[e], { cause: r }); - } - }, - _Gr = (t) => { - var e, r; - if ( - (e = - (r = t.whitelistMintSettings) === null || r === void 0 - ? void 0 - : r.presale) !== null && e !== void 0 - ? e - : !1 - ) - return; - let i = t.goLiveDate; - if (!i || i.gte(oh())) throw new zce(i); - }, - xGr = (t) => { - let { endSettings: e } = t; - if (!e) return; - let r = - e.endSettingType === VOe.EndSettingType.Amount && - t.itemsMinted.gte(e.number), - n = e.endSettingType === VOe.EndSettingType.Date && e.date.lt(oh()); - if (r || n) throw new jce(e); - }, - K6t = (t, e) => { - wGr(t), !t.authorityAddress.equals(e.publicKey) && (_Gr(t), xGr(t)); - }; - var SGr = "InsertItemsToCandyMachineV2Operation", - Kce = ot(SGr), - V6t = { - async handle(t, e, r) { - return WOe(e, t.input, r).sendAndConfirm(e, r.confirmOptions); - }, - }, - WOe = (t, e, r = {}) => { - var n, i, o; - let { payer: a = t.rpc().getDefaultFeePayer() } = r, - s = (n = e.authority) !== null && n !== void 0 ? n : t.identity(), - c = - (i = e.index) !== null && i !== void 0 - ? i - : e.candyMachine.itemsLoaded, - { items: u } = e; - return ( - z6t(e.candyMachine, c), - j6t(e.candyMachine, c, u.length), - U6t(u), - ct - .make() - .setFeePayer(a) - .add({ - instruction: (0, H6t.createAddConfigLinesInstruction)( - { candyMachine: e.candyMachine.address, authority: s.publicKey }, - { index: c.toNumber(), configLines: u } - ), - signers: [s], - key: - (o = e.instructionKey) !== null && o !== void 0 - ? o - : "insertItems", - }) - ); - }; - m(); - g(); - var Hce = qe(hm(), 1), - tS = qe(Le(), 1); - m(); - g(); - var Q9 = qe(hm(), 1); - var W6t = Lu(Q9.CandyMachine), - G6t = wc(Q9.CandyMachine), - eD = Lu(Q9.CollectionPDA), - F4n = wc(Q9.CollectionPDA); - var AGr = "MintCandyMachineV2Operation", - Vce = ot(AGr), - J6t = { - async handle(t, e, r) { - K6t(t.input.candyMachine, r.payer); - let n = await GOe(e, t.input, r); - r.throwIfCanceled(); - let i = go(e, r.confirmOptions), - o = await n.sendAndConfirm(e, i); - r.throwIfCanceled(); - let a; - try { - a = await e.nfts().findByMint( - { - mintAddress: o.mintSigner.publicKey, - tokenAddress: o.tokenAddress, - }, - r - ); - } catch (s) { - throw new Uce(e.rpc().getSolanaExporerUrl(o.response.signature), s); - } - return { nft: a, ...o }; - }, - }, - GOe = async (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - candyMachine: a, - newMint: s = tS.Keypair.generate(), - newOwner: c = t.identity().publicKey, - newToken: u, - } = e, - h = t.programs().getTokenMetadata(i).address, - w = t.nfts().pdas().metadata({ mint: s.publicKey, programs: i }), - M = t.nfts().pdas().masterEdition({ mint: s.publicKey, programs: i }), - k = Bce(a.address), - O = x0(a.address), - D = eD(await t.rpc().getAccount(O)), - F = await t - .tokens() - .builders() - .createTokenWithMint( - { - decimals: 0, - initialSupply: Jo(1), - mint: s, - mintAuthority: o, - freezeAuthority: o.publicKey, - owner: c, - token: u, - createMintAccountInstructionKey: - e.createMintAccountInstructionKey, - initializeMintInstructionKey: e.initializeMintInstructionKey, - createAssociatedTokenAccountInstructionKey: - e.createAssociatedTokenAccountInstructionKey, - createTokenAccountInstructionKey: - e.createTokenAccountInstructionKey, - initializeTokenInstructionKey: e.initializeTokenInstructionKey, - mintTokensInstructionKey: e.mintTokensInstructionKey, - }, - { payer: o, programs: i } - ), - { tokenAddress: N } = F.getContext(), - q = (0, Hce.createMintNftInstruction)( - { - candyMachine: a.address, - candyMachineCreator: k, - payer: o.publicKey, - wallet: a.walletAddress, - metadata: w, - mint: s.publicKey, - mintAuthority: o.publicKey, - updateAuthority: o.publicKey, - masterEdition: M, - tokenMetadataProgram: h, - clock: tS.SYSVAR_CLOCK_PUBKEY, - recentBlockhashes: tS.SYSVAR_SLOT_HASHES_PUBKEY, - instructionSysvarAccount: tS.SYSVAR_INSTRUCTIONS_PUBKEY, - }, - { creatorBump: k.bump } - ); - if (a.whitelistMintSettings) { - var z; - let Z = - (z = e.whitelistToken) !== null && z !== void 0 - ? z - : t.tokens().pdas().associatedTokenAccount({ - mint: a.whitelistMintSettings.mint, - owner: o.publicKey, - }); - q.keys.push( - { pubkey: Z, isWritable: !0, isSigner: !1 }, - { - pubkey: a.whitelistMintSettings.mint, - isWritable: !0, - isSigner: !1, - }, - { pubkey: o.publicKey, isWritable: !1, isSigner: !0 } - ); - } - if (a.tokenMintAddress) { - var H; - let Z = - (H = e.payerToken) !== null && H !== void 0 - ? H - : t.tokens().pdas().associatedTokenAccount({ - mint: a.tokenMintAddress, - owner: o.publicKey, - }); - q.keys.push( - { pubkey: Z, isWritable: !0, isSigner: !1 }, - { pubkey: o.publicKey, isWritable: !1, isSigner: !0 } - ); - } - return ct - .make() - .setFeePayer(o) - .setContext({ mintSigner: s, tokenAddress: N }) - .add(F) - .add({ - instruction: q, - signers: [o, s], - key: - (n = e.mintNftInstructionKey) !== null && n !== void 0 - ? n - : "mintNft", - }) - .when(D.exists, (Z) => { - var $; - $b(D); - let ue = D.data.mint, - te = t.nfts().pdas().metadata({ mint: ue, programs: i }), - ne = t.nfts().pdas().masterEdition({ mint: ue, programs: i }), - A = t.nfts().pdas().collectionAuthorityRecord({ - mint: ue, - collectionAuthority: D.publicKey, - programs: i, - }); - return Z.add({ - instruction: (0, Hce.createSetCollectionDuringMintInstruction)({ - candyMachine: a.address, - metadata: w, - payer: o.publicKey, - collectionPda: D.publicKey, - tokenMetadataProgram: h, - instructions: tS.SYSVAR_INSTRUCTIONS_PUBKEY, - collectionMint: D.data.mint, - collectionMetadata: te, - collectionMasterEdition: ne, - authority: a.authorityAddress, - collectionAuthorityRecord: A, - }), - signers: [o], - key: - ($ = e.setCollectionInstructionKey) !== null && $ !== void 0 - ? $ - : "setCollection", - }); - }); - }; - m(); - g(); - var e3 = qe(hm(), 1), - $6t = qe(Jse(), 1); - var Z6t = "UpdateCandyMachineV2Operation", - Wce = ot(Z6t), - X6t = { - async handle(t, e, r) { - let { - candyMachine: n, - authority: i = e.identity(), - newAuthority: o, - newCollection: a, - ...s - } = t.input, - c = N6t(n), - u = PV(n.address, c), - h = PV(n.address, { ...c, ...s }), - { data: w, wallet: M, tokenMint: k } = h, - O = !(0, $6t.default)(h, u), - D = JOe( - e, - { - candyMachine: n, - authority: i, - newData: O ? { ...w, wallet: M, tokenMint: k } : void 0, - newCollection: a, - newAuthority: o, - }, - r - ); - if (D.isEmpty()) throw new Nv(Z6t); - return D.sendAndConfirm(e, r.confirmOptions); - }, - }, - JOe = (t, e, r = {}) => { - let { programs: n, payer: i = t.rpc().getDefaultFeePayer() } = r, - { - candyMachine: o, - authority: a = t.identity(), - newData: s, - newAuthority: c, - newCollection: u, - } = e, - h = t.programs().getTokenMetadata(n).address, - w = !!c && !c.equals(a.publicKey), - M = u && o.collectionMintAddress && o.collectionMintAddress.equals(u), - k = !!u && !M, - O = !k && u === null && o.collectionMintAddress !== null; - return ct - .make() - .setFeePayer(i) - .when(!!s, (D) => { - var F; - let N = s, - q = s?.wallet, - z = s?.tokenMint, - H = (0, e3.createUpdateCandyMachineInstruction)( - { candyMachine: o.address, authority: a.publicKey, wallet: q }, - { data: N } - ); - return ( - z && H.keys.push({ pubkey: z, isWritable: !1, isSigner: !1 }), - D.add({ - instruction: H, - signers: [a], - key: - (F = e.updateInstructionKey) !== null && F !== void 0 - ? F - : "update", - }) - ); - }) - .when(k, (D) => { - var F; - let N = u, - q = t.nfts().pdas().metadata({ mint: N, programs: n }), - z = t.nfts().pdas().masterEdition({ mint: N, programs: n }), - H = x0(o.address), - Z = t.nfts().pdas().collectionAuthorityRecord({ - mint: N, - collectionAuthority: H, - programs: n, - }); - return D.add({ - instruction: (0, e3.createSetCollectionInstruction)({ - candyMachine: o.address, - authority: a.publicKey, - collectionPda: H, - payer: i.publicKey, - metadata: q, - mint: N, - edition: z, - collectionAuthorityRecord: Z, - tokenMetadataProgram: h, - }), - signers: [i, a], - key: - (F = e.setCollectionInstructionKey) !== null && F !== void 0 - ? F - : "setCollection", - }); - }) - .when(O, (D) => { - var F; - let N = o.collectionMintAddress, - q = t.nfts().pdas().metadata({ mint: N, programs: n }), - z = x0(o.address), - H = t.nfts().pdas().collectionAuthorityRecord({ - mint: N, - collectionAuthority: z, - programs: n, - }); - return D.add({ - instruction: (0, e3.createRemoveCollectionInstruction)({ - candyMachine: o.address, - authority: a.publicKey, - collectionPda: z, - metadata: q, - mint: N, - collectionAuthorityRecord: H, - tokenMetadataProgram: h, - }), - signers: [a], - key: - (F = e.removeCollectionInstructionKey) !== null && F !== void 0 - ? F - : "removeCollection", - }); - }) - .when(w, (D) => { - var F, N; - return D.add({ - instruction: (0, e3.createUpdateAuthorityInstruction)( - { - candyMachine: o.address, - authority: a.publicKey, - wallet: - (F = s?.wallet) !== null && F !== void 0 - ? F - : o.walletAddress, - }, - { newAuthority: c } - ), - signers: [a], - key: - (N = e.updateAuthorityInstructionKey) !== null && N !== void 0 - ? N - : "updateAuthority", - }); - }); - }; - var Gce = class { - constructor(e) { - this.metaplex = e; - } - create(e, r) { - return UOe(this.metaplex, e, r); - } - delete(e, r) { - return KOe(this.metaplex, e, r); - } - insertItems(e, r) { - return WOe(this.metaplex, e, r); - } - mint(e, r) { - return GOe(this.metaplex, e, r); - } - update(e, r) { - return JOe(this.metaplex, e, r); - } - }; - m(); - g(); - var Y6t = qe(Le(), 1); - var EGr = "FindCandyMachinesV2ByPublicKeyOperation", - Jce = ot(EGr), - Q6t = { - handle: async (t, e, r) => { - let { commitment: n } = r, - { type: i, publicKey: o } = t.input, - a = Qx.accounts(e).mergeConfig({ commitment: n }), - s; - switch (i) { - case "authority": - s = a.candyMachineAccountsForAuthority(o); - break; - case "wallet": - s = a.candyMachineAccountsForWallet(o); - break; - default: - throw new hee(i); - } - let c = await s.get(); - r.throwIfCanceled(); - let u = c.map((F) => x0(F.publicKey)), - h = Object.fromEntries( - c.map((F) => [F.publicKey.toString(), W6t(F)]) - ), - w = [ - ...new Set( - Object.values(h) - .map((F) => { - var N; - return (N = F.data.tokenMint) === null || N === void 0 - ? void 0 - : N.toString(); - }) - .filter((F) => F !== void 0) - ), - ].map((F) => new Y6t.PublicKey(F)), - M = await e.rpc().getMultipleAccounts(w.concat(u), n); - r.throwIfCanceled(); - let k = M.slice(0, w.length), - O = M.slice(-u.length), - D = Object.fromEntries( - k.map((F) => [F.publicKey.toString(), Yb(Zb(F))]) - ); - return gee(c, O, (F, N) => { - var q; - let z = h[F.publicKey.toString()], - H = N ? eD(N) : null, - Z = - (q = z.data.tokenMint) === null || q === void 0 - ? void 0 - : q.toString(); - return Ice(z, F, H, Z ? D[Z] : null); - }); - }, - }; - m(); - g(); - var MGr = "FindCandyMachineV2ByAddressOperation", - $ce = ot(MGr), - e8t = { - handle: async (t, e, r) => { - let { commitment: n } = r, - { address: i } = t.input, - o = x0(i), - a = await e.rpc().getMultipleAccounts([i, o], n), - s = a[0]; - $b(s); - let c = G6t(s), - u = eD(a[1]), - h = c.data.tokenMint - ? await e - .tokens() - .findMintByAddress({ address: c.data.tokenMint }, r) - : null; - return Ice(c, s, u, h); - }, - }; - m(); - g(); - var TGr = "FindMintedNftsByCandyMachineV2Operation", - Zce = ot(TGr), - t8t = { - handle: async (t, e, r) => { - let { candyMachine: n, version: i = 2 } = t.input, - o = i === 2 ? Bce(n) : n; - return await e.nfts().findAllByCreator({ creator: o, position: 1 }, r); - }, - }; - var Xce = class { - constructor(e) { - this.metaplex = e; - } - builders() { - return new Gce(this.metaplex); - } - create(e, r) { - return this.metaplex.operations().execute(Rce(e), r); - } - delete(e, r) { - return this.metaplex.operations().execute(Nce(e), r); - } - findAllBy(e, r) { - return this.metaplex.operations().execute(Jce(e), r); - } - findByAddress(e, r) { - return this.metaplex.operations().execute($ce(e), r); - } - findMintedNfts(e, r) { - return this.metaplex.operations().execute(Zce(e), r); - } - insertItems(e, r) { - return this.metaplex.operations().execute(Kce(e), r); - } - mint(e, r) { - return this.metaplex.operations().execute(Vce(e), r); - } - refresh(e, r) { - return this.findByAddress({ address: Jt(e) }, r); - } - update(e, r) { - return this.metaplex.operations().execute(Wce(e), r); - } - }; - var r8t = () => ({ - install(t) { - let e = t.operations(); - e.register(Rce, F6t), - e.register(Nce, q6t), - e.register($ce, e8t), - e.register(Jce, Q6t), - e.register(Zce, t8t), - e.register(Kce, V6t), - e.register(Vce, J6t), - e.register(Wce, X6t), - (t.candyMachinesV2 = function () { - return new Xce(this); - }); - }, - }); - m(); - g(); - m(); - g(); - m(); - g(); - m(); - g(); - var Vkt = qe(vo(), 1); - var cXr = "UpdateCandyGuardAuthorityOperation", - Sle = ot(cXr), - Wkt = { - async handle(t, e, r) { - return WBe(e, t.input, r).sendAndConfirm(e, r.confirmOptions); - }, - }, - WBe = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { candyGuard: a, newAuthority: s, authority: c = t.identity() } = e, - u = t.programs().getCandyGuard(i); - return ct - .make() - .setFeePayer(o) - .add({ - instruction: (0, Vkt.createSetAuthorityInstruction)( - { candyGuard: a, authority: c.publicKey }, - { newAuthority: s }, - u.address - ), - signers: [c, o], - key: - (n = e.instructionKey) !== null && n !== void 0 - ? n - : "updateCandyGuardAuthority", - }); - }; - m(); - g(); - var Gkt = qe(vo(), 1), - Jkt = qe(Wt(), 1); - m(); - g(); - var Ap = class extends Mu { - constructor(e) { - super({ - ...e, - key: `plugin.candy_machine_v3.${e.key}`, - title: `Candy Machine V3 > ${e.title}`, - source: "plugin", - sourceDetails: "Candy Machine V3", - }); - } - }, - Ale = class extends Ap { - constructor(e, r) { - super({ - options: r, - key: "unregistered_candy_guard", - title: "Unregistered Candy Guard", - problem: `The SDK is trying to access a custom Candy Guard named [${e}] but that guard was not registered in the SDK`, - solution: - "Register your custom guard by calling the `metaplex.candyMachines().guards().register()` method.", - }); - } - }, - Ele = class extends Ap { - constructor(e, r, n) { - super({ - options: n, - key: "candy_machine_is_full", - title: "Candy Machine Is Full", - problem: `You are trying to add an item at index ${e} to a Candy Machine that can only hold a maximum of ${r} items.`, - solution: - "Limit number of items you are adding or create a Candy Machine that can hold more of them.", - }); - } - }, - Mle = class extends Ap { - constructor(e, r, n, i) { - super({ - options: i, - key: "candy_machine_cannot_add_amount", - title: "Candy Machine Cannot Add Amount", - problem: `You are trying to add ${r} items to candy machine starting at index ${e} but it can only hold a maximum of ${n} items.`, - solution: - "Limit number of assets you are adding or create a Candy Machine that can hold more of them.", - }); - } - }, - RV = class extends Ap { - constructor(e, r, n, i, o) { - super({ - options: o, - key: "candy_machine_item_text_too_long", - title: "Candy Machine Item Text Too Long", - problem: `You are trying to add an item to a Candy Machine but its ${r} is too long. The item settings define the ${r} limit as ${i} characters but the following content was provided [${n}] for the item at index ${e}`, - solution: `Reduce the size of the ${r} for the item at index ${e}.`, - }); - } - }, - Tle = class extends Ap { - constructor(e, r, n) { - super({ - options: { ...n, cause: r }, - key: "candy_machine_bot_tax", - title: "Candy Machine Bot Tax", - problem: - "The NFT couldn't be fetched after being minted. This is most likely due to a bot tax that occured during minting. When someone tries to mint an NFT from a Candy Machine which cannot be minted from, the program will succeed and charge a small tax to fight against bots.", - solution: `Ensure you can mint from the Candy Machine. You may want to check the transaction logs for more details: [${e}].`, - }); - } - }, - kle = class extends Ap { - constructor(e, r) { - super({ - options: r, - key: "guard_group_required", - title: "Guard Group Required", - problem: - "The provided Candy Machine defines groups of guards but nogroup label was provided to identity which group we should select.", - solution: `Please provide the label of the group you wish to select from via the \`group\` parameter. The available groups are [${e.join( - ", " - )}]`, - }); - } - }, - Ple = class extends Ap { - constructor(e, r, n) { - super({ - options: n, - key: "selected_guard_group_does_not_exist", - title: "Selected Guard Group Does Not Exist", - problem: `You're trying to select the guard group [${e}] from a Candy Machine but this group does not exists on this Candy Machine.`, - solution: - r.length > 0 - ? `Please provide the label of a group that exists on the Candy Machine. The available groups are [${r.join( - ", " - )}]` - : "There are no guard groups defined on the Candy Machine. Please set the `group` parameter to `null` or remove it altogether.", - }); - } - }, - Bw = class extends Ap { - constructor(e, r) { - super({ - options: r, - key: "guard_mint_settings_missing", - title: "Guard Mint Settings Missing", - problem: `The Candy Machine you are trying to mint from has the [${e}] guard enabled. This guard requires you to provide some additional settings when minting which you did not provide.`, - solution: `Please provide some minting settings for the [${e}] guard via the \`guards\` parameter like so: \`guards.${e} = {...}\`.`, - }); - } - }, - Ole = class extends Ap { - constructor(e, r) { - super({ - options: r, - key: "guard_route_not_supported", - title: "Guard Route Not Supported", - problem: `You are trying to call the route instruction of the [${e}] guard but this guard does not support this feature or did not register it on the SDK.`, - solution: - "Please select a guard that support the route instruction feature. If you are using a custom guard, make sure you registered the route instruction feature by implementing the `routeSettingsParser` method on the guard manifest.", - }); - } - }, - Ble = class extends Ap { - constructor(e) { - super({ - options: e, - key: "candy_guard_required_on_candy_machine", - title: "Candy Guard Required On Candy Machine", - problem: - "The provided Candy Machine does not have a Candy Guard associated with it yet, it is required for the operation you are trying to execute.", - solution: - "Please provide a Candy Machine with an associated Candy Guard account.", - }); - } - }, - Ile = class extends Ap { - constructor(e, r, n) { - super({ - options: n, - key: "guard_not_enabled", - title: "Guard Not Enabled", - problem: r - ? `The guard [${e}] is not enabled on the group [${r}] of the Candy Machine.` - : `The guard [${e}] is not enabled on the Candy Machine.`, - solution: - "Please provide a different guard or select a different group such that the provided guard is enabled on the selected group.", - }); - } - }, - Cle = class extends Ap { - constructor(e, r, n) { - super({ - options: n, - key: "guard_group_label_too_long", - title: "Guard Group Label Too Long", - problem: `The provided group label [${e}] is too long. Group labels cannot be longer than ${r} characters.`, - solution: "Please provide a shorter group label.", - }); - } - }; - var $kt = "CallCandyGuardRouteOperation", - Rle = Zkt; - function Zkt(t) { - return { key: $kt, input: t }; - } - Zkt.key = $kt; - var Xkt = { - async handle(t, e, r) { - return GBe(e, t.input, r).sendAndConfirm(e, r.confirmOptions); - }, - }, - GBe = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { candyMachine: a, guard: s, settings: c, group: u = null } = e; - if (!a.candyGuard) throw new Ble(); - let h = t - .candyMachines() - .guards() - .parseRouteSettings(a.address, a.candyGuard, o, s, c, u, i), - w = [o, ...h.signers], - M = (0, Gkt.createRouteInstruction)( - { - candyGuard: a.candyGuard.address, - candyMachine: a.address, - payer: o.publicKey, - }, - { args: { guard: 0, data: h.arguments }, label: u }, - t.programs().getCandyGuard(i).address - ); - M.keys.push(...h.accountMetas); - let O = t - .candyMachines() - .guards() - .forCandyGuardProgram(i) - .findIndex((D) => D.name === s); - return ( - Jkt.u8.write(M.data, 8, O), - ct - .make() - .setFeePayer(o) - .add({ - instruction: M, - signers: w, - key: - (n = e.instructionKey) !== null && n !== void 0 - ? n - : "callGuardRoute", - }) - ); - }; - m(); - g(); - var ZPt = qe(l3(), 1), - XPt = qe(Le(), 1); - m(); - g(); - var GPt = qe(Qr(), 1), - Vle = qe(l3(), 1); - m(); - g(); - var UV = qe(Wt(), 1); - m(); - g(); - var CIe = qe(Qr(), 1), - UPt = (t, e, r = !0) => { - let n = [], - i = 0; - for (let a = 0; a < t.length; a++) { - let s = a % 8; - r ? (i |= Number(t[a]) << s) : (i |= Number(t[a]) >> s), - s === 7 && (n.push(i), (i = 0)); - } - let o = CIe.Buffer.from(n); - return e === void 0 ? o : CIe.Buffer.concat([o], e); - }, - MD = (t, e, r = 0, n = !0) => { - let i = [], - o = Math.ceil(e / 8), - a = t.slice(r, r + o); - for (let s of a) - for (let c = 0; c < 8; c++) - n - ? (i.push(Boolean(s & 1)), (s >>= 1)) - : (i.push(Boolean(s & 128)), (s <<= 1)); - return [i.slice(0, e), r + o]; - }; - var HPt = (t, e, r, n, i = 0) => { - let o = UV.u32.read(t, i); - i += 4; - let { nameLength: a } = n, - { uriLength: s } = n, - c = a + s, - u = c * e, - h = t.slice(i, i + u); - i += u; - let [w] = MD(t, e, i, !1); - i += Math.floor(e / 8) + 1; - let k = UV.uniformFixedSizeArray(UV.u32, e).read(t, i).slice(0, r), - O = e - r, - D = (N) => (n.isSequential ? N < O : !k.includes(N)), - F = []; - return ( - w.forEach((N, q) => { - if (!N) return; - let z = q * c, - H = z + a, - Z = h.slice(z, z + a).toString("utf8"), - $ = h.slice(H, H + s).toString("utf8"), - ue = KPt(n.prefixName, q), - te = KPt(n.prefixUri, q); - F.push({ index: q, minted: D(q), name: ue + Wc(Z), uri: te + Wc($) }); - }), - { itemsLoaded: o, items: F, itemsLoadedMap: w, itemsLeftToMint: k } - ); - }, - KPt = (t, e) => t.replace("$ID+1$", `${e + 1}`).replace("$ID$", `${e}`); - m(); - g(); - var VPt = (t, e) => typeof e == "object" && e.model === t; - var UO = (t) => VPt("candyMachine", t); - var JPt = (t, e = null) => { - let r = WN(Vle.CandyMachine, Vle.candyMachineBeet.description), - n = GN(t, r), - i = Sr(n.data.data.itemsAvailable), - o = Sr(n.data.itemsRedeemed), - a = Sr(i.sub(o)), - s = [], - c = 0, - u = !0, - { hiddenSettings: h } = n.data.data, - { configLineSettings: w } = n.data.data, - M; - if (h) M = { ...h, type: "hidden" }; - else { - ba(!!w, "Expected either hidden or config line settings"), - (M = { ...w, type: "configLines" }); - let k = HPt(t.data, i.toNumber(), a.toNumber(), M, 850); - (s = k.items), (c = k.itemsLoaded), (u = k.itemsLoaded >= i.toNumber()); - } - return { - model: "candyMachine", - address: t.publicKey, - accountInfo: wae(t), - authorityAddress: n.data.authority, - mintAuthorityAddress: n.data.mintAuthority, - collectionMintAddress: n.data.collectionMint, - symbol: Wc(n.data.data.symbol), - sellerFeeBasisPoints: n.data.data.sellerFeeBasisPoints, - isMutable: n.data.data.isMutable, - maxEditionSupply: Sr(n.data.data.maxSupply), - creators: n.data.data.creators.map((k) => ({ - ...k, - share: k.percentageShare, - })), - items: s, - itemsAvailable: i, - itemsMinted: o, - itemsRemaining: a, - itemsLoaded: c, - isFullyLoaded: u, - itemSettings: M, - featureFlags: MD( - Sr(n.data.features).toArrayLike(GPt.Buffer, "le", 8), - 64 - )[0], - candyGuard: e, - }; - }, - KV = (t) => ({ - itemsAvailable: t.itemsAvailable, - symbol: t.symbol, - sellerFeeBasisPoints: t.sellerFeeBasisPoints, - maxSupply: t.maxEditionSupply, - isMutable: t.isMutable, - creators: t.creators.map((e) => ({ - ...e, - verified: !1, - percentageShare: e.share, - })), - configLineSettings: - t.itemSettings.type === "configLines" ? t.itemSettings : null, - hiddenSettings: t.itemSettings.type === "hidden" ? t.itemSettings : null, - }), - $Pt = (t) => { - if (t.hiddenSettings) return 850; - ba( - !!t.configLineSettings, - "No config line settings nor hidden settings were provided. Please provide one of them." - ); - let e = Sr(t.itemsAvailable).toNumber(), - r = t.configLineSettings.nameLength + t.configLineSettings.uriLength; - return Math.ceil( - 850 + 4 + e * r + (4 + Math.floor(e / 8) + 1) + (4 + e * 4) - ); - }; - var YPt = "CreateCandyMachineOperation", - Wle = QPt; - function QPt(t) { - return { key: YPt, input: t }; - } - QPt.key = YPt; - var e4t = { - async handle(t, e, r) { - let n = await RIe(e, t.input, r); - r.throwIfCanceled(); - let i = go(e, r.confirmOptions), - o = await n.sendAndConfirm(e, i); - r.throwIfCanceled(); - let a = await e - .candyMachines() - .findByAddress({ address: o.candyMachineSigner.publicKey }, r); - return r.throwIfCanceled(), { ...o, candyMachine: a }; - }, - }, - RIe = async (t, e, r = {}) => { - var n, i, o; - let { programs: a, payer: s = t.rpc().getDefaultFeePayer() } = r, - { - candyMachine: c = XPt.Keypair.generate(), - authority: u = t.identity(), - collection: h, - sellerFeeBasisPoints: w, - itemsAvailable: M, - symbol: k = "", - maxEditionSupply: O = Sr(0), - isMutable: D = !0, - withoutCandyGuard: F = !1, - } = e, - N = - (n = e.creators) !== null && n !== void 0 - ? n - : [{ address: Jt(u), share: 100 }], - q = - (i = e.itemSettings) !== null && i !== void 0 - ? i - : { - type: "configLines", - prefixName: "", - nameLength: 32, - prefixUri: "", - uriLength: 200, - isSequential: !1, - }, - z = t - .candyMachines() - .pdas() - .authority({ candyMachine: c.publicKey, programs: a }), - H = t.nfts().pdas().metadata({ mint: h.address, programs: a }), - Z = t.nfts().pdas().masterEdition({ mint: h.address, programs: a }), - $ = t.nfts().pdas().collectionAuthorityRecord({ - mint: h.address, - collectionAuthority: z, - programs: a, - }), - ue = t.programs().getCandyMachine(a), - te = t.programs().getTokenMetadata(a), - ne = KV({ - itemsAvailable: M, - symbol: k, - sellerFeeBasisPoints: w, - maxEditionSupply: O, - isMutable: D, - creators: N, - itemSettings: q, - }), - A = ct.make().setFeePayer(s).setContext({ candyMachineSigner: c }), - l = Jt(u); - if (!F) { - var p; - let y = t - .candyMachines() - .builders() - .createCandyGuard( - { - base: c, - authority: Jt(u), - guards: (p = e.guards) !== null && p !== void 0 ? p : {}, - groups: e.groups, - }, - { programs: a, payer: s } - ), - { candyGuardAddress: d } = y.getContext(); - (l = d), A.add(y); - } - return A.add( - await t - .system() - .builders() - .createAccount( - { space: $Pt(ne), newAccount: c, program: ue.address }, - { payer: s, programs: a } - ) - ) - .add({ - instruction: (0, ZPt.createInitializeInstruction)( - { - candyMachine: c.publicKey, - authorityPda: z, - authority: Jt(u), - payer: s.publicKey, - collectionMetadata: H, - collectionMint: h.address, - collectionMasterEdition: Z, - collectionUpdateAuthority: h.updateAuthority.publicKey, - collectionAuthorityRecord: $, - tokenMetadataProgram: te.address, - }, - { data: ne }, - ue.address - ), - signers: [s, c, h.updateAuthority], - key: - (o = e.initializeCandyMachineInstructionKey) !== null && - o !== void 0 - ? o - : "initializeCandyMachine", - }) - .when(!F, (y) => { - if (!kr(u)) - throw new xy("authority", "PublicKey", { - problemSuffix: - "In order to create a Candy Machine with an associated Candy Guard you must provide the authority as a Signer.", - }); - return y.add( - t.candyMachines().builders().wrapCandyGuard( - { - candyMachine: c.publicKey, - candyMachineAuthority: u, - candyGuard: l, - candyGuardAuthority: u, - wrapCandyGuardInstructionKey: e.wrapCandyGuardInstructionKey, - }, - { payer: s, programs: a } - ) - ); - }); - }; - m(); - g(); - var t4t = qe(vo(), 1), - r4t = qe(Le(), 1); - var n4t = "CreateCandyGuardOperation", - Gle = i4t; - function i4t(t) { - return { key: n4t, input: t }; - } - i4t.key = n4t; - var o4t = { - async handle(t, e, r) { - let n = NIe(e, t.input, r), - i = go(e, r.confirmOptions), - o = await n.sendAndConfirm(e, i); - r.throwIfCanceled(); - let a = await e - .candyMachines() - .findCandyGuardByBaseAddress({ address: o.base.publicKey }, r); - return { ...o, candyGuard: a }; - }, - }, - NIe = (t, e, r = {}) => { - var n, i, o, a; - let { programs: s, payer: c = t.rpc().getDefaultFeePayer() } = r, - u = (n = e.base) !== null && n !== void 0 ? n : r4t.Keypair.generate(), - h = - (i = e.authority) !== null && i !== void 0 - ? i - : t.identity().publicKey, - w = t.programs().getCandyGuard(s), - M = t - .candyMachines() - .pdas() - .candyGuard({ base: u.publicKey, programs: s }), - k = t - .candyMachines() - .guards() - .serializeSettings( - e.guards, - (o = e.groups) !== null && o !== void 0 ? o : [], - s - ); - return ct - .make() - .setFeePayer(c) - .setContext({ base: u, candyGuardAddress: M }) - .add({ - instruction: (0, t4t.createInitializeInstruction)( - { - candyGuard: M, - base: u.publicKey, - authority: h, - payer: c.publicKey, - }, - { data: k }, - w.address - ), - signers: [u, c], - key: - (a = e.createCandyGuardInstructionKey) !== null && a !== void 0 - ? a - : "createCandyGuard", - }); - }; - m(); - g(); - var a4t = qe(l3(), 1); - var eQr = "DeleteCandyMachineOperation", - Jle = ot(eQr), - s4t = { - async handle(t, e, r) { - return DIe(e, t.input, r).sendAndConfirm(e, r.confirmOptions); - }, - }, - DIe = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - candyMachine: a, - candyGuard: s, - authority: c = t.identity(), - candyGuardAuthority: u = c, - } = e, - h = t.programs().getCandyMachine(i), - w = ct - .make() - .setFeePayer(o) - .add({ - instruction: (0, a4t.createWithdrawInstruction)( - { candyMachine: a, authority: c.publicKey }, - h.address - ), - signers: [c], - key: - (n = e.deleteCandyMachineInstructionKey) !== null && n !== void 0 - ? n - : "deleteCandyMachine", - }); - return ( - s && - w.add( - t - .candyMachines() - .builders() - .deleteCandyGuard( - { candyGuard: s, authority: u }, - { payer: o, programs: i } - ) - ), - w - ); - }; - m(); - g(); - var u4t = qe(vo(), 1); - var tQr = "DeleteCandyGuardOperation", - $le = ot(tQr), - c4t = { - async handle(t, e, r) { - return FIe(e, t.input, r).sendAndConfirm(e, r.confirmOptions); - }, - }, - FIe = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { candyGuard: a, authority: s = t.identity() } = e, - c = t.programs().getCandyGuard(i); - return ct - .make() - .setFeePayer(o) - .add({ - instruction: (0, u4t.createWithdrawInstruction)( - { candyGuard: a, authority: s.publicKey }, - c.address - ), - signers: [s], - key: - (n = e.deleteCandyGuardInstructionKey) !== null && n !== void 0 - ? n - : "deleteCandyGuard", - }); - }; - m(); - g(); - var h4t = qe(l3(), 1); - m(); - g(); - var l4t = (t, e) => { - if (t.itemsAvailable.lten(t.itemsLoaded)) - throw new Ele(e, t.itemsAvailable.toNumber()); - }, - f4t = (t, e, r) => { - if (e + r > t.itemsAvailable.toNumber()) - throw new Mle(e, r, t.itemsAvailable.toNumber()); - }, - d4t = (t, e) => { - if (t.itemSettings.type !== "configLines") return; - let { nameLength: r } = t.itemSettings, - { uriLength: n } = t.itemSettings; - for (let i = 0; i < e.length; i++) { - if (e[i].name.length > r) throw new RV(i, "name", e[i].name, r); - if (e[i].uri.length > n) throw new RV(i, "uri", e[i].uri, n); - } - }; - var rQr = "InsertCandyMachineItemsOperation", - Zle = ot(rQr), - p4t = { - async handle(t, e, r) { - return LIe(e, t.input, r).sendAndConfirm(e, r.confirmOptions); - }, - }, - LIe = (t, e, r = {}) => { - var n, i, o; - let { programs: a, payer: s = t.rpc().getDefaultFeePayer() } = r, - c = (n = e.authority) !== null && n !== void 0 ? n : t.identity(), - u = - (i = e.index) !== null && i !== void 0 - ? i - : e.candyMachine.itemsLoaded, - { items: h } = e; - l4t(e.candyMachine, u), - f4t(e.candyMachine, u, h.length), - d4t(e.candyMachine, h); - let w = t.programs().getCandyMachine(a); - return ct - .make() - .setFeePayer(s) - .add({ - instruction: (0, h4t.createAddConfigLinesInstruction)( - { candyMachine: e.candyMachine.address, authority: c.publicKey }, - { index: u, configLines: h }, - w.address - ), - signers: [c], - key: - (o = e.instructionKey) !== null && o !== void 0 ? o : "insertItems", - }); - }; - m(); - g(); - var y4t = qe(vo(), 1), - m4t = qe(l3(), 1), - TD = qe(Le(), 1); - var g4t = "MintFromCandyMachineOperation", - Xle = v4t; - function v4t(t) { - return { key: g4t, input: t }; - } - v4t.key = g4t; - var b4t = { - async handle(t, e, r) { - let n = await qIe(e, t.input, r); - r.throwIfCanceled(); - let i = go(e, r.confirmOptions), - o = await n.sendAndConfirm(e, i); - r.throwIfCanceled(); - let a; - try { - a = await e.nfts().findByMint( - { - mintAddress: o.mintSigner.publicKey, - tokenAddress: o.tokenAddress, - }, - r - ); - } catch (c) { - var s; - let { candyGuard: u } = t.input.candyMachine; - if (!u) throw c; - let h = e - .candyMachines() - .guards() - .resolveGroupSettings( - u.guards, - u.groups, - (s = t.input.group) !== null && s !== void 0 ? s : null - ); - throw "botTax" in h - ? new Tle(e.rpc().getSolanaExporerUrl(o.response.signature), c) - : c; - } - return { nft: a, ...o }; - }, - }, - qIe = async (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - candyMachine: a, - collectionUpdateAuthority: s, - mintAuthority: c = t.identity(), - mint: u = TD.Keypair.generate(), - owner: h = o.publicKey, - group: w = null, - guards: M = {}, - token: k, - } = e, - O = t.programs().getCandyMachine(i), - D = t.programs().getCandyGuard(i), - F = t.programs().getTokenMetadata(i), - N = t.programs().getToken(i), - q = t.programs().getSystem(i), - z = t - .candyMachines() - .pdas() - .authority({ candyMachine: a.address, programs: i }), - H = t.nfts().pdas().metadata({ mint: u.publicKey, programs: i }), - Z = t.nfts().pdas().masterEdition({ mint: u.publicKey, programs: i }), - $ = t - .nfts() - .pdas() - .metadata({ mint: a.collectionMintAddress, programs: i }), - ue = t - .nfts() - .pdas() - .masterEdition({ mint: a.collectionMintAddress, programs: i }), - te = t.nfts().pdas().collectionAuthorityRecord({ - mint: a.collectionMintAddress, - collectionAuthority: z, - programs: i, - }), - ne = await t - .tokens() - .builders() - .createTokenWithMint( - { - decimals: 0, - initialSupply: Jo(1), - mint: u, - mintAuthority: o, - freezeAuthority: o.publicKey, - owner: h, - token: k, - createMintAccountInstructionKey: - e.createMintAccountInstructionKey, - initializeMintInstructionKey: e.initializeMintInstructionKey, - createAssociatedTokenAccountInstructionKey: - e.createAssociatedTokenAccountInstructionKey, - createTokenAccountInstructionKey: - e.createTokenAccountInstructionKey, - initializeTokenInstructionKey: e.initializeTokenInstructionKey, - mintTokensInstructionKey: e.mintTokensInstructionKey, - }, - { payer: o, programs: i } - ), - { tokenAddress: A } = ne.getContext(), - l = { - candyMachine: a.address, - payer: o.publicKey, - nftMetadata: H, - nftMint: u.publicKey, - nftMintAuthority: o.publicKey, - nftMasterEdition: Z, - collectionAuthorityRecord: te, - collectionMint: a.collectionMintAddress, - collectionMetadata: $, - collectionMasterEdition: ue, - collectionUpdateAuthority: s, - candyMachineProgram: O.address, - tokenMetadataProgram: F.address, - tokenProgram: N.address, - systemProgram: q.address, - recentSlothashes: TD.SYSVAR_SLOT_HASHES_PUBKEY, - instructionSysvarAccount: TD.SYSVAR_INSTRUCTIONS_PUBKEY, - }, - p, - y; - if (a.candyGuard) { - let { candyGuard: d } = a, - _ = t - .candyMachines() - .guards() - .parseMintSettings(a.address, d, o, M, w, i); - (y = [o, u, ..._.signers]), - (p = (0, y4t.createMintInstruction)( - { - ...l, - candyGuard: a.candyGuard.address, - candyMachineAuthorityPda: z, - }, - { mintArgs: _.arguments, label: w }, - D.address - )), - p.keys.push(..._.accountMetas); - } else - (y = [o, u, c]), - (p = (0, m4t.createMintInstruction)( - { ...l, authorityPda: z, mintAuthority: c.publicKey }, - O.address - )); - return ct - .make() - .setFeePayer(o) - .setContext({ tokenAddress: A, mintSigner: u }) - .add(ne) - .add({ - instruction: p, - signers: y, - key: - (n = e.mintFromCandyMachineInstructionKey) !== null && n !== void 0 - ? n - : "mintNft", - }); - }; - m(); - g(); - var w4t = qe(vo(), 1); - var nQr = "UnwrapCandyGuardOperation", - Yle = ot(nQr), - _4t = { - async handle(t, e, r) { - return zIe(e, t.input, r).sendAndConfirm(e, r.confirmOptions); - }, - }, - zIe = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - candyGuard: a, - candyGuardAuthority: s = t.identity(), - candyMachine: c, - candyMachineAuthority: u = t.identity(), - } = e, - h = t.programs().getCandyMachine(i), - w = t.programs().getCandyGuard(i); - return ct - .make() - .setFeePayer(o) - .add({ - instruction: (0, w4t.createUnwrapInstruction)( - { - candyGuard: a, - authority: s.publicKey, - candyMachine: c, - candyMachineProgram: h.address, - candyMachineAuthority: u.publicKey, - }, - w.address - ), - signers: [s, u], - key: - (n = e.unwrapCandyGuardInstructionKey) !== null && n !== void 0 - ? n - : "unwrapCandyGuard", - }); - }; - m(); - g(); - var f3 = qe(l3(), 1); - var jIe = "UpdateCandyMachineOperation", - Qle = x4t; - function x4t(t) { - return { key: jIe, input: t }; - } - x4t.key = jIe; - var S4t = { - async handle(t, e, r) { - let n = UIe(e, t.input, r); - if (n.isEmpty()) throw new Nv(jIe); - return n.sendAndConfirm(e, r.confirmOptions); - }, - }, - UIe = (t, e, r = {}) => { - let { programs: n, payer: i = t.rpc().getDefaultFeePayer() } = r, - { authority: o = t.identity(), candyGuardAuthority: a = o } = e; - return ct - .make() - .setFeePayer(i) - .add(iQr(t, e, o, n)) - .add(oQr(t, e, o, i, n)) - .add(aQr(t, e, a, i, n)) - .add(sQr(t, e, o, n)) - .add(uQr(t, e, o, n)) - .add(cQr(t, e, a, i, n)); - }, - iQr = (t, e, r, n) => { - var i; - let o = sxe({ - itemsAvailable: e.itemsAvailable, - symbol: e.symbol, - sellerFeeBasisPoints: e.sellerFeeBasisPoints, - maxEditionSupply: e.maxEditionSupply, - isMutable: e.isMutable, - creators: e.creators, - itemSettings: e.itemSettings, - }), - a = t.programs().getCandyMachine(n), - s; - return Object.keys(o).length === 0 - ? ct.make() - : (UO(e.candyMachine) - ? (s = KV({ ...e.candyMachine, ...o })) - : (fxe( - o, - [ - "itemsAvailable", - "symbol", - "sellerFeeBasisPoints", - "maxEditionSupply", - "isMutable", - "creators", - "itemSettings", - ], - efe - ), - (s = KV(o))), - ct.make().add({ - instruction: (0, f3.createUpdateInstruction)( - { candyMachine: Jt(e.candyMachine), authority: r.publicKey }, - { data: s }, - a.address - ), - signers: [r], - key: - (i = e.updateDataInstructionKey) !== null && i !== void 0 - ? i - : "updateCandyMachineData", - })); - }, - oQr = (t, e, r, n, i) => { - var o, a; - if (!e.collection) return ct.make(); - let s = - (o = e.collection.currentCollectionAddress) !== null && o !== void 0 - ? o - : UO(e.candyMachine) - ? e.candyMachine.collectionMintAddress - : null; - if (!s) throw efe(["collection.currentCollectionAddress"]); - let c = t.programs().getTokenMetadata(i), - u = t.programs().getCandyMachine(i), - h = Jt(e.candyMachine), - w = e.collection.address, - M = e.collection.updateAuthority, - k = t - .candyMachines() - .pdas() - .authority({ candyMachine: h, programs: i }), - O = t.nfts().pdas().metadata({ mint: s }), - D = t - .nfts() - .pdas() - .collectionAuthorityRecord({ mint: s, collectionAuthority: k }), - F = t.nfts().pdas().metadata({ mint: w }), - N = t.nfts().pdas().masterEdition({ mint: w }), - q = t - .nfts() - .pdas() - .collectionAuthorityRecord({ mint: w, collectionAuthority: k }); - return ct.make().add({ - instruction: (0, f3.createSetCollectionInstruction)( - { - candyMachine: h, - authority: r.publicKey, - authorityPda: k, - payer: n.publicKey, - collectionMint: s, - collectionMetadata: O, - collectionAuthorityRecord: D, - newCollectionUpdateAuthority: M.publicKey, - newCollectionMetadata: F, - newCollectionMint: w, - newCollectionMasterEdition: N, - newCollectionAuthorityRecord: q, - tokenMetadataProgram: c.address, - }, - u.address - ), - signers: [r, n, M], - key: - (a = e.setCollectionInstructionKey) !== null && a !== void 0 - ? a - : "setCandyMachineCollection", - }); - }, - aQr = (t, e, r, n, i) => { - var o; - let a = sxe({ - candyGuard: e.candyGuard, - guards: e.guards, - groups: e.groups, - }), - s; - return Object.keys(a).length === 0 - ? ct.make() - : (UO(e.candyMachine) && e.candyMachine.candyGuard - ? (s = { - candyGuard: e.candyMachine.candyGuard.address, - guards: e.candyMachine.candyGuard.guards, - groups: e.candyMachine.candyGuard.groups, - ...a, - }) - : (fxe(a, ["candyGuard", "guards", "groups"], efe), (s = a)), - t - .candyMachines() - .builders() - .updateCandyGuard( - { - candyGuard: s.candyGuard, - guards: s.guards, - groups: s.groups, - authority: r, - updateInstructionKey: - (o = e.updateCandyGuardInstructionKey) !== null && - o !== void 0 - ? o - : "updateCandyGuard", - }, - { payer: n, programs: i } - )); - }, - sQr = (t, e, r, n) => { - var i; - if (!e.newMintAuthority) return ct.make(); - let o = t.programs().getCandyMachine(n); - return ct.make().add({ - instruction: (0, f3.createSetMintAuthorityInstruction)( - { - candyMachine: Jt(e.candyMachine), - authority: r.publicKey, - mintAuthority: e.newMintAuthority.publicKey, - }, - o.address - ), - signers: [r, e.newMintAuthority], - key: - (i = e.setAuthorityInstructionKey) !== null && i !== void 0 - ? i - : "setCandyMachineAuthority", - }); - }, - uQr = (t, e, r, n) => { - var i; - if (!e.newAuthority) return ct.make(); - let o = t.programs().getCandyMachine(n); - return ct.make().add({ - instruction: (0, f3.createSetAuthorityInstruction)( - { candyMachine: Jt(e.candyMachine), authority: r.publicKey }, - { newAuthority: e.newAuthority }, - o.address - ), - signers: [r], - key: - (i = e.setAuthorityInstructionKey) !== null && i !== void 0 - ? i - : "setCandyMachineAuthority", - }); - }, - cQr = (t, e, r, n, i) => { - var o; - if (!e.newCandyGuardAuthority) return ct.make(); - let a = - (o = e.candyGuard) !== null && o !== void 0 - ? o - : UO(e.candyMachine) && e.candyMachine.candyGuard - ? e.candyMachine.candyGuard.address - : null; - if (!a) throw efe(["candyGuard"]); - return ct.make().add( - t.candyMachines().builders().updateCandyGuardAuthority( - { - candyGuard: a, - authority: r, - newAuthority: e.newCandyGuardAuthority, - instructionKey: e.setCandyGuardAuthorityInstructionKey, - }, - { payer: n, programs: i } - ) - ); - }, - efe = (t) => - new fee(t, { - problem: - "When passing the Candy Machine as a `PublicKey` instead of a Candy Machine model the SDK cannot rely on current data to fill the gaps within the provided input.", - solutionSuffix: - " Alternatively, you can pass the Candy Machine model instead.", - }); - m(); - g(); - var A4t = qe(vo(), 1); - var E4t = "UpdateCandyGuardOperation", - tfe = M4t; - function M4t(t) { - return { key: E4t, input: t }; - } - M4t.key = E4t; - var T4t = { - async handle(t, e, r) { - return KIe(e, t.input, r).sendAndConfirm(e, r.confirmOptions); - }, - }, - KIe = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - candyGuard: a, - guards: s, - groups: c, - authority: u = t.identity(), - } = e, - h = t.programs().getCandyGuard(i), - w = t.candyMachines().guards().serializeSettings(s, c, i); - return ct - .make() - .setFeePayer(o) - .add({ - instruction: (0, A4t.createUpdateInstruction)( - { candyGuard: a, authority: u.publicKey, payer: o.publicKey }, - { data: w }, - h.address - ), - signers: [u, o], - key: - (n = e.updateInstructionKey) !== null && n !== void 0 - ? n - : "updateCandyGuard", - }); - }; - m(); - g(); - var k4t = qe(vo(), 1); - var lQr = "WrapCandyGuardOperation", - rfe = ot(lQr), - P4t = { - async handle(t, e, r) { - return HIe(e, t.input, r).sendAndConfirm(e, r.confirmOptions); - }, - }, - HIe = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - candyGuard: a, - candyGuardAuthority: s = t.identity(), - candyMachine: c, - candyMachineAuthority: u = t.identity(), - } = e, - h = t.programs().getCandyMachine(i), - w = t.programs().getCandyGuard(i); - return ct - .make() - .setFeePayer(o) - .add({ - instruction: (0, k4t.createWrapInstruction)( - { - candyGuard: a, - authority: s.publicKey, - candyMachine: c, - candyMachineProgram: h.address, - candyMachineAuthority: u.publicKey, - }, - w.address - ), - signers: [s, u], - key: - (n = e.wrapCandyGuardInstructionKey) !== null && n !== void 0 - ? n - : "wrapCandyGuard", - }); - }; - var nfe = class { - constructor(e) { - this.metaplex = e; - } - callGuardRoute(e, r) { - return GBe(this.metaplex, e, r); - } - create(e, r) { - return RIe(this.metaplex, e, r); - } - createCandyGuard(e, r) { - return NIe(this.metaplex, e, r); - } - delete(e, r) { - return DIe(this.metaplex, e, r); - } - deleteCandyGuard(e, r) { - return FIe(this.metaplex, e, r); - } - insertItems(e, r) { - return LIe(this.metaplex, e, r); - } - mint(e, r) { - return qIe(this.metaplex, e, r); - } - unwrapCandyGuard(e, r) { - return zIe(this.metaplex, e, r); - } - update(e, r) { - return UIe(this.metaplex, e, r); - } - updateCandyGuard(e, r) { - return KIe(this.metaplex, e, r); - } - updateCandyGuardAuthority(e, r) { - return WBe(this.metaplex, e, r); - } - wrapCandyGuard(e, r) { - return HIe(this.metaplex, e, r); - } - }; - m(); - g(); - var Uw = qe(Qr(), 1), - VIe = qe(Wt(), 1); - var ife = class { - constructor(e) { - Go(this, "guards", []), (this.metaplex = e); - } - register(...e) { - this.guards.push(...e); - } - get(e) { - let r = this.guards.find((n) => n.name === e); - if (!r) throw new Ale(e); - return r; - } - all() { - return this.guards; - } - forProgram(e = "CandyGuardProgram") { - return ( - typeof e == "object" && "availableGuards" in e - ? e - : this.metaplex.programs().get(e) - ).availableGuards.map((n) => this.get(n)); - } - forCandyGuardProgram(e = []) { - let r = this.metaplex.programs().getCandyGuard(e); - return this.forProgram(r); - } - serializeSettings(e, r = [], n = []) { - let i = this.forCandyGuardProgram(n), - o = (c) => { - let { features: u, buffer: h } = i.reduce( - (w, M, k) => { - var O; - let D = (O = c[M.name]) !== null && O !== void 0 ? O : null; - return ( - (w.features[k] = Boolean(D)), - D && - (w.buffer = Uw.Buffer.concat([ - w.buffer, - z1t(D, M.settingsSerializer), - ])), - w - ); - }, - { features: [], buffer: Uw.Buffer.from([]) } - ); - return Uw.Buffer.concat([UPt(u, 8), h]); - }, - a = o(e), - s = Uw.Buffer.alloc(4); - return ( - VIe.u32.write(s, 0, r.length), - (a = Uw.Buffer.concat([a, s])), - r.forEach((c) => { - if (c.label.length > 6) throw new Cle(c.label, 6); - let u = Uw.Buffer.alloc(6); - u.write(qC(c.label, 6), 0, 6, "utf8"), - (a = Uw.Buffer.concat([a, u, o(c.guards)])); - }), - a - ); - } - deserializeSettings(e, r = "CandyGuardProgram") { - let n = this.forProgram(r), - i = () => { - let c = e.slice(0, 8), - u = MD(c, 64)[0]; - return ( - (e = e.slice(8)), - n.reduce((h, w, M) => { - var k; - let O = (k = u[M]) !== null && k !== void 0 ? k : !1; - if (((h[w.name] = null), !O)) return h; - let [D] = j1t(e, w.settingsSerializer); - return (e = e.slice(w.settingsBytes)), (h[w.name] = D), h; - }, {}) - ); - }, - o = i(), - a = [], - s = VIe.u32.read(e, 0); - e = e.slice(4); - for (let c = 0; c < s; c++) { - let u = Wc(e.slice(0, 6).toString("utf8")); - (e = e.slice(6)), a.push({ label: u, guards: i() }); - } - return { guards: o, groups: a }; - } - resolveGroupSettings(e, r = [], n) { - let i = r.map((s) => s.label), - o = r.find((s) => s.label === n); - if (n && !o) throw new Ple(n, i); - if (r.length === 0) return e; - if (!o) throw new kle(i); - let a = Object.fromEntries( - Object.entries(o.guards).filter(([, s]) => s != null) - ); - return { ...e, ...a }; - } - parseMintSettings(e, r, n, i, o, a = []) { - let s = this.forCandyGuardProgram(a), - c = this.resolveGroupSettings(r.guards, r.groups, o), - u = { arguments: Uw.Buffer.from([]), accountMetas: [], signers: [] }; - return s.reduce((h, w) => { - var M, k; - let O = (M = c[w.name]) !== null && M !== void 0 ? M : null, - D = (k = i[w.name]) !== null && k !== void 0 ? k : null; - if (!w.mintSettingsParser || !O) return h; - let F = w.mintSettingsParser({ - metaplex: this.metaplex, - settings: O, - mintSettings: D, - payer: n, - candyMachine: e, - candyGuard: r.address, - programs: a, - }), - N = this.getAccountMetas(F.remainingAccounts), - q = this.getSigners(F.remainingAccounts); - return ( - (h.arguments = Uw.Buffer.concat([h.arguments, F.arguments])), - h.accountMetas.push(...N), - h.signers.push(...q), - h - ); - }, u); - } - parseRouteSettings(e, r, n, i, o, a, s = []) { - var c; - let u = this.get(i); - if (!u.routeSettingsParser) throw new Ole(i); - let w = - (c = this.resolveGroupSettings(r.guards, r.groups, a)[i]) !== null && - c !== void 0 - ? c - : null; - if (!w) throw new Ile(i, a); - let M = u.routeSettingsParser({ - metaplex: this.metaplex, - settings: w, - routeSettings: o, - payer: n, - candyMachine: e, - candyGuard: r.address, - programs: s, - }); - return { - arguments: M.arguments, - accountMetas: this.getAccountMetas(M.remainingAccounts), - signers: this.getSigners(M.remainingAccounts), - }; - } - getAccountMetas(e) { - return e.map((r) => ({ - pubkey: r.isSigner ? r.address.publicKey : r.address, - isSigner: r.isSigner, - isWritable: r.isWritable, - })); - } - getSigners(e) { - return e.filter((r) => r.isSigner).map((r) => r.address); - } - }; - m(); - g(); - var PD = qe(Qr(), 1); - var ofe = class { - constructor(e) { - this.metaplex = e; - } - authority({ candyMachine: e, programs: r }) { - let n = this.metaplex.programs().getCandyMachine(r); - return Br.find(n.address, [ - PD.Buffer.from("candy_machine", "utf8"), - e.toBuffer(), - ]); - } - candyGuard({ base: e, programs: r }) { - let n = this.metaplex.programs().getCandyGuard(r); - return Br.find(n.address, [ - PD.Buffer.from("candy_guard", "utf8"), - e.toBuffer(), - ]); - } - mintLimitCounter({ - id: e, - user: r, - candyMachine: n, - candyGuard: i, - programs: o, - }) { - let a = this.metaplex.programs().getCandyGuard(o); - return Br.find(a.address, [ - PD.Buffer.from("mint_limit", "utf8"), - PD.Buffer.from([e]), - r.toBuffer(), - i.toBuffer(), - n.toBuffer(), - ]); - } - merkleProof({ - merkleRoot: e, - user: r, - candyMachine: n, - candyGuard: i, - programs: o, - }) { - let a = this.metaplex.programs().getCandyGuard(o); - return Br.find(a.address, [ - PD.Buffer.from("allow_list", "utf8"), - e, - r.toBuffer(), - i.toBuffer(), - n.toBuffer(), - ]); - } - }; - m(); - g(); - var O4t = qe(vo(), 1); - m(); - g(); - var afe = qe(vo(), 1); - var KO = (t, e) => { - let r = WN(afe.CandyGuard, afe.candyGuardBeet.description), - n = GN(t, r), - { guards: i, groups: o } = e - .candyMachines() - .guards() - .deserializeSettings(t.data.slice(73), t.owner); - return { - model: "candyGuard", - address: new Br(n.publicKey, n.data.bump), - accountInfo: wae(t), - baseAddress: n.data.base, - authorityAddress: n.data.authority, - guards: i, - groups: o, - }; - }; - var B4t = "FindCandyGuardsByAuthorityOperation", - sfe = I4t; - function I4t(t) { - return { key: B4t, input: t }; - } - I4t.key = B4t; - var C4t = { - handle: async (t, e, r) => { - let { authority: n } = t.input, - { programs: i, commitment: o } = r, - a = e.programs().getCandyGuard(i), - s = O4t.CandyGuard.gpaBuilder(a.address).addFilter("authority", n), - c = new yf(e, a.address); - return ( - c.mergeConfig({ ...s.config, commitment: o }), - c.getAndMap((u) => KO(u, e)) - ); - }, - }; - m(); - g(); - m(); - g(); - var ufe = qe(vo(), 1), - cfe = qe(l3(), 1); - m(); - g(); - var WIe = [ - "botTax", - "solPayment", - "tokenPayment", - "startDate", - "thirdPartySigner", - "tokenGate", - "gatekeeper", - "endDate", - "allowList", - "mintLimit", - "nftPayment", - "redeemedAmount", - "addressGate", - "nftGate", - "nftBurn", - "tokenBurn", - ], - vCn = WIe.reduce((t, e) => ((t[e] = null), t), {}); - var R4t = qe(Le(), 1), - GIe = { - name: "CandyMachineProgram", - address: cfe.PROGRAM_ID, - errorResolver: (t) => cfe.cusper.errorFromProgramLogs(t.logs, !1), - }, - fQr = (t) => typeof t == "object" && "availableGuards" in t; - function N4t(t) { - ba(fQr(t), "Expected CandyGuardProgram model"); - } - var JIe = { - name: "CandyGuardProgram", - address: ufe.PROGRAM_ID, - errorResolver: (t) => ufe.cusper.errorFromProgramLogs(t.logs, !1), - availableGuards: WIe, - }, - $Ie = { - name: "GatewayProgram", - address: new R4t.PublicKey("gatem74V238djXdzWnJf94Wo1DcnuGkfijbf3AuBhfs"), - }; - var D4t = qe(Le(), 1), - F4t = "FindCandyMachineByAddressOperation", - lfe = L4t; - function L4t(t) { - return { key: F4t, input: t }; - } - L4t.key = F4t; - var q4t = { - async handle(t, e, r) { - let { address: n } = t.input, - { commitment: i, programs: o } = r, - a = e.candyMachines().pdas().candyGuard({ base: n, programs: o }), - [s, c] = await e.rpc().getMultipleAccounts([n, a], i); - r.throwIfCanceled(), $b(s, "CandyMachine"); - let u = JPt(s), - h = u.mintAuthorityAddress; - if (c.exists && c.publicKey.equals(h)) - return { ...u, candyGuard: KO(c, e) }; - if (D4t.PublicKey.isOnCurve(h)) return u; - let w = await e.rpc().getAccount(h, i); - r.throwIfCanceled(); - try { - $b(w); - let M = e.programs().get(w.owner); - return N4t(M), { ...u, candyGuard: KO(w, e) }; - } catch { - return u; - } - }, - }; - m(); - g(); - var z4t = "FindCandyGuardByAddressOperation", - ffe = j4t; - function j4t(t) { - return { key: z4t, input: t }; - } - j4t.key = z4t; - var U4t = { - handle: async (t, e, r) => { - let { address: n } = t.input, - i = await e.rpc().getAccount(n, r.commitment); - return $b(i), KO(i, e); - }, - }; - var dfe = class { - constructor(e) { - (this.metaplex = e), (this.guardsClient = new ife(e)); - } - guards() { - return this.guardsClient; - } - builders() { - return new nfe(this.metaplex); - } - pdas() { - return new ofe(this.metaplex); - } - callGuardRoute(e, r) { - return this.metaplex.operations().execute(Rle(e), r); - } - create(e, r) { - return this.metaplex.operations().execute(Wle(e), r); - } - createCandyGuard(e, r) { - return this.metaplex.operations().execute(Gle(e), r); - } - delete(e, r) { - return this.metaplex.operations().execute(Jle(e), r); - } - deleteCandyGuard(e, r) { - return this.metaplex.operations().execute($le(e), r); - } - findAllCandyGuardsByAuthority(e, r) { - return this.metaplex.operations().execute(sfe(e), r); - } - findByAddress(e, r) { - return this.metaplex.operations().execute(lfe(e), r); - } - findCandyGuardByAddress(e, r) { - return this.metaplex.operations().execute(ffe(e), r); - } - findCandyGuardByBaseAddress(e, r) { - let n = this.pdas().candyGuard({ base: e.address }); - return this.findCandyGuardByAddress({ ...e, address: n }, r); - } - insertItems(e, r) { - return this.metaplex.operations().execute(Zle(e), r); - } - mint(e, r) { - return this.metaplex.operations().execute(Xle(e), r); - } - async refresh(e, r) { - let n = { address: Jt(e) }; - return UO(e) - ? await this.findByAddress(n, r) - : await this.findCandyGuardByAddress(n, r); - } - unwrapCandyGuard(e, r) { - return this.metaplex.operations().execute(Yle(e), r); - } - update(e, r) { - return this.metaplex.operations().execute(Qle(e), r); - } - updateCandyGuard(e, r) { - return this.metaplex.operations().execute(tfe(e), r); - } - updateCandyGuardAuthority(e, r) { - return this.metaplex.operations().execute(Sle(e), r); - } - wrapCandyGuard(e, r) { - return this.metaplex.operations().execute(rfe(e), r); - } - }; - m(); - g(); - var K4t = qe(vo(), 1); - var H4t = { - name: "botTax", - settingsBytes: 9, - settingsSerializer: Ps( - Di(K4t.botTaxBeet), - (t) => ({ ...t, lamports: Xi(t.lamports) }), - (t) => ({ ...t, lamports: t.lamports.basisPoints }) - ), - }; - m(); - g(); - var V4t = qe(Qr(), 1), - W4t = qe(vo(), 1); - var G4t = { - name: "solPayment", - settingsBytes: 40, - settingsSerializer: Ps( - Di(W4t.solPaymentBeet), - (t) => ({ ...t, amount: Xi(t.lamports) }), - (t) => ({ ...t, lamports: t.amount.basisPoints }) - ), - mintSettingsParser: ({ settings: t }) => ({ - arguments: V4t.Buffer.from([]), - remainingAccounts: [ - { isSigner: !1, address: t.destination, isWritable: !0 }, - ], - }), - }; - m(); - g(); - var J4t = qe(Qr(), 1), - $4t = qe(vo(), 1); - var Z4t = { - name: "tokenPayment", - settingsBytes: 72, - settingsSerializer: Ps( - Di($4t.tokenPaymentBeet), - (t) => ({ - mint: t.mint, - amount: Jo(t.amount), - destinationAta: t.destinationAta, - }), - (t) => ({ - mint: t.mint, - amount: t.amount.basisPoints, - destinationAta: t.destinationAta, - }) - ), - mintSettingsParser: ({ - metaplex: t, - settings: e, - payer: r, - programs: n, - }) => { - let i = t.tokens().pdas().associatedTokenAccount({ - mint: e.mint, - owner: r.publicKey, - programs: n, - }); - return { - arguments: J4t.Buffer.from([]), - remainingAccounts: [ - { isSigner: !1, address: i, isWritable: !0 }, - { isSigner: !1, address: e.destinationAta, isWritable: !0 }, - ], - }; - }, - }; - m(); - g(); - var X4t = qe(vo(), 1); - var Y4t = { - name: "startDate", - settingsBytes: 8, - settingsSerializer: Ps( - Di(X4t.startDateBeet), - (t) => ({ date: _p(t.date) }), - (t) => t - ), - }; - m(); - g(); - var Q4t = qe(Qr(), 1), - eOt = qe(vo(), 1); - var tOt = { - name: "thirdPartySigner", - settingsBytes: 32, - settingsSerializer: Di(eOt.thirdPartySignerBeet), - mintSettingsParser: ({ mintSettings: t }) => { - if (!t) throw new Bw("thirdPartySigner"); - return { - arguments: Q4t.Buffer.from([]), - remainingAccounts: [ - { isSigner: !0, address: t.signer, isWritable: !0 }, - ], - }; - }, - }; - m(); - g(); - var rOt = qe(vo(), 1); - var nOt = { - name: "tokenGate", - settingsBytes: 40, - settingsSerializer: Ps( - Di(rOt.tokenGateBeet), - (t) => ({ ...t, amount: Jo(t.amount) }), - (t) => ({ ...t, amount: t.amount.basisPoints }) - ), - mintSettingsParser: ({ - metaplex: t, - settings: e, - payer: r, - programs: n, - }) => { - let i = t.tokens().pdas().associatedTokenAccount({ - mint: e.mint, - owner: r.publicKey, - programs: n, - }); - return { - arguments: Buffer.from([]), - remainingAccounts: [{ isSigner: !1, address: i, isWritable: !1 }], - }; - }, - }; - m(); - g(); - var HV = qe(Qr(), 1), - iOt = qe(vo(), 1); - var oOt = { - name: "gatekeeper", - settingsBytes: 33, - settingsSerializer: Ps( - Di(iOt.gatekeeperBeet), - (t) => ({ ...t, network: t.gatekeeperNetwork }), - (t) => ({ ...t, gatekeeperNetwork: t.network }) - ), - mintSettingsParser: ({ - metaplex: t, - settings: e, - mintSettings: r, - payer: n, - programs: i, - }) => { - var o; - let a = t.programs().getGateway(i), - s = - (o = r?.tokenAccount) !== null && o !== void 0 - ? o - : Br.find(a.address, [ - n.publicKey.toBuffer(), - HV.Buffer.from("gateway"), - HV.Buffer.from([0, 0, 0, 0, 0, 0, 0, 0]), - e.network.toBuffer(), - ]), - c = [{ isSigner: !1, address: s, isWritable: !0 }]; - if (e.expireOnUse) { - let u = Br.find(a.address, [ - e.network.toBuffer(), - HV.Buffer.from("expire"), - ]); - c.push({ isSigner: !1, address: a.address, isWritable: !1 }), - c.push({ isSigner: !1, address: u, isWritable: !1 }); - } - return { arguments: HV.Buffer.from([]), remainingAccounts: c }; - }, - }; - m(); - g(); - var aOt = qe(vo(), 1); - var sOt = { - name: "endDate", - settingsBytes: 8, - settingsSerializer: Ps( - Di(aOt.endDateBeet), - (t) => ({ date: _p(t.date) }), - (t) => t - ), - }; - m(); - g(); - var hfe = qe(Qr(), 1), - uOt = qe(Wt(), 1), - cOt = qe(vo(), 1); - var lOt = { - name: "allowList", - settingsBytes: 32, - settingsSerializer: Ps( - Di(cOt.allowListBeet), - (t) => ({ merkleRoot: new Uint8Array(t.merkleRoot) }), - (t) => ({ merkleRoot: Array.from(t.merkleRoot) }) - ), - mintSettingsParser: ({ - metaplex: t, - settings: e, - payer: r, - candyMachine: n, - candyGuard: i, - }) => ({ - arguments: hfe.Buffer.from([]), - remainingAccounts: [ - { - isSigner: !1, - isWritable: !1, - address: t.candyMachines().pdas().merkleProof({ - merkleRoot: e.merkleRoot, - user: r.publicKey, - candyMachine: n, - candyGuard: i, - }), - }, - ], - }), - routeSettingsParser: ({ - metaplex: t, - settings: e, - routeSettings: r, - programs: n, - candyMachine: i, - candyGuard: o, - payer: a, - }) => { - let s = r.merkleProof, - c = hfe.Buffer.alloc(4); - return ( - uOt.u32.write(c, 0, s.length), - { - arguments: hfe.Buffer.concat([c, ...s]), - remainingAccounts: [ - { - isSigner: !1, - isWritable: !0, - address: t.candyMachines().pdas().merkleProof({ - merkleRoot: e.merkleRoot, - user: a.publicKey, - candyMachine: i, - candyGuard: o, - }), - }, - { - isSigner: !1, - isWritable: !1, - address: t.programs().getSystem(n).address, - }, - ], - } - ); - }, - }; - m(); - g(); - var fOt = qe(Qr(), 1), - dOt = qe(vo(), 1); - var hOt = { - name: "mintLimit", - settingsBytes: 3, - settingsSerializer: Di(dOt.mintLimitBeet), - mintSettingsParser: ({ - metaplex: t, - settings: e, - payer: r, - candyMachine: n, - candyGuard: i, - programs: o, - }) => { - let a = t.candyMachines().pdas().mintLimitCounter({ - id: e.id, - user: r.publicKey, - candyMachine: n, - candyGuard: i, - programs: o, - }); - return { - arguments: fOt.Buffer.from([]), - remainingAccounts: [{ address: a, isSigner: !1, isWritable: !0 }], - }; - }, - }; - m(); - g(); - var pOt = qe(vo(), 1); - var yOt = { - name: "nftPayment", - settingsBytes: 64, - settingsSerializer: Di(pOt.nftPaymentBeet), - mintSettingsParser: ({ - metaplex: t, - settings: e, - mintSettings: r, - payer: n, - programs: i, - }) => { - var o; - if (!r) throw new Bw("nftPayment"); - let a = t.programs().getAssociatedToken(i), - s = - (o = r.tokenAccount) !== null && o !== void 0 - ? o - : t.tokens().pdas().associatedTokenAccount({ - mint: r.mint, - owner: n.publicKey, - programs: i, - }), - c = t.nfts().pdas().metadata({ mint: r.mint, programs: i }), - u = t.tokens().pdas().associatedTokenAccount({ - mint: r.mint, - owner: e.destination, - programs: i, - }); - return { - arguments: Buffer.from([]), - remainingAccounts: [ - { isSigner: !1, address: s, isWritable: !0 }, - { isSigner: !1, address: c, isWritable: !0 }, - { isSigner: !1, address: r.mint, isWritable: !1 }, - { isSigner: !1, address: e.destination, isWritable: !1 }, - { isSigner: !1, address: u, isWritable: !0 }, - { isSigner: !1, address: a.address, isWritable: !1 }, - ], - }; - }, - }; - m(); - g(); - var mOt = qe(vo(), 1); - var gOt = { - name: "redeemedAmount", - settingsBytes: 8, - settingsSerializer: Ps( - Di(mOt.redeemedAmountBeet), - (t) => ({ maximum: Sr(t.maximum) }), - (t) => t - ), - }; - m(); - g(); - var vOt = qe(vo(), 1); - var bOt = { - name: "addressGate", - settingsBytes: 32, - settingsSerializer: Di(vOt.addressGateBeet), - }; - m(); - g(); - var wOt = qe(vo(), 1); - var _Ot = { - name: "nftGate", - settingsBytes: 32, - settingsSerializer: Di(wOt.nftGateBeet), - mintSettingsParser: ({ - metaplex: t, - mintSettings: e, - payer: r, - programs: n, - }) => { - var i; - if (!e) throw new Bw("nftGate"); - let o = - (i = e.tokenAccount) !== null && i !== void 0 - ? i - : t.tokens().pdas().associatedTokenAccount({ - mint: e.mint, - owner: r.publicKey, - programs: n, - }), - a = t.nfts().pdas().metadata({ mint: e.mint, programs: n }); - return { - arguments: Buffer.from([]), - remainingAccounts: [ - { isSigner: !1, address: o, isWritable: !1 }, - { isSigner: !1, address: a, isWritable: !1 }, - ], - }; - }, - }; - m(); - g(); - var xOt = qe(vo(), 1); - var SOt = { - name: "nftBurn", - settingsBytes: 32, - settingsSerializer: Di(xOt.nftBurnBeet), - mintSettingsParser: ({ - metaplex: t, - settings: e, - mintSettings: r, - payer: n, - programs: i, - }) => { - var o; - if (!r) throw new Bw("nftBurn"); - let a = - (o = r.tokenAccount) !== null && o !== void 0 - ? o - : t.tokens().pdas().associatedTokenAccount({ - mint: r.mint, - owner: n.publicKey, - programs: i, - }), - s = t.nfts().pdas().metadata({ mint: r.mint, programs: i }), - c = t.nfts().pdas().masterEdition({ mint: r.mint, programs: i }), - u = t - .nfts() - .pdas() - .metadata({ mint: e.requiredCollection, programs: i }); - return { - arguments: Buffer.from([]), - remainingAccounts: [ - { isSigner: !1, address: a, isWritable: !0 }, - { isSigner: !1, address: s, isWritable: !0 }, - { isSigner: !1, address: c, isWritable: !0 }, - { isSigner: !1, address: r.mint, isWritable: !0 }, - { isSigner: !1, address: u, isWritable: !0 }, - ], - }; - }, - }; - m(); - g(); - var AOt = qe(vo(), 1); - var EOt = { - name: "tokenBurn", - settingsBytes: 40, - settingsSerializer: Ps( - Di(AOt.tokenBurnBeet), - (t) => ({ ...t, amount: Jo(t.amount) }), - (t) => ({ ...t, amount: t.amount.basisPoints }) - ), - mintSettingsParser: ({ - metaplex: t, - settings: e, - payer: r, - programs: n, - }) => { - let i = t.tokens().pdas().associatedTokenAccount({ - mint: e.mint, - owner: r.publicKey, - programs: n, - }); - return { - arguments: Buffer.from([]), - remainingAccounts: [ - { isSigner: !1, address: i, isWritable: !0 }, - { isSigner: !1, address: e.mint, isWritable: !0 }, - ], - }; - }, - }; - var MOt = () => ({ - install(t) { - let e = new dfe(t); - (t.candyMachines = () => e), - t.programs().register(GIe), - (t.programs().getCandyMachine = function (n) { - return this.get(GIe.name, n); - }), - t.programs().register(JIe), - (t.programs().getCandyGuard = function (n) { - return this.get(JIe.name, n); - }), - t.programs().register($Ie), - (t.programs().getGateway = function (n) { - return this.get($Ie.name, n); - }), - e.guards().register(H4t), - e.guards().register(G4t), - e.guards().register(Z4t), - e.guards().register(Y4t), - e.guards().register(tOt), - e.guards().register(nOt), - e.guards().register(oOt), - e.guards().register(sOt), - e.guards().register(lOt), - e.guards().register(hOt), - e.guards().register(yOt), - e.guards().register(gOt), - e.guards().register(bOt), - e.guards().register(_Ot), - e.guards().register(SOt), - e.guards().register(EOt); - let r = t.operations(); - r.register(Rle, Xkt), - r.register(Gle, o4t), - r.register(Wle, e4t), - r.register($le, c4t), - r.register(Jle, s4t), - r.register(ffe, U4t), - r.register(sfe, C4t), - r.register(lfe, q4t), - r.register(Zle, p4t), - r.register(Xle, b4t), - r.register(Yle, _4t), - r.register(Sle, Wkt), - r.register(tfe, T4t), - r.register(Qle, S4t), - r.register(rfe, P4t); - }, - }); - m(); - g(); - var ihe = qe(fh(), 1); - m(); - g(); - m(); - g(); - m(); - g(); - var rde = qe(fh(), 1); - m(); - g(); - var _3 = qe(fh(), 1); - var ede = Sr("18446744073709551615"), - tde = [ - _3.AuthorityScope.Deposit, - _3.AuthorityScope.Buy, - _3.AuthorityScope.PublicBuy, - _3.AuthorityScope.ExecuteSale, - _3.AuthorityScope.Sell, - _3.AuthorityScope.Cancel, - _3.AuthorityScope.Withdraw, - ]; - var qrn = "CreateAuctionHouseOperation", - nde = ot(qrn), - rIt = { - async handle(t, e, r) { - let n = sCe(e, t.input, r), - i = go(e, r.confirmOptions), - o = await n.sendAndConfirm(e, i); - r.throwIfCanceled(); - let a = await e.auctionHouse().findByAddress( - { - address: o.auctionHouseAddress, - auctioneerAuthority: t.input.auctioneerAuthority, - }, - r - ); - return { ...o, auctionHouse: a }; - }, - }, - sCe = (t, e, r = {}) => { - var n, i, o, a, s, c, u; - let { programs: h, payer: w = t.rpc().getDefaultFeePayer() } = r, - M = (n = e.canChangeSalePrice) !== null && n !== void 0 ? n : !1, - k = (i = e.requiresSignOff) !== null && i !== void 0 ? i : M, - O = (o = e.authority) !== null && o !== void 0 ? o : t.identity(), - D = (a = e.treasuryMint) !== null && a !== void 0 ? a : jH, - F = - (s = e.treasuryWithdrawalDestinationOwner) !== null && s !== void 0 - ? s - : t.identity().publicKey, - N = - (c = e.feeWithdrawalDestination) !== null && c !== void 0 - ? c - : t.identity().publicKey; - if (e.auctioneerAuthority && !kr(O)) - throw new xy("authority", "PublicKey", { - problemSuffix: - "You are trying to delegate to an Auctioneer authority which requires the Auction House authority to sign a transaction. But you provided the Auction House authority as a Public Key.", - }); - let q = t - .auctionHouse() - .pdas() - .auctionHouse({ creator: Jt(O), treasuryMint: D, programs: h }), - z = t.auctionHouse().pdas().fee({ auctionHouse: q, programs: h }), - H = t.auctionHouse().pdas().treasury({ auctionHouse: q, programs: h }), - Z = D.equals(jH) - ? F - : t - .tokens() - .pdas() - .associatedTokenAccount({ mint: D, owner: F, programs: h }); - return ct - .make() - .setFeePayer(w) - .setContext({ - auctionHouseAddress: q, - auctionHouseFeeAccountAddress: z, - auctionHouseTreasuryAddress: H, - treasuryWithdrawalDestinationAddress: Z, - }) - .add({ - instruction: (0, rde.createCreateAuctionHouseInstruction)( - { - treasuryMint: D, - payer: w.publicKey, - authority: Jt(O), - feeWithdrawalDestination: N, - treasuryWithdrawalDestination: Z, - treasuryWithdrawalDestinationOwner: F, - auctionHouse: q, - auctionHouseFeeAccount: z, - auctionHouseTreasury: H, - }, - { - bump: q.bump, - feePayerBump: z.bump, - treasuryBump: H.bump, - sellerFeeBasisPoints: e.sellerFeeBasisPoints, - requiresSignOff: k, - canChangeSalePrice: M, - } - ), - signers: [w], - key: - (u = e.instructionKey) !== null && u !== void 0 - ? u - : "createAuctionHouse", - }) - .when(Boolean(e.auctioneerAuthority), ($) => { - var ue, te; - let ne = e.auctioneerAuthority; - return $.add({ - instruction: (0, rde.createDelegateAuctioneerInstruction)( - { - auctionHouse: q, - authority: Jt(O), - auctioneerAuthority: ne, - ahAuctioneerPda: t.auctionHouse().pdas().auctioneer({ - auctionHouse: q, - auctioneerAuthority: ne, - programs: h, - }), - }, - { - scopes: - (ue = e.auctioneerScopes) !== null && ue !== void 0 - ? ue - : tde, - } - ), - signers: [O], - key: - (te = e.delegateAuctioneerInstructionKey) !== null && - te !== void 0 - ? te - : "delegateAuctioneer", - }); - }); - }; - m(); - g(); - var Yw = qe(fh(), 1), - nIt = qe(Le(), 1); - m(); - g(); - var I0 = class extends Mu { - constructor(e) { - super({ - ...e, - key: `plugin.auction_house.${e.key}`, - title: `AuctionHouse > ${e.title}`, - source: "plugin", - sourceDetails: "AuctionHouse", - }); - } - }, - ide = class extends I0 { - constructor(e) { - super({ - options: e, - key: "treasury_destination_owner_required", - title: "Treasury Destination Owner Required", - problem: - 'You are trying to update an Auction House which uses a custom token as a treasury. You have not provided the "treasuryWithdrawalDestinationOwner" because you do not wish to change it. However, the Auction House account does not keep track of that information so we cannot prefill that for you. Thus, if you wish to keep the same treasury withdrawal, you must provide it explicilty.', - solution: - 'Please provide the current "treasuryWithdrawalDestinationOwner" parameter so you can update the other fields.Note that we keep that parameter optional because no Associate Token Account is needed for Auction Houses whose treasury is the native SOL.', - }); - } - }, - Za = class extends I0 { - constructor(e) { - super({ - options: e, - key: "auctioneer_authority_required", - title: "Auctioneer Authority Required", - problem: - 'You are trying to use or fetch an Auction House which delegates to an Auctioneer authority but you have not provided the required "auctioneerAuthority" parameter.', - solution: - 'Please provide the "auctioneerAuthority" parameter so the SDK can figure out which Auctioneer instance to interact with. Note that we keep that parameter optional because no Auctioneer Authority is needed for Auction Houses that use native Auction House behavior.', - }); - } - }, - ode = class extends I0 { - constructor(e) { - super({ - options: e, - key: "auctioneer_partial_sale_not_supported", - title: "Auctioneer Partial Sale Is Not Supported", - problem: - "You are trying to execute a partial sale, but partial orders are not supported in Auctioneer.", - solution: - "Any Partial Buys must be executed against a sale listed through the Auction House Sale.", - }); - } - }, - ade = class extends I0 { - constructor(e) { - super({ - options: e, - key: "bid_and_listing_have_different_auction_houses", - title: "Bid And Listing Have Different Auction Houses", - problem: - "You are trying to use a Bid and a Listing from different Auction Houses.", - solution: - 'Please provide both Bid and Listing from the same Auction House. They should have the same "auctionHouse.address".', - }); - } - }, - sde = class extends I0 { - constructor(e) { - super({ - options: e, - key: "bid_and_listing_have_different_mints", - title: "Bid And Listing Have Different Mints", - problem: - "You are trying to execute a sale using a Bid and a Listing that have different mint addresses.", - solution: - 'Please provide a Bid and a Listing on the same asset in order to execute the sale. They should have the same "asset.address".', - }); - } - }, - ude = class extends I0 { - constructor(e) { - super({ - options: e, - key: "canceled_bid_is_not_allowed", - title: "Canceled Bid Is Not Allowed", - problem: "You are trying to execute a sale using a canceled Bid.", - solution: - "Please provide a Bid that is not cancelled in order to execute the sale.", - }); - } - }, - cde = class extends I0 { - constructor(e) { - super({ - options: e, - key: "canceled_listing_is_not_allowed", - title: "Canceled Listing Is Not Allowed", - problem: "You are trying to execute a sale using a canceled Listing.", - solution: - "Please provide a Listing that is not cancelld in order to execute the sale.", - }); - } - }, - lde = class extends I0 { - constructor(e) { - super({ - options: e, - key: "create_listing_requires_signer", - title: "Create Listing Requires Signer", - problem: - "You are trying to create a listing without providing a signer.", - solution: "Either a seller or authority must be a Signer.", - }); - } - }, - fde = class extends I0 { - constructor(e) { - super({ - options: e, - key: "withdraw_from_buyer_account_requires_signer", - title: "Withdraw From Buyer Account Requires Signer", - problem: - "You are trying to withdraw from buyer account without providing a signer.", - solution: "Either a buyer or authority must be a Signer.", - }); - } - }, - dde = class extends I0 { - constructor(e, r, n) { - super({ - options: n, - key: "partial_price_mismatch_signer", - title: - "The calculated partial price does not equal the partial price provided", - problem: `Expected to receive ${yxe(e)} per SFT but provided ${yxe( - r - )} per SFT.`, - solution: - "The token price must equal the price it has in the listing. If executing a partial sale, divide the total price by the number of total tokens on sale and multiply it by the number of tokens you want to buy.", - }); - } - }, - hde = class extends I0 { - constructor(e) { - super({ - options: e, - key: "find_all_supports_only_three_filters_max", - title: "Find all supports only three filters max", - problem: - "Solana filter allows only to provide four custom filters, one of the filters is internal so it is only possible to provide 3 custom filters.", - solution: "Please provide less filters to the find all query.", - }); - } - }; - var zrn = "CreateBidOperation", - pde = ot(zrn), - iIt = { - async handle(t, e, r) { - let { auctionHouse: n } = t.input, - i = await uCe(e, t.input, r), - o = go(e, r.confirmOptions), - a = await i.sendAndConfirm(e, o); - if ((r.throwIfCanceled(), a.receipt)) - return { - bid: await e - .auctionHouse() - .findBidByReceipt( - { auctionHouse: n, receiptAddress: a.receipt }, - r - ), - ...a, - }; - r.throwIfCanceled(); - let s = { - model: "bid", - lazy: !0, - auctionHouse: n, - tradeStateAddress: a.buyerTradeState, - bookkeeperAddress: a.bookkeeper, - tokenAddress: a.tokenAccount, - buyerAddress: a.buyer, - metadataAddress: a.metadata, - receiptAddress: a.receipt, - purchaseReceiptAddress: null, - isPublic: Boolean(a.tokenAccount), - price: a.price, - tokens: a.tokens.basisPoints, - createdAt: oh(), - canceledAt: null, - }; - return { bid: await e.auctionHouse().loadBid({ lazyBid: s }, r), ...a }; - }, - }, - uCe = async (t, e, r = {}) => { - var n, i, o, a, s, c, u, h; - let { programs: w, payer: M = t.rpc().getDefaultFeePayer() } = r, - { auctionHouse: k } = e, - O = (n = e.tokens) !== null && n !== void 0 ? n : Jo(1), - D = - (i = - (o = e.price) === null || o === void 0 ? void 0 : o.basisPoints) !== - null && i !== void 0 - ? i - : 0, - F = k.isNative ? Xi(D) : ci(D, k.treasuryMint.currency); - if (k.hasAuctioneer && !e.auctioneerAuthority) throw new Za(); - let N = (a = e.buyer) !== null && a !== void 0 ? a : t.identity(), - q = (s = e.authority) !== null && s !== void 0 ? s : k.authorityAddress, - z = t.nfts().pdas().metadata({ mint: e.mintAccount, programs: w }), - H = k.isNative - ? Jt(N) - : t - .tokens() - .pdas() - .associatedTokenAccount({ - mint: k.treasuryMint.address, - owner: Jt(N), - programs: w, - }), - Z = t - .auctionHouse() - .pdas() - .buyerEscrow({ auctionHouse: k.address, buyer: Jt(N), programs: w }), - $ = - (c = e.tokenAccount) !== null && c !== void 0 - ? c - : e.seller - ? t.tokens().pdas().associatedTokenAccount({ - mint: e.mintAccount, - owner: e.seller, - programs: w, - }) - : null, - ue = t - .tokens() - .pdas() - .associatedTokenAccount({ - mint: e.mintAccount, - owner: Jt(N), - programs: w, - }), - te = t - .auctionHouse() - .pdas() - .tradeState({ - auctionHouse: k.address, - wallet: Jt(N), - treasuryMint: k.treasuryMint.address, - tokenMint: e.mintAccount, - price: F.basisPoints, - tokenSize: O.basisPoints, - tokenAccount: $, - programs: w, - }), - ne = { - wallet: Jt(N), - paymentAccount: H, - transferAuthority: Jt(N), - treasuryMint: k.treasuryMint.address, - metadata: z, - escrowPaymentAccount: Z, - authority: Jt(q), - auctionHouse: k.address, - auctionHouseFeeAccount: k.feeAccountAddress, - buyerTradeState: te, - }, - A = { - tradeStateBump: te.bump, - escrowPaymentBump: Z.bump, - buyerPrice: F.basisPoints, - tokenSize: O.basisPoints, - }, - l = $ - ? (0, Yw.createBuyInstruction)({ ...ne, tokenAccount: $ }, A) - : (0, Yw.createPublicBuyInstruction)({ ...ne, tokenAccount: ue }, A); - if (e.auctioneerAuthority) { - let S = t.auctionHouse().pdas().auctioneer({ - auctionHouse: k.address, - auctioneerAuthority: e.auctioneerAuthority.publicKey, - programs: w, - }), - b = { - ...ne, - auctioneerAuthority: e.auctioneerAuthority.publicKey, - ahAuctioneerPda: S, - }; - l = $ - ? (0, Yw.createAuctioneerBuyInstruction)({ ...b, tokenAccount: $ }, A) - : (0, Yw.createAuctioneerPublicBuyInstruction)( - { ...b, tokenAccount: ue }, - A - ); - } - let p = [N, q, e.auctioneerAuthority].filter(kr); - p.forEach((S) => { - let b = l.keys.findIndex(({ pubkey: f }) => f.equals(S.publicKey)); - l.keys[b].isSigner = !0; - }); - let y = - ((u = e.printReceipt) !== null && u !== void 0 ? u : !0) && - !e.auctioneerAuthority, - d = (h = e.bookkeeper) !== null && h !== void 0 ? h : t.identity(), - v = t.auctionHouse().pdas().bidReceipt({ tradeState: te, programs: w }), - _ = ct - .make() - .setFeePayer(M) - .setContext({ - buyerTradeState: te, - tokenAccount: $, - metadata: z, - buyer: Jt(N), - receipt: y ? v : null, - bookkeeper: y ? d.publicKey : null, - price: F, - tokens: O, - }); - return ( - $ || - (await t.rpc().getAccount(ue)).exists || - _.add( - await t - .tokens() - .builders() - .createToken({ mint: e.mintAccount, owner: Jt(N) }) - ), - _.add({ instruction: l, signers: p, key: "buy" }).when(y, (S) => - S.add({ - instruction: (0, Yw.createPrintBidReceiptInstruction)( - { - receipt: v, - bookkeeper: d.publicKey, - instruction: nIt.SYSVAR_INSTRUCTIONS_PUBKEY, - }, - { receiptBump: v.bump } - ), - signers: [d], - key: "printBidReceipt", - }) - ) - ); - }; - m(); - g(); - var KD = qe(fh(), 1), - oIt = qe(Le(), 1); - var jrn = "CreateListingOperation", - yde = ot(jrn), - aIt = { - async handle(t, e, r) { - let { auctionHouse: n } = t.input, - i = cCe(e, t.input, r), - o = go(e, r.confirmOptions), - a = await i.sendAndConfirm(e, o); - if ((r.throwIfCanceled(), a.receipt)) - return { - listing: await e - .auctionHouse() - .findListingByReceipt( - { receiptAddress: a.receipt, auctionHouse: n }, - r - ), - ...a, - }; - r.throwIfCanceled(); - let s = { - model: "listing", - lazy: !0, - auctionHouse: n, - tradeStateAddress: a.sellerTradeState, - bookkeeperAddress: a.bookkeeper, - sellerAddress: a.seller, - metadataAddress: a.metadata, - receiptAddress: a.receipt, - purchaseReceiptAddress: null, - price: a.price, - tokens: a.tokens.basisPoints, - createdAt: oh(), - canceledAt: null, - }; - return { - listing: await e.auctionHouse().loadListing({ lazyListing: s }, r), - ...a, - }; - }, - }, - cCe = (t, e, r = {}) => { - var n, i, o, a, s; - let { programs: c, payer: u = t.rpc().getDefaultFeePayer() } = r, - { - auctionHouse: h, - auctioneerAuthority: w, - mintAccount: M, - tokens: k = Jo(1), - seller: O = t.identity(), - authority: D = h.authorityAddress, - } = e, - F = w - ? ede - : (n = - (i = e.price) === null || i === void 0 - ? void 0 - : i.basisPoints) !== null && n !== void 0 - ? n - : 0, - N = h.isNative ? Xi(F) : ci(F, h.treasuryMint.currency); - if (h.hasAuctioneer && !w) throw new Za(); - if (!kr(O) && !kr(D)) throw new lde(); - let q = t.nfts().pdas().metadata({ mint: M, programs: c }), - z = - (o = e.tokenAccount) !== null && o !== void 0 - ? o - : t - .tokens() - .pdas() - .associatedTokenAccount({ mint: M, owner: Jt(O), programs: c }), - H = t - .auctionHouse() - .pdas() - .tradeState({ - auctionHouse: h.address, - wallet: Jt(O), - treasuryMint: h.treasuryMint.address, - tokenMint: M, - price: N.basisPoints, - tokenSize: k.basisPoints, - tokenAccount: z, - programs: c, - }), - Z = t - .auctionHouse() - .pdas() - .tradeState({ - auctionHouse: h.address, - wallet: Jt(O), - treasuryMint: h.treasuryMint.address, - tokenMint: M, - price: Xi(0).basisPoints, - tokenSize: k.basisPoints, - tokenAccount: z, - programs: c, - }), - $ = t.auctionHouse().pdas().programAsSigner({ programs: c }), - ue = { - wallet: Jt(O), - tokenAccount: z, - metadata: q, - authority: Jt(D), - auctionHouse: h.address, - auctionHouseFeeAccount: h.feeAccountAddress, - sellerTradeState: H, - freeSellerTradeState: Z, - programAsSigner: $, - }, - te = { - tradeStateBump: H.bump, - freeTradeStateBump: Z.bump, - programAsSignerBump: $.bump, - buyerPrice: N.basisPoints, - tokenSize: k.basisPoints, - }, - ne = (0, KD.createSellInstruction)(ue, te); - w && - (ne = (0, KD.createAuctioneerSellInstruction)( - { - ...ue, - auctioneerAuthority: w.publicKey, - ahAuctioneerPda: t.auctionHouse().pdas().auctioneer({ - auctionHouse: h.address, - auctioneerAuthority: w.publicKey, - programs: c, - }), - }, - te - )); - let A = kr(O) ? O : D, - l = [A, w].filter(kr), - p = ne.keys.findIndex((_) => _.pubkey.equals(A.publicKey)); - (ne.keys[p].isSigner = !0), - ne.keys[p].pubkey.equals(Jt(O)) && (ne.keys[p].isWritable = !0); - let y = ((a = e.printReceipt) !== null && a !== void 0 ? a : !0) && !w, - d = (s = e.bookkeeper) !== null && s !== void 0 ? s : t.identity(), - v = t - .auctionHouse() - .pdas() - .listingReceipt({ tradeState: H, programs: c }); - return ct - .make() - .setFeePayer(u) - .setContext({ - sellerTradeState: H, - freeSellerTradeState: Z, - tokenAccount: z, - metadata: q, - seller: Jt(O), - receipt: y ? v : null, - bookkeeper: y ? d.publicKey : null, - price: N, - tokens: k, - }) - .add({ instruction: ne, signers: l, key: "sell" }) - .when(y, (_) => - _.add({ - instruction: (0, KD.createPrintListingReceiptInstruction)( - { - receipt: v, - bookkeeper: d.publicKey, - instruction: oIt.SYSVAR_INSTRUCTIONS_PUBKEY, - }, - { receiptBump: v.bump } - ), - signers: [d], - key: "printListingReceipt", - }) - ); - }; - m(); - g(); - var x3 = qe(fh(), 1), - sIt = qe(Le(), 1); - var Urn = "ExecuteSaleOperation", - mde = ot(Urn), - uIt = { - async handle(t, e, r) { - let { auctionHouse: n } = t.input, - i = await lCe(e, t.input, r).sendAndConfirm(e, r.confirmOptions); - if ((r.throwIfCanceled(), i.receipt)) - return { - purchase: await e - .auctionHouse() - .findPurchaseByReceipt( - { auctionHouse: n, receiptAddress: i.receipt }, - r - ), - ...i, - }; - let o = { - model: "purchase", - lazy: !0, - auctionHouse: t.input.auctionHouse, - buyerAddress: i.buyer, - sellerAddress: i.seller, - metadataAddress: i.metadata, - bookkeeperAddress: i.bookkeeper, - receiptAddress: i.receipt, - price: i.price, - tokens: i.tokens.basisPoints, - createdAt: oh(), - }; - return { - purchase: await e.auctionHouse().loadPurchase({ lazyPurchase: o }, r), - ...i, - }; - }, - }, - lCe = (t, e, r = {}) => { - var n, i, o; - let { programs: a, payer: s = t.rpc().getDefaultFeePayer() } = r, - { auctionHouse: c, listing: u, bid: h, auctioneerAuthority: w } = e, - { sellerAddress: M, asset: k } = u, - { buyerAddress: O } = h, - { - hasAuctioneer: D, - isNative: F, - treasuryMint: N, - address: q, - authorityAddress: z, - feeAccountAddress: H, - treasuryAccountAddress: Z, - } = c, - $ = h.tokens.basisPoints < u.tokens.basisPoints, - { tokens: ue, price: te } = $ ? u : h, - { price: ne, tokens: A } = h; - if (!u.auctionHouse.address.equals(h.auctionHouse.address)) - throw new ade(); - if (!u.asset.address.equals(h.asset.address)) throw new sde(); - if (h.canceledAt) throw new ude(); - if (u.canceledAt) throw new cde(); - if (D && !w) throw new Za(); - if ($ && D) throw new ode(); - if ($) { - let G = te.basisPoints.div(ue.basisPoints), - L = ne.basisPoints.div(A.basisPoints); - if (!G.eq(L)) - throw new dde( - c.isNative ? Xi(G) : ci(G, c.treasuryMint.currency), - c.isNative ? Xi(L) : ci(L, c.treasuryMint.currency) - ); - } - let l = F - ? M - : t.tokens().pdas().associatedTokenAccount({ - mint: N.address, - owner: M, - programs: a, - }), - p = t - .tokens() - .pdas() - .associatedTokenAccount({ mint: k.address, owner: O, programs: a }), - y = t - .auctionHouse() - .pdas() - .buyerEscrow({ auctionHouse: q, buyer: O, programs: a }), - d = t - .auctionHouse() - .pdas() - .tradeState({ - auctionHouse: q, - wallet: M, - treasuryMint: N.address, - tokenMint: k.address, - price: Xi(0).basisPoints, - tokenSize: ue.basisPoints, - tokenAccount: k.token.address, - programs: a, - }), - v = t.auctionHouse().pdas().programAsSigner(), - _ = { - buyer: O, - seller: M, - tokenAccount: k.token.address, - tokenMint: k.address, - metadata: k.metadataAddress, - treasuryMint: N.address, - escrowPaymentAccount: y, - sellerPaymentReceiptAccount: l, - buyerReceiptTokenAccount: p, - authority: z, - auctionHouse: q, - auctionHouseFeeAccount: H, - auctionHouseTreasury: Z, - buyerTradeState: h.tradeStateAddress, - sellerTradeState: u.tradeStateAddress, - freeTradeState: d, - programAsSigner: v, - }, - S = { - freeTradeStateBump: d.bump, - escrowPaymentBump: y.bump, - programAsSignerBump: v.bump, - buyerPrice: te.basisPoints, - tokenSize: ue.basisPoints, - }, - b = { - ...S, - partialOrderSize: h.tokens.basisPoints, - partialOrderPrice: h.price.basisPoints, - }, - f = $ - ? (0, x3.createExecutePartialSaleInstruction)(_, b) - : (0, x3.createExecuteSaleInstruction)(_, S); - if (w) { - let G = { - ..._, - auctioneerAuthority: w.publicKey, - ahAuctioneerPda: t.auctionHouse().pdas().auctioneer({ - auctionHouse: c.address, - auctioneerAuthority: w.publicKey, - programs: a, - }), - }; - f = (0, x3.createAuctioneerExecuteSaleInstruction)(G, S); - } - k.creators.forEach(({ address: G }) => { - f.keys.push({ pubkey: G, isWritable: !0, isSigner: !1 }), - F || - f.keys.push({ - pubkey: t.tokens().pdas().associatedTokenAccount({ - mint: N.address, - owner: G, - programs: a, - }), - isWritable: !0, - isSigner: !1, - }); - }); - let x = [w].filter(kr), - C = - ((n = e.printReceipt) !== null && n !== void 0 ? n : !0) && - Boolean(u.receiptAddress && h.receiptAddress && !$), - E = (i = e.bookkeeper) !== null && i !== void 0 ? i : t.identity(), - B = t.auctionHouse().pdas().purchaseReceipt({ - listingTradeState: u.tradeStateAddress, - bidTradeState: h.tradeStateAddress, - programs: a, - }); - return ct - .make() - .setFeePayer(s) - .setContext({ - sellerTradeState: u.tradeStateAddress, - buyerTradeState: h.tradeStateAddress, - buyer: O, - seller: M, - metadata: k.metadataAddress, - bookkeeper: C ? E.publicKey : null, - receipt: C ? B : null, - price: te, - tokens: ue, - }) - .add({ - instruction: f, - signers: x, - key: - (o = e.instructionKey) !== null && o !== void 0 ? o : "executeSale", - }) - .when(C, (G) => - G.add({ - instruction: (0, x3.createPrintPurchaseReceiptInstruction)( - { - purchaseReceipt: B, - listingReceipt: u.receiptAddress, - bidReceipt: h.receiptAddress, - bookkeeper: E.publicKey, - instruction: sIt.SYSVAR_INSTRUCTIONS_PUBKEY, - }, - { purchaseReceiptBump: B.bump } - ), - signers: [E], - key: "printPurchaseReceipt", - }) - ); - }; - m(); - g(); - var HD = qe(fh(), 1), - dCe = qe(Jse(), 1); - m(); - g(); - var Krn = (t) => typeof t == "object" && t.model === "auctionHouse"; - var Hrn = (t) => Krn(t) && t.hasAuctioneer; - function cIt(t) { - ba(Hrn(t), "Expected AuctioneerAuctionHouse type"); - } - var fCe = (t, e, r) => ( - t.data.hasAuctioneer && - (ba(!!r, "Auctioneer account is required when hasAuctioneer is true"), - ba( - !!r && r.data.auctionHouse.equals(t.publicKey), - "Auctioneer account does not match the AuctionHouse account" - )), - { - model: "auctionHouse", - address: new Br(t.publicKey, t.data.bump), - creatorAddress: t.data.creator, - authorityAddress: t.data.authority, - treasuryMint: e, - feeAccountAddress: new Br( - t.data.auctionHouseFeeAccount, - t.data.feePayerBump - ), - treasuryAccountAddress: new Br( - t.data.auctionHouseTreasury, - t.data.treasuryBump - ), - feeWithdrawalDestinationAddress: t.data.feeWithdrawalDestination, - treasuryWithdrawalDestinationAddress: - t.data.treasuryWithdrawalDestination, - sellerFeeBasisPoints: t.data.sellerFeeBasisPoints, - requiresSignOff: t.data.requiresSignOff, - canChangeSalePrice: t.data.canChangeSalePrice, - isNative: e.isWrappedSol, - ...(t.data.hasAuctioneer && r - ? { - hasAuctioneer: !0, - auctioneer: { - address: r.publicKey, - authority: r.data.auctioneerAuthority, - scopes: r.data.scopes.reduce( - (n, i, o) => (i ? [...n, o] : n), - [] - ), - }, - } - : { hasAuctioneer: !1 }), - } - ); - var lIt = "UpdateAuctionHouseOperation", - gde = ot(lIt), - fIt = { - async handle(t, e, r) { - let { auctionHouse: n, auctioneerAuthority: i } = t.input, - o = hCe(e, t.input, r); - if (o.isEmpty()) throw new Nv(lIt); - let a = await o.sendAndConfirm(e, r.confirmOptions), - s = n.hasAuctioneer ? n.auctioneer.authority : void 0, - c = await e - .auctionHouse() - .findByAddress( - { address: n.address, auctioneerAuthority: i ?? s }, - r - ); - return { ...a, auctionHouse: c }; - }, - }, - hCe = (t, e, r = {}) => { - var n, i, o, a, s, c; - let { programs: u, payer: h = t.rpc().getDefaultFeePayer() } = r, - w = (n = e.authority) !== null && n !== void 0 ? n : t.identity(), - { auctionHouse: M } = e, - k, - O; - if (M.isNative) { - var D; - (k = - (D = e.treasuryWithdrawalDestinationOwner) !== null && D !== void 0 - ? D - : M.treasuryWithdrawalDestinationAddress), - (O = k); - } else if (e.treasuryWithdrawalDestinationOwner) - (k = e.treasuryWithdrawalDestinationOwner), - (O = t.tokens().pdas().associatedTokenAccount({ - mint: M.treasuryMint.address, - owner: k, - programs: u, - })); - else throw new ide(); - let F = { - authority: M.authorityAddress, - feeWithdrawalDestination: M.feeWithdrawalDestinationAddress, - treasuryWithdrawalDestination: M.treasuryWithdrawalDestinationAddress, - sellerFeeBasisPoints: M.sellerFeeBasisPoints, - requiresSignOff: M.requiresSignOff, - canChangeSalePrice: M.canChangeSalePrice, - }, - N = { - authority: - (i = e.newAuthority) !== null && i !== void 0 ? i : F.authority, - feeWithdrawalDestination: - (o = e.feeWithdrawalDestination) !== null && o !== void 0 - ? o - : F.feeWithdrawalDestination, - treasuryWithdrawalDestination: O, - sellerFeeBasisPoints: - (a = e.sellerFeeBasisPoints) !== null && a !== void 0 - ? a - : F.sellerFeeBasisPoints, - requiresSignOff: - (s = e.requiresSignOff) !== null && s !== void 0 - ? s - : F.requiresSignOff, - canChangeSalePrice: - (c = e.canChangeSalePrice) !== null && c !== void 0 - ? c - : F.canChangeSalePrice, - }, - q = !(0, dCe.default)(F, N), - z = !M.hasAuctioneer && !!e.auctioneerAuthority, - H = - M.hasAuctioneer && - !!e.auctioneerAuthority && - !e.auctioneerAuthority.equals(M.auctioneer.authority), - Z = - M.hasAuctioneer && - !!e.auctioneerScopes && - !(0, dCe.default)( - e.auctioneerScopes.sort(), - M.auctioneer.scopes.sort() - ), - $ = z || H; - return ct - .make() - .setFeePayer(h) - .when(q, (ue) => { - var te, ne, A, l; - return ue.add({ - instruction: (0, HD.createUpdateAuctionHouseInstruction)( - { - treasuryMint: M.treasuryMint.address, - payer: h.publicKey, - authority: w.publicKey, - newAuthority: N.authority, - feeWithdrawalDestination: N.feeWithdrawalDestination, - treasuryWithdrawalDestination: O, - treasuryWithdrawalDestinationOwner: k, - auctionHouse: M.address, - }, - { - sellerFeeBasisPoints: - (te = e.sellerFeeBasisPoints) !== null && te !== void 0 - ? te - : null, - requiresSignOff: - (ne = e.requiresSignOff) !== null && ne !== void 0 - ? ne - : null, - canChangeSalePrice: - (A = e.canChangeSalePrice) !== null && A !== void 0 - ? A - : null, - } - ), - signers: [h, w], - key: - (l = e.instructionKey) !== null && l !== void 0 - ? l - : "updateAuctionHouse", - }); - }) - .when($, (ue) => { - var te, ne; - let A = e.auctioneerAuthority, - l = M.hasAuctioneer ? M.auctioneer.scopes : tde; - return ue.add({ - instruction: (0, HD.createDelegateAuctioneerInstruction)( - { - auctionHouse: M.address, - authority: w.publicKey, - auctioneerAuthority: A, - ahAuctioneerPda: t.auctionHouse().pdas().auctioneer({ - auctionHouse: M.address, - auctioneerAuthority: A, - programs: u, - }), - }, - { - scopes: - (te = e.auctioneerScopes) !== null && te !== void 0 ? te : l, - } - ), - signers: [w], - key: - (ne = e.delegateAuctioneerInstructionKey) !== null && - ne !== void 0 - ? ne - : "delegateAuctioneer", - }); - }) - .when(Z, (ue) => { - var te, ne, A; - cIt(M); - let l = - (te = e.auctioneerAuthority) !== null && te !== void 0 - ? te - : M.auctioneer.authority; - return ue.add({ - instruction: (0, HD.createUpdateAuctioneerInstruction)( - { - auctionHouse: M.address, - authority: w.publicKey, - auctioneerAuthority: l, - ahAuctioneerPda: t.auctionHouse().pdas().auctioneer({ - auctionHouse: M.address, - auctioneerAuthority: l, - programs: u, - }), - }, - { - scopes: - (ne = e.auctioneerScopes) !== null && ne !== void 0 - ? ne - : M.auctioneer.scopes, - } - ), - signers: [w], - key: - (A = e.updateAuctioneerInstructionKey) !== null && A !== void 0 - ? A - : "updateAuctioneer", - }); - }); - }; - m(); - g(); - var Vrn = "DirectBuyOperation", - vde = ot(Vrn), - dIt = { - handle: async (t, e, r) => { - let n = await pCe(e, t.input, r); - return r.throwIfCanceled(), n.sendAndConfirm(e, r.confirmOptions); - }, - }, - pCe = async (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - auctionHouse: a, - auctioneerAuthority: s, - listing: c, - price: u = c.price, - buyer: h = t.identity(), - authority: w = a.authorityAddress, - bookkeeper: M = t.identity(), - createBidInstructionKey: k, - executeSaleInstructionKey: O, - } = e, - { tokens: D, asset: F, sellerAddress: N, receiptAddress: q } = c, - z = - ((n = e.printReceipt) !== null && n !== void 0 ? n : !0) && - Boolean(q); - if (a.hasAuctioneer && !s) throw new Za(); - let H = await t.auctionHouse().builders().bid( - { - auctionHouse: a, - auctioneerAuthority: s, - authority: w, - tokens: D, - price: u, - mintAccount: F.mint.address, - seller: N, - buyer: h, - printReceipt: z, - bookkeeper: M, - instructionKey: k, - }, - { programs: i, payer: o } - ), - { receipt: Z, buyerTradeState: $ } = H.getContext(), - ue = { - model: "bid", - lazy: !1, - auctionHouse: a, - asset: F, - tradeStateAddress: $, - bookkeeperAddress: M.publicKey, - buyerAddress: h.publicKey, - receiptAddress: Z, - purchaseReceiptAddress: null, - price: u, - tokens: D, - canceledAt: null, - createdAt: oh(), - isPublic: !1, - }, - te = t.auctionHouse().builders().executeSale( - { - auctionHouse: a, - auctioneerAuthority: s, - bid: ue, - listing: c, - printReceipt: z, - bookkeeper: M, - instructionKey: O, - }, - { programs: i, payer: o } - ), - { receipt: ne } = te.getContext(), - A = t - .tokens() - .pdas() - .associatedTokenAccount({ - mint: F.address, - owner: Jt(h), - programs: i, - }), - l = { ...F, token: { ...F.token, address: A, ownerAddress: Jt(h) } }, - p = { - auctionHouse: a, - model: "purchase", - lazy: !1, - buyerAddress: Jt(h), - sellerAddress: N, - asset: l, - bookkeeperAddress: Jt(M), - receiptAddress: ne, - price: c.price, - tokens: D, - createdAt: oh(), - }; - return ct.make().setContext({ bid: ue, purchase: p }).add(H).add(te); - }; - m(); - g(); - var VD = qe(fh(), 1), - hIt = qe(Le(), 1); - var Wrn = "CancelBidOperation", - bde = ot(Wrn), - pIt = { - handle: async (t, e, r) => - yCe(e, t.input, r).sendAndConfirm(e, r.confirmOptions), - }, - yCe = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { auctionHouse: a, auctioneerAuthority: s, bid: c } = e, - { - asset: u, - buyerAddress: h, - tradeStateAddress: w, - price: M, - receiptAddress: k, - tokens: O, - isPublic: D, - } = c, - { - authorityAddress: F, - address: N, - feeAccountAddress: q, - hasAuctioneer: z, - } = a; - if (z && !s) throw new Za(); - let H = D - ? t - .tokens() - .pdas() - .associatedTokenAccount({ - mint: u.mint.address, - owner: Jt(h), - programs: i, - }) - : u.token.address, - Z = { - wallet: h, - tokenAccount: H, - tokenMint: u.address, - authority: F, - auctionHouse: N, - auctionHouseFeeAccount: q, - tradeState: w, - }, - $ = { buyerPrice: M.basisPoints, tokenSize: O.basisPoints }, - ue = (0, VD.createCancelInstruction)(Z, $); - s && - (ue = (0, VD.createAuctioneerCancelInstruction)( - { - ...Z, - auctioneerAuthority: s.publicKey, - ahAuctioneerPda: t.auctionHouse().pdas().auctioneer({ - auctionHouse: N, - auctioneerAuthority: s.publicKey, - programs: i, - }), - }, - $ - )); - let te = [s].filter(kr); - return ct - .make() - .setFeePayer(o) - .add({ - instruction: ue, - signers: te, - key: - (n = e.instructionKey) !== null && n !== void 0 ? n : "cancelBid", - }) - .when(Boolean(k), (ne) => - ne.add({ - instruction: (0, VD.createCancelBidReceiptInstruction)({ - receipt: k, - instruction: hIt.SYSVAR_INSTRUCTIONS_PUBKEY, - }), - signers: [], - key: "cancelBidReceipt", - }) - ); - }; - m(); - g(); - var WD = qe(fh(), 1), - yIt = qe(Le(), 1); - var Grn = "CancelListingOperation", - wde = ot(Grn), - mIt = { - handle: async (t, e, r) => - mCe(e, t.input, r).sendAndConfirm(e, r.confirmOptions), - }, - mCe = (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { auctionHouse: a, auctioneerAuthority: s, listing: c } = e, - { - asset: u, - sellerAddress: h, - receiptAddress: w, - tradeStateAddress: M, - price: k, - tokens: O, - } = c, - { - address: D, - authorityAddress: F, - feeAccountAddress: N, - hasAuctioneer: q, - } = a; - if (q && !s) throw new Za(); - let z = q ? ede : k.basisPoints, - H = { - wallet: h, - tokenAccount: u.token.address, - tokenMint: u.address, - authority: F, - auctionHouse: D, - auctionHouseFeeAccount: N, - tradeState: M, - }, - Z = { buyerPrice: z, tokenSize: O.basisPoints }, - $ = (0, WD.createCancelInstruction)(H, Z); - s && - ($ = (0, WD.createAuctioneerCancelInstruction)( - { - ...H, - auctioneerAuthority: s.publicKey, - ahAuctioneerPda: t.auctionHouse().pdas().auctioneer({ - auctionHouse: D, - auctioneerAuthority: s.publicKey, - programs: i, - }), - }, - Z - )); - let ue = [s].filter(kr); - return ct - .make() - .setFeePayer(o) - .add({ - instruction: $, - signers: ue, - key: - (n = e.instructionKey) !== null && n !== void 0 - ? n - : "cancelListing", - }) - .when(Boolean(w), (te) => - te.add({ - instruction: (0, WD.createCancelListingReceiptInstruction)({ - receipt: w, - instruction: yIt.SYSVAR_INSTRUCTIONS_PUBKEY, - }), - signers: [], - key: "cancelListingReceipt", - }) - ); - }; - m(); - g(); - var _de = qe(fh(), 1); - var Jrn = "DepositToBuyerAccountOperation", - xde = ot(Jrn), - gIt = { - handle: async (t, e, r) => - gCe(e, t.input, r).sendAndConfirm(e, r.confirmOptions), - }, - gCe = (t, e, r = {}) => { - let { programs: n, payer: i = t.rpc().getDefaultFeePayer() } = r, - { - auctionHouse: o, - auctioneerAuthority: a, - amount: s, - instructionKey: c, - buyer: u = t.identity(), - } = e; - if (o.hasAuctioneer && !a) throw new Za(); - let h = o.isNative - ? Jt(u) - : t - .tokens() - .pdas() - .associatedTokenAccount({ - mint: o.treasuryMint.address, - owner: Jt(u), - programs: n, - }), - w = t - .auctionHouse() - .pdas() - .buyerEscrow({ auctionHouse: o.address, buyer: Jt(u), programs: n }), - M = { - wallet: Jt(u), - paymentAccount: h, - transferAuthority: Jt(u), - escrowPaymentAccount: w, - treasuryMint: o.treasuryMint.address, - authority: o.authorityAddress, - auctionHouse: o.address, - auctionHouseFeeAccount: o.feeAccountAddress, - }, - k = { escrowPaymentBump: w.bump, amount: s.basisPoints }, - O = (0, _de.createDepositInstruction)(M, k); - if (a) { - let F = t.auctionHouse().pdas().auctioneer({ - auctionHouse: o.address, - auctioneerAuthority: a.publicKey, - programs: n, - }), - N = { ...M, auctioneerAuthority: a.publicKey, ahAuctioneerPda: F }; - O = (0, _de.createAuctioneerDepositInstruction)({ ...N }, k); - } - let D = [u, a].filter(kr); - return ct - .make() - .setFeePayer(i) - .add({ instruction: O, signers: D, key: c ?? "depositToBuyerAccount" }); - }; - m(); - g(); - m(); - g(); - var vIt = (t) => typeof t == "object" && t.model === "bid" && !t.isPublic; - var Sde = (t, e) => ({ - model: "bid", - lazy: !0, - auctionHouse: e, - tradeStateAddress: new Br(t.data.tradeState, t.data.tradeStateBump), - bookkeeperAddress: t.data.bookkeeper, - buyerAddress: t.data.buyer, - metadataAddress: t.data.metadata, - tokenAddress: t.data.tokenAccount, - receiptAddress: new Br(t.publicKey, t.data.bump), - purchaseReceiptAddress: t.data.purchaseReceipt, - isPublic: Boolean(t.data.tokenAccount), - price: e.isNative - ? Xi(t.data.price) - : ci(t.data.price, e.treasuryMint.currency), - tokens: Sr(t.data.tokenSize), - createdAt: _p(t.data.createdAt), - canceledAt: Y9(t.data.canceledAt), - }); - var $rn = "DirectSellOperation", - Ade = ot($rn), - bIt = { - handle: async (t, e, r) => { - let n = await vCe(e, t.input, r); - return r.throwIfCanceled(), n.sendAndConfirm(e, r.confirmOptions); - }, - }, - vCe = async (t, e, r = {}) => { - var n; - let { programs: i, payer: o = t.rpc().getDefaultFeePayer() } = r, - { - auctionHouse: a, - auctioneerAuthority: s, - bid: c, - seller: u = t.identity(), - authority: h = a.authorityAddress, - bookkeeper: w = t.identity(), - createListingInstructionKey: M, - executeSaleInstructionKey: k, - } = e, - { hasAuctioneer: O } = a, - { tokens: D, price: F, buyerAddress: N } = c, - q = - ((n = e.printReceipt) !== null && n !== void 0 ? n : !0) && - Boolean(c.receiptAddress); - if (O && !s) throw new Za(); - let z = vIt(c) ? c.asset : { ...c.asset, token: e.sellerToken }, - H = t.auctionHouse().builders().list( - { - mintAccount: z.mint.address, - price: F, - auctionHouse: a, - auctioneerAuthority: s, - seller: u, - authority: h, - tokenAccount: z.token.address, - tokens: D, - printReceipt: q, - bookkeeper: w, - instructionKey: M, - }, - { programs: i, payer: o } - ), - { receipt: Z, sellerTradeState: $ } = H.getContext(), - ue = { - model: "listing", - lazy: !1, - auctionHouse: a, - asset: z, - tradeStateAddress: $, - bookkeeperAddress: Jt(w), - sellerAddress: Jt(u), - receiptAddress: Z, - purchaseReceiptAddress: null, - price: F, - tokens: D, - createdAt: oh(), - canceledAt: null, - }, - te = t.auctionHouse().builders().executeSale( - { - auctionHouse: a, - auctioneerAuthority: s, - bid: c, - listing: ue, - printReceipt: q, - bookkeeper: w, - instructionKey: k, - }, - { programs: i, payer: o } - ), - { receipt: ne } = te.getContext(), - A = t - .tokens() - .pdas() - .associatedTokenAccount({ mint: z.address, owner: N, programs: i }), - l = { ...z, token: { ...z.token, address: A, ownerAddress: N } }, - p = { - auctionHouse: a, - model: "purchase", - lazy: !1, - asset: l, - buyerAddress: N, - sellerAddress: Jt(u), - bookkeeperAddress: Jt(w), - receiptAddress: ne, - price: c.price, - tokens: D, - createdAt: oh(), - }; - return ct - .make() - .setFeePayer(o) - .setContext({ listing: ue, purchase: p }) - .add(H) - .add(te); - }; - m(); - g(); - var Ede = qe(fh(), 1); - var Zrn = "WithdrawFromBuyerAccountOperation", - Mde = ot(Zrn), - wIt = { - handle: async (t, e, r) => - bCe(e, t.input, r).sendAndConfirm(e, r.confirmOptions), - }, - bCe = (t, e, r = {}) => { - var n, i, o; - let { programs: a, payer: s = t.rpc().getDefaultFeePayer() } = r, - { auctionHouse: c, auctioneerAuthority: u, amount: h } = e; - if (c.hasAuctioneer && !e.auctioneerAuthority) throw new Za(); - let w = h.basisPoints, - M = (n = e.buyer) !== null && n !== void 0 ? n : t.identity(), - k = (i = e.authority) !== null && i !== void 0 ? i : c.authorityAddress; - if (!kr(M) && !kr(k)) throw new fde(); - let O = t - .auctionHouse() - .pdas() - .buyerEscrow({ auctionHouse: c.address, buyer: Jt(M), programs: a }), - D = { - wallet: Jt(M), - receiptAccount: Jt(M), - escrowPaymentAccount: O, - treasuryMint: c.treasuryMint.address, - authority: Jt(k), - auctionHouse: c.address, - auctionHouseFeeAccount: c.feeAccountAddress, - }, - F = { escrowPaymentBump: O.bump, amount: w }, - N = (0, Ede.createWithdrawInstruction)(D, F); - if (u) { - let Z = t.auctionHouse().pdas().auctioneer({ - auctionHouse: c.address, - auctioneerAuthority: u.publicKey, - programs: a, - }), - $ = { ...D, auctioneerAuthority: u.publicKey, ahAuctioneerPda: Z }; - N = (0, Ede.createAuctioneerWithdrawInstruction)($, F); - } - let q = kr(M) ? M : k, - z = [q, e.auctioneerAuthority].filter(kr), - H = N.keys.findIndex((Z) => Z.pubkey.equals(q.publicKey)); - return ( - (N.keys[H].isSigner = !0), - ct - .make() - .setFeePayer(s) - .add({ - instruction: N, - signers: z, - key: - (o = e.instructionKey) !== null && o !== void 0 - ? o - : "withdrawFromBuyerAccount", - }) - ); - }; - var Tde = class { - constructor(e) { - this.metaplex = e; - } - bid(e, r) { - return uCe(this.metaplex, e, r); - } - buy(e, r) { - return pCe(this.metaplex, e, r); - } - cancelBid(e, r) { - return yCe(this.metaplex, e, r); - } - cancelListing(e, r) { - return mCe(this.metaplex, e, r); - } - createAuctionHouse(e, r) { - return sCe(this.metaplex, e, r); - } - depositToBuyerAccount(e, r) { - return gCe(this.metaplex, e, r); - } - executeSale(e, r) { - return lCe(this.metaplex, e, r); - } - list(e, r) { - return cCe(this.metaplex, e, r); - } - sell(e, r) { - return vCe(this.metaplex, e, r); - } - updateAuctionHouse(e, r) { - return hCe(this.metaplex, e, r); - } - withdrawFromBuyerAccount(e, r) { - return bCe(this.metaplex, e, r); - } - }; - m(); - g(); - var Cd = qe(Qr(), 1); - var kde = class { - constructor(e) { - this.metaplex = e; - } - auctionHouse(e) { - let r = this.programId(e.programs); - return Br.find(r, [ - Cd.Buffer.from("auction_house", "utf8"), - e.creator.toBuffer(), - e.treasuryMint.toBuffer(), - ]); - } - auctioneer(e) { - let r = this.programId(e.programs); - return Br.find(r, [ - Cd.Buffer.from("auctioneer", "utf8"), - e.auctionHouse.toBuffer(), - e.auctioneerAuthority.toBuffer(), - ]); - } - programAsSigner(e) { - let r = this.programId(e?.programs); - return Br.find(r, [ - Cd.Buffer.from("auction_house", "utf8"), - Cd.Buffer.from("signer", "utf8"), - ]); - } - fee(e) { - let r = this.programId(e.programs); - return Br.find(r, [ - Cd.Buffer.from("auction_house", "utf8"), - e.auctionHouse.toBuffer(), - Cd.Buffer.from("fee_payer", "utf8"), - ]); - } - treasury(e) { - let r = this.programId(e.programs); - return Br.find(r, [ - Cd.Buffer.from("auction_house", "utf8"), - e.auctionHouse.toBuffer(), - Cd.Buffer.from("treasury", "utf8"), - ]); - } - buyerEscrow(e) { - let r = this.programId(e.programs); - return Br.find(r, [ - Cd.Buffer.from("auction_house", "utf8"), - e.auctionHouse.toBuffer(), - e.buyer.toBuffer(), - ]); - } - tradeState(e) { - let r = this.programId(e.programs); - return Br.find(r, [ - Cd.Buffer.from("auction_house", "utf8"), - e.wallet.toBuffer(), - e.auctionHouse.toBuffer(), - ...(e.tokenAccount ? [e.tokenAccount.toBuffer()] : []), - e.treasuryMint.toBuffer(), - e.tokenMint.toBuffer(), - e.price.toArrayLike(Cd.Buffer, "le", 8), - e.tokenSize.toArrayLike(Cd.Buffer, "le", 8), - ]); - } - listingReceipt(e) { - let r = this.programId(e.programs); - return Br.find(r, [ - Cd.Buffer.from("listing_receipt", "utf8"), - e.tradeState.toBuffer(), - ]); - } - bidReceipt(e) { - let r = this.programId(e.programs); - return Br.find(r, [ - Cd.Buffer.from("bid_receipt", "utf8"), - e.tradeState.toBuffer(), - ]); - } - purchaseReceipt(e) { - let r = this.programId(e.programs); - return Br.find(r, [ - Cd.Buffer.from("purchase_receipt", "utf8"), - e.listingTradeState.toBuffer(), - e.bidTradeState.toBuffer(), - ]); - } - programId(e) { - return this.metaplex.programs().getAuctionHouse(e).address; - } - }; - m(); - g(); - m(); - g(); - var dh = qe(fh(), 1); - var MDn = Lu(dh.Auctioneer), - _It = wc(dh.Auctioneer), - TDn = Lu(dh.AuctionHouse), - xIt = wc(dh.AuctionHouse), - kDn = Lu(dh.ListingReceipt), - Pde = wc(dh.ListingReceipt), - PDn = Lu(dh.BidReceipt), - Ode = wc(dh.BidReceipt), - ODn = Lu(dh.PurchaseReceipt), - Bde = wc(dh.PurchaseReceipt); - var Xrn = "FindAuctionHouseByAddressOperation", - Ide = ot(Xrn), - SIt = { - handle: async (t, e, r) => { - let { programs: n, commitment: i } = r, - { address: o, auctioneerAuthority: a } = t.input, - s = a - ? e.auctionHouse().pdas().auctioneer({ - auctionHouse: o, - auctioneerAuthority: a, - programs: n, - }) - : void 0, - c = [o, s].filter((k) => !!k), - u = await e.rpc().getMultipleAccounts(c, i); - r.throwIfCanceled(); - let h = xIt(u[0]), - w = await e - .tokens() - .findMintByAddress({ address: h.data.treasuryMint }, r); - if ((r.throwIfCanceled(), !h.data.hasAuctioneer)) return fCe(h, w); - if (!u[1] || !u[1].exists) throw new Za(); - let M = _It(u[1]); - return fCe(h, w, M); - }, - }; - m(); - g(); - var Yrn = "FindAuctionHouseByCreatorAndMintOperation", - Cde = ot(Yrn), - AIt = { - handle: async (t, e, r) => { - let { creator: n, treasuryMint: i } = t.input; - return e.auctionHouse().findByAddress( - { - address: e.auctionHouse().pdas().auctionHouse({ - creator: n, - treasuryMint: i, - programs: r.programs, - }), - ...t.input, - }, - r - ); - }, - }; - m(); - g(); - var Qrn = "FindBidByReceiptOperation", - Rde = ot(Qrn), - EIt = { - handle: async (t, e, r) => { - let { receiptAddress: n, auctionHouse: i } = t.input, - o = Ode(await e.rpc().getAccount(n, r.commitment)); - r.throwIfCanceled(); - let a = Sde(o, i); - return e.auctionHouse().loadBid({ lazyBid: a, ...t.input }, r); - }, - }; - m(); - g(); - var enn = "FindBidByTradeStateOperation", - Nde = ot(enn), - MIt = { - handle: async (t, e, r) => { - let { tradeStateAddress: n } = t.input, - i = e - .auctionHouse() - .pdas() - .bidReceipt({ tradeState: n, programs: r.programs }); - return e - .auctionHouse() - .findBidByReceipt({ receiptAddress: i, ...t.input }, r); - }, - }; - m(); - g(); - m(); - g(); - var TIt = qe(Le(), 1); - var kIt = [186, 150, 141, 135, 59, 122, 39, 99], - Fde = TIt.PublicKey.default.toBytes().byteLength, - tnn = kIt.length, - rnn = tnn + Fde, - PIt = rnn + Fde, - OIt = PIt + Fde, - nnn = OIt + Fde, - Dde = class extends yf { - whereDiscriminator(e) { - return this.where(0, Buffer.from(e)); - } - bidReceiptAccounts() { - return this.whereDiscriminator(kIt); - } - whereAuctionHouse(e) { - return this.bidReceiptAccounts().where(PIt, e); - } - whereBuyer(e) { - return this.where(OIt, e); - } - whereMetadata(e) { - return this.where(nnn, e); - } - }; - var inn = "FindBidsOperation", - Lde = ot(inn), - BIt = { - handle: async (t, e, r) => { - let { programs: n, commitment: i } = r, - { auctionHouse: o, buyer: a, metadata: s, mint: c } = t.input, - u = e.programs().getAuctionHouse(n), - h = new Dde(e, u.address) - .mergeConfig({ commitment: i }) - .whereAuctionHouse(o.address); - return ( - a && (h = h.whereBuyer(a)), - s && !c && (h = h.whereMetadata(s)), - c && - (h = h.whereMetadata( - e.nfts().pdas().metadata({ mint: c, programs: n }) - )), - r.throwIfCanceled(), - h.getAndMap((w) => Sde(Ode(w), o)) - ); - }, - }; - m(); - g(); - var onn = "FindListingByTradeStateOperation", - qde = ot(onn), - IIt = { - handle: async (t, e, r) => { - let { tradeStateAddress: n } = t.input, - i = e - .auctionHouse() - .pdas() - .listingReceipt({ tradeState: n, programs: r.programs }); - return e - .auctionHouse() - .findListingByReceipt({ receiptAddress: i, ...t.input }, r); - }, - }; - m(); - g(); - m(); - g(); - var zde = (t, e) => ({ - model: "listing", - lazy: !0, - auctionHouse: e, - tradeStateAddress: new Br(t.data.tradeState, t.data.tradeStateBump), - bookkeeperAddress: t.data.bookkeeper, - sellerAddress: t.data.seller, - metadataAddress: t.data.metadata, - receiptAddress: new Br(t.publicKey, t.data.bump), - purchaseReceiptAddress: t.data.purchaseReceipt, - price: e.isNative - ? Xi(t.data.price) - : ci(t.data.price, e.treasuryMint.currency), - tokens: Sr(t.data.tokenSize), - createdAt: _p(t.data.createdAt), - canceledAt: Y9(t.data.canceledAt), - }); - var ann = "FindListingByReceiptOperation", - jde = ot(ann), - CIt = { - handle: async (t, e, r) => { - let { receiptAddress: n, auctionHouse: i } = t.input, - o = Pde(await e.rpc().getAccount(n, r.commitment)); - r.throwIfCanceled(); - let a = zde(o, i); - return e.auctionHouse().loadListing({ lazyListing: a, ...t.input }, r); - }, - }; - m(); - g(); - m(); - g(); - var RIt = qe(Le(), 1); - var NIt = [240, 71, 225, 94, 200, 75, 84, 231], - Kde = RIt.PublicKey.default.toBytes().byteLength, - snn = NIt.length, - unn = snn + Kde, - DIt = unn + Kde, - FIt = DIt + Kde, - cnn = FIt + Kde, - Ude = class extends yf { - whereDiscriminator(e) { - return this.where(0, Buffer.from(e)); - } - listingReceiptAccounts() { - return this.whereDiscriminator(NIt); - } - whereAuctionHouse(e) { - return this.listingReceiptAccounts().where(DIt, e); - } - whereSeller(e) { - return this.where(FIt, e); - } - whereMetadata(e) { - return this.where(cnn, e); - } - }; - var lnn = "FindListingsOperation", - Hde = ot(lnn), - LIt = { - handle: async (t, e, r) => { - let { commitment: n, programs: i } = r, - { auctionHouse: o, seller: a, metadata: s, mint: c } = t.input, - u = e.programs().getAuctionHouse(i), - h = new Ude(e, u.address) - .mergeConfig({ commitment: n }) - .whereAuctionHouse(o.address); - return ( - a && (h = h.whereSeller(a)), - s && !c && (h = h.whereMetadata(s)), - c && - (h = h.whereMetadata( - e.nfts().pdas().metadata({ mint: c, programs: i }) - )), - r.throwIfCanceled(), - h.getAndMap((w) => zde(Pde(w), o)) - ); - }, - }; - m(); - g(); - var fnn = "FindPurchaseByTradeStateOperation", - Vde = ot(fnn), - qIt = { - handle: async (t, e, r) => { - let { sellerTradeState: n, buyerTradeState: i } = t.input, - o = e.auctionHouse().pdas().purchaseReceipt({ - listingTradeState: n, - bidTradeState: i, - programs: r.programs, - }); - return e - .auctionHouse() - .findPurchaseByReceipt({ receiptAddress: o, ...t.input }, r); - }, - }; - m(); - g(); - m(); - g(); - var Wde = (t, e) => ({ - model: "purchase", - lazy: !0, - auctionHouse: e, - buyerAddress: t.data.buyer, - sellerAddress: t.data.seller, - metadataAddress: t.data.metadata, - bookkeeperAddress: t.data.bookkeeper, - receiptAddress: t.publicKey, - price: e.isNative - ? Xi(t.data.price) - : ci(t.data.price, e.treasuryMint.currency), - tokens: Sr(t.data.tokenSize), - createdAt: _p(t.data.createdAt), - }); - var dnn = "FindPurchaseByReceiptOperation", - Gde = ot(dnn), - zIt = { - handle: async (t, e, r) => { - let { receiptAddress: n, auctionHouse: i } = t.input, - o = Bde(await e.rpc().getAccount(n, r.commitment)); - r.throwIfCanceled(); - let a = Wde(o, i); - return e - .auctionHouse() - .loadPurchase({ lazyPurchase: a, ...t.input }, r); - }, - }; - m(); - g(); - m(); - g(); - var jIt = qe(Le(), 1); - var UIt = [79, 127, 222, 137, 154, 131, 150, 134], - $de = jIt.PublicKey.default.toBytes().byteLength, - hnn = UIt.length, - KIt = hnn + $de, - HIt = KIt + $de, - VIt = HIt + $de, - pnn = VIt + $de, - Jde = class extends yf { - whereDiscriminator(e) { - return this.where(0, Buffer.from(e)); - } - purchaseReceiptAccounts() { - return this.whereDiscriminator(UIt); - } - whereAuctionHouse(e) { - return this.purchaseReceiptAccounts().where(VIt, e); - } - whereBuyer(e) { - return this.where(KIt, e); - } - whereSeller(e) { - return this.where(HIt, e); - } - whereMetadata(e) { - return this.where(pnn, e); - } - }; - var ynn = "FindPurchasesOperation", - Zde = ot(ynn), - WIt = { - handle: async (t, e, r) => { - let { programs: n, commitment: i } = r, - { - auctionHouse: o, - buyer: a, - seller: s, - metadata: c, - mint: u, - } = t.input, - h = e.programs().getAuctionHouse(n), - w = new Jde(e, h.address) - .mergeConfig({ commitment: i }) - .whereAuctionHouse(o.address); - if (Object.keys(t.input).length > 3) throw new hde(); - return ( - a && (w = w.whereBuyer(a)), - s && (w = w.whereSeller(s)), - c && !u && (w = w.whereMetadata(c)), - u && - (w = w.whereMetadata( - e.nfts().pdas().metadata({ mint: u, programs: n }) - )), - r.throwIfCanceled(), - w.getAndMap((M) => Wde(Bde(M), o)) - ); - }, - }; - m(); - g(); - var mnn = "GetBuyerBalanceOperation", - Xde = ot(mnn), - GIt = { - handle: async (t, e, r) => { - let { auctionHouse: n, buyerAddress: i } = t.input, - o = e - .auctionHouse() - .pdas() - .buyerEscrow({ auctionHouse: n, buyer: i, programs: r.programs }); - return e.rpc().getBalance(o, r.commitment); - }, - }; - m(); - g(); - var gnn = "LoadBidOperation", - Yde = ot(gnn), - JIt = { - handle: async (t, e, r) => { - let { lazyBid: n, loadJsonMetadata: i = !0 } = t.input, - o = { ...n, model: "bid", lazy: !1 }; - if (n.tokenAddress) { - let s = await e - .nfts() - .findByToken({ token: n.tokenAddress, loadJsonMetadata: i }, r); - return ( - r.throwIfCanceled(), - A9(s), - ba( - s.metadataAddress.equals(n.metadataAddress), - `Asset metadata address must be ${n.metadataAddress}` - ), - { - ...o, - isPublic: !1, - asset: s, - tokens: ci(n.tokens, s.mint.currency), - } - ); - } - let a = await e - .nfts() - .findByMetadata( - { metadata: n.metadataAddress, loadJsonMetadata: i }, - r - ); - return ( - r.throwIfCanceled(), - { - ...o, - isPublic: !0, - asset: a, - tokens: ci(n.tokens, a.mint.currency), - } - ); - }, - }; - m(); - g(); - var vnn = "LoadListingOperation", - Qde = ot(vnn), - $It = { - handle: async (t, e, r) => { - let { lazyListing: n, loadJsonMetadata: i = !0 } = t.input, - o = await e.nfts().findByMetadata( - { - metadata: n.metadataAddress, - tokenOwner: n.sellerAddress, - loadJsonMetadata: i, - }, - r - ); - return ( - A9(o), - { - ...n, - model: "listing", - lazy: !1, - asset: o, - tokens: ci(n.tokens, o.mint.currency), - } - ); - }, - }; - m(); - g(); - var bnn = "LoadPurchaseOperation", - ehe = ot(bnn), - ZIt = { - handle: async (t, e, r) => { - let { lazyPurchase: n, loadJsonMetadata: i = !0 } = t.input, - o = await e.nfts().findByMetadata( - { - metadata: n.metadataAddress, - tokenOwner: n.buyerAddress, - loadJsonMetadata: i, - }, - r - ); - return ( - A9(o), - { - ...n, - lazy: !1, - isPublic: !1, - asset: o, - tokens: ci(n.tokens, o.mint.currency), - } - ); - }, - }; - m(); - g(); - var XIt = qe(fh(), 1); - var wnn = "WithdrawFromFeeAccountOperation", - the = ot(wnn), - YIt = { - handle: async (t, e, r) => - _nn(e, t.input, r).sendAndConfirm(e, r.confirmOptions), - }, - _nn = (t, e, r = {}) => { - let { payer: n = t.rpc().getDefaultFeePayer() } = r, - { - auctionHouse: i, - amount: o, - instructionKey: a, - authority: s = t.identity(), - } = e, - c = { - authority: i.authorityAddress, - feeWithdrawalDestination: i.feeWithdrawalDestinationAddress, - auctionHouse: i.address, - auctionHouseFeeAccount: i.feeAccountAddress, - }, - u = (0, XIt.createWithdrawFromFeeInstruction)(c, { - amount: o.basisPoints, - }); - return ct - .make() - .setFeePayer(n) - .add({ - instruction: u, - signers: [s], - key: a ?? "withdrawFromFeeAccount", - }); - }; - m(); - g(); - var QIt = qe(fh(), 1); - var xnn = "WithdrawFromTreasuryAccountOperation", - rhe = ot(xnn), - e5t = { - handle: async (t, e, r) => - Snn(e, t.input, r).sendAndConfirm(e, r.confirmOptions), - }, - Snn = (t, e, r = {}) => { - let { programs: n, payer: i = t.rpc().getDefaultFeePayer() } = r, - { - auctionHouse: o, - amount: a, - instructionKey: s, - authority: c = t.identity(), - } = e, - u = t - .auctionHouse() - .pdas() - .treasury({ auctionHouse: o.address, programs: n }), - h = { - treasuryMint: o.treasuryMint.address, - authority: o.authorityAddress, - treasuryWithdrawalDestination: o.treasuryWithdrawalDestinationAddress, - auctionHouseTreasury: u, - auctionHouse: o.address, - }, - w = (0, QIt.createWithdrawFromTreasuryInstruction)(h, { - amount: a.basisPoints, - }); - return ct - .make() - .setFeePayer(i) - .add({ - instruction: w, - signers: [c], - key: s ?? "withdrawFromTreasuryAccount", - }); - }; - var nhe = class { - constructor(e) { - this.metaplex = e; - } - builders() { - return new Tde(this.metaplex); - } - pdas() { - return new kde(this.metaplex); - } - bid(e, r) { - return this.metaplex.operations().execute(pde(e), r); - } - buy(e, r) { - return this.metaplex.operations().execute(vde(e), r); - } - cancelBid(e, r) { - return this.metaplex.operations().execute(bde(e), r); - } - cancelListing(e, r) { - return this.metaplex.operations().execute(wde(e), r); - } - create(e, r) { - return this.metaplex.operations().execute(nde(e), r); - } - depositToBuyerAccount(e, r) { - return this.metaplex.operations().execute(xde(e), r); - } - executeSale(e, r) { - return this.metaplex.operations().execute(mde(e), r); - } - findByAddress(e, r) { - return this.metaplex.operations().execute(Ide(e), r); - } - findByCreatorAndMint(e, r) { - return this.metaplex.operations().execute(Cde(e), r); - } - findBidByReceipt(e, r) { - return this.metaplex.operations().execute(Rde(e), r); - } - findBidByTradeState(e, r) { - return this.metaplex.operations().execute(Nde(e), r); - } - findBids(e, r) { - return this.metaplex.operations().execute(Lde(e), r); - } - findListingByTradeState(e, r) { - return this.metaplex.operations().execute(qde(e), r); - } - findListingByReceipt(e, r) { - return this.metaplex.operations().execute(jde(e), r); - } - findListings(e, r) { - return this.metaplex.operations().execute(Hde(e), r); - } - findPurchaseByTradeState(e, r) { - return this.metaplex.operations().execute(Vde(e), r); - } - findPurchaseByReceipt(e, r) { - return this.metaplex.operations().execute(Gde(e), r); - } - findPurchases(e, r) { - return this.metaplex.operations().execute(Zde(e), r); - } - getBuyerBalance(e, r) { - return this.metaplex.operations().execute(Xde(e), r); - } - list(e, r) { - return this.metaplex.operations().execute(yde(e), r); - } - loadBid(e, r) { - return this.metaplex.operations().execute(Yde(e), r); - } - loadListing(e, r) { - return this.metaplex.operations().execute(Qde(e), r); - } - loadPurchase(e, r) { - return this.metaplex.operations().execute(ehe(e), r); - } - sell(e, r) { - return this.metaplex.operations().execute(Ade(e), r); - } - update(e, r) { - return this.metaplex.operations().execute(gde(e), r); - } - withdrawFromBuyerAccount(e, r) { - return this.metaplex.operations().execute(Mde(e), r); - } - withdrawFromFeeAccount(e, r) { - return this.metaplex.operations().execute(the(e), r); - } - withdrawFromTreasuryAccount(e, r) { - return this.metaplex.operations().execute(rhe(e), r); - } - }; - var t5t = () => ({ - install(t) { - let e = { - name: "AuctionHouseProgram", - address: ihe.PROGRAM_ID, - errorResolver: (n) => ihe.cusper.errorFromProgramLogs(n.logs, !1), - }; - t.programs().register(e), - (t.programs().getAuctionHouse = function (n) { - return this.get(e.name, n); - }); - let r = t.operations(); - r.register(bde, pIt), - r.register(wde, mIt), - r.register(nde, rIt), - r.register(pde, iIt), - r.register(yde, aIt), - r.register(xde, gIt), - r.register(vde, dIt), - r.register(Ade, bIt), - r.register(mde, uIt), - r.register(Ide, SIt), - r.register(Cde, AIt), - r.register(Rde, EIt), - r.register(Nde, MIt), - r.register(Lde, BIt), - r.register(jde, CIt), - r.register(qde, IIt), - r.register(Hde, LIt), - r.register(Gde, zIt), - r.register(Vde, qIt), - r.register(Zde, WIt), - r.register(Xde, GIt), - r.register(Yde, JIt), - r.register(Qde, $It), - r.register(ehe, ZIt), - r.register(gde, fIt), - r.register(Mde, wIt), - r.register(the, YIt), - r.register(rhe, e5t), - (t.auctionHouse = function () { - return new nhe(this); - }); - }, - }); - var r5t = () => ({ - install(t) { - t.use(Ret()), - t.use(Yet()), - t.use(itt()), - t.use(att()), - t.use(stt()), - t.use(utt()), - t.use(ltt()), - t.use(gbt()), - t.use(Sbt()), - t.use($1t()), - t.use(bMt()), - t.use(r8t()), - t.use(MOt()), - t.use(t5t()); - }, - }); - var tW = class { - constructor(e, r = {}) { - var n; - (this.connection = e), - (this.cluster = (n = r.cluster) !== null && n !== void 0 ? n : wet(e)), - this.use(r5t()); - } - static make(e, r = {}) { - return new this(e, r); - } - use(e) { - return e.install(this), this; - } - }; - var wCe = qe(Le(), 1); - m(); - g(); - var Ann = (t) => t.replace("ipfs://", "https://nftstorage.link/ipfs/"), - lS = Ann; - m(); - g(); - var D5t = qe(Le()), - F5t = qe(OCe()); - m(); - g(); - var YD = { - version: "0.1.0", - name: "xnft", - constants: [ - { name: "MAX_NAME_LEN", type: { defined: "usize" }, value: "30" }, - { name: "MAX_RATING", type: "u8", value: "5" }, - ], - instructions: [ - { - name: "createXnft", - docs: [ - "Creates all parts of an xNFT instance.", - "", - "* Master mint (supply 1).", - "* Master token.", - "* Master metadata PDA associated with the master mint.", - "* Master edition PDA associated with the master mint.", - "* xNFT PDA associated with the master edition.", - "", - 'Once this is invoked, an xNFT exists and can be "installed" by users.', - ], - accounts: [ - { - name: "masterMint", - isMut: !0, - isSigner: !1, - pda: { - seeds: [ - { kind: "const", type: "string", value: "mint" }, - { kind: "account", type: "publicKey", path: "publisher" }, - { kind: "arg", type: "string", path: "name" }, - ], - }, - }, - { name: "masterToken", isMut: !0, isSigner: !1 }, - { - name: "masterMetadata", - isMut: !0, - isSigner: !1, - pda: { - seeds: [ - { kind: "const", type: "string", value: "metadata" }, - { - kind: "account", - type: "publicKey", - path: "metadata_program", - }, - { - kind: "account", - type: "publicKey", - account: "Mint", - path: "master_mint", - }, - ], - programId: { - kind: "account", - type: "publicKey", - path: "metadata_program", - }, - }, - }, - { - name: "masterEdition", - isMut: !0, - isSigner: !1, - pda: { - seeds: [ - { kind: "const", type: "string", value: "metadata" }, - { - kind: "account", - type: "publicKey", - path: "metadata_program", - }, - { - kind: "account", - type: "publicKey", - account: "Mint", - path: "master_mint", - }, - { kind: "const", type: "string", value: "edition" }, - ], - programId: { - kind: "account", - type: "publicKey", - path: "metadata_program", - }, - }, - }, - { - name: "xnft", - isMut: !0, - isSigner: !1, - pda: { - seeds: [ - { kind: "const", type: "string", value: "xnft" }, - { kind: "account", type: "publicKey", path: "master_edition" }, - ], - }, - }, - { name: "payer", isMut: !0, isSigner: !0 }, - { name: "publisher", isMut: !1, isSigner: !0 }, - { name: "systemProgram", isMut: !1, isSigner: !1 }, - { name: "tokenProgram", isMut: !1, isSigner: !1 }, - { name: "associatedTokenProgram", isMut: !1, isSigner: !1 }, - { name: "metadataProgram", isMut: !1, isSigner: !1 }, - { name: "rent", isMut: !1, isSigner: !1 }, - ], - args: [ - { name: "name", type: "string" }, - { name: "params", type: { defined: "CreateXnftParams" } }, - { name: "updateReviewAuthority", type: { option: "publicKey" } }, - ], - }, - { - name: "updateXnft", - docs: [ - "Updates the code of an xNFT.", - "", - "This is simply a token metadata update cpi.", - ], - accounts: [ - { name: "xnft", isMut: !0, isSigner: !1 }, - { name: "masterToken", isMut: !1, isSigner: !1 }, - { name: "masterMetadata", isMut: !0, isSigner: !1 }, - { name: "authority", isMut: !1, isSigner: !0 }, - { name: "metadataProgram", isMut: !1, isSigner: !1 }, - ], - args: [{ name: "updates", type: { defined: "UpdateParams" } }], - }, - { - name: "createReview", - docs: [ - 'Creates a "review" of an xNFT containing a URI to a comment and a 0-5 rating.', - ], - accounts: [ - { name: "install", isMut: !1, isSigner: !1 }, - { name: "masterToken", isMut: !1, isSigner: !1 }, - { name: "xnft", isMut: !0, isSigner: !1 }, - { - name: "review", - isMut: !0, - isSigner: !1, - pda: { - seeds: [ - { kind: "const", type: "string", value: "review" }, - { - kind: "account", - type: "publicKey", - account: "Xnft", - path: "xnft", - }, - { kind: "account", type: "publicKey", path: "author" }, - ], - }, - }, - { name: "author", isMut: !0, isSigner: !0 }, - { name: "systemProgram", isMut: !1, isSigner: !1 }, - ], - args: [ - { name: "uri", type: "string" }, - { name: "rating", type: "u8" }, - ], - }, - { - name: "createInstall", - docs: [ - 'Creates an "installation" of an xNFT.', - "", - "Installation is just a synonym for minting an xNFT edition for a given", - "user.", - ], - accounts: [ - { name: "xnft", isMut: !0, isSigner: !1 }, - { name: "installVault", isMut: !0, isSigner: !1 }, - { - name: "install", - isMut: !0, - isSigner: !1, - pda: { - seeds: [ - { kind: "const", type: "string", value: "install" }, - { kind: "account", type: "publicKey", path: "target" }, - { - kind: "account", - type: "publicKey", - account: "Xnft", - path: "xnft", - }, - ], - }, - }, - { name: "authority", isMut: !0, isSigner: !0 }, - { name: "target", isMut: !1, isSigner: !0 }, - { name: "systemProgram", isMut: !1, isSigner: !1 }, - ], - args: [], - }, - { - name: "createPermissionedInstall", - docs: [ - 'Creates an "installation" of a private xNFT through prior access approval', - "granted by the xNFT's installation authority.", - ], - accounts: [ - { name: "xnft", isMut: !0, isSigner: !1 }, - { name: "installVault", isMut: !0, isSigner: !1 }, - { - name: "install", - isMut: !0, - isSigner: !1, - pda: { - seeds: [ - { kind: "const", type: "string", value: "install" }, - { kind: "account", type: "publicKey", path: "authority" }, - { - kind: "account", - type: "publicKey", - account: "Xnft", - path: "xnft", - }, - ], - }, - }, - { - name: "access", - isMut: !1, - isSigner: !1, - pda: { - seeds: [ - { kind: "const", type: "string", value: "access" }, - { kind: "account", type: "publicKey", path: "authority" }, - { - kind: "account", - type: "publicKey", - account: "Xnft", - path: "xnft", - }, - ], - }, - }, - { name: "authority", isMut: !0, isSigner: !0 }, - { name: "systemProgram", isMut: !1, isSigner: !1 }, - ], - args: [], - }, - { - name: "deleteInstall", - docs: ["Closes the install account."], - accounts: [ - { name: "install", isMut: !0, isSigner: !1 }, - { name: "receiver", isMut: !0, isSigner: !1 }, - { name: "authority", isMut: !1, isSigner: !0 }, - ], - args: [], - }, - { - name: "deleteReview", - docs: [ - "Closes the review account and removes metrics from xNFT account.", - ], - accounts: [ - { name: "review", isMut: !0, isSigner: !1 }, - { name: "xnft", isMut: !0, isSigner: !1 }, - { name: "receiver", isMut: !0, isSigner: !1 }, - { name: "author", isMut: !1, isSigner: !0 }, - ], - args: [], - }, - { - name: "setSuspended", - docs: ["Sets the install suspension flag on the xnft."], - accounts: [ - { name: "xnft", isMut: !0, isSigner: !1 }, - { name: "masterToken", isMut: !1, isSigner: !1 }, - { name: "authority", isMut: !1, isSigner: !0 }, - ], - args: [{ name: "flag", type: "bool" }], - }, - { - name: "grantAccess", - docs: [ - "Creates an access program account that indicates a wallet's", - "access permission to install a private xNFT.", - ], - accounts: [ - { name: "xnft", isMut: !1, isSigner: !1 }, - { name: "wallet", isMut: !1, isSigner: !1 }, - { - name: "access", - isMut: !0, - isSigner: !1, - pda: { - seeds: [ - { kind: "const", type: "string", value: "access" }, - { kind: "account", type: "publicKey", path: "wallet" }, - { - kind: "account", - type: "publicKey", - account: "Xnft", - path: "xnft", - }, - ], - }, - }, - { name: "authority", isMut: !0, isSigner: !0 }, - { name: "systemProgram", isMut: !1, isSigner: !1 }, - ], - args: [], - }, - { - name: "revokeAccess", - docs: [ - "Closes the access program account for a given wallet on a private xNFT,", - "effectively revoking their permission to create installations of the xNFT.", - ], - accounts: [ - { name: "xnft", isMut: !1, isSigner: !1 }, - { name: "wallet", isMut: !0, isSigner: !1 }, - { - name: "access", - isMut: !0, - isSigner: !1, - pda: { - seeds: [ - { kind: "const", type: "string", value: "access" }, - { kind: "account", type: "publicKey", path: "wallet" }, - { - kind: "account", - type: "publicKey", - account: "Xnft", - path: "xnft", - }, - ], - }, - }, - { name: "authority", isMut: !0, isSigner: !0 }, - ], - args: [], - }, - ], - accounts: [ - { - name: "access", - type: { - kind: "struct", - fields: [ - { - name: "wallet", - docs: ["The pubkey of the wallet being granted access (32)."], - type: "publicKey", - }, - { - name: "xnft", - docs: [ - "The pubkey of the xNFT account that is access gated (32).", - ], - type: "publicKey", - }, - { name: "bump", docs: ["Bump nonce of the PDA (1)."], type: "u8" }, - { - name: "reserved", - docs: ["Unused reserved byte space for additive future changes."], - type: { array: ["u8", 32] }, - }, - ], - }, - }, - { - name: "install", - type: { - kind: "struct", - fields: [ - { - name: "authority", - docs: ["The authority who created the installation (32)."], - type: "publicKey", - }, - { - name: "xnft", - docs: ["The pubkey of the xNFT that was installed (32)."], - type: "publicKey", - }, - { - name: "masterMetadata", - docs: ["The pubkey of the MPL master metadata account (32)."], - type: "publicKey", - }, - { - name: "edition", - docs: ["The sequential installation number of the xNFT (8)."], - type: "u64", - }, - { - name: "reserved", - docs: ["Unused reserved byte space for additive future changes."], - type: { array: ["u8", 64] }, - }, - ], - }, - }, - { - name: "review", - type: { - kind: "struct", - fields: [ - { - name: "author", - docs: ["The pubkey of the account that created the review (32)."], - type: "publicKey", - }, - { - name: "xnft", - docs: ["The pubkey of the associated xNFT (32)."], - type: "publicKey", - }, - { - name: "rating", - docs: ["The numerical rating for the review, 0-5 (1)."], - type: "u8", - }, - { - name: "uri", - docs: [ - "The URI of the off-chain JSON data that holds the comment (4 + len).", - ], - type: "string", - }, - { - name: "reserved", - docs: ["Unused reserved byte space for future additive changes."], - type: { array: ["u8", 32] }, - }, - ], - }, - }, - { - name: "xnft", - type: { - kind: "struct", - fields: [ - { - name: "publisher", - docs: ["The pubkey of the original xNFT creator (32)."], - type: "publicKey", - }, - { - name: "installVault", - docs: [ - "The pubkey of the account to receive install payments (32).", - ], - type: "publicKey", - }, - { - name: "masterEdition", - docs: ["The pubkey of the ML master edition account (32)."], - type: "publicKey", - }, - { - name: "masterMetadata", - docs: ["The pubkey of the MPL master metadata account (32)."], - type: "publicKey", - }, - { - name: "masterMint", - docs: ["The pubkey of the master token mint (32)."], - type: "publicKey", - }, - { - name: "installAuthority", - docs: [ - "The optional pubkey of the xNFT installation authority (33).", - ], - type: { option: "publicKey" }, - }, - { - name: "bump", - docs: ["The bump nonce for the xNFT's PDA (1)."], - type: "u8", - }, - { - name: "kind", - docs: [ - "The `Kind` enum variant describing the type of xNFT (1).", - ], - type: { defined: "Kind" }, - }, - { - name: "tag", - docs: [ - "The `Tag` enum variant to assign the category of xNFT (1).", - ], - type: { defined: "Tag" }, - }, - { - name: "name", - docs: ["The display name of the xNFT account (MAX_NAME_LEN)."], - type: "string", - }, - { - name: "totalInstalls", - docs: [ - "Total amount of install accounts that have been created for this xNFT (8).", - ], - type: "u64", - }, - { - name: "installPrice", - docs: ["The price-per-install of this xNFT (8)."], - type: "u64", - }, - { - name: "createdTs", - docs: ["The unix timestamp of when the account was created (8)."], - type: "i64", - }, - { - name: "updatedTs", - docs: [ - "The unix timestamp of the last time the account was updated (8).", - ], - type: "i64", - }, - { - name: "suspended", - docs: [ - "Flag to determine whether new installations of the xNFT should be halted (1).", - ], - type: "bool", - }, - { - name: "totalRating", - docs: ["The total cumulative rating value of all reviews (8)."], - type: "u64", - }, - { - name: "numRatings", - docs: [ - "The number of ratings created used to calculate the average (4).", - ], - type: "u32", - }, - { - name: "l1", - docs: [ - "The `L1` enum variant to designate the associated blockchain (1).", - ], - type: { defined: "L1" }, - }, - { - name: "supply", - docs: [ - "The optional finite supply of installations available for this xNFT (9).", - ], - type: { option: "u64" }, - }, - { - name: "updateReviewAuthority", - docs: [ - "Optional pubkey of the global authority required for reviewing xNFT updates (33).", - ], - type: { option: "publicKey" }, - }, - { - name: "reserved", - docs: ["Unused reserved byte space for additive future changes."], - type: { array: ["u8", 27] }, - }, - ], - }, - }, - ], - types: [ - { - name: "CreatorsParam", - type: { - kind: "struct", - fields: [ - { name: "address", type: "publicKey" }, - { name: "share", type: "u8" }, - ], - }, - }, - { - name: "CreateXnftParams", - type: { - kind: "struct", - fields: [ - { name: "collection", type: { option: "publicKey" } }, - { name: "creators", type: { vec: { defined: "CreatorsParam" } } }, - { name: "installAuthority", type: { option: "publicKey" } }, - { name: "installPrice", type: "u64" }, - { name: "installVault", type: "publicKey" }, - { name: "kind", type: { defined: "Kind" } }, - { name: "l1", type: { defined: "L1" } }, - { name: "sellerFeeBasisPoints", type: "u16" }, - { name: "supply", type: { option: "u64" } }, - { name: "symbol", type: "string" }, - { name: "tag", type: { defined: "Tag" } }, - { name: "uri", type: "string" }, - ], - }, - }, - { - name: "UpdateParams", - type: { - kind: "struct", - fields: [ - { name: "installVault", type: { option: "publicKey" } }, - { name: "price", type: { option: "u64" } }, - { name: "tag", type: { option: { defined: "Tag" } } }, - { name: "uri", type: { option: "string" } }, - ], - }, - }, - { - name: "Kind", - type: { - kind: "enum", - variants: [{ name: "App" }, { name: "Collection" }], - }, - }, - { - name: "L1", - type: { - kind: "enum", - variants: [{ name: "Solana" }, { name: "Ethereum" }], - }, - }, - { - name: "Tag", - type: { - kind: "enum", - variants: [ - { name: "None" }, - { name: "Defi" }, - { name: "Game" }, - { name: "Nft" }, - ], - }, - }, - ], - events: [ - { - name: "AccessGranted", - fields: [ - { name: "wallet", type: "publicKey", index: !1 }, - { name: "xnft", type: "publicKey", index: !1 }, - ], - }, - { - name: "InstallationCreated", - fields: [ - { name: "installer", type: "publicKey", index: !1 }, - { name: "xnft", type: "publicKey", index: !1 }, - ], - }, - { - name: "ReviewCreated", - fields: [ - { name: "author", type: "publicKey", index: !1 }, - { name: "rating", type: "u8", index: !1 }, - { name: "xnft", type: "publicKey", index: !1 }, - ], - }, - { - name: "XnftUpdated", - fields: [ - { name: "metadataUri", type: "string", index: !1 }, - { name: "xnft", type: "publicKey", index: !1 }, - ], - }, - ], - errors: [ - { - code: 6e3, - name: "CannotReviewOwned", - msg: "You cannot create a review for an xNFT that you currently own or published", - }, - { - code: 6001, - name: "CollectionWithoutKind", - msg: "A collection pubkey was provided without the collection Kind variant", - }, - { - code: 6002, - name: "InstallAuthorityMismatch", - msg: "The provided xNFT install authority did not match", - }, - { - code: 6003, - name: "InstallOwnerMismatch", - msg: "The asserted authority/owner did not match that of the Install account", - }, - { - code: 6004, - name: "InstallExceedsSupply", - msg: "The max supply has been reached for the xNFT.", - }, - { - code: 6005, - name: "NameTooLong", - msg: "The name provided for creating the xNFT exceeded the byte limit", - }, - { - code: 6006, - name: "RatingOutOfBounds", - msg: "The rating for a review must be between 0 and 5", - }, - { - code: 6007, - name: "ReviewInstallMismatch", - msg: "The installation provided for the review does not match the xNFT", - }, - { - code: 6008, - name: "SuspendedInstallation", - msg: "Attempting to install a currently suspended xNFT", - }, - { - code: 6009, - name: "UnauthorizedInstall", - msg: "The access account provided is not associated with the wallet", - }, - { - code: 6010, - name: "UpdateReviewAuthorityMismatch", - msg: "The signing authority for the xNFT update did not match the review authority", - }, - ], - }; - m(); - g(); - var N5t = qe(Le()), - lhe = () => - new N5t.PublicKey("BaHSGaf883GA3u8qSC5wNigcXyaScJLSBJZbALWvPcjs"); - function Hg(t, e) { - return new fT( - YD, - lhe(), - new F5t.AnchorProvider( - t, - e ?? { - publicKey: D5t.PublicKey.default, - signTransaction: async (r) => r, - signAllTransactions: async (r) => r, - }, - { commitment: "confirmed", skipPreflight: !0 } - ) - ); - } - m(); - g(); - async function qCe(t, e) { - return ( - await Hg(t).account.install.all([ - { memcmp: { offset: 8, bytes: e.toBase58() } }, - ]) - ).map((i) => i.account.xnft.toString()); - } - m(); - g(); - var QD = qe(Le(), 1), - L5t = new QD.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"), - ezn = new QD.PublicKey("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"), - tzn = new QD.PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"), - rzn = new QD.PublicKey("So11111111111111111111111111111111111111112"), - nzn = new QD.PublicKey("9pan9bMn5HatX4EJdBwg9VgCa7Uz5HL8N1m5D3NdXejP"); - m(); - g(); - var M3 = qe(Sn(), 1); - var q5t; - (function (t) { - (t[(t.Uninitialized = 0)] = "Uninitialized"), - (t[(t.Initialized = 1)] = "Initialized"), - (t[(t.Frozen = 2)] = "Frozen"); - })(q5t || (q5t = {})); - var zCe = (0, M3.struct)([ - hl("mint"), - hl("owner"), - dl("amount"), - (0, M3.u32)("delegateOption"), - hl("delegate"), - (0, M3.u8)("state"), - (0, M3.u32)("isNativeOption"), - dl("isNative"), - dl("delegatedAmount"), - (0, M3.u32)("closeAuthorityOption"), - hl("closeAuthority"), - ]), - z5t = zCe.span; - async function jCe(t, e) { - let r = Hg(t), - n = tW.make(t), - [i, o] = await Promise.all([qCe(t, e), r.account.xnft.all()]), - a = ( - await n - .rpc() - .getMultipleAccounts(o.map((h) => h.account.masterMetadata)) - ).map((h) => p0(h).data), - s = await Promise.all( - a.map((h) => n.storage().downloadJson(lS(h.data.uri))) - ), - c = await Promise.all( - o.map((h) => Gin(r.provider.connection, h.account.masterMint)) - ), - u = []; - for (let h = 0; h < o.length; h++) - u.push({ - account: o[h].account, - json: s[h], - metadata: a[h], - publicKey: o[h].publicKey, - installed: i.includes(o[h].publicKey.toString()), - token: c[h], - }); - return u; - } - async function Gin(t, e) { - let r = await t.getProgramAccounts(L5t, { - filters: [ - { dataSize: z5t }, - { memcmp: { offset: 0, bytes: e.toBase58() } }, - ], - }); - if (r.length === 0) - throw new Error(`no token accounts found for mint ${e.toBase58()}`); - return { - owner: zCe.decode(r[0].account.data).owner, - publicKey: r[0].pubkey, - }; - } - m(); - g(); - var Jin = e2({ - key: "solanaConnectionAtom", - effects: [ - ({ setSelf: t }) => { - t( - new Promise((e) => { - let r = 0, - n = setInterval(() => { - if (window?.xnft?.solana?.connection) - return clearInterval(n), e(!0); - if (r > 100) return clearInterval(n), e(!1); - r++; - }, 100); - }) - ); - }, - ], - }), - fhe = Jin; - var $in = e2({ - key: "xnftAtom", - effects: [ - ({ setSelf: t, getPromise: e }) => { - let r = async () => { - let n = await jCe( - window.xnft.solana.connection, - window.xnft.solana.publicKey - ); - window.xnft.setStorage("xnfts", JSON.stringify(n)), t(n); - }; - window.xnft - .getStorage("xnfts") - .then((n) => { - if (n) { - let i = JSON.parse(n); - t(Zin(i)); - } - }) - .then(() => e(fhe)) - .then(async () => { - await r(); - }); - }, - ], - }); - function Zin(t) { - return ( - t.forEach((e) => { - (e.account.createdTs = new hT.default(e.account.createdTs, 16)), - (e.account.updatedTs = new hT.default(e.account.updatedTs, 16)), - (e.account.totalInstalls = new hT.default( - e.account.totalInstalls, - 16 - )), - (e.account.installPrice = new hT.default(e.account.installPrice, 16)), - (e.account.totalRating = new hT.default(e.account.totalRating, 16)); - }), - t - ); - } - var dhe = $in; - var K5t = qe(U5t()), - Xin = (0, K5t.default)((t, e, r, n) => - t.filter( - (i) => - !( - (!e && i?.account?.suspended) || - (r === "freeOnly" && i.account?.installPrice?.toNumber() > 0) || - (r === "paidOnly" && i.account?.installPrice?.toNumber() <= 0) || - (!n && i.installed) - ) - ) - ), - Yin = w$({ - key: "filteredXnftsAtom", - get: ({ get: t }) => { - let e = t(x$), - r = t(dhe), - n = [ - ...Xin(r, e.includeSuspended, e.includePrice, e.includeInstalled), - ]; - if (e.sortDesc) - switch (e.sortBy) { - case "installs": { - n.sort( - (i, o) => - o.account.totalInstalls.toNumber() - - i.account.totalInstalls.toNumber() - ); - break; - } - case "ratings": { - n.sort( - (i, o) => - o.account.totalRating.toNumber() - - i.account.totalRating.toNumber() - ); - break; - } - case "updated": { - n.sort( - (i, o) => - o.account.updatedTs.toNumber() - - i.account.updatedTs.toNumber() - ); - break; - } - default: - n.sort( - (i, o) => - o.account.createdTs.toNumber() - - i.account.createdTs.toNumber() - ); - } - else - switch (e.sortBy) { - case "installs": { - n.sort( - (i, o) => - i.account.totalInstalls.toNumber() - - o.account.totalInstalls.toNumber() - ); - break; - } - case "ratings": { - n.sort( - (i, o) => - i.account.totalRating.toNumber() - - o.account.totalRating.toNumber() - ); - break; - } - case "updated": { - n.sort( - (i, o) => - i.account.updatedTs.toNumber() - - o.account.updatedTs.toNumber() - ); - break; - } - default: { - n.sort( - (i, o) => - i.account.createdTs.toNumber() - - o.account.createdTs.toNumber() - ); - break; - } - } - return n; - }, - }), - hhe = Yin; - m(); - g(); - var H5t = qe(to()); - function Qin({ ...t }) { - return H5t.default.createElement(Mh, { - path: "M5.4 6.81113C5.3514 6.87019 5.29033 6.91775 5.22117 6.95041C5.15201 6.98306 5.07648 7 5 7C4.92352 7 4.84798 6.98306 4.77882 6.95041C4.70966 6.91775 4.64859 6.87019 4.6 6.81113L0.1 0.811127C0.0442867 0.736842 0.0103596 0.64851 0.00202058 0.556029C-0.0063184 0.463549 0.0112601 0.370572 0.0527866 0.287519C0.094313 0.204466 0.158147 0.134618 0.237135 0.0858011C0.316123 0.036984 0.407144 0.0111265 0.5 0.0111265H9.5C9.59285 0.0111265 9.68388 0.036984 9.76287 0.0858011C9.84185 0.134618 9.90569 0.204466 9.94721 0.287519C9.98874 0.370572 10.0063 0.463549 9.99798 0.556029C9.98964 0.64851 9.95571 0.736842 9.9 0.811127L5.4 6.81113Z", - pathWidth: 10, - pathHeight: 7, - ...t, - }); - } - var V5t = Qin; - m(); - g(); - var W5t = qe(to()); - function eon({ ...t }) { - return W5t.default.createElement(Mh, { - path: "M5.40879 0.188874C5.36019 0.129815 5.29912 0.0822487 5.22996 0.0495925C5.1608 0.0169363 5.08527 0 5.00879 0C4.93231 0 4.85677 0.0169363 4.78761 0.0495925C4.71845 0.0822487 4.65738 0.129815 4.60879 0.188874L0.108789 6.18887C0.0530757 6.26316 0.0191486 6.35149 0.0108096 6.44397C0.00247066 6.53645 0.0200492 6.62943 0.0615756 6.71248C0.103102 6.79553 0.166936 6.86538 0.245924 6.9142C0.324912 6.96302 0.415933 6.98887 0.508789 6.98887H9.50879C9.60164 6.98887 9.69267 6.96302 9.77165 6.9142C9.85064 6.86538 9.91447 6.79553 9.956 6.71248C9.99753 6.62943 10.0151 6.53645 10.0068 6.44397C9.99843 6.35149 9.9645 6.26316 9.90879 6.18887L5.40879 0.188874Z", - pathWidth: 10, - pathHeight: 7, - ...t, - }); - } - var G5t = eon; - m(); - g(); - var J5t = qe(to()); - function ton({ size: t, ...e }) { - return J5t.default.createElement(Mh, { - path: "M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.42 0-8-3.58-8-8s3.58-8 8-8 8 3.58 8 8-3.58 8-8 8z", - pathHeight: 24, - pathWidth: 24, - width: t, - height: t, - ...e, - }); - } - var KCe = ton; - m(); - g(); - var $5t = qe(to()); - function ron({ size: t, ...e }) { - return $5t.default.createElement(Mh, { - path: "M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm0 18c-4.41 0-8-3.59-8-8s3.59-8 8-8 8 3.59 8 8-3.59 8-8 8zm4.59-12.42L10 14.17l-2.59-2.58L6 13l4 4 8-8z", - pathHeight: 24, - pathWidth: 24, - width: t, - height: t, - ...e, - }); - } - var phe = ron; - m(); - g(); - var eF = qe(to()); - m(); - g(); - var Z5t = qe(to()); - function non({ size: t, ...e }) { - return Z5t.default.createElement(Mh, { - path: "M9.00001 14.5196L13.15 17.0296C13.91 17.4896 14.84 16.8096 14.64 15.9496L13.54 11.2296L17.21 8.04958C17.88 7.46958 17.52 6.36958 16.64 6.29958L11.81 5.88958L9.92001 1.42958C9.58001 0.619583 8.42001 0.619583 8.08001 1.42958L6.19001 5.87958L1.36001 6.28958C0.480012 6.35958 0.120012 7.45958 0.790012 8.03958L4.46001 11.2196L3.36001 15.9396C3.16001 16.7996 4.09001 17.4796 4.85001 17.0196L9.00001 14.5196Z", - pathWidth: 18, - pathHeight: 18, - height: t, - width: t, - ...e, - }); - } - var HCe = non; - function ion({ rating: t, totalReviews: e, onClick: r, starSize: n }) { - let i = (o) => { - r && r(o + 1); - }; - return eF.default.createElement( - dr, - { tw: "flex items-center gap-1" }, - [...new Array(5)].map((o, a) => - eF.default.createElement( - dr, - { key: a, onClick: () => i(a), tw: r ? "cursor-pointer" : "" }, - t >= a + 1 - ? eF.default.createElement(HCe, { - size: n, - color: "#FC9870", - isFilled: !0, - }) - : eF.default.createElement(HCe, { - size: n, - color: "#FC9870", - isFilled: !1, - strokeWidth: 2, - }) - ) - ), - e !== void 0 && - eF.default.createElement( - vh, - { tw: "pl-2 text-xs font-medium text-white" }, - e, - " Reviews" - ) - ); - } - var WB = ion; - m(); - g(); - var X5t = qe(to()); - function oon({ size: t, ...e }) { - return X5t.default.createElement(Mh, { - path: "M18,15v3H6v-3H4v3c0,1.1,0.9,2,2,2h12c1.1,0,2-0.9,2-2v-3H18z M17,11l-1.41-1.41L13,12.17V4h-2v8.17L8.41,9.59L7,11l5,5 L17,11z", - pathHeight: 24, - pathWidth: 24, - width: t, - height: t, - ...e, - }); - } - var iW = oon; - function aon() { - let t = YI(hhe), - [e, r] = uze(x$), - [n, i] = (0, un.useState)(""), - [o, a] = (0, un.useState)(!1); - if (t.state !== "hasValue") return null; - let s = t.contents; - if (n !== "") { - let c = new RegExp(n, "i"); - s = s.filter((u) => c.test(u.json.name) || c.test(u.json.description)); - } - return un.default.createElement( - dr, - { tw: "flex flex-col h-full py-3" }, - un.default.createElement( - dr, - { tw: "flex flex-row px-4 pb-3" }, - un.default.createElement( - dr, - { tw: "flex-1" }, - un.default.createElement(MG, { - placeholder: "Search all apps", - onChange: (c) => { - i(c.target.value); - }, - value: n, - }) - ), - un.default.createElement( - dr, - { - tw: "pl-4 flex justify-center items-center cursor-pointer", - onClick: () => a(!o), - }, - un.default.createElement(fze, { - size: 32, - color: o ? "#33CCFF" : "white", - }) - ) - ), - un.default.createElement( - dr, - { - tw: `max-h-[0rem] ${ - o ? "max-h-[10rem]" : "max-h-[0rem]" - } h-auto overflow-hidden transition-[max-height] duration-300 ease-in-out`, - }, - un.default.createElement( - dr, - { - tw: "p-2 bg-[#27272A]", - style: { boxShadow: "inset 0 0 4px 1px rgba(0,0,0,0.8)" }, - }, - un.default.createElement(vh, { tw: "mx-2" }, "Sort By:"), - un.default.createElement( - dr, - { tw: "flex-row" }, - un.default.createElement(yhe, { - label: "Rating", - desc: !!e.sortDesc, - active: e.sortBy === "ratings", - onClick: () => { - e.sortBy !== "ratings" - ? r({ sortBy: "ratings" }) - : r({ sortDesc: !e.sortDesc }); - }, - }), - un.default.createElement(yhe, { - label: "Installs", - desc: !!e.sortDesc, - active: e.sortBy === "installs", - onClick: () => { - e.sortBy !== "installs" - ? r({ sortBy: "installs" }) - : r({ sortDesc: !e.sortDesc }); - }, - }), - un.default.createElement(yhe, { - label: "Updated", - desc: !!e.sortDesc, - active: e.sortBy === "updated", - onClick: () => { - e.sortBy !== "updated" - ? r({ sortBy: "updated" }) - : r({ sortDesc: !e.sortDesc }); - }, - }), - un.default.createElement(yhe, { - label: "Created", - desc: !!e.sortDesc, - active: e.sortBy === "created", - onClick: () => { - e.sortBy !== "created" - ? r({ sortBy: "created" }) - : r({ sortDesc: !e.sortDesc }); - }, - }) - ), - un.default.createElement(vh, { tw: "mx-2" }, "Include:"), - un.default.createElement( - dr, - { tw: "flex flex-row items-center justify-start" }, - un.default.createElement( - Fd, - { - onClick: () => { - r({ includeSuspended: !e.includeSuspended }); - }, - tw: `${ - e.includeSuspended ? "text-[#000] font-bold" : "font-medium " - } inline-flex flex-row m-2 px-3 justify-center items-center rounded text-xs tracking-wide`, - }, - e.includeSuspended - ? un.default.createElement(phe, { - tw: "m-0 mr-1", - size: 16, - color: "black", - }) - : un.default.createElement(KCe, { - tw: "m-0 mr-1", - size: 16, - color: "#71717A", - }), - "Suspended" - ), - un.default.createElement( - Fd, - { - onClick: () => { - let c = - e.includePrice === "all" - ? "paidOnly" - : e.includePrice === "paidOnly" - ? "freeOnly" - : "all"; - r({ includePrice: c }); - }, - tw: "text-[#000] font-bold inline-flex flex-row m-2 px-3 justify-center items-center rounded text-xs tracking-wide", - }, - e.includePrice === "all" - ? "Paid & Free" - : e.includePrice === "paidOnly" - ? "Paid Only" - : "Free Only" - ), - un.default.createElement( - Fd, - { - onClick: () => { - r({ includeInstalled: !e.includeInstalled }); - }, - tw: `${ - e.includeInstalled ? "text-[#000] font-bold" : "font-medium " - } inline-flex flex-row m-2 px-3 justify-center items-center rounded text-xs tracking-wide`, - }, - e.includeInstalled - ? un.default.createElement(phe, { - tw: "m-0 mr-1", - size: 16, - color: "black", - }) - : un.default.createElement(KCe, { - tw: "m-0 mr-1", - size: 16, - color: "#71717A", - }), - "Installed" - ) - ) - ) - ), - un.default.createElement( - dr, - { tw: "flex-1" }, - un.default.createElement( - qF, - { key: Math.random() }, - s && - s.map((c) => - un.default.createElement(son, { - key: c.publicKey.toString(), - app: c, - }) - ) - ) - ) - ); - } - function yhe({ label: t, desc: e, active: r, onClick: n }) { - return un.default.createElement( - Fd, - { - onClick: n, - tw: `${ - r ? "text-[#000] font-bold" : "font-medium " - } inline-flex flex-row m-2 px-3 justify-center items-center rounded text-xs tracking-wide`, - }, - t, - r && - (e - ? un.default.createElement(V5t, { - tw: "ml-1 mt-1", - width: 12, - height: 9, - color: "black", - }) - : un.default.createElement(G5t, { - tw: "ml-1 mt-1", - width: 12, - height: 9, - color: "black", - })) - ); - } - function son({ app: t }) { - let e = m_(); - return un.default.createElement( - dr, - { - onClick: () => e.push("details", { app: t }), - tw: "relative flex items-center gap-4 rounded-lg bg-[#27272A] m-4 p-4 shadow-lg transition-all hover:-translate-y-0.1 hover:bg-[#27272A]/40 cursor-pointer", - }, - un.default.createElement( - dr, - { tw: "flex items-center" }, - un.default.createElement(LF, { - tw: "rounded-lg", - src: lS(t.json.image), - style: { height: "64px", width: "64px" }, - }) - ), - un.default.createElement( - dr, - { tw: "min-w-0 flex-1" }, - un.default.createElement( - dr, - { tw: "truncate font-bold tracking-wide text-white" }, - t.account.name - ), - un.default.createElement( - dr, - { tw: "truncate text-xs tracking-wide text-[#FAFAFA]/75" }, - t.json.description - ), - un.default.createElement( - dr, - { tw: "py-1 flex justify-between" }, - un.default.createElement(WB, { - rating: t.account.totalRating.toNumber(), - totalReviews: t.account.numRatings, - starSize: 12, - }), - un.default.createElement( - dr, - { tw: "flex gap-1 text-white text-xs" }, - t.account.totalInstalls.toNumber(), - t.installed - ? un.default.createElement(phe, { size: 14, color: "white" }) - : un.default.createElement(iW, { size: 14, color: "white" }) - ) - ) - ) - ); - } - var Y5t = aon; - m(); - g(); - var xr = qe(to()); - var oW = qe(Le()); - m(); - g(); - m(); - g(); - var Q5t = qe(Le()); - m(); - g(); - var uon = () => "https://app-store-api.backpack.workers.dev", - mhe = uon; - async function VCe(t, e) { - let n = await Hg(t).account.review.all([ - { memcmp: { offset: 8 + 32, bytes: e.toBase58() } }, - ]), - i = Promise.all( - n.map( - (u) => - u.account.uri && - fetch(lS(u.account.uri), { - headers: { Accept: "application/json" }, - }) - .then((h) => h.json()) - .then((h) => h.comment) - ) - ), - o = n.map((u) => u?.account?.author?.toString()), - a = fetch(`${mhe()}/api/identity/usernames?pubkeys=${o.join(",")}`, { - headers: { Accept: "application/json" }, - }) - .then((u) => u.json()) - .then((u) => u.users) - .catch(() => []), - [s, c] = await Promise.all([i, a]); - return n.map((u, h) => ({ - rating: u.account.rating, - comment: s[h], - author: - c.find((w) => u.account.author.equals(new Q5t.PublicKey(w.pubkey))) - ?.username ?? u.account.author.toString(), - })); - } - var con = sze({ - key: "reviewsAtom", - effects: (t) => [ - ({ setSelf: e, getPromise: r }) => { - window.xnft - .getStorage(t + "xnftsReview") - .then((n) => { - if (n) { - let i = JSON.parse(n); - e(i); - } - }) - .then(() => r(fhe)) - .then(async () => { - let n = await VCe( - window.xnft.solana.connection, - new wCe.PublicKey(t) - ); - window.xnft.setStorage(t + "xnftsReview", JSON.stringify(n)), - e(n); - }); - }, - ], - }), - eCt = con; - m(); - g(); - var lon = e2({ - key: "installedAppAtom", - effects: [ - ({ setSelf: t, getPromise: e }) => { - t( - e(dhe).then((r) => - r.filter((n) => n.installed).map((n) => n.publicKey.toString()) - ) - ); - }, - ], - }), - tCt = lon; - var rCt = [ - { name: "Screenshots" }, - { name: "Information" }, - { name: "Reviews" }, - ], - fon = YD.types[3].type.variants.map((t) => t.name), - don = YD.types[4].type.variants.map((t) => t.name), - hon = YD.types[5].type.variants.map((t) => t.name); - function pon({ app: t }) { - let [e, r] = cze(tCt), - n = m_(), - [i, o] = (0, xr.useState)(rCt[0].name), - a = YI(eCt(t.publicKey.toString())), - s = t.account.installPrice.toNumber(), - c = a.state === "hasValue" && a.contents.length === 0, - u = t.metadata.collectionDetails, - h = t.metadata.data.uri, - w = e.state === "hasValue" ? e.contents : [], - M = w.includes(t.publicKey.toString()), - k = async () => { - let D = await Hg(window.xnft.solana.connection, window.xnft.solana) - .methods.createInstall() - .accounts({ - xnft: new oW.PublicKey(t.publicKey), - installVault: new oW.PublicKey(t.account.installVault), - }) - .transaction(); - await window.xnft.solana.sendAndConfirm(D), - r([...w, t.publicKey.toString()]); - }; - return xr.default.createElement( - dr, - { tw: "pb-2" }, - xr.default.createElement( - dr, - { tw: "flex gap-6 py-2 px-4" }, - xr.default.createElement(LF, { - tw: "col-Text-1 rounded-lg h-[120px] w-[120px]", - src: lS(t.json.image), - }), - xr.default.createElement( - dr, - { tw: "flex flex-col items-start gap-4" }, - xr.default.createElement(WB, { - rating: t.account.totalRating.toNumber(), - totalReviews: t.account.numRatings, - starSize: 16, - }), - xr.default.createElement( - dr, - { tw: "flex items-center gap-4" }, - t.account.suspended && - xr.default.createElement( - vh, - { - tw: "badge rounded-xl bg-red-400/25 py-1 px-2 text-xs text-red-400", - }, - "suspended" - ), - xr.default.createElement( - vh, - { - tw: "flex items-center gap-1.5 rounded-2xl bg-[#4F46E5] px-3 py-1 text-xs font-small tracking-wide text-white", - }, - xr.default.createElement(iW, { size: 16, color: "#fff" }), - " ", - t.account.totalInstalls.toNumber() - ) - ), - !t.account.suspended && - xr.default.createElement( - dr, - { tw: "flex items-center gap-4" }, - M - ? xr.default.createElement( - xr.default.Fragment, - null, - xr.default.createElement( - Fd, - { - tw: "rounded bg-[#27272A] px-3 rounded text-xs font-medium tracking-wide", - }, - "Installed" - ), - xr.default.createElement( - Fd, - { - onClick: () => { - n.push("review", { app: t }); - }, - tw: "flex items-center gap-2.5 bg-white py-2 text-[#374151] px-3 rounded text-xs font-medium tracking-wide", - }, - "Add Review" - ) - ) - : xr.default.createElement( - Fd, - { - onClick: () => k(), - tw: "flex items-center gap-2.5 bg-white py-2 text-[#374151] px-3 rounded text-xs font-medium tracking-wide", - }, - s === 0 ? "Free" : `${s / oW.LAMPORTS_PER_SOL} SOL`, - !M && - xr.default.createElement(iW, { - size: 16, - color: "#374151", - }) - ) - ) - ) - ), - xr.default.createElement( - dr, - { tw: "px-4 py-2 max-w-md text-lg font-medium text-[#99A4B4]" }, - t.json.description - ), - xr.default.createElement( - dr, - { tw: "mb-2 border-b-2 border-[#393C43]" }, - xr.default.createElement( - dr, - { tw: "mx-auto -mb-px flex justify-center space-x-12" }, - rCt.map((O) => - xr.default.createElement( - dr, - { - key: O.name, - tw: `${ - i === O.name - ? "border-[#FC9870] text-[#FC9870]" - : "border-transparent text-[#99A4B4]" - } - cursor-pointer whitespace-nowrap border-b-2 py-4 px-1 text-sm font-medium - `, - onClick: () => o(O.name), - }, - O.name - ) - ) - ) - ), - i === "Screenshots" && - xr.default.createElement( - dr, - { - tw: "flex flex-row flex-wrap items-center gap-6 px-4 py-2 max-w-md text-lg font-medium text-[#99A4B4] ", - }, - t.json.properties.files.map((O) => - xr.default.createElement(LF, { - key: O.uri, - tw: "rounded-lg w-[158px]", - style: { boxShadow: "0 0 4px rgba(255, 255, 255, 0.2)" }, - src: lS(O.uri), - }) - ) - ), - !c && - i === "Reviews" && - xr.default.createElement( - xr.default.Fragment, - null, - xr.default.createElement( - dr, - { tw: "pb-0 max-w-md text-lg font-medium text-[#99A4B4]" }, - a.state === "loading" && xr.default.createElement(PG, null), - a.state === "hasValue" && - a.contents.map((O) => - xr.default.createElement( - dr, - { tw: "rounded-lg bg-[#27272A] m-4 p-4 shadow-lg" }, - xr.default.createElement( - dr, - { tw: "truncate text-xs tracking-wide text-[#FAFAFA]/75" }, - O.author - ), - xr.default.createElement( - dr, - { tw: "py-1" }, - xr.default.createElement(WB, { - rating: O.rating, - starSize: 12, - }) - ), - xr.default.createElement( - dr, - { tw: "font-bold tracking-wide text-white" }, - O.comment - ) - ) - ) - ) - ), - c && - i === "Reviews" && - xr.default.createElement( - xr.default.Fragment, - null, - xr.default.createElement( - dr, - { tw: "pb-0 max-w-md text-lg font-medium text-[#99A4B4]" }, - xr.default.createElement( - dr, - { tw: "rounded-lg bg-[#27272A] m-4 p-4 shadow-lg" }, - xr.default.createElement( - dr, - { tw: "font-bold tracking-wide text-white" }, - "No reviews available." - ) - ) - ) - ), - i === "Information" && - xr.default.createElement( - dr, - { - tw: "m-4 p-4 mb-2 flex break-words max-w-3xl flex-col gap-4 rounded-2xl bg-[#27272A]", - }, - xr.default.createElement(pS, { - name: "Authority", - value: t.token.owner.toString(), - }), - xr.default.createElement(pS, { - name: "Publisher", - value: t.account.publisher.toString(), - }), - xr.default.createElement(pS, { - name: "L1", - value: WCe(don, t.account.l1), - }), - xr.default.createElement(pS, { - name: "Kind", - value: WCe(fon, t.account.kind), - }), - xr.default.createElement(pS, { - name: "Tag", - value: WCe(hon, t.account.tag), - }), - t.json.external_url && - xr.default.createElement(pS, { - name: "Website", - value: t.json.external_url, - }), - xr.default.createElement(pS, { - name: "Supply", - value: u - ? parseInt(u.size.toString(), 16).toLocaleString() - : xr.default.createElement(xr.default.Fragment, null, "\u221E"), - }), - xr.default.createElement(pS, { - name: "Last Updated", - value: new Date(t.account.updatedTs.toNumber() * 1e3).toUTCString(), - }), - h && xr.default.createElement(pS, { name: "Metadata", value: h }) - ) - ); - } - function WCe(t, e) { - let r = Object.keys(e)[0].toLowerCase(); - return t.find((n) => n.toLowerCase() === r) ?? ""; - } - function pS({ name: t, value: e }) { - return xr.default.createElement( - dr, - { tw: "flex flex-col gap-1" }, - xr.default.createElement(vh, { tw: "text-sm text-[#99A4B4]" }, t), - xr.default.createElement(vh, { tw: "font-medium text-white" }, e) - ); - } - var nCt = pon; - m(); - g(); - var C0 = qe(to()); - m(); - g(); - var ghe = qe(Le()); - m(); - g(); - var yon = () => "https://xnfts.s3.us-west-2.amazonaws.com", - iCt = yon; - async function GCe(t, e, r, n, i) { - let o = new ghe.PublicKey(r.publicKey), - [a] = await ghe.PublicKey.findProgramAddress( - [Buffer.from("install"), e.toBytes(), o.toBytes()], - lhe() - ); - if (!((await t.provider.connection.getAccountInfo(a)) !== null)) - throw new Error("Must have an active installation to review an xNFT"); - let c = await mon(o, e, n); - return await t.methods - .createReview(c, i) - .accounts({ - install: a, - xnft: o, - masterToken: new ghe.PublicKey(r.token.publicKey), - }) - .transaction(); - } - async function mon(t, e, r) { - let n = `${t.toBase58()}/comments/${e.toBase58()}/comment.json`, - i = JSON.stringify({ - name: n, - content: JSON.stringify({ comment: r }), - type: "application/json", - }), - o = await fetch(`${mhe()}/api/storage/s3`, { - method: "PUT", - headers: { "Content-Type": "application/json" }, - body: i, - }), - a = await o.json(); - if (o.status !== 201) throw new Error(JSON.stringify(a)); - return `${iCt()}/${a.key}`; - } - function gon({ app: t }) { - let [e, r] = (0, C0.useState)(0), - [n, i] = (0, C0.useState)(""), - o = m_(); - return C0.default.createElement( - C0.default.Fragment, - null, - C0.default.createElement( - dr, - { tw: "m-4" }, - C0.default.createElement(WB, { - rating: e, - onClick: (a) => r(a), - starSize: 24, - }) - ), - C0.default.createElement( - dr, - { tw: "m-4" }, - C0.default.createElement(MG, { - multiline: !0, - numberOfLines: 6, - value: n, - onChange: (a) => i(a.target.value), - }) - ), - C0.default.createElement( - dr, - { tw: "flex-row items-start m-4" }, - n === "" || e <= 0 - ? C0.default.createElement( - Fd, - { - tw: "rounded bg-[#27272A] px-3 rounded text-xs font-medium tracking-wide", - }, - "Submit Review" - ) - : C0.default.createElement( - Fd, - { - onClick: async () => { - let a = Hg(window.xnft.solana.connection, window.xnft.solana), - s = await GCe(a, window.xnft.solana.publicKey, t, n, e); - await window.xnft.solana.sendAndConfirm(s), o.pop(); - }, - tw: "flex items-center gap-2.5 bg-white py-2 text-[#374151] px-3 rounded text-xs font-medium tracking-wide", - }, - "Submit Review" - ) - ) - ); - } - var oCt = gon; - function von() { - return T3.default.createElement( - jF.Navigator, - { - initialRoute: { name: "list" }, - options: ({ route: t }) => { - switch (t.name) { - case "list": - return { - title: "xNFTs", - props: { style: { textAlign: "left" } }, - }; - case "details": - return { title: t.props?.app.json.name }; - case "review": - return { title: "New Review" }; - default: - throw new Error("unknown route"); - } - }, - style: { - font: "Inter", - fontSize: "20px", - fontWeight: "700", - height: "56px", - }, - }, - T3.default.createElement(jF.Screen, { - name: "list", - component: (t) => T3.default.createElement(Y5t, null), - }), - T3.default.createElement(jF.Screen, { - name: "details", - component: (t) => T3.default.createElement(nCt, { ...t }), - }), - T3.default.createElement(jF.Screen, { - name: "review", - component: (t) => T3.default.createElement(oCt, { ...t }), - }) - ); - } - var aCt = von; - function sCt() { - let t = YI(hhe); - return t.state === "loading" - ? aW.default.createElement(PG, null) - : t.state === "hasError" - ? (console.error(t), aW.default.createElement(vh, null, "Error")) - : aW.default.createElement( - dr, - { tw: "bg-[#18181B] relative h-full" }, - aW.default.createElement(aCt, null) - ); - } - F9e.render( - vhe.default.createElement( - T9e, - null, - vhe.default.createElement(aze, null, vhe.default.createElement(sCt, null)) - ) - ); -})(); -/* -object-assign -(c) Sindre Sorhus -@license MIT -*/ -/*! - * The buffer module from node.js, for the browser. - * - * @author Feross Aboukhadijeh - * @license MIT - */ -/*! - * The buffer module from node.js, for the browser. - * - * @author Feross Aboukhadijeh - * @license MIT - */ -/*! - * depd - * Copyright(c) 2015 Douglas Christopher Wilson - * MIT Licensed - */ -/*! - * http-errors - * Copyright(c) 2014 Jonathan Ong - * Copyright(c) 2016 Douglas Christopher Wilson - * MIT Licensed - */ -/*! - * mustache.js - Logic-less {{mustache}} templates with JavaScript - * http://github.com/janl/mustache.js - */ -/*! - * statuses - * Copyright(c) 2014 Jonathan Ong - * Copyright(c) 2016 Douglas Christopher Wilson - * MIT Licensed - */ -/*! - * toidentifier - * Copyright(c) 2016 Douglas Christopher Wilson - * MIT Licensed - */ -/*! ***************************************************************************** -Copyright (c) Microsoft Corporation. - -Permission to use, copy, modify, and/or distribute this software for any -purpose with or without fee is hereby granted. - -THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH -REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY -AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, -INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM -LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR -OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR -PERFORMANCE OF THIS SOFTWARE. -***************************************************************************** */ -/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh */ -/*! noble-ed25519 - MIT License (c) 2019 Paul Miller (paulmillr.com) */ -/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */ -/*! noble-secp256k1 - MIT License (c) 2019 Paul Miller (paulmillr.com) */ -/*! pako 2.0.4 https://github.com/nodeca/pako @license (MIT AND Zlib) */ -/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ -/*! safe-buffer. MIT License. Feross Aboukhadijeh */ -/** - * @license React - * use-sync-external-store-shim.production.min.js - * - * Copyright (c) Facebook, Inc. and its affiliates. - * - * This source code is licensed under the MIT license found in the - * LICENSE file in the root directory of this source tree. - */ -/** - * @license React - * use-sync-external-store-shim/with-selector.production.min.js - * - * Copyright (c) Facebook, Inc. and its affiliates. - * - * This source code is licensed under the MIT license found in the - * LICENSE file in the root directory of this source tree. - */ -/** - * Support for translating between Buffer instances and JavaScript - * native types. - * - * {@link module:Layout~Layout|Layout} is the basis of a class - * hierarchy that associates property names with sequences of encoded - * bytes. - * - * Layouts are supported for these scalar (numeric) types: - * * {@link module:Layout~UInt|Unsigned integers in little-endian - * format} with {@link module:Layout.u8|8-bit}, {@link - * module:Layout.u16|16-bit}, {@link module:Layout.u24|24-bit}, - * {@link module:Layout.u32|32-bit}, {@link - * module:Layout.u40|40-bit}, and {@link module:Layout.u48|48-bit} - * representation ranges; - * * {@link module:Layout~UIntBE|Unsigned integers in big-endian - * format} with {@link module:Layout.u16be|16-bit}, {@link - * module:Layout.u24be|24-bit}, {@link module:Layout.u32be|32-bit}, - * {@link module:Layout.u40be|40-bit}, and {@link - * module:Layout.u48be|48-bit} representation ranges; - * * {@link module:Layout~Int|Signed integers in little-endian - * format} with {@link module:Layout.s8|8-bit}, {@link - * module:Layout.s16|16-bit}, {@link module:Layout.s24|24-bit}, - * {@link module:Layout.s32|32-bit}, {@link - * module:Layout.s40|40-bit}, and {@link module:Layout.s48|48-bit} - * representation ranges; - * * {@link module:Layout~IntBE|Signed integers in big-endian format} - * with {@link module:Layout.s16be|16-bit}, {@link - * module:Layout.s24be|24-bit}, {@link module:Layout.s32be|32-bit}, - * {@link module:Layout.s40be|40-bit}, and {@link - * module:Layout.s48be|48-bit} representation ranges; - * * 64-bit integral values that decode to an exact (if magnitude is - * less than 2^53) or nearby integral Number in {@link - * module:Layout.nu64|unsigned little-endian}, {@link - * module:Layout.nu64be|unsigned big-endian}, {@link - * module:Layout.ns64|signed little-endian}, and {@link - * module:Layout.ns64be|unsigned big-endian} encodings; - * * 32-bit floating point values with {@link - * module:Layout.f32|little-endian} and {@link - * module:Layout.f32be|big-endian} representations; - * * 64-bit floating point values with {@link - * module:Layout.f64|little-endian} and {@link - * module:Layout.f64be|big-endian} representations; - * * {@link module:Layout.const|Constants} that take no space in the - * encoded expression. - * - * and for these aggregate types: - * * {@link module:Layout.seq|Sequence}s of instances of a {@link - * module:Layout~Layout|Layout}, with JavaScript representation as - * an Array and constant or data-dependent {@link - * module:Layout~Sequence#count|length}; - * * {@link module:Layout.struct|Structure}s that aggregate a - * heterogeneous sequence of {@link module:Layout~Layout|Layout} - * instances, with JavaScript representation as an Object; - * * {@link module:Layout.union|Union}s that support multiple {@link - * module:Layout~VariantLayout|variant layouts} over a fixed - * (padded) or variable (not padded) span of bytes, using an - * unsigned integer at the start of the data or a separate {@link - * module:Layout.unionLayoutDiscriminator|layout element} to - * determine which layout to use when interpreting the buffer - * contents; - * * {@link module:Layout.bits|BitStructure}s that contain a sequence - * of individual {@link - * module:Layout~BitStructure#addField|BitField}s packed into an 8, - * 16, 24, or 32-bit unsigned integer starting at the least- or - * most-significant bit; - * * {@link module:Layout.cstr|C strings} of varying length; - * * {@link module:Layout.blob|Blobs} of fixed- or variable-{@link - * module:Layout~Blob#length|length} raw data. - * - * All {@link module:Layout~Layout|Layout} instances are immutable - * after construction, to prevent internal state from becoming - * inconsistent. - * - * @local Layout - * @local ExternalLayout - * @local GreedyCount - * @local OffsetLayout - * @local UInt - * @local UIntBE - * @local Int - * @local IntBE - * @local NearUInt64 - * @local NearUInt64BE - * @local NearInt64 - * @local NearInt64BE - * @local Float - * @local FloatBE - * @local Double - * @local DoubleBE - * @local Sequence - * @local Structure - * @local UnionDiscriminator - * @local UnionLayoutDiscriminator - * @local Union - * @local VariantLayout - * @local BitStructure - * @local BitField - * @local Boolean - * @local Blob - * @local CString - * @local Constant - * @local bindConstructorLayout - * @module Layout - * @license MIT - * @author Peter A. Bigot - * @see {@link https://github.com/pabigot/buffer-layout|buffer-layout on GitHub} - */ -/** - * Support for translating between Uint8Array instances and JavaScript - * native types. - * - * {@link module:Layout~Layout|Layout} is the basis of a class - * hierarchy that associates property names with sequences of encoded - * bytes. - * - * Layouts are supported for these scalar (numeric) types: - * * {@link module:Layout~UInt|Unsigned integers in little-endian - * format} with {@link module:Layout.u8|8-bit}, {@link - * module:Layout.u16|16-bit}, {@link module:Layout.u24|24-bit}, - * {@link module:Layout.u32|32-bit}, {@link - * module:Layout.u40|40-bit}, and {@link module:Layout.u48|48-bit} - * representation ranges; - * * {@link module:Layout~UIntBE|Unsigned integers in big-endian - * format} with {@link module:Layout.u16be|16-bit}, {@link - * module:Layout.u24be|24-bit}, {@link module:Layout.u32be|32-bit}, - * {@link module:Layout.u40be|40-bit}, and {@link - * module:Layout.u48be|48-bit} representation ranges; - * * {@link module:Layout~Int|Signed integers in little-endian - * format} with {@link module:Layout.s8|8-bit}, {@link - * module:Layout.s16|16-bit}, {@link module:Layout.s24|24-bit}, - * {@link module:Layout.s32|32-bit}, {@link - * module:Layout.s40|40-bit}, and {@link module:Layout.s48|48-bit} - * representation ranges; - * * {@link module:Layout~IntBE|Signed integers in big-endian format} - * with {@link module:Layout.s16be|16-bit}, {@link - * module:Layout.s24be|24-bit}, {@link module:Layout.s32be|32-bit}, - * {@link module:Layout.s40be|40-bit}, and {@link - * module:Layout.s48be|48-bit} representation ranges; - * * 64-bit integral values that decode to an exact (if magnitude is - * less than 2^53) or nearby integral Number in {@link - * module:Layout.nu64|unsigned little-endian}, {@link - * module:Layout.nu64be|unsigned big-endian}, {@link - * module:Layout.ns64|signed little-endian}, and {@link - * module:Layout.ns64be|unsigned big-endian} encodings; - * * 32-bit floating point values with {@link - * module:Layout.f32|little-endian} and {@link - * module:Layout.f32be|big-endian} representations; - * * 64-bit floating point values with {@link - * module:Layout.f64|little-endian} and {@link - * module:Layout.f64be|big-endian} representations; - * * {@link module:Layout.const|Constants} that take no space in the - * encoded expression. - * - * and for these aggregate types: - * * {@link module:Layout.seq|Sequence}s of instances of a {@link - * module:Layout~Layout|Layout}, with JavaScript representation as - * an Array and constant or data-dependent {@link - * module:Layout~Sequence#count|length}; - * * {@link module:Layout.struct|Structure}s that aggregate a - * heterogeneous sequence of {@link module:Layout~Layout|Layout} - * instances, with JavaScript representation as an Object; - * * {@link module:Layout.union|Union}s that support multiple {@link - * module:Layout~VariantLayout|variant layouts} over a fixed - * (padded) or variable (not padded) span of bytes, using an - * unsigned integer at the start of the data or a separate {@link - * module:Layout.unionLayoutDiscriminator|layout element} to - * determine which layout to use when interpreting the buffer - * contents; - * * {@link module:Layout.bits|BitStructure}s that contain a sequence - * of individual {@link - * module:Layout~BitStructure#addField|BitField}s packed into an 8, - * 16, 24, or 32-bit unsigned integer starting at the least- or - * most-significant bit; - * * {@link module:Layout.cstr|C strings} of varying length; - * * {@link module:Layout.blob|Blobs} of fixed- or variable-{@link - * module:Layout~Blob#length|length} raw data. - * - * All {@link module:Layout~Layout|Layout} instances are immutable - * after construction, to prevent internal state from becoming - * inconsistent. - * - * @local Layout - * @local ExternalLayout - * @local GreedyCount - * @local OffsetLayout - * @local UInt - * @local UIntBE - * @local Int - * @local IntBE - * @local NearUInt64 - * @local NearUInt64BE - * @local NearInt64 - * @local NearInt64BE - * @local Float - * @local FloatBE - * @local Double - * @local DoubleBE - * @local Sequence - * @local Structure - * @local UnionDiscriminator - * @local UnionLayoutDiscriminator - * @local Union - * @local VariantLayout - * @local BitStructure - * @local BitField - * @local Boolean - * @local Blob - * @local CString - * @local Constant - * @local bindConstructorLayout - * @module Layout - * @license MIT - * @author Peter A. Bigot - * @see {@link https://github.com/pabigot/buffer-layout|buffer-layout on GitHub} - */ -/** - * [js-sha256]{@link https://github.com/emn178/js-sha256} - * - * @version 0.9.0 - * @author Chen, Yi-Cyuan [emn178@gmail.com] - * @copyright Chen, Yi-Cyuan 2014-2017 - * @license MIT - */ -/** - * [js-sha3]{@link https://github.com/emn178/js-sha3} - * - * @version 0.8.0 - * @author Chen, Yi-Cyuan [emn178@gmail.com] - * @copyright Chen, Yi-Cyuan 2015-2018 - * @license MIT - */ -/** @license React v0.20.2 - * scheduler.production.min.js - * - * Copyright (c) Facebook, Inc. and its affiliates. - * - * This source code is licensed under the MIT license found in the - * LICENSE file in the root directory of this source tree. - */ -/** @license React v0.26.2 - * react-reconciler.production.min.js - * - * Copyright (c) Facebook, Inc. and its affiliates. - * - * This source code is licensed under the MIT license found in the - * LICENSE file in the root directory of this source tree. - */ -/** @license React v17.0.2 - * react-dom.production.min.js - * - * Copyright (c) Facebook, Inc. and its affiliates. - * - * This source code is licensed under the MIT license found in the - * LICENSE file in the root directory of this source tree. - */ -/** @license React v17.0.2 - * react-jsx-runtime.production.min.js - * - * Copyright (c) Facebook, Inc. and its affiliates. - * - * This source code is licensed under the MIT license found in the - * LICENSE file in the root directory of this source tree. - */ -/** @license React v17.0.2 - * react.production.min.js - * - * Copyright (c) Facebook, Inc. and its affiliates. - * - * This source code is licensed under the MIT license found in the - * LICENSE file in the root directory of this source tree. - */ diff --git a/examples/xnft/iframe/src/index.tsx b/examples/xnft/iframe/src/index.tsx index e2ad832ca..5c6f8272c 100644 --- a/examples/xnft/iframe/src/index.tsx +++ b/examples/xnft/iframe/src/index.tsx @@ -1,3 +1,4 @@ +import React from "react"; import ReactXnft, { AnchorDom, Iframe } from "react-xnft"; ReactXnft.render( diff --git a/packages/app-extension/src/app/DbRecoilSync.tsx b/packages/app-extension/src/app/DbRecoilSync.tsx index f30eae3ae..e03862444 100644 --- a/packages/app-extension/src/app/DbRecoilSync.tsx +++ b/packages/app-extension/src/app/DbRecoilSync.tsx @@ -1,5 +1,6 @@ import { useEffect } from "react"; import type { EnrichedMessage, SubscriptionType } from "@coral-xyz/common"; +import { BACKEND_API_URL } from "@coral-xyz/common"; import { RecoilSync } from "@coral-xyz/db"; import { SignalingManager } from "@coral-xyz/react-common"; import { @@ -7,6 +8,7 @@ import { groupCollections, requestCount, roomChats, + unreadCount, useUser, } from "@coral-xyz/recoil"; import { useRecoilCallback, useRecoilState } from "recoil"; @@ -22,8 +24,24 @@ export const DbRecoilSync = () => { const [_groupCollectionsValue, setGroupCollectionsValue] = useRecoilState( groupCollections({ uuid }) ); + const [_unreadCount, setUnreadCount] = useRecoilState(unreadCount); const updateChats = useUpdateChats(); + const updateUnread = async () => { + const response = await fetch( + `${BACKEND_API_URL}/notifications/unreadCount`, + { + method: "GET", + } + ); + try { + const json = await response.json(); + setUnreadCount(json.unreadCount || 0); + } catch (e) { + console.error(e); + } + }; + const getGroupedRooms = ( chats: EnrichedMessage[] ): { @@ -68,6 +86,8 @@ export const DbRecoilSync = () => { chats: group.messages, }); }); + RecoilSync.getInstance().refreshUsersMetadata(uuid); + updateUnread(); }; useEffect(() => { diff --git a/packages/app-extension/src/app/Router.tsx b/packages/app-extension/src/app/Router.tsx index aab9db433..9eef13775 100644 --- a/packages/app-extension/src/app/Router.tsx +++ b/packages/app-extension/src/app/Router.tsx @@ -10,15 +10,18 @@ import { QUERY_APPROVE_ALL_TRANSACTIONS, QUERY_APPROVE_MESSAGE, QUERY_APPROVE_TRANSACTION, - QUERY_COLD, QUERY_LOCKED, + QUERY_LOCKED_APPROVAL, toTitleCase, } from "@coral-xyz/common"; import { - BackgroundChatsSync, EmptyState, + BackgroundChatsSync, + EmptyState, refreshGroupsAndFriendships, - SignalingManager } from "@coral-xyz/react-common"; + SignalingManager, +} from "@coral-xyz/react-common"; import { + isKeyCold, KeyringStoreStateEnum, useApprovedOrigins, useBackgroundClient, @@ -32,6 +35,7 @@ import { import { styles, useCustomTheme } from "@coral-xyz/themes"; import { Block as BlockIcon } from "@mui/icons-material"; import { AnimatePresence, motion } from "framer-motion"; +import { useRecoilValue } from "recoil"; import { refreshXnftPreferences } from "../api/preferences"; import { Locked } from "../components/Locked"; @@ -132,6 +136,8 @@ function PopupRouter() { switch (query) { case QUERY_LOCKED: return ; + case QUERY_LOCKED_APPROVAL: + return ; case QUERY_APPROVAL: return ; case QUERY_APPROVE_TRANSACTION: @@ -140,8 +146,6 @@ function PopupRouter() { return ; case QUERY_APPROVE_MESSAGE: return ; - case QUERY_COLD: - return ; default: return ; } @@ -171,6 +175,13 @@ function QueryLocked() { ); } +function QueryLockedApproval() { + logger.debug("query locked approval"); + const keyringStoreState = useKeyringStoreState(); + const isLocked = keyringStoreState === KeyringStoreStateEnum.Locked; + return isLocked ? : ; +} + function QueryApproval() { logger.debug("query approval"); const background = useBackgroundResponder(); @@ -216,8 +227,16 @@ function QueryApproveTransaction() { const tx = url.searchParams.get("tx"); const wallet = url.searchParams.get("wallet")!; const blockchain = url.searchParams.get("blockchain")! as Blockchain; + const _isKeyCold = useRecoilValue(isKeyCold(wallet)); - return ( + return _isKeyCold ? ( + {}} + /> + ) : ( {}} + /> + ) : ( { - bg.response({}); - window.close(); - }} - /> - ); -} - function QueryApproveMessage() { logger.debug("query approve message"); const bg = useBackgroundResponder(); @@ -328,8 +334,16 @@ function QueryApproveMessage() { const requestId = parseInt(url.searchParams.get("requestId")!); const wallet = url.searchParams.get("wallet")!; const blockchain = url.searchParams.get("blockchain")! as Blockchain; + const _isKeyCold = useRecoilValue(isKeyCold(wallet)); - return ( + return _isKeyCold ? ( + {}} + /> + ) : ( void; + onNext: (walletDescriptor: Array) => void; onError?: (error: Error) => void; allowMultiple?: boolean; }) { const background = useBackgroundClient(); const checkPublicKeyConflicts = useConflictQuery(); const theme = useCustomTheme(); - const [accounts, setAccounts] = useState>([]); - const [selectedAccounts, setSelectedAccounts] = useState( - [] + + // Loaded balances for each public key + const [balances, setBalances] = useState<{ [publicKey: string]: BigNumber }>( + {} ); + // Path to the public key + const [walletDescriptors, setWalletDescriptors] = useState< + Array + >([]); + const [checkedWalletDescriptors, setCheckedWalletDescriptors] = useState< + Array + >([]); + // Lock flag to prevent changing of derivation path while ledger is loading const [ledgerLocked, setLedgerLocked] = useState(false); // Public keys that have already been imported on this account - const [importedPubkeys, setImportedPubkeys] = useState([]); + const [importedPublicKeys, setImportedPublicKeys] = useState([]); // Public keys that are in use on other Backpack accounts - const [conflictingPubkeys, setConflictingPubkeys] = useState([]); - const [derivationPath, setDerivationPath] = useState( - DerivationPath.Default + const [conflictingPublicKeys, setConflictingPublicKeys] = useState( + [] ); - const disabledPubkeys = [...importedPubkeys, ...conflictingPubkeys]; + const derivationPathOptions = { + [Blockchain.SOLANA]: [ + { + path: (i: number) => legacyBip44Indexed(Blockchain.SOLANA, i), + label: "m/44/501'/ ", + }, + { + path: (i: number) => legacyBip44ChangeIndexed(Blockchain.SOLANA, i), + label: "m/44/501'/0'", + }, + { + path: (i: number) => + legacyBip44ChangeIndexed(Blockchain.SOLANA, i) + "/0'", + label: "m/44/501'/0'/0'", + }, + /** + { + path: (i: number) => getIndexedPath(Blockchain.SOLANA, i), + label: "Backpack", + }, + **/ + ] + // Note: We only allow importing the deprecated sollet derivation path for + // hot wallets. This UI is hidden behind a local storage flag we + // expect people to manually set, since this derivation path was only + // used by mostly technical early Solana users. + .concat( + mnemonic && window.localStorage.getItem("sollet") + ? [ + { + path: (i: number) => legacySolletIndexed(i), + label: "501'/0'/0/0 (Deprecated)", + }, + ] + : [] + ), + [Blockchain.ETHEREUM]: [ + { + path: (i: number) => legacyBip44Indexed(Blockchain.ETHEREUM, i), + label: "m/44/501'/", + }, + { + path: (i: number) => legacyBip44ChangeIndexed(Blockchain.ETHEREUM, i), + label: "m/44/501'/0'", + }, + { + path: (i: number) => + legacyBip44ChangeIndexed(Blockchain.ETHEREUM, i) + "/0'", + label: "m/44/501'/0'/0'", + }, + /** + { + path: (i: number) => getIndexedPath(Blockchain.SOLANA, i), + label: "Backpack", + }, + **/ + ], + }[blockchain]; + + const [derivationPathLabel, setDerivationPathLabel] = useState( + derivationPathOptions[0].label + ); + const [derivationPaths, setDerivationPaths] = useState>([]); + + const disabledPublicKeys = [...importedPublicKeys, ...conflictingPublicKeys]; useEffect(() => { (async () => { @@ -96,7 +153,7 @@ export function ImportAccounts({ params: [], }); const keyring = blockchainKeyrings[blockchain]; - setImportedPubkeys( + setImportedPublicKeys( Object.values(keyring) .flat() .map((a: any) => a.publicKey) @@ -112,46 +169,58 @@ export function ImportAccounts({ // useEffect(() => { (async () => { - if (accounts.length === 0) return; + if (walletDescriptors.length === 0) return; try { const response = await checkPublicKeyConflicts( - accounts.map((a) => ({ + walletDescriptors.map((a) => ({ blockchain, publicKey: a.publicKey, })) ); - setConflictingPubkeys(response.map((r: any) => r.public_key)); + setConflictingPublicKeys(response.map((r: any) => r.public_key)); } catch { // If the query failed assume all are valid } })(); - }, [accounts, blockchain]); + }, [walletDescriptors]); // // Load a list of accounts and their associated balances // useEffect(() => { - if (!derivationPath) return; + if (!derivationPaths) return; + + setCheckedWalletDescriptors([]); let loaderFn; if (mnemonic) { // Loading accounts from a mnemonic - loaderFn = (derivationPath: DerivationPath) => - loadMnemonicPublicKeys(mnemonic, derivationPath); + loaderFn = (derivationPaths: Array) => + loadMnemonicPublicKeys(mnemonic, derivationPaths); } else if (transport) { // Loading accounts from a Ledger - loaderFn = (derivationPath: DerivationPath) => - loadLedgerPublicKeys(transport, derivationPath); + loaderFn = (derivationPaths: Array) => + loadLedgerPublicKeys(transport, derivationPaths); } else { return; } - loaderFn(derivationPath) + loaderFn(derivationPaths) .then(async (publicKeys: string[]) => { + setWalletDescriptors( + derivationPaths.map((derivationPath, i) => ({ + publicKey: publicKeys[i], + derivationPath, + })) + ); const balances = await loadBalances(publicKeys); - setAccounts( - balances.sort((a, b) => - b.balance.lt(a.balance) ? -1 : b.balance.eq(a.balance) ? 0 : 1 + setBalances( + Object.fromEntries( + balances + .sort((a, b) => + b.balance.lt(a.balance) ? -1 : b.balance.eq(a.balance) ? 0 : 1 + ) + .map((a) => [a.publicKey, a.balance]) ) ); }) @@ -165,15 +234,26 @@ export function ImportAccounts({ throw error; } }); - }, [mnemonic, transport, derivationPath]); + }, [mnemonic, transport, derivationPaths]); // // Clear accounts and selected acounts on change of derivation path. // useEffect(() => { - setAccounts([]); - setSelectedAccounts([]); - }, [derivationPath]); + setBalances({}); + setWalletDescriptors([]); + if (derivationPathLabel !== null) { + const derivationPath = derivationPathOptions.find( + (d) => d.label === derivationPathLabel + ); + if (!derivationPath) throw new Error("Invalid derivation path label"); + setDerivationPaths( + [...Array(LOAD_PUBLIC_KEY_AMOUNT).keys()].map((i) => + derivationPath.path(i) + ) + ); + } + }, [derivationPathLabel]); // // Load balances for accounts that have been loaded @@ -227,11 +307,11 @@ export function ImportAccounts({ // const loadMnemonicPublicKeys = async ( mnemonic: string, - derivationPath: DerivationPath + derivationPaths: Array ) => { return await background.request({ method: UI_RPC_METHOD_PREVIEW_PUBKEYS, - params: [blockchain, mnemonic, derivationPath, LOAD_PUBLIC_KEY_AMOUNT], + params: [blockchain, mnemonic, derivationPaths], }); }; @@ -240,22 +320,20 @@ export function ImportAccounts({ // const loadLedgerPublicKeys = async ( transport: Transport, - derivationPath: DerivationPath + derivationPaths: Array ): Promise => { const publicKeys = []; setLedgerLocked(true); - const ledger = { [Blockchain.SOLANA]: new Solana(transport), [Blockchain.ETHEREUM]: new Ethereum(transport), }[blockchain]; - // Add remaining accounts - for (let account = 0; account < LOAD_PUBLIC_KEY_AMOUNT; account += 1) { - const path = accountDerivationPath(blockchain, derivationPath, account); - publicKeys.push((await ledger.getAddress(path)).address); + for (const derivationPath of derivationPaths) { + publicKeys.push( + (await ledger.getAddress(derivationPath.replace("m/", ""))).address + ); } - setLedgerLocked(false); return publicKeys.map((p) => blockchain === Blockchain.SOLANA ? bs58.encode(p) : p.toString() @@ -265,72 +343,32 @@ export function ImportAccounts({ // // Handles checkbox clicks to select accounts to import. // - const handleSelect = (index: number, publicKey: string) => () => { - const currentIndex = selectedAccounts.findIndex((a) => a.index === index); - let newSelectedAccounts = [...selectedAccounts]; + const handleSelect = (publicKey: string, derivationPath: string) => () => { + const currentIndex = checkedWalletDescriptors.findIndex( + (a) => a.publicKey === publicKey + ); + let newCheckedWalletDescriptors = [...checkedWalletDescriptors]; if (currentIndex === -1) { + // Not selected, add it + const walletDescriptor = { + derivationPath, + publicKey, + } as WalletDescriptor; // Adding the account if (allowMultiple) { - newSelectedAccounts.push({ index, publicKey }); + newCheckedWalletDescriptors.push(walletDescriptor); } else { - newSelectedAccounts = [{ index, publicKey }]; + newCheckedWalletDescriptors = [walletDescriptor]; } } else { // Removing the account - newSelectedAccounts.splice(currentIndex, 1); + newCheckedWalletDescriptors.splice(currentIndex, 1); } - // Sort by account indices - newSelectedAccounts.sort((a, b) => a.index - b.index); - setSelectedAccounts(newSelectedAccounts); + // TODO Sort by account indices + // newCheckedWalletDescriptors.sort((a, b) => a.index - b.index); + setCheckedWalletDescriptors(newCheckedWalletDescriptors); }; - const derivationPathOptions = { - [Blockchain.SOLANA]: [ - { - path: DerivationPath.Bip44, - label: derivationPathPrefix(Blockchain.SOLANA, DerivationPath.Bip44), - }, - { - path: DerivationPath.Bip44Change, - label: derivationPathPrefix( - Blockchain.SOLANA, - DerivationPath.Bip44Change - ), - }, - ] - // Note: We only allow importing the deprecated sollet derivation path for - // hot wallets. This UI is hidden behind a local storage flag we - // expect people to manually set, since this derivation path was only - // used by mostly technical early Solana users. - .concat( - mnemonic && window.localStorage.getItem("sollet") - ? [ - { - path: DerivationPath.SolletDeprecated, - label: - derivationPathPrefix( - Blockchain.SOLANA, - DerivationPath.SolletDeprecated - ) + " (deprecated)", - }, - ] - : [] - ), - [Blockchain.ETHEREUM]: [ - { - path: DerivationPath.Bip44, - label: derivationPathPrefix(Blockchain.ETHEREUM, DerivationPath.Bip44), - }, - { - path: DerivationPath.Bip44Change, - label: derivationPathPrefix( - Blockchain.ETHEREUM, - DerivationPath.Bip44Change - ), - }, - ], - }[blockchain]; - // Symbol for balance displays const symbol = { [Blockchain.SOLANA]: "SOL", @@ -368,19 +406,19 @@ export function ImportAccounts({

- {accounts.length > 0 && ( + {Object.keys(balances).length > 0 ? ( <> - {accounts + {walletDescriptors .slice(0, DISPLAY_PUBKEY_AMOUNT) - .map(({ publicKey, balance, index }) => ( + .map(({ publicKey, derivationPath }) => (
a.index === index) || - importedPubkeys.includes(publicKey.toString()) + checkedWalletDescriptors.some( + (a) => a.derivationPath === derivationPath + ) || + importedPublicKeys.includes(publicKey.toString()) } tabIndex={-1} - disabled={disabledPubkeys.includes( + disabled={disabledPublicKeys.includes( publicKey.toString() )} disableRipple @@ -447,12 +487,12 @@ export function ImportAccounts({ textAlign: "right", }} primary={`${ - balance + balances[publicKey] ? (+ethers.utils.formatUnits( - balance, + balances[publicKey], decimals )).toFixed(4) - : 0 + : "-" } ${symbol}`} /> @@ -460,9 +500,10 @@ export function ImportAccounts({ ))} + ) : ( + )} - {accounts.length === 0 && } onNext(selectedAccounts, derivationPath, mnemonic)} - disabled={selectedAccounts.length === 0} + onClick={() => onNext(checkedWalletDescriptors)} + disabled={walletDescriptors.length === 0} /> diff --git a/packages/app-extension/src/components/common/Account/SetupComplete.tsx b/packages/app-extension/src/components/common/Account/SetupComplete.tsx index b01a81e59..0c8c59068 100644 --- a/packages/app-extension/src/components/common/Account/SetupComplete.tsx +++ b/packages/app-extension/src/components/common/Account/SetupComplete.tsx @@ -1,4 +1,4 @@ -import { useState } from "react"; +import type { ReactNode } from "react"; import { BACKPACK_FEATURE_XNFT, DISCORD_INVITE_LINK, @@ -11,45 +11,23 @@ import { PinIcon, PrimaryButton, TwitterIcon, - WidgetIcon, } from "@coral-xyz/react-common"; import { useCustomTheme } from "@coral-xyz/themes"; -import { Box, Grid, Typography } from "@mui/material"; - import { - registerNotificationServiceWorker, - saveSubscription, -} from "../../../permissions/utils"; + Box, + Button, + Card, + CardContent, + Grid, + Typography, +} from "@mui/material"; + import { Header, SubtextParagraph } from "../../common"; import { ActionCard } from "../../common/Layout/ActionCard"; -import { SwitchToggle } from "../../Unlocked/Settings/Preferences"; +import { AppStoreIcon } from "../Icon"; export function SetupComplete({ onClose }: { onClose: () => void }) { const theme = useCustomTheme(); - const [notificationPermissionGranted, setNotificationPermissionGranted] = - useState(false); - - const requestNotificationPermission = async () => { - const permission = await window.Notification.requestPermission(); - if (permission !== "granted") { - setNotificationPermissionGranted(false); - } - }; - - const registerSubscription = async () => { - registerNotificationServiceWorker() - .then(async function (subscription) { - setNotificationPermissionGranted(true); - if (!subscription) { - // Set appropriate app states. - return; - } - await saveSubscription(subscription); - }) - .catch(function () { - setNotificationPermissionGranted(false); - }); - }; return ( <> @@ -79,69 +57,42 @@ export function SetupComplete({ onClose }: { onClose: () => void }) { mr: "24px", }} > -
+
- Now get started exploring what your Backpack can do. + We recommend downloading a few xNFTs to get started. - - -
- - Turn on notifications - -
-
- { - await requestNotificationPermission(); - await registerSubscription(); - }} - /> -
- - + {BACKPACK_FEATURE_XNFT && ( - } - text="Browse the xNFT library" + } + title="Browse the xNFT library" onClick={() => window.open(XNFT_GG_LINK, "_blank")} /> )} - } - text="Follow us on Twitter" + title="Follow us on Twitter" onClick={() => window.open(TWITTER_LINK, "_blank")} /> - } - text="Join the Discord community" + title="Join Discord" onClick={() => window.open(DISCORD_INVITE_LINK, "_blank")} /> @@ -156,7 +107,7 @@ export function SetupComplete({ onClose }: { onClose: () => void }) { }} > void }) { ); } +function CallToAction({ + icon, + title, + onClick, +}: { + icon: ReactNode; + title: string; + onClick: () => void; +}) { + const theme = useCustomTheme(); + return ( + + ); +} + function PinNotification() { const theme = useCustomTheme(); diff --git a/packages/app-extension/src/components/common/Icon/index.tsx b/packages/app-extension/src/components/common/Icon/index.tsx index cedc25c15..b9ff7052e 100644 --- a/packages/app-extension/src/components/common/Icon/index.tsx +++ b/packages/app-extension/src/components/common/Icon/index.tsx @@ -54,6 +54,42 @@ export function WidgetIcon({ fill = "#FAFAFA" }) { ); } +export function AppStoreIcon() { + return ( + + + + + + + + + + + + + + ); +} + export function TwitterIcon({ fill = "#FAFAFA", style, diff --git a/packages/app-extension/src/components/common/Layout/Nav.tsx b/packages/app-extension/src/components/common/Layout/Nav.tsx index c0c81bd7d..2e3a2aed2 100644 --- a/packages/app-extension/src/components/common/Layout/Nav.tsx +++ b/packages/app-extension/src/components/common/Layout/Nav.tsx @@ -36,7 +36,7 @@ const useStyles = styles((theme) => ({ position: "absolute", left: 0, "&:hover": { - background: "transparent", + background: "transparent !important", }, }, })); @@ -270,7 +270,7 @@ function CenterDisplay({ style={{ fontSize: 19, marginLeft: 3, - color: theme.custom.colors.blue, + color: theme.custom.colors.verified, }} /> )} diff --git a/packages/app-extension/src/components/common/Layout/Router.tsx b/packages/app-extension/src/components/common/Layout/Router.tsx index 7794b2fa1..392f997b8 100644 --- a/packages/app-extension/src/components/common/Layout/Router.tsx +++ b/packages/app-extension/src/components/common/Layout/Router.tsx @@ -16,7 +16,6 @@ import { MESSAGING_COMMUNICATION_FETCH, MESSAGING_COMMUNICATION_PUSH, } from "@coral-xyz/common/src/constants"; -import { useDbUser } from "@coral-xyz/db"; import { ChatScreen, Inbox, @@ -30,7 +29,6 @@ import { useDarkMode, useDecodedSearchParams, useFeatureGates, - useFriendships, useNavigation, useRedirectUrl, useUser, @@ -52,7 +50,6 @@ import { NftOptionsButton, NftsDetail } from "../../Unlocked/Nfts/Detail"; import { NftChat, NftsExperience } from "../../Unlocked/Nfts/Experience"; import { SettingsButton } from "../../Unlocked/Settings"; -import { AvatarPopoverButton } from "./../../Unlocked/Settings/AvatarPopover"; import { useBreakpoints } from "./hooks"; import { NavBackButton, WithNav } from "./Nav"; import { WithMotion } from "./NavStack"; @@ -84,8 +81,13 @@ export function Router() { Auto-lock functionality is dependent on checking if the URL contains "xnft", if this changes then please verify that it still works */} + } /> } /> - } /> + {isXs ? ( + } /> + ) : ( + } /> + )} ); @@ -104,6 +106,17 @@ export function Redirect() { return ; } +// We use a separate redirect for the xs size because some routes, e.g., /notifications +// and /recent-activity don't exist on the xs size--for xs, they are ephemeral drawers, +// for larger screens they are normal routes. +export function RedirectXs() { + let url = useRedirectUrl(); + if (url.startsWith("/notifications") || url.startsWith("/recent-activity")) { + return ; + } + return ; +} + function BalancesPage() { return } />; } @@ -356,6 +369,7 @@ function NavScreen({ }; }) { const { title, isRoot, pop } = useNavigation(); + const { style, navButtonLeft, @@ -420,7 +434,6 @@ function useNavBar() { const pathname = useLocation().pathname; const theme = useCustomTheme(); const { props }: any = useDecodedSearchParams(); // TODO: fix type - const { uuid } = useUser(); const { isXs } = useBreakpoints(); const profileUser = useUsersMetadata({ remoteUserIds: [props?.userId] }); const image: string | undefined = profileUser[props?.userId]?.image; diff --git a/packages/app-extension/src/components/common/Layout/Tab.tsx b/packages/app-extension/src/components/common/Layout/Tab.tsx index 588f38245..e7e36af4d 100644 --- a/packages/app-extension/src/components/common/Layout/Tab.tsx +++ b/packages/app-extension/src/components/common/Layout/Tab.tsx @@ -27,10 +27,10 @@ import { } from "@coral-xyz/recoil"; import { styles, useCustomTheme } from "@coral-xyz/themes"; import FormatListBulletedIcon from "@mui/icons-material/FormatListBulleted"; -import NotificationsIcon from "@mui/icons-material/Notifications"; import { Tab, Tabs } from "@mui/material"; import { AvatarPopoverButton } from "../../Unlocked/Settings/AvatarPopover"; +import { NotificationIconWithBadge } from "../NotificationIconWithBadge"; import { useBreakpoints } from "./hooks"; @@ -294,7 +294,7 @@ function TabBar() { tab === TAB_MESSAGES ? classes.activeTab : "" }`} icon={ - ({ + badge: { + fontSize: 10, + }, +})); + +export const NotificationIconWithBadge = ({ style }: { style: any }) => { + const unreadCount = useUnreadCount(); + const classes = useStyles(); + + if (!unreadCount) { + return ; + } + + return ( + + + + ); +}; diff --git a/packages/app-extension/src/components/common/PopoverMenu.tsx b/packages/app-extension/src/components/common/PopoverMenu.tsx new file mode 100644 index 000000000..b75e6456d --- /dev/null +++ b/packages/app-extension/src/components/common/PopoverMenu.tsx @@ -0,0 +1,74 @@ +import type { FunctionComponent } from "react"; +import { useCustomTheme } from "@coral-xyz/themes"; +import Button, { type ButtonProps } from "@mui/material/Button"; +import Popover, { type PopoverProps } from "@mui/material/Popover"; + +export const PopoverMenu: FunctionComponent = ({ + children, + ...rest +}) => { + const theme = useCustomTheme(); + return ( + +
+ {children} +
+ + ); +}; + +export const PopoverMenuItemGroup: FunctionComponent = ({ children }) => { + const theme = useCustomTheme(); + return ( +
+ {children} +
+ ); +}; + +export const PopoverMenuItem: FunctionComponent = ({ + children, + style, + ...rest +}) => { + const theme = useCustomTheme(); + return ( + + ); +}; + +export default { + Group: PopoverMenuItemGroup, + Item: PopoverMenuItem, + Root: PopoverMenu, +}; diff --git a/packages/app-extension/src/components/common/WalletList.tsx b/packages/app-extension/src/components/common/WalletList.tsx index fe2dbb200..0940cbfcf 100644 --- a/packages/app-extension/src/components/common/WalletList.tsx +++ b/packages/app-extension/src/components/common/WalletList.tsx @@ -17,8 +17,7 @@ import { Add, ExpandMore, MoreHoriz } from "@mui/icons-material"; import ContentCopyIcon from "@mui/icons-material/ContentCopy"; import ErrorIcon from "@mui/icons-material/Error"; import InfoIcon from "@mui/icons-material/Info"; -import { Box, Button, Grid, Typography } from "@mui/material"; -import { Tooltip } from "@mui/material"; +import { Box, Button, Grid, Tooltip, Typography } from "@mui/material"; import { EthereumIconOnboarding as EthereumIcon, From 92e3e5284740fb1c9855636197dd837ab0c66b39 Mon Sep 17 00:00:00 2001 From: mj221 Date: Fri, 3 Feb 2023 13:49:50 +1000 Subject: [PATCH 09/36] WIP Merge branch 'master' of https://github.com/mjLabrys/backpack into mj/domain-content-resolver-revised --- .../src/components/Locked/index.tsx | 3 +- .../src/components/Onboarding/index.tsx | 1 - .../components/Onboarding/pages/Finish.tsx | 25 +- .../pages/HardwareDefaultAccount.tsx | 44 +-- .../Onboarding/pages/HardwareOnboard.tsx | 64 ++-- .../Onboarding/pages/HardwareSearch.tsx | 41 ++- .../Onboarding/pages/HardwareSign.tsx | 17 +- .../Onboarding/pages/MnemonicSearch.tsx | 65 ++-- .../pages/NotificationsPermission.tsx | 93 +++++ .../Onboarding/pages/OnboardAccount.tsx | 130 +++---- .../Onboarding/pages/RecoverAccount.tsx | 159 +++------ .../pages/RecoverAccountUsernameForm.tsx | 9 +- .../Unlocked/Approvals/ApproveTransaction.tsx | 10 +- .../Unlocked/ApproveTransactionRequest.tsx | 34 +- .../src/components/Unlocked/Apps/Plugin.tsx | 47 ++- .../components/Unlocked/Apps/Simulator.tsx | 30 +- .../src/components/Unlocked/Apps/index.tsx | 2 +- .../Unlocked/Balances/Notifications.tsx | 334 +++++++++--------- .../Unlocked/Messages/ChatDrawer.tsx | 130 ++++--- .../components/Unlocked/Messages/Contacts.tsx | 89 ++++- .../Unlocked/Messages/MessageOptions.tsx | 39 +- .../components/Unlocked/Messages/Requests.tsx | 11 +- .../Unlocked/Messages/SearchBox.tsx | 12 +- .../Unlocked/Messages/SearchUsers.tsx | 85 ++++- .../src/components/Unlocked/Nfts/Detail.tsx | 118 +++---- .../src/components/Unlocked/Nfts/EntryONE.tsx | 23 +- .../src/components/Unlocked/Nfts/index.tsx | 8 +- .../ConnectHardwareSearching.tsx | 39 +- .../ConnectHardware/index.tsx | 36 +- .../Settings/AddConnectWallet/index.tsx | 46 ++- .../AvatarHeader/UpdateProfilePicture.tsx | 63 +++- .../Unlocked/Settings/Preferences/index.tsx | 55 ++- .../Settings/SettingsNavStackDrawer.tsx | 11 +- .../Unlocked/Settings/Xnfts/Detail.tsx | 6 +- .../YourAccount/EditWallets/WalletDetail.tsx | 12 +- .../src/components/Unlocked/WithAuth.tsx | 19 +- .../components/Unlocked/WithSyncAccount.tsx | 108 ------ .../src/components/Unlocked/WithVersion.tsx | 64 ++++ .../src/components/Unlocked/index.tsx | 27 +- .../components/common/Layout/XnftAppStack.tsx | 3 + .../app-extension/src/hooks/useIsONELive.ts | 17 - .../src/hooks/useSignMessageForWallet.tsx | 29 ++ .../permissions/NotificationPermissions.tsx | 29 +- .../src/permissions/Permissions.tsx | 2 +- 44 files changed, 1216 insertions(+), 973 deletions(-) create mode 100644 packages/app-extension/src/components/Onboarding/pages/NotificationsPermission.tsx delete mode 100644 packages/app-extension/src/components/Unlocked/WithSyncAccount.tsx create mode 100644 packages/app-extension/src/components/Unlocked/WithVersion.tsx delete mode 100644 packages/app-extension/src/hooks/useIsONELive.ts create mode 100644 packages/app-extension/src/hooks/useSignMessageForWallet.tsx diff --git a/packages/app-extension/src/components/Locked/index.tsx b/packages/app-extension/src/components/Locked/index.tsx index 68cf499a1..a5d0c51cc 100644 --- a/packages/app-extension/src/components/Locked/index.tsx +++ b/packages/app-extension/src/components/Locked/index.tsx @@ -39,6 +39,7 @@ export function Locked({ onUnlock }: { onUnlock?: () => Promise }) { onUnlock(); } } catch (err) { + console.error(err); setError(true); } }; @@ -147,10 +148,8 @@ export function Locked({ onUnlock }: { onUnlock?: () => Promise }) { } export function BackpackHeader({ - alphaStyle, disableUsername, }: { - alphaStyle?: React.CSSProperties; disableUsername?: boolean; }) { const theme = useCustomTheme(); diff --git a/packages/app-extension/src/components/Onboarding/index.tsx b/packages/app-extension/src/components/Onboarding/index.tsx index 6d7648854..890542bfa 100644 --- a/packages/app-extension/src/components/Onboarding/index.tsx +++ b/packages/app-extension/src/components/Onboarding/index.tsx @@ -30,7 +30,6 @@ export const Onboarding = ({ const [action, setAction] = useState<"onboard" | "recover" | "waiting">( "onboard" ); - const keyringStoreState = useKeyringStoreState(); const isOnboarded = !isAddingAccount && useKeyringStoreState() !== KeyringStoreStateEnum.NeedsOnboarding; diff --git a/packages/app-extension/src/components/Onboarding/pages/Finish.tsx b/packages/app-extension/src/components/Onboarding/pages/Finish.tsx index 414f9815a..27cf1c190 100644 --- a/packages/app-extension/src/components/Onboarding/pages/Finish.tsx +++ b/packages/app-extension/src/components/Onboarding/pages/Finish.tsx @@ -4,9 +4,11 @@ import { BACKEND_API_URL, BrowserRuntimeExtension, getAuthMessage, + getBlockchainFromPath, UI_RPC_METHOD_KEYRING_STORE_CREATE, UI_RPC_METHOD_KEYRING_STORE_KEEP_ALIVE, UI_RPC_METHOD_USERNAME_ACCOUNT_CREATE, + XNFT_GG_LINK, } from "@coral-xyz/common"; import { Loading } from "@coral-xyz/react-common"; import { useBackgroundClient } from "@coral-xyz/recoil"; @@ -66,10 +68,10 @@ export const Finish = ({ // Authenticate the user that the recovery has a JWT. // Take the first keyring init to fetch the JWT, it doesn't matter which // we use if there are multiple. - const { blockchain, publicKey, signature } = - keyringInit.blockchainKeyrings[0]; + const { derivationPath, publicKey, signature } = + keyringInit.signedWalletDescriptors[0]; const authData = { - blockchain, + blockchain: getBlockchainFromPath(derivationPath), publicKey, signature, message: getAuthMessage(userId), @@ -91,8 +93,8 @@ export const Finish = ({ username, inviteCode, waitlistId: getWaitlistId?.(), - blockchainPublicKeys: keyringInit.blockchainKeyrings.map((b) => ({ - blockchain: b.blockchain, + blockchainPublicKeys: keyringInit.signedWalletDescriptors.map((b) => ({ + blockchain: getBlockchainFromPath(b.derivationPath), publicKey: b.publicKey, signature: b.signature, })), @@ -121,15 +123,15 @@ export const Finish = ({ // async function createStore(uuid: string, jwt: string) { try { - // - // If usernames are disabled, use a default one for developing. - // if (isAddingAccount) { + // Add a new account if needed, this will also create the new keyring + // store await background.request({ method: UI_RPC_METHOD_USERNAME_ACCOUNT_CREATE, params: [username, keyringInit, uuid, jwt], }); } else { + // Add a new keyring store under the new account await background.request({ method: UI_RPC_METHOD_KEYRING_STORE_CREATE, params: [username, password, keyringInit, uuid, jwt], @@ -147,7 +149,12 @@ export const Finish = ({ } return isValid ? ( - + { + BrowserRuntimeExtension.closeActiveTab(); + window.open(XNFT_GG_LINK, "_blank"); + }} + /> ) : ( ); diff --git a/packages/app-extension/src/components/Onboarding/pages/HardwareDefaultAccount.tsx b/packages/app-extension/src/components/Onboarding/pages/HardwareDefaultAccount.tsx index 6f4b7228f..acae39d72 100644 --- a/packages/app-extension/src/components/Onboarding/pages/HardwareDefaultAccount.tsx +++ b/packages/app-extension/src/components/Onboarding/pages/HardwareDefaultAccount.tsx @@ -2,18 +2,13 @@ // default derivation path. import { useEffect } from "react"; -import { - accountDerivationPath, - Blockchain, - DerivationPath, -} from "@coral-xyz/common"; +import type { WalletDescriptor } from "@coral-xyz/common"; +import { Blockchain, getIndexedPath } from "@coral-xyz/common"; import { Loading } from "@coral-xyz/react-common"; import Ethereum from "@ledgerhq/hw-app-eth"; import Solana from "@ledgerhq/hw-app-solana"; import type Transport from "@ledgerhq/hw-transport"; -import { encode } from "bs58"; - -import type { SelectedAccount } from "../../common/Account/ImportAccounts"; +import { ethers } from "ethers"; export const HardwareDefaultAccount = ({ blockchain, @@ -23,7 +18,7 @@ export const HardwareDefaultAccount = ({ }: { blockchain: Blockchain; transport: Transport; - onNext: (accounts: SelectedAccount[], derivationPath: DerivationPath) => void; + onNext: (walletDescriptor: WalletDescriptor) => void; onError?: (error: Error) => void; }) => { useEffect(() => { @@ -33,19 +28,17 @@ export const HardwareDefaultAccount = ({ [Blockchain.ETHEREUM]: new Ethereum(transport), }[blockchain]; - const derivationPath = DerivationPath.Default; - const accountIndex = 0; - const path = accountDerivationPath( - blockchain, - derivationPath, - accountIndex - ); - + // The default path for newly created wallets + const derivationPath = getIndexedPath(blockchain).toString(); + // Get the public key for the default path from the hardware wallet let ledgerAddress; try { - ledgerAddress = (await ledger.getAddress(path)).address; + ledgerAddress = ( + await ledger.getAddress(derivationPath.replace("m/", "")) + ).address; } catch (error) { if (onError) { + console.debug("hardware default account transport error", error); onError(error as Error); return; } else { @@ -55,18 +48,13 @@ export const HardwareDefaultAccount = ({ const publicKey = blockchain === Blockchain.SOLANA - ? encode(ledgerAddress as Buffer) + ? ethers.utils.base58.encode(ledgerAddress as Buffer) : ledgerAddress.toString(); - onNext( - [ - { - index: accountIndex, - publicKey, - }, - ], - derivationPath - ); + onNext({ + derivationPath, + publicKey, + }); })(); }, [blockchain]); diff --git a/packages/app-extension/src/components/Onboarding/pages/HardwareOnboard.tsx b/packages/app-extension/src/components/Onboarding/pages/HardwareOnboard.tsx index defa57a54..73e4e17e8 100644 --- a/packages/app-extension/src/components/Onboarding/pages/HardwareOnboard.tsx +++ b/packages/app-extension/src/components/Onboarding/pages/HardwareOnboard.tsx @@ -1,14 +1,13 @@ import { useState } from "react"; import type { Blockchain, - BlockchainKeyringInit, - DerivationPath, + SignedWalletDescriptor, + WalletDescriptor, } from "@coral-xyz/common"; import { useCustomTheme } from "@coral-xyz/themes"; import type Transport from "@ledgerhq/hw-transport"; import { useSteps } from "../../../hooks/useSteps"; -import type { SelectedAccount } from "../../common/Account/ImportAccounts"; import { ImportAccounts } from "../../common/Account/ImportAccounts"; import { CloseButton } from "../../common/Layout/Drawer"; import { NavBackButton, WithNav } from "../../common/Layout/Nav"; @@ -39,20 +38,14 @@ export function useHardwareOnboardSteps({ signMessage: string | ((publicKey: string) => string); signText: string; successComponent?: React.ReactElement; - onComplete: (keyringInit: BlockchainKeyringInit) => void; + onComplete: (signedWalletDescriptor: SignedWalletDescriptor) => void; nextStep: () => void; prevStep: () => void; }) { const [transport, setTransport] = useState(null); const [transportError, setTransportError] = useState(false); - const [accounts, setAccounts] = useState>(); - const [derivationPath, setDerivationPath] = useState(); - - // Component only allows onboarding of a singular selected account at this - // time, the signing prompt needs to be reworked to handle multiple accounts - // and handle failures to sign (or optional skipping the signatures) to allow - // this component to handle multiple accounts - const account = accounts ? accounts[0] : undefined; + const [walletDescriptor, setWalletDescriptor] = + useState(null); // // Flow for onboarding a hardware wallet. @@ -68,21 +61,21 @@ export function useHardwareOnboardSteps({ isConnectFailure={!!transportError} />, // - // Use one of multiple components to get a wallet to proceed with + // Use a component to get a wallet to proceed with. The create flow uses a + // component that gets a default account, the search flow searches a + // hardware wallet for a given public key, and the import flow allows the + // user to select a wallet. // { // The "create" flow uses a component that selects the first found public - // key. This step auto-proceeds and there is no user intervention + // key. This step automatically proceeds to the next step and and there is + // no user input required. create: ( { - setAccounts(accounts); - setDerivationPath(derivationPath); + onNext={(walletDescriptor: WalletDescriptor) => { + setWalletDescriptor(walletDescriptor); nextStep(); }} onError={() => { @@ -98,12 +91,8 @@ export function useHardwareOnboardSteps({ blockchain={blockchain!} transport={transport!} publicKey={searchPublicKey!} - onNext={async ( - accounts: SelectedAccount[], - derivationPath: DerivationPath - ) => { - setAccounts(accounts); - setDerivationPath(derivationPath); + onNext={(walletDescriptor: WalletDescriptor) => { + setWalletDescriptor(walletDescriptor); nextStep(); }} onError={() => { @@ -120,12 +109,8 @@ export function useHardwareOnboardSteps({ blockchain={blockchain} transport={transport} allowMultiple={false} - onNext={async ( - accounts: SelectedAccount[], - derivationPath: DerivationPath - ) => { - setAccounts(accounts); - setDerivationPath(derivationPath); + onNext={(walletDescriptors: Array) => { + setWalletDescriptor(walletDescriptors[0]); nextStep(); }} onError={() => { @@ -135,25 +120,20 @@ export function useHardwareOnboardSteps({ /> ), }[action], - ...(account && derivationPath + ...(walletDescriptor ? [ { onComplete({ - blockchain, - publicKey: account.publicKey, - derivationPath: derivationPath, - accountIndex: account.index, + ...walletDescriptor, signature, }); if (successComponent) { @@ -188,7 +168,7 @@ export function HardwareOnboard({ signMessage: string | ((publicKey: string) => string); signText: string; successComponent?: React.ReactElement; - onComplete: (keyringInit: BlockchainKeyringInit) => void; + onComplete: (signedWalletDescriptor: SignedWalletDescriptor) => void; onClose?: () => void; }) { const theme = useCustomTheme(); diff --git a/packages/app-extension/src/components/Onboarding/pages/HardwareSearch.tsx b/packages/app-extension/src/components/Onboarding/pages/HardwareSearch.tsx index 2dc2ac69b..16f8b6b9f 100644 --- a/packages/app-extension/src/components/Onboarding/pages/HardwareSearch.tsx +++ b/packages/app-extension/src/components/Onboarding/pages/HardwareSearch.tsx @@ -2,11 +2,10 @@ // a loading indicator until it is found (or an error if it not found). import { useEffect, useState } from "react"; -import type { DerivationPath } from "@coral-xyz/common"; +import type { WalletDescriptor } from "@coral-xyz/common"; import { - accountDerivationPath, Blockchain, - LOAD_PUBLIC_KEY_AMOUNT, + getRecoveryPaths, walletAddressDisplay, } from "@coral-xyz/common"; import { Loading, PrimaryButton } from "@coral-xyz/react-common"; @@ -17,9 +16,6 @@ import { Box } from "@mui/material"; import { ethers } from "ethers"; import { Header, SubtextParagraph } from "../../common"; -import type { SelectedAccount } from "../../common/Account/ImportAccounts"; - -import { DERIVATION_PATHS } from "./MnemonicSearch"; const { base58: bs58 } = ethers.utils; @@ -28,12 +24,13 @@ export const HardwareSearch = ({ transport, publicKey, onNext, + onError, onRetry, }: { blockchain: Blockchain; transport: Transport; publicKey: string; - onNext: (accounts: SelectedAccount[], derivationPath: DerivationPath) => void; + onNext: (walletDescriptor: WalletDescriptor) => void; onError?: (error: Error) => void; onRetry: () => void; }) => { @@ -45,23 +42,25 @@ export const HardwareSearch = ({ [Blockchain.SOLANA]: new Solana(transport), [Blockchain.ETHEREUM]: new Ethereum(transport), }[blockchain]; - for (const derivationPath of DERIVATION_PATHS) { - for ( - let accountIndex = 0; - accountIndex < LOAD_PUBLIC_KEY_AMOUNT; - accountIndex += 1 - ) { - const path = accountDerivationPath( - blockchain, - derivationPath, - accountIndex - ); - const ledgerAddress = (await ledger.getAddress(path)).address; - if (bs58.encode(ledgerAddress) === publicKey) { - onNext([{ index: accountIndex, publicKey }], derivationPath); + for (const derivationPath of getRecoveryPaths(blockchain)) { + let ledgerAddress; + try { + ledgerAddress = ( + await ledger.getAddress(derivationPath.replace("m/", "")) + ).address; + } catch (error) { + if (onError) { + console.debug("hardware search transport error", error); + onError(error as Error); return; + } else { + throw error; } } + if (bs58.encode(ledgerAddress) === publicKey) { + onNext({ derivationPath, publicKey }); + return; + } } setError(true); })(); diff --git a/packages/app-extension/src/components/Onboarding/pages/HardwareSign.tsx b/packages/app-extension/src/components/Onboarding/pages/HardwareSign.tsx index f63fddbed..dc8c7b667 100644 --- a/packages/app-extension/src/components/Onboarding/pages/HardwareSign.tsx +++ b/packages/app-extension/src/components/Onboarding/pages/HardwareSign.tsx @@ -1,5 +1,5 @@ import { useEffect, useState } from "react"; -import type { Blockchain, DerivationPath } from "@coral-xyz/common"; +import type { Blockchain, WalletDescriptor } from "@coral-xyz/common"; import { toTitleCase, UI_RPC_METHOD_SIGN_MESSAGE_FOR_PUBLIC_KEY, @@ -13,18 +13,14 @@ import { Header, HeaderIcon, SubtextParagraph } from "../../common"; export function HardwareSign({ blockchain, + walletDescriptor, message, - publicKey, - derivationPath, - accountIndex, text, onNext, }: { blockchain: Blockchain; + walletDescriptor: WalletDescriptor; message: string; - publicKey: string; - derivationPath: DerivationPath; - accountIndex: number; text: string; onNext: (signature: string) => void; }) { @@ -40,12 +36,9 @@ export function HardwareSign({ method: UI_RPC_METHOD_SIGN_MESSAGE_FOR_PUBLIC_KEY, params: [ blockchain, + walletDescriptor.publicKey, encode(Buffer.from(message, "utf-8")), - publicKey, - { - derivationPath, - accountIndex, - }, + [[walletDescriptor]], ], }); setSignature(signature); diff --git a/packages/app-extension/src/components/Onboarding/pages/MnemonicSearch.tsx b/packages/app-extension/src/components/Onboarding/pages/MnemonicSearch.tsx index f7c643d94..24eea1855 100644 --- a/packages/app-extension/src/components/Onboarding/pages/MnemonicSearch.tsx +++ b/packages/app-extension/src/components/Onboarding/pages/MnemonicSearch.tsx @@ -2,10 +2,9 @@ // a loading indicator until it is found (or an error if it not found). import { useEffect, useState } from "react"; -import type { Blockchain } from "@coral-xyz/common"; +import type { ServerPublicKey, WalletDescriptor } from "@coral-xyz/common"; import { - DerivationPath, - LOAD_PUBLIC_KEY_AMOUNT, + getRecoveryPaths, UI_RPC_METHOD_PREVIEW_PUBKEYS, walletAddressDisplay, } from "@coral-xyz/common"; @@ -15,21 +14,15 @@ import { Box } from "@mui/material"; import { Header, SubtextParagraph } from "../../common"; -export const DERIVATION_PATHS = [ - DerivationPath.Bip44, - DerivationPath.Bip44Change, -]; export const MnemonicSearch = ({ - blockchain, + serverPublicKeys, mnemonic, - publicKey, onNext, onRetry, }: { - blockchain: Blockchain; + serverPublicKeys: Array; mnemonic: string; - publicKey: string; - onNext: (derivationPath: DerivationPath, accountIndex: number) => void; + onNext: (walletDescriptors: Array) => void; onRetry: () => void; }) => { const [error, setError] = useState(false); @@ -37,25 +30,36 @@ export const MnemonicSearch = ({ useEffect(() => { (async () => { - for (const derivationPath of DERIVATION_PATHS) { + const walletDescriptors: Array = []; + const blockchains = [ + ...new Set(serverPublicKeys.map((x) => x.blockchain)), + ]; + for (const blockchain of blockchains) { + const recoveryPaths = getRecoveryPaths(blockchain); const publicKeys = await background.request({ method: UI_RPC_METHOD_PREVIEW_PUBKEYS, - params: [ - blockchain, - mnemonic, - derivationPath, - LOAD_PUBLIC_KEY_AMOUNT, - ], + params: [blockchain, mnemonic, recoveryPaths], }); - const index = publicKeys.findIndex((p: string) => p === publicKey); - if (index !== -1) { - onNext(derivationPath, index); - return; + const searchPublicKeys = serverPublicKeys + .filter((b) => b.blockchain === blockchain) + .map((p) => p.publicKey); + for (const publicKey of searchPublicKeys) { + const index = publicKeys.findIndex((p: string) => p === publicKey); + if (index !== -1) { + walletDescriptors.push({ + derivationPath: recoveryPaths[index], + publicKey, + }); + } } } - setError(true); + if (walletDescriptors.length > 0) { + onNext(walletDescriptors); + } else { + setError(true); + } })(); - }, [mnemonic, publicKey]); + }, [serverPublicKeys, mnemonic]); if (!error) { return ; @@ -73,8 +77,15 @@ export const MnemonicSearch = ({
- We couldn't find the public key {walletAddressDisplay(publicKey)}{" "} - using your hardware wallet. + {serverPublicKeys.length === 1 ? ( + <> + We couldn't find the public key{" "} + {walletAddressDisplay(serverPublicKeys[0].publicKey)} using your + recovery phrase. + + ) : ( + <>We couldn't find any wallets using your recovery phrase. + )} void }) => { + const theme = useCustomTheme(); + + const requestNotificationPermission = async (): Promise => { + const permission = await window.Notification.requestPermission(); + return permission === "granted"; + }; + + const registerSubscription = async () => { + try { + const sub = await registerNotificationServiceWorker(); + if (!sub) { + // Set appropriate app states + return; + } + await saveSubscription(sub); + } catch (err) { + console.error(err); + } + }; + + const handleAllow = async () => { + const success = await requestNotificationPermission(); + if (success) { + await registerSubscription(); + } + onNext(); + }; + + const handleDisable = () => { + onNext(); + }; + + return ( + + + +
+ + Find out when you have: + +
+
    +
  • New messages
    • +
  • Contact requests
    • +
+
+ + You can change this later in preferences. + + + + + + + + + ); +}; diff --git a/packages/app-extension/src/components/Onboarding/pages/OnboardAccount.tsx b/packages/app-extension/src/components/Onboarding/pages/OnboardAccount.tsx index 7ffde2ae6..f8e8fefd7 100644 --- a/packages/app-extension/src/components/Onboarding/pages/OnboardAccount.tsx +++ b/packages/app-extension/src/components/Onboarding/pages/OnboardAccount.tsx @@ -1,21 +1,20 @@ import { useEffect, useState } from "react"; import type { Blockchain, - BlockchainKeyringInit, KeyringType, + SignedWalletDescriptor, + WalletDescriptor, } from "@coral-xyz/common"; import { - DerivationPath, + getBlockchainFromPath, getCreateMessage, - UI_RPC_METHOD_PREVIEW_PUBKEYS, - UI_RPC_METHOD_SIGN_MESSAGE_FOR_PUBLIC_KEY, + UI_RPC_METHOD_FIND_SIGNED_WALLET_DESCRIPTOR, } from "@coral-xyz/common"; import { useBackgroundClient } from "@coral-xyz/recoil"; -import { encode } from "bs58"; +import { useSignMessageForWallet } from "../../../hooks/useSignMessageForWallet"; import { useSteps } from "../../../hooks/useSteps"; import { CreatePassword } from "../../common/Account/CreatePassword"; -import type { SelectedAccount } from "../../common/Account/ImportAccounts"; import { ImportAccounts } from "../../common/Account/ImportAccounts"; import { MnemonicInput } from "../../common/Account/MnemonicInput"; import { WithContaineredDrawer } from "../../common/Layout/Drawer"; @@ -28,6 +27,7 @@ import { Finish } from "./Finish"; import { HardwareOnboard } from "./HardwareOnboard"; import { InviteCodeForm } from "./InviteCodeForm"; import { KeyringTypeSelector } from "./KeyringTypeSelector"; +import { NotificationsPermission } from "./NotificationsPermission"; import { UsernameForm } from "./UsernameForm"; export const OnboardAccount = ({ @@ -45,35 +45,45 @@ export const OnboardAccount = ({ isAddingAccount?: boolean; isOnboarded?: boolean; }) => { - const { step, nextStep, prevStep } = useSteps(); const background = useBackgroundClient(); + const { step, nextStep, prevStep } = useSteps(); const [inviteCode, setInviteCode] = useState(undefined); const [username, setUsername] = useState(null); const [action, setAction] = useState<"create" | "import">(); const [keyringType, setKeyringType] = useState(null); - const [blockchainKeyrings, setBlockchainKeyrings] = useState< - Array - >([]); const [blockchain, setBlockchain] = useState(null); const [password, setPassword] = useState(null); const [mnemonic, setMnemonic] = useState(undefined); const [openDrawer, setOpenDrawer] = useState(false); + const [signedWalletDescriptors, setSignedWalletDescriptors] = useState< + Array + >([]); - const selectedBlockchains = blockchainKeyrings.map((b) => b.blockchain); + const signMessageForWallet = useSignMessageForWallet(mnemonic); + + const selectedBlockchains = [ + ...new Set( + signedWalletDescriptors.map((s) => + getBlockchainFromPath(s.derivationPath) + ) + ), + ]; useEffect(() => { // Reset blockchain keyrings on certain changes that invalidate the addresses // and signatures that they might contain // e.g. user has navigated backward through the onboarding flow - setBlockchainKeyrings([]); + setSignedWalletDescriptors([]); }, [action, keyringType, mnemonic]); const handleBlockchainClick = async (blockchain: Blockchain) => { if (selectedBlockchains.includes(blockchain)) { // Blockchain is being deselected setBlockchain(null); - setBlockchainKeyrings( - blockchainKeyrings.filter((b) => b.blockchain !== blockchain) + setSignedWalletDescriptors( + signedWalletDescriptors.filter( + (s) => getBlockchainFromPath(s.derivationPath) !== blockchain + ) ); } else { // Blockchain is being selected @@ -84,60 +94,18 @@ export const OnboardAccount = ({ setBlockchain(blockchain); setOpenDrawer(true); } else if (action === "create") { - // We are creating a new wallet, generate the signature using a default - // derivation path and account index - signForWallet(blockchain, DerivationPath.Default, 0); + const signedWalletDescriptor = await background.request({ + method: UI_RPC_METHOD_FIND_SIGNED_WALLET_DESCRIPTOR, + params: [blockchain, 0, true, mnemonic], + }); + setSignedWalletDescriptors([ + ...signedWalletDescriptors, + signedWalletDescriptor, + ]); } } }; - const signForWallet = async ( - blockchain: Blockchain, - derivationPath: DerivationPath, - accountIndex: number, - publicKey?: string - ) => { - if (!publicKey) { - // No publicKey given, this is a create action, so preview the public keys - // and grab the one at the index - const publicKeys = await background.request({ - method: UI_RPC_METHOD_PREVIEW_PUBKEYS, - params: [blockchain, mnemonic, derivationPath, accountIndex + 1], - }); - publicKey = publicKeys[accountIndex]; - } - const signature = await background.request({ - method: UI_RPC_METHOD_SIGN_MESSAGE_FOR_PUBLIC_KEY, - params: [ - blockchain, - encode(Buffer.from(getCreateMessage(publicKey!), "utf-8")), - publicKey!, - { - derivationPath, - accountIndex, - mnemonic, - }, - ], - }); - addBlockchainKeyring({ - blockchain: blockchain!, - derivationPath, - accountIndex, - publicKey: publicKey!, - signature, - }); - }; - - // Add the initialisation parameters for a blockchain keyring to state - const addBlockchainKeyring = (blockchainKeyring: BlockchainKeyringInit) => { - setBlockchainKeyrings([...blockchainKeyrings, blockchainKeyring]); - }; - - const keyringInit = { - mnemonic, - blockchainKeyrings, - }; - const steps = [ , ] : []), + , , ]; @@ -237,8 +206,11 @@ export const OnboardAccount = ({ action={action!} signMessage={(publicKey: string) => getCreateMessage(publicKey)} signText={`Sign the message to authenticate with Backpack.`} - onComplete={(result: BlockchainKeyringInit) => { - addBlockchainKeyring(result); + onComplete={(signedWalletDescriptor: SignedWalletDescriptor) => { + setSignedWalletDescriptors([ + ...signedWalletDescriptors, + signedWalletDescriptor, + ]); setOpenDrawer(false); }} onClose={() => setOpenDrawer(false)} @@ -248,18 +220,20 @@ export const OnboardAccount = ({ blockchain={blockchain!} mnemonic={mnemonic!} allowMultiple={false} - onNext={( - selectedAccounts: SelectedAccount[], - derivationPath: DerivationPath - ) => { - // Should only be one selected account due to allowMultiple being false - const account = selectedAccounts[0]; - signForWallet( - blockchain!, - derivationPath, - account.index, - account.publicKey + onNext={async (walletDescriptors: Array) => { + // Should only be one public key path + const walletDescriptor = walletDescriptors[0]; + const signature = await signMessageForWallet( + walletDescriptor, + getCreateMessage(walletDescriptor.publicKey) ); + setSignedWalletDescriptors([ + ...signedWalletDescriptors, + { + ...walletDescriptor, + signature, + }, + ]); setOpenDrawer(false); }} /> diff --git a/packages/app-extension/src/components/Onboarding/pages/RecoverAccount.tsx b/packages/app-extension/src/components/Onboarding/pages/RecoverAccount.tsx index 8a2a14c6d..bf3f0a5e7 100644 --- a/packages/app-extension/src/components/Onboarding/pages/RecoverAccount.tsx +++ b/packages/app-extension/src/components/Onboarding/pages/RecoverAccount.tsx @@ -1,21 +1,15 @@ -import { useEffect, useState } from "react"; +import { useState } from "react"; import type { - Blockchain, - BlockchainKeyringInit, - DerivationPath, KeyringType, + ServerPublicKey, + SignedWalletDescriptor, + WalletDescriptor, } from "@coral-xyz/common"; -import { - BACKEND_API_URL, - getAuthMessage, - UI_RPC_METHOD_SIGN_MESSAGE_FOR_PUBLIC_KEY, -} from "@coral-xyz/common"; -import { useBackgroundClient } from "@coral-xyz/recoil"; -import { encode } from "bs58"; +import { Blockchain, getAuthMessage } from "@coral-xyz/common"; +import { useSignMessageForWallet } from "../../../hooks/useSignMessageForWallet"; import { useSteps } from "../../../hooks/useSteps"; import { CreatePassword } from "../../common/Account/CreatePassword"; -// import { BlockchainSelector } from "./BlockchainSelector"; import { MnemonicInput } from "../../common/Account/MnemonicInput"; import { NavBackButton, WithNav } from "../../common/Layout/Nav"; import { useHardwareOnboardSteps } from "../../Onboarding/pages/HardwareOnboard"; @@ -38,107 +32,50 @@ export const RecoverAccount = ({ isOnboarded?: boolean; }) => { const { step, nextStep, prevStep } = useSteps(); - const background = useBackgroundClient(); - const [username, setUsername] = useState(null); const [password, setPassword] = useState(null); - const [publicKey, setPublicKey] = useState(null); const [keyringType, setKeyringType] = useState(null); - const [blockchain, setBlockchain] = useState(null); const [mnemonic, setMnemonic] = useState(undefined); const [userId, setUserId] = useState(undefined); - // TODO onboarded blockchains is currently unused but it will be used to recover - // multiple accounts on different blockchains - const [, setOnboardedBlockchains] = useState>([]); - const [blockchainKeyrings, setBlockchainKeyrings] = useState< - Array + const [serverPublicKeys, setServerPublicKeys] = useState< + Array + >([]); + const [signedWalletDescriptors, setSignedWalletDescriptors] = useState< + Array >([]); - const authMessage = userId ? getAuthMessage(userId) : ""; - + const signMessageForWallet = useSignMessageForWallet(mnemonic); const hardwareOnboardSteps = useHardwareOnboardSteps({ - blockchain: blockchain!, + blockchain: + serverPublicKeys.length > 0 + ? serverPublicKeys[0].blockchain! + : Blockchain.SOLANA, // TODO refactor out this default requirement action: "search", - searchPublicKey: publicKey!, + searchPublicKey: + serverPublicKeys.length > 0 ? serverPublicKeys[0].publicKey : undefined, signMessage: authMessage, signText: "Sign the message to authenticate with Backpack", - onComplete: (keyringInit: BlockchainKeyringInit) => { - addBlockchainKeyring(keyringInit); + onComplete: (signedWalletDescriptor: SignedWalletDescriptor) => { + setSignedWalletDescriptors([ + ...signedWalletDescriptors, + signedWalletDescriptor, + ]); nextStep(); }, nextStep, prevStep, }); - useEffect(() => { - (async () => { - if (username) { - const response = await fetch(`${BACKEND_API_URL}/users/${username}`); - const json = await response.json(); - if (response.ok) { - setUserId(json.id); - if (json.publicKeys.length > 0) { - setOnboardedBlockchains( - json.publicKeys.map( - (b: { blockchain: Blockchain }) => b.blockchain - ) - ); - // Default to first available blockchain. For mnemonic keyrings we - // can do this and search all available public keys for the mnemonic - // to find a match. For ledger keyrings we need to prompt them to open - // a specific app on the ledger so we'll allow them to select which - // blockchain they want to use as part of the flow. - setBlockchain(json.publicKeys[0].blockchain); - } - } - } - })(); - }, [username]); - - const signForWallet = async ( - blockchain: Blockchain, - derivationPath: DerivationPath, - accountIndex: number, - publicKey?: string - ) => { - const signature = await background.request({ - method: UI_RPC_METHOD_SIGN_MESSAGE_FOR_PUBLIC_KEY, - params: [ - blockchain, - encode(Buffer.from(authMessage, "utf-8")), - publicKey!, - { - derivationPath, - accountIndex, - mnemonic, - }, - ], - }); - - addBlockchainKeyring({ - blockchain: blockchain!, - derivationPath, - accountIndex, - publicKey: publicKey!, - signature, - }); - }; - - // Add the initialisation parameters for a blockchain keyring to state - const addBlockchainKeyring = (blockchainKeyring: BlockchainKeyringInit) => { - setBlockchainKeyrings([...blockchainKeyrings, blockchainKeyring]); - }; - - const keyringInit = { - mnemonic, - blockchainKeyrings, - }; - const steps = [ { + onNext={( + userId: string, + username: string, + serverPublicKeys: Array + ) => { + setUserId(userId); setUsername(username); - setPublicKey(publicKey); + setServerPublicKeys(serverPublicKeys); nextStep(); }} />, @@ -160,16 +97,16 @@ export const RecoverAccount = ({ }} />, { - signForWallet( - blockchain!, - derivationPath, - accountIndex, - publicKey! + onNext={async (walletDescriptors: Array) => { + const signedWalletDescriptors = await Promise.all( + walletDescriptors.map(async (w) => ({ + ...w, + signature: await signMessageForWallet(w, authMessage), + })) ); + setSignedWalletDescriptors(signedWalletDescriptors); nextStep(); }} onRetry={prevStep} @@ -186,27 +123,37 @@ export const RecoverAccount = ({ />, ] : []), - ...(blockchainKeyrings.length > 0 + ...(signedWalletDescriptors.length > 0 ? [ , ] : []), ]; - if (isOnboarded && step !== steps.length - 1) { + // Cant go backwards from the last step as the keyring is already created + const isLastStep = step === steps.length - 1; + // Cant go backwards from the password step as can hit mnemonic search which + // auto progresses. This could be handled by jumping to a step. + const isPasswordStep = steps[step].type.name === "CreatePassword"; + // Display message if already onboarded and not on last step + if (isOnboarded && !isLastStep) { return ; } return ( 0 ? prevStep : onClose} />} + navButtonLeft={ + !isLastStep && !isPasswordStep ? ( + 0 ? prevStep : onClose} /> + ) : undefined + } {...navProps} // Only display the onboarding menu on the first step navButtonRight={undefined} diff --git a/packages/app-extension/src/components/Onboarding/pages/RecoverAccountUsernameForm.tsx b/packages/app-extension/src/components/Onboarding/pages/RecoverAccountUsernameForm.tsx index b40498c2c..f6cc91925 100644 --- a/packages/app-extension/src/components/Onboarding/pages/RecoverAccountUsernameForm.tsx +++ b/packages/app-extension/src/components/Onboarding/pages/RecoverAccountUsernameForm.tsx @@ -1,4 +1,5 @@ import { type FormEvent, useCallback, useEffect, useState } from "react"; +import type { ServerPublicKey } from "@coral-xyz/common"; import { BACKEND_API_URL } from "@coral-xyz/common"; import { PrimaryButton, TextInput } from "@coral-xyz/react-common"; import { useCustomTheme } from "@coral-xyz/themes"; @@ -10,7 +11,11 @@ import { Header, SubtextParagraph } from "../../common"; export const RecoverAccountUsernameForm = ({ onNext, }: { - onNext: (username: string, publicKey: string) => void; + onNext: ( + userId: string, + username: string, + serverPublicKeys: Array + ) => void; }) => { const [username, setUsername] = useState(""); const [error, setError] = useState(""); @@ -28,7 +33,7 @@ export const RecoverAccountUsernameForm = ({ const json = await response.json(); if (!response.ok) throw new Error(json.msg); // Use the first found public key - onNext(username, json.publicKeys[0].publicKey); + onNext(json.id, username, json.publicKeys); } catch (err: any) { setError(err.message || "Something went wrong"); } diff --git a/packages/app-extension/src/components/Unlocked/Approvals/ApproveTransaction.tsx b/packages/app-extension/src/components/Unlocked/Approvals/ApproveTransaction.tsx index d1cae3349..ed9a08586 100644 --- a/packages/app-extension/src/components/Unlocked/Approvals/ApproveTransaction.tsx +++ b/packages/app-extension/src/components/Unlocked/Approvals/ApproveTransaction.tsx @@ -1,10 +1,9 @@ import type { Blockchain, FeeConfig } from "@coral-xyz/common"; -import { EmptyState } from "@coral-xyz/react-common"; -import { Loading } from "@coral-xyz/react-common"; +import { EmptyState, Loading } from "@coral-xyz/react-common"; import { useTransactionData, useWalletBlockchain } from "@coral-xyz/recoil"; import { styles, useCustomTheme } from "@coral-xyz/themes"; -import { Typography } from "@mui/material"; import { Block as BlockIcon } from "@mui/icons-material"; +import { Typography } from "@mui/material"; import { BigNumber, ethers } from "ethers"; import { TransactionData } from "../../common/TransactionData"; @@ -148,11 +147,13 @@ export function Cold({ title, wallet, onCompletion, + style, }: { origin: string; title: string; wallet: string; onCompletion: () => Promise; + style?: React.CSSProperties; }) { return (
} title={"Request Rejected"} - subtitle={`WARNING: ${origin} is trying to sign with your wallet. This may be dangerous. To enable, see wallet settings. Do so with caution!`} + subtitle={`WARNING: ${origin} is trying to sign with your cold wallet. This may be dangerous. To enable, see your wallet settings and enable "App Signing". Do so with caution!`} buttonText={""} onClick={() => {}} + style={style} />
diff --git a/packages/app-extension/src/components/Unlocked/ApproveTransactionRequest.tsx b/packages/app-extension/src/components/Unlocked/ApproveTransactionRequest.tsx index 7dcbe4303..f0c3d8865 100644 --- a/packages/app-extension/src/components/Unlocked/ApproveTransactionRequest.tsx +++ b/packages/app-extension/src/components/Unlocked/ApproveTransactionRequest.tsx @@ -22,7 +22,9 @@ import { SecondaryButton, } from "@coral-xyz/react-common"; import { + isKeyCold, useActivePublicKeys, + useActiveWallet, useBackgroundClient, usePluginUrl, useSolanaCtx, @@ -33,12 +35,14 @@ import { styles, useCustomTheme } from "@coral-xyz/themes"; import { Typography } from "@mui/material"; import * as anchor from "@project-serum/anchor"; import type { ConfirmOptions, SendOptions } from "@solana/web3.js"; +import { useRecoilValue } from "recoil"; import { sanitizeTransactionWithFeeConfig } from "../../utils/solana"; import { walletAddressDisplay } from "../common"; import { ApproveTransactionDrawer } from "../common/ApproveTransactionDrawer"; import { Scrollbar } from "../common/Layout/Scrollbar"; import { TransactionData } from "../common/TransactionData"; +import { Cold } from "../Unlocked/Approvals/ApproveTransaction"; import { ErrorTransaction } from "./XnftPopovers/ErrorTransaction"; import { Sending } from "./XnftPopovers/Sending"; @@ -104,24 +108,23 @@ const pluginRpcBlockchainMap = { export function ApproveTransactionRequest() { const [request, setRequest] = useTransactionRequest(); - const activePublicKeys = useActivePublicKeys(); + const { publicKey } = useActiveWallet(); const [openDrawer, setOpenDrawer] = useState(false); const [signature, setSignature] = useState(null); + const _isKeyCold = useRecoilValue(isKeyCold(publicKey)); useEffect(() => { setOpenDrawer(request !== undefined); }, [request, signature]); - if (!request) return <>; + if (!request) { + return <>; + } const rpcMethod = pluginUiRpcMap[request!.kind]; const blockchain = pluginRpcBlockchainMap[request!.kind]; - const publicKey = activePublicKeys[blockchain]; - // TODO: this check shouldn't be necessary. - if (request && !Object.values(activePublicKeys).includes(request.publicKey)) { - throw new Error("invariant violation"); - } + if (!request) return <>; const onResolve = (signature: string) => { request!.resolve(signature); @@ -144,10 +147,6 @@ export function ApproveTransactionRequest() { PLUGIN_REQUEST_SOLANA_SIGN_MESSAGE, ].includes(request!.kind); - if (!request) { - return <>; - } - return ( }> - {isMessageSign ? ( + {_isKeyCold ? ( + {}} + style={{ + padding: 0, + width: "100%", + }} + /> + ) : isMessageSign ? ( void; }) { const theme = useCustomTheme(); @@ -37,13 +39,19 @@ export function PluginApp({ > }> - +
); } -export function LoadPlugin({ xnftAddress }: { xnftAddress?: string }) { +export function LoadPlugin({ + xnftAddress, + deepXnftPath, +}: { + xnftAddress: string | undefined; + deepXnftPath: string; +}) { const { publicKey } = useActiveSolanaWallet(); // TODO: aggregate wallet considerations. const plugins = usePlugins(publicKey); const segue = useNavigationSegue(); @@ -52,14 +60,19 @@ export function LoadPlugin({ xnftAddress }: { xnftAddress?: string }) { const connectionBackgroundClient = useConnectionBackgroundClient(); const openPlugin = useOpenPlugin(); - if (!plugins || !xnftAddress) { + if (!xnftAddress) { return ; } const plugin = plugins?.find((p) => p.xnftAddress.toString() === xnftAddress); if (!plugin) { - return ; + return ( + + ); } plugin.setHostApi({ push: segue.push, @@ -69,21 +82,34 @@ export function LoadPlugin({ xnftAddress }: { xnftAddress?: string }) { connectionBackgroundClient, openPlugin, }); + if (xnftAddress === "11111111111111111111111111111111") { - return ; + return ; } - return ; + return ; } -function DisplayFreshPlugin({ xnftAddress }: { xnftAddress: string }) { +function DisplayFreshPlugin({ + xnftAddress, + deepXnftPath, +}: { + xnftAddress: string; + deepXnftPath: string; +}) { const p = useFreshPlugin(xnftAddress); if (!p.result) { return null; } - return ; + return ; } -export function PluginDisplay({ plugin }: { plugin?: Plugin }) { +export function PluginDisplay({ + plugin, + deepXnftPath, +}: { + plugin?: Plugin; + deepXnftPath: string; +}) { const xnftPreference = useRecoilValue( xnftPreferenceAtom(plugin?.xnftInstallAddress?.toString()) ); @@ -98,6 +124,7 @@ export function PluginDisplay({ plugin }: { plugin?: Plugin }) { key={plugin.iframeRootUrl} plugin={plugin} xnftPreference={xnftPreference} + deepXnftPath={deepXnftPath} /> ); } diff --git a/packages/app-extension/src/components/Unlocked/Apps/Simulator.tsx b/packages/app-extension/src/components/Unlocked/Apps/Simulator.tsx index 814936b27..4d5de2005 100644 --- a/packages/app-extension/src/components/Unlocked/Apps/Simulator.tsx +++ b/packages/app-extension/src/components/Unlocked/Apps/Simulator.tsx @@ -5,14 +5,19 @@ import { useCustomTheme } from "@coral-xyz/themes"; import { PluginDisplay } from "./Plugin"; +const removeTimestamps = /[0-9]{13}/g; + // The refresh code is a big hack. :) -export function Simulator({ plugin }: { plugin: Plugin }) { - const theme = useCustomTheme(); +export function Simulator({ + plugin, + deepXnftPath, +}: { + plugin: Plugin; + deepXnftPath: string; +}) { const refresh = useJavaScriptRefresh(SIMULATOR_URL); - return refresh % 2 === 1 ? ( -
- ) : ( - + return ( + ); } @@ -24,22 +29,15 @@ function useJavaScriptRefresh(url: string): number { const i = setInterval(() => { (async () => { const js = await (await fetch(url)).text(); - if (previous !== null && previous !== js) { + const noTSjs = js?.replaceAll(removeTimestamps, ""); // remove cachebusting timestamps next.js + if (previous !== null && previous !== noTSjs) { setRefresh((r) => r + 1); } - previous = js; + previous = noTSjs; })(); }, 1000); return () => clearInterval(i); }, []); - useEffect(() => { - if (refresh % 2 === 1) { - setTimeout(() => { - setRefresh((r) => r + 1); - }, 100); - } - }, [refresh]); - return refresh; } diff --git a/packages/app-extension/src/components/Unlocked/Apps/index.tsx b/packages/app-extension/src/components/Unlocked/Apps/index.tsx index ff63df4b1..53b2c499f 100644 --- a/packages/app-extension/src/components/Unlocked/Apps/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Apps/index.tsx @@ -124,7 +124,7 @@ function PluginGrid() { icon={(props: any) => } title={"No xNFTs"} subtitle={"Get started with your first xNFT"} - buttonText={"Browse xNFTs"} + buttonText={"Browse the xNFT Library"} onClick={() => window.open("https://xnft.gg")} header={ !_isAggregateWallets && ( diff --git a/packages/app-extension/src/components/Unlocked/Balances/Notifications.tsx b/packages/app-extension/src/components/Unlocked/Balances/Notifications.tsx index aafe6de2d..453051b02 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/Notifications.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/Notifications.tsx @@ -1,35 +1,28 @@ -import { Suspense, useState } from "react"; -import type { EnrichedNotification, Friendship } from "@coral-xyz/common"; -import { sendFriendRequest, unFriend } from "@coral-xyz/common"; -import { updateFriendshipIfExists } from "@coral-xyz/db"; +import { Suspense, useEffect, useState } from "react"; +import type { EnrichedNotification } from "@coral-xyz/common"; +import { BACKEND_API_URL } from "@coral-xyz/common"; import { - DangerButton, EmptyState, isFirstLastListItemStyle, Loading, - PrimaryButton, ProxyImage, - SecondaryButton, - SuccessButton, useUserMetadata, } from "@coral-xyz/react-common"; -import { - friendship, - useFriendship, - useRecentNotifications, - useUser, -} from "@coral-xyz/recoil"; +import { unreadCount, useRecentNotifications } from "@coral-xyz/recoil"; import { styles, useCustomTheme } from "@coral-xyz/themes"; -import CheckCircleOutlineIcon from "@mui/icons-material/CheckCircleOutline"; import NotificationsIcon from "@mui/icons-material/Notifications"; -import { Button,IconButton, List, ListItem, Typography } from "@mui/material"; +import { IconButton, List, ListItem, Typography } from "@mui/material"; import { useRecoilState } from "recoil"; import { CloseButton, WithDrawer } from "../../common/Layout/Drawer"; +import { useBreakpoints } from "../../common/Layout/hooks"; import { NavStackEphemeral, NavStackScreen, + useNavStack, } from "../../common/Layout/NavStack"; +import { NotificationIconWithBadge } from "../../common/NotificationIconWithBadge"; +import { ContactRequests, Contacts } from "../Messages/Contacts"; const useStyles = styles((theme) => ({ recentActivityLabel: { @@ -92,16 +85,12 @@ const useStyles = styles((theme) => ({ background: "transparent", }, }, - networkSettingsIcon: { - color: theme.custom.colors.icon, - backgroundColor: "transparent", - borderRadius: "12px", - }, })); export function NotificationButton() { const classes = useStyles(); const [openDrawer, setOpenDrawer] = useState(false); + const theme = useCustomTheme(); return (
setOpenDrawer(true)} size="large" > - +
@@ -123,6 +118,18 @@ export function NotificationButton() { name={"root"} component={(props: any) => } /> + } + /> + } + /> + } + />
@@ -159,7 +166,9 @@ const getGroupedNotifications = (notifications: EnrichedNotification[]) => { const sortedNotifications = notifications .slice() - .sort((a, b) => (a.timestamp < b.timestamp ? 1 : -1)); + .sort((a, b) => + new Date(a.timestamp).getTime() < new Date(b.timestamp).getTime() ? 1 : -1 + ); for (let i = 0; i < sortedNotifications.length; i++) { const date = formatDate(new Date(sortedNotifications[i].timestamp)); if ( @@ -180,19 +189,80 @@ const getGroupedNotifications = (notifications: EnrichedNotification[]) => { }; export function Notifications() { + const { isXs } = useBreakpoints(); + const [openDrawer, setOpenDrawer] = isXs + ? [false, () => {}] + : useState(false); + + const [_unreadCount, setUnreadCount] = useRecoilState(unreadCount); + const notifications: EnrichedNotification[] = useRecentNotifications({ limit: 50, offset: 0, }); + useEffect(() => { + const sortedNotifications = notifications + .slice() + .sort((a, b) => + new Date(a.timestamp).getTime() < new Date(b.timestamp).getTime() + ? -1 + : 1 + ); + const latestNotification = + sortedNotifications[sortedNotifications.length - 1]; + if (latestNotification && latestNotification.id) { + fetch(`${BACKEND_API_URL}/notifications/cursor`, { + method: "PUT", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ + lastNotificationId: latestNotification.id, + }), + }); + } + setUnreadCount(0); + }, [notifications, setUnreadCount]); + const groupedNotifications: { date: string; notifications: EnrichedNotification[]; }[] = getGroupedNotifications(notifications); + return ( - }> - - + <> + }> + setOpenDrawer(true)} + groupedNotifications={groupedNotifications} + /> + + {!isXs && ( + +
+ ({ title: "Notifications" })} + navButtonLeft={ + setOpenDrawer(false)} /> + } + > + } + /> + } + /> + } + /> + +
+ + )} + ); } @@ -236,51 +306,56 @@ function NotificationsLoader() { export function NotificationList({ groupedNotifications, + onOpenDrawer, }: { groupedNotifications: { date: string; notifications: EnrichedNotification[]; }[]; + onOpenDrawer?: () => void; }) { const theme = useCustomTheme(); return groupedNotifications.length > 0 ? ( -
- {groupedNotifications.map(({ date, notifications }) => ( -
-
{date}
- +
+ {groupedNotifications.map(({ date, notifications }) => ( +
-
- {notifications.map((notification: any, idx: number) => ( - - ))} -
- -
- ))} -
+
{date}
+ +
+ {notifications.map((notification: any, idx: number) => ( + + ))} +
+ +
+ ))} +
+ ) : ( ); @@ -294,35 +369,37 @@ const getTimeStr = (timestamp: number) => { if (elapsedTimeSeconds / 60 < 60) { const min = Math.floor(elapsedTimeSeconds / 60); if (min === 1) { - return "1 minute ago"; + return "1 minute"; } else { - return `${min} minutes ago`; + return `${min} minutes`; } } if (elapsedTimeSeconds / 3600 < 24) { const hours = Math.floor(elapsedTimeSeconds / 3600); if (hours === 1) { - return "1 hour ago"; + return "1 hour"; } else { - return `${hours} hours ago`; + return `${hours} hours`; } } const days = Math.floor(elapsedTimeSeconds / 3600 / 24); if (days === 1) { - return `1 day ago`; + return `1 day`; } - return `${days} day ago`; + return `${days} day`; }; function NotificationListItem({ notification, isFirst, isLast, + onOpenDrawer, }: { notification: EnrichedNotification; isFirst: boolean; isLast: boolean; + onOpenDrawer?: () => void; }) { const classes = useStyles(); const theme = useCustomTheme(); @@ -333,6 +410,7 @@ function NotificationListItem({ notification={notification} isFirst={isFirst} isLast={isLast} + onOpenDrawer={onOpenDrawer} /> ); } @@ -400,11 +478,15 @@ function FriendRequestListItem({ notification, isFirst, isLast, + onOpenDrawer, }: { notification: EnrichedNotification; isFirst: boolean; isLast: boolean; + onOpenDrawer?: () => void; }) { + const { isXs } = useBreakpoints(); + const nav = isXs ? useNavStack() : undefined; const user = useUserMetadata({ remoteUserId: parseJson(notification.body).from, }); @@ -415,7 +497,7 @@ function FriendRequestListItem({ {}} + onClick={() => (isXs ? nav!.push("contacts") : onOpenDrawer!())} style={{ paddingLeft: "12px", paddingRight: "12px", @@ -435,6 +517,7 @@ function FriendRequestListItem({ width: "100%", display: "flex", justifyContent: "space-between", + alignItems: "center", }} >
@@ -448,119 +531,34 @@ function FriendRequestListItem({
- Friend request - - {user.username} requested to connect - + Contact request + @{user.username}
-
- +
+ {getTimeStr(notification.timestamp)} + View
); } -function AcceptRejectRequest({ userId }: { userId: string }) { - const [friendshipValue, setFriendshipValue] = - useRecoilState(friendship({ userId })); - const { uuid } = useUser(); - - if (friendshipValue?.areFriends) { - return ( -
- {" "} - { - await unFriend({ to: userId }); - await updateFriendshipIfExists(uuid, userId, { - areFriends: 0, - requested: 0, - }); - - setFriendshipValue((x: any) => ({ - ...x, - requested: false, - areFriends: false, - })); - }} - />{" "} -
- ); - } - - if (friendshipValue?.remoteRequested) { - return ( -
- { - await sendFriendRequest({ to: userId, sendRequest: true }); - await updateFriendshipIfExists(uuid, userId, { - requested: 0, - areFriends: 1, - }); - - setFriendshipValue((x: any) => ({ - ...x, - requested: false, - areFriends: true, - })); - }} - /> -
- ); - } - - if (friendshipValue?.requested) { - return ( -
- { - await sendFriendRequest({ to: userId, sendRequest: false }); - await updateFriendshipIfExists(uuid, userId, { - requested: 0, - }); - setFriendshipValue((x: any) => ({ - ...x, - requested: false, - })); - }} - /> -
- ); - } - - return ( -
- { - await sendFriendRequest({ to: userId, sendRequest: true }); - await updateFriendshipIfExists(uuid, userId, { - requested: 1, - }); - setFriendshipValue((x: any) => ({ - ...x, - requested: true, - })); - }} - style={{ height: 38 }} - label={"Send request"} - /> -
- ); -} - function NotificationListItemIcon({ image }: any) { const classes = useStyles(); return ( - + ); } diff --git a/packages/app-extension/src/components/Unlocked/Messages/ChatDrawer.tsx b/packages/app-extension/src/components/Unlocked/Messages/ChatDrawer.tsx index 9671b1305..f42b3994a 100644 --- a/packages/app-extension/src/components/Unlocked/Messages/ChatDrawer.tsx +++ b/packages/app-extension/src/components/Unlocked/Messages/ChatDrawer.tsx @@ -5,6 +5,7 @@ import { BACKEND_API_URL } from "@coral-xyz/common"; import { UserList } from "@coral-xyz/message-sdk"; import { useActiveSolanaWallet, + useDarkMode, useDecodedSearchParams, } from "@coral-xyz/recoil"; import { styles, useCustomTheme } from "@coral-xyz/themes"; @@ -16,41 +17,49 @@ import { UserListSkeleton } from "./UserListSkeleton"; const LIMIT = 25; let debouncedTimer = 0; -export const useStyles = styles((theme) => ({ - container: { - padding: 0, - backgroundColor: `${theme.custom.colors.nav}`, - color: theme.custom.colors.fontColor2, - }, - icon: { - color: theme.custom.colors.icon, - marginRight: 10, - height: "24px", - width: "24px", - }, - horizontalCenter: { - justifyContent: "center", - display: "flex", - }, - title: { - marginTop: 20, - marginBottom: 20, - color: theme.custom.colors.fontColor4, - }, - drawerContainer: { - padding: 10, - height: "80vh", - }, - drawer: { - "& .MuiDrawer-paper": { - borderTopLeftRadius: "15px", - borderTopRightRadius: "15px", +export const useStyles = (isDark: boolean) => + styles((theme) => ({ + container: { + padding: 0, + color: theme.custom.colors.fontColor2, }, - }, -})); + icon: { + color: theme.custom.colors.icon, + marginRight: 10, + height: "24px", + width: "24px", + }, + horizontalCenter: { + justifyContent: "center", + display: "flex", + }, + title: { + marginTop: 20, + marginBottom: 20, + color: theme.custom.colors.fontColor4, + }, + drawerContainer: { + padding: 10, + height: "80vh", + }, + drawer: { + "& .MuiDrawer-paper": { + background: isDark + ? theme.custom.colors.background + : theme.custom.colors.nav, + height: "90vh", + borderTopLeftRadius: "15px", + borderTopRightRadius: "15px", + "&::-webkit-scrollbar": { + display: "none", + }, + }, + }, + })); export const ChatDrawer = ({ setOpenDrawer }: { setOpenDrawer: any }) => { - const classes = useStyles(); + const isDark = useDarkMode(); + const classes = useStyles(isDark)(); const { props, title }: any = useDecodedSearchParams(); const { publicKey } = useActiveSolanaWallet(); const [members, setMembers] = useState([]); @@ -77,10 +86,7 @@ export const ChatDrawer = ({ setOpenDrawer }: { setOpenDrawer: any }) => { pathname === "/messages/groupchat" ? props.id : props.collectionId }&mint=${ props.nftMint - }&publicKey=${publicKey}&type=collection&limit=${LIMIT}&offset=${offset}&prefix=${prefix}`, - { - method: "GET", - } + }&publicKey=${publicKey}&type=collection&limit=${LIMIT}&offset=${offset}&prefix=${prefix}` ); const json = await response.json(); setMembers(json.members); @@ -114,6 +120,7 @@ export const ChatDrawer = ({ setOpenDrawer }: { setOpenDrawer: any }) => { {count !== 0 && } { setSearchFilter(prefix); debouncedInit(prefix, 0); @@ -122,12 +129,19 @@ export const ChatDrawer = ({ setOpenDrawer }: { setOpenDrawer: any }) => { - onConfirm()} /> + onConfirm()} /> ); }; diff --git a/packages/app-extension/src/components/Unlocked/Settings/Xnfts/index.tsx b/packages/app-extension/src/components/Unlocked/Settings/Xnfts/index.tsx index ac110e48d..43b4852e5 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Xnfts/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Xnfts/index.tsx @@ -74,12 +74,12 @@ export function XnftSettings() { return xnfts.length === 0 ? ( } - title={"No xNFTs"} - subtitle={"Get started by adding your first xNFT"} + title="No xNFTs" + subtitle="Get started by adding your first xNFT" contentStyle={{ marginBottom: "64px", // Tab height offset. }} - buttonText={"Browse the xNFT Library"} + buttonText="Browse the xNFT Library" onClick={() => window.open(XNFT_GG_LINK, "_blank")} /> ) : ( diff --git a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/ChangePassword.tsx b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/ChangePassword.tsx index 2dde0518c..2d041903f 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/ChangePassword.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/ChangePassword.tsx @@ -65,14 +65,14 @@ export function ChangePassword() {
setCurrentPassword(e.target.value)} placeholder="Enter password" type="password" button={false} - title={"Current"} + title="Current" />
: null} ); }; diff --git a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/ShowPrivateKey.tsx b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/ShowPrivateKey.tsx index 708d382b9..3eee4db7b 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/ShowPrivateKey.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/ShowPrivateKey.tsx @@ -200,12 +200,12 @@ export function ShowPrivateKeyWarning({ publicKey }: { publicKey: string }) { > setPassword(e.target.value)} /> @@ -252,7 +252,7 @@ export function ShowPrivateKey({ privateKey }: { privateKey: string }) { diff --git a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/ShowRecoveryPhrase.tsx b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/ShowRecoveryPhrase.tsx index 93c1e3ccc..053e75d8e 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/ShowRecoveryPhrase.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/ShowRecoveryPhrase.tsx @@ -148,12 +148,12 @@ export function ShowRecoveryPhraseWarning() { > setPassword(e.target.value)} error={error} - type={"password"} - placeholder={"Password"} + type="password" + placeholder="Password" /> nav.push("logout"), }, }; diff --git a/packages/app-extension/src/components/Unlocked/Settings/index.tsx b/packages/app-extension/src/components/Unlocked/Settings/index.tsx index c723e3545..5e0900640 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/index.tsx @@ -1,8 +1,6 @@ import { Suspense, useEffect, useMemo } from "react"; import { BACKPACK_FEATURE_XNFT, - MESSAGES_ENABLED, - NOTIFICATIONS_ENABLED, UI_RPC_METHOD_KEYRING_STORE_LOCK, } from "@coral-xyz/common"; import { @@ -12,7 +10,7 @@ import { ListItem, PushDetail, } from "@coral-xyz/react-common"; -import { useBackgroundClient, useFeatureGates } from "@coral-xyz/recoil"; +import { useBackgroundClient } from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; import { AccountCircleOutlined, Lock, Settings } from "@mui/icons-material"; import AccountBalanceWalletIcon from "@mui/icons-material/AccountBalanceWallet"; @@ -24,14 +22,12 @@ import { NotificationButton } from "../Balances/Notifications"; import { AvatarHeader } from "./AvatarHeader/AvatarHeader"; import { AvatarPopoverButton } from "./AvatarPopover"; -import { UserAccountsMenuButton } from "./UsernamesMenu"; export function SettingsButton() { - const featureGates = useFeatureGates(); return (
- {featureGates[NOTIFICATIONS_ENABLED] && } +
@@ -41,14 +37,12 @@ export function SettingsButton() { export function SettingsMenu() { const nav = useNavigation(); - const headerTitle = useMemo(() => , []); - useEffect(() => { - nav.setOptions({ headerTitle }); + nav.setOptions({ headerTitle: "" }); }, [nav.setOptions]); return ( -
}> + }> <_SettingsContent /> ); @@ -67,7 +61,6 @@ function SettingsList() { const theme = useCustomTheme(); const nav = useNavigation(); const background = useBackgroundClient(); - const featureGates = useFeatureGates(); const lockWallet = () => { background @@ -102,14 +95,12 @@ function SettingsList() { }, ]; - if (featureGates[MESSAGES_ENABLED]) { - settingsMenu.push({ - label: "Contacts", - onClick: () => nav.push("contacts"), - icon: (props: any) => , - detailIcon: , - }); - } + settingsMenu.push({ + label: "Friends", + onClick: () => nav.push("contacts"), + icon: (props: any) => , + detailIcon: , + }); if (BACKPACK_FEATURE_XNFT) { settingsMenu.push({ @@ -136,7 +127,7 @@ function SettingsList() { label: "Lock", onClick: () => lockWallet(), icon: (props: any) => , - detailIcon: <>, + detailIcon: null as unknown as JSX.Element, }); const aboutList = [ diff --git a/packages/app-extension/src/components/Unlocked/Swap.tsx b/packages/app-extension/src/components/Unlocked/Swap.tsx index 82bf04b82..f2cdd1721 100644 --- a/packages/app-extension/src/components/Unlocked/Swap.tsx +++ b/packages/app-extension/src/components/Unlocked/Swap.tsx @@ -1,4 +1,3 @@ -import { useEffect, useState } from "react"; import { Blockchain, SOL_NATIVE_MINT, @@ -24,13 +23,16 @@ import { } from "@coral-xyz/recoil"; import { styles, useCustomTheme } from "@coral-xyz/themes"; import { ExpandMore, SwapVert } from "@mui/icons-material"; +import Info from "@mui/icons-material/Info"; import { IconButton, InputAdornment, Skeleton, + Tooltip, Typography, } from "@mui/material"; import { ethers, FixedNumber } from "ethers"; +import { useEffect, useState } from "react"; import { Button as XnftButton } from "../../plugin/Component"; import { TextField } from "../common"; @@ -47,6 +49,10 @@ import { WalletDrawerButton } from "../common/WalletList"; const { Zero } = ethers.constants; const useStyles = styles((theme) => ({ + tooltipIcon: { + color: theme.custom.colors.secondary, + height: 14, + }, container: { display: "flex", flexDirection: "column", @@ -190,6 +196,8 @@ const useStyles = styles((theme) => ({ lineHeight: "20px", fontSize: "14px", fontWeight: 500, + display: "flex", + alignItems: "center", }, swapInfoTitleRight: { color: theme.custom.colors.fontColor, @@ -210,12 +218,13 @@ enum SwapState { export function Swap({ blockchain }: { blockchain: Blockchain }) { const isDark = useDarkMode(); const nav = useNavigation(); + useEffect(() => { nav.setOptions({ headerTitle: "Swap", style: isDark ? { background: "#1D1D20" } : undefined, }); - }, [nav]); + }, [nav, isDark]); if (blockchain && blockchain !== Blockchain.SOLANA) { throw new Error("only Solana swaps are supported currently"); @@ -324,18 +333,18 @@ const SwapConfirmationCard: React.FC<{ return (
- {swapState === SwapState.CONFIRMATION && ( + {swapState === SwapState.CONFIRMATION ? ( - )} - {swapState === SwapState.CONFIRMING && ( + ) : null} + {swapState === SwapState.CONFIRMING ? ( - )} - {swapState === SwapState.CONFIRMED && ( - - )} - {swapState === SwapState.ERROR && ( + ) : null} + {swapState === SwapState.CONFIRMED ? ( + + ) : null} + {swapState === SwapState.ERROR ? ( onClose()} onRetry={onConfirm} /> - )} + ) : null}
); }; @@ -353,7 +362,7 @@ function InputTextField() { return ( <> - + - ) + ) : null } endAdornment={} rootClass={classes.receiveFieldRoot} - type={"number"} + type="number" value={ toAmount && toToken ? ethers.utils.formatUnits(toAmount, toToken.decimals) : "" } - disabled={true} + disabled inputProps={{ style: { textFill: `${theme.custom.colors.fontColor} !important`, @@ -418,19 +427,19 @@ function OutputTextField() { } const SwapUnavailableButton = () => { - return ; + return ; }; const SwapInvalidButton = () => { - return ; + return ; }; const InsufficientBalanceButton = () => { - return ; + return ; }; const InsufficientFeeButton = () => { - return ; + return ; }; const ConfirmSwapButton = () => { @@ -479,7 +488,7 @@ const ConfirmSwapButton = () => { function SwapConfirmation({ onConfirm }: { onConfirm: () => void }) { const classes = useStyles(); return ( - + - {isConfirmed && ( + {isConfirmed ? (
onViewBalances()} - label={"View Balances"} + label="View Balances" />
- )} + ) : null} ); } @@ -581,9 +590,9 @@ function SwapError({ onRetry, onCancel }: any) { const classes = useStyles(); return ( { @@ -673,9 +681,7 @@ function SwapInfo({ compact = true }: { compact?: boolean }) { const rate = fromAmount.gt(Zero) ? ethers.utils.commify( scale( - FixedNumber.from(toAmountWithFees).divUnsafe( - FixedNumber.from(fromAmount) - ), + FixedNumber.from(toAmount).divUnsafe(FixedNumber.from(fromAmount)), decimalDifference ).toString() ) @@ -701,6 +707,7 @@ function SwapInfo({ compact = true }: { compact?: boolean }) { networkFee: transactionFee ? `${ethers.utils.formatUnits(transactionFee, 9)} SOL` : "-", + swapFee, }} /> ); @@ -712,33 +719,58 @@ function SwapInfoRows({ networkFee, priceImpact, compact, + swapFee, }: { youPay: any; rate: any; priceImpact: any; networkFee: any; + swapFee?: any; compact?: boolean; }) { const classes = useStyles(); const wallet = useActiveWallet(); - const rows = []; - rows.push([ - "Wallet", - , - ]); + + const rows: Array<{ + label: string; + value: string | React.ReactElement; + tooltip?: string; + }> = [ + { + label: "Wallet", + value: , + }, + ]; + if (!compact) { - rows.push(["You Pay", youPay]); + rows.push({ label: "You Pay", value: youPay }); } - rows.push(["Rate", rate]); - rows.push(["Network Fee", networkFee]); - rows.push(["Price Impact", priceImpact]); + + rows.push({ label: "Rate", value: rate }); + rows.push({ + label: "Network Fee", + value: networkFee, + tooltip: swapFee?.pct + ? `Quote includes a ${swapFee?.pct}% Backpack fee` + : undefined, + }); + rows.push({ label: "Price Impact", value: priceImpact }); return ( <> - {rows.map((r: any) => ( -
- {r[0]} - {r[1]} + {rows.map(({ label, value, tooltip }) => ( +
+ + {label} + {tooltip ? ( + + + + ) : null} + + + {value} +
))} @@ -768,13 +800,7 @@ function SwapTokensButton({ function InputTokenSelectorButton() { const { fromToken, setFromMint } = useSwapContext(); - return ( - - ); + return ; } function OutputTokensSelectorButton() { @@ -812,15 +838,15 @@ function TokenSelectorButton({ justifyContent: "right", }} > - {token && ( + {token ? ( (event.currentTarget.style.display = "none")} /> - )} + ) : null} - {token && token.ticker} + {token ? token.ticker : null} @@ -841,6 +867,15 @@ export function SwapSelectToken({ const theme = useCustomTheme(); const nav = useNavigation(); const { fromTokens, toTokens } = useSwapContext(); + useEffect(() => { + nav.setOptions({ + headerTitle: "Select Token", + style: isDark + ? { background: theme.custom.colors.background } + : undefined, + }); + }, [nav, isDark, theme]); + const tokenAccounts = ( !input ? toTokens : fromTokens ) as Array; @@ -850,15 +885,6 @@ export function SwapSelectToken({ nav.pop(); }; - useEffect(() => { - nav.setOptions({ - headerTitle: "Select Token", - style: isDark - ? { background: theme.custom.colors.background } - : undefined, - }); - }, [nav]); - return ( (null); const [authSignature, setAuthSignature] = useState(null); const [openDrawer, setOpenDrawer] = useState(false); - const [isAuthenticated, setIsAuthenticated] = useState(null); const [serverPublicKeys, setServerPublicKeys] = useState { + setAuthSignature(null); + setServerPublicKeys(null); (async () => { - setAuthSignature(null); - setServerPublicKeys(null); setClientPublicKeys(await getSigners()); - const result = await checkAuthentication(user.jwt); + const result = user.jwt ? await checkAuthentication(user.jwt) : null; // These set state calls should be batched if (result) { const { publicKeys } = result; - setIsAuthenticated(true); setServerPublicKeys(publicKeys); } else { // Not authenticated so couldn't get public keys, get the primary @@ -75,7 +73,6 @@ export function WithAuth({ children }: { children: React.ReactElement }) { ); const serverPublicKeys = (await response.json()).publicKeys; setServerPublicKeys(serverPublicKeys); - setIsAuthenticated(false); // Find a local signer that exists on the client and server and // set the auth data const signer = await getAuthSigner( @@ -217,28 +214,26 @@ export function WithAuth({ children }: { children: React.ReactElement }) { return ( <> {children} - {authData && ( - - { + { setAuthSignature(signedWalletDescriptor.signature); }} /> - - )} + : null} ); } diff --git a/packages/app-extension/src/components/Unlocked/WithVersion.tsx b/packages/app-extension/src/components/Unlocked/WithVersion.tsx index ef4b666f0..79c74ecc3 100644 --- a/packages/app-extension/src/components/Unlocked/WithVersion.tsx +++ b/packages/app-extension/src/components/Unlocked/WithVersion.tsx @@ -55,7 +55,7 @@ function VersionWarning() { > } - title={"Please upgrade your Backpack"} + title="Please upgrade your Backpack" subtitle={`During the duration of the beta program, Backpack requires users to use the most up to date version of the extension.`} /> diff --git a/packages/app-extension/src/components/Unlocked/XnftPopovers/ErrorTransaction.tsx b/packages/app-extension/src/components/Unlocked/XnftPopovers/ErrorTransaction.tsx index 936a6911d..c0dc20a2a 100644 --- a/packages/app-extension/src/components/Unlocked/XnftPopovers/ErrorTransaction.tsx +++ b/packages/app-extension/src/components/Unlocked/XnftPopovers/ErrorTransaction.tsx @@ -59,22 +59,20 @@ export function ErrorTransaction({ >
- {explorer && connectionUrl && signature && ( - + label="View Explorer" + onClick={() => window.open( explorerUrl(explorer, signature, connectionUrl), "_blank" ) } - /> - )} + /> : null} - onRetry()} /> + onRetry()} /> ); } diff --git a/packages/app-extension/src/components/Unlocked/XnftPopovers/Sending.tsx b/packages/app-extension/src/components/Unlocked/XnftPopovers/Sending.tsx index 7c1a33da8..ec5ce3c0a 100644 --- a/packages/app-extension/src/components/Unlocked/XnftPopovers/Sending.tsx +++ b/packages/app-extension/src/components/Unlocked/XnftPopovers/Sending.tsx @@ -63,14 +63,12 @@ export function Sending({ marginRight: "16px", }} > - {explorer && connectionUrl && ( - { + {explorer && connectionUrl ? { window.open(explorerUrl(explorer, signature, connectionUrl)); }} - label={"View Explorer"} - /> - )} + label="View Explorer" + /> : null} ); diff --git a/packages/app-extension/src/components/Unlocked/XnftPopovers/Success.tsx b/packages/app-extension/src/components/Unlocked/XnftPopovers/Success.tsx index 2cdabdc45..8db45a45c 100644 --- a/packages/app-extension/src/components/Unlocked/XnftPopovers/Success.tsx +++ b/packages/app-extension/src/components/Unlocked/XnftPopovers/Success.tsx @@ -58,14 +58,12 @@ export function Success({ marginRight: "16px", }} > - {explorer && connectionUrl && ( - { + {explorer && connectionUrl ? { window.open(explorerUrl(explorer, signature, connectionUrl)); }} - label={"View Explorer"} - /> - )} + label="View Explorer" + /> : null} ); diff --git a/packages/app-extension/src/components/Unlocked/index.tsx b/packages/app-extension/src/components/Unlocked/index.tsx index 1f66c23a4..44acb36e0 100644 --- a/packages/app-extension/src/components/Unlocked/index.tsx +++ b/packages/app-extension/src/components/Unlocked/index.tsx @@ -16,8 +16,8 @@ export function Unlocked() { return ( - - + +
- - + + ); } diff --git a/packages/app-extension/src/components/common/Account/CreatePassword.tsx b/packages/app-extension/src/components/common/Account/CreatePassword.tsx index 058ccfda9..31410b590 100644 --- a/packages/app-extension/src/components/common/Account/CreatePassword.tsx +++ b/packages/app-extension/src/components/common/Account/CreatePassword.tsx @@ -110,17 +110,15 @@ export function CreatePassword({ setValue={(e) => setPasswordConfirm(e.target.value)} error={error === PasswordError.NO_MATCH} /> - {error !== null && ( - - { + {error !== null ? + { { [PasswordError.TOO_SHORT]: "Your password must be at least 8 characters.", [PasswordError.NO_MATCH]: "Your passwords do not match.", }[error] } - - )} + : null} setDerivationPathLabel(e.target.value)} - select={true} + select disabled={ledgerLocked} > {derivationPathOptions.map((o, index) => ( @@ -443,20 +442,30 @@ export function ImportWallets({ {Object.keys(balances).length > 0 ? ( - <> - - {walletDescriptors - .slice(0, DISPLAY_PUBKEY_AMOUNT) + + + {[...walletDescriptors] + .sort((a, b) => { + // Sort so that any public keys with balances are displayed first + if (balances[a.publicKey] < balances[b.publicKey]) { + return 1; + } else if (balances[a.publicKey] > balances[b.publicKey]) { + return -1; + } else { + return 0; + } + }) .map(({ publicKey, derivationPath }) => ( ))} - - + + ) : ( )} diff --git a/packages/app-extension/src/components/common/Account/MnemonicInput.tsx b/packages/app-extension/src/components/common/Account/MnemonicInput.tsx index 10f269308..51042f23f 100644 --- a/packages/app-extension/src/components/common/Account/MnemonicInput.tsx +++ b/packages/app-extension/src/components/common/Account/MnemonicInput.tsx @@ -207,28 +207,26 @@ export function MnemonicInput({ )} - {readOnly && ( - <> - + } - disabled={!copyEnabled} + disabled={!copyEnabled} /> - - + - - - )} + + : null} - {error && {error}} + {error ? {error} : null} void }) { }} > - {BACKPACK_FEATURE_XNFT && ( - - } - title="Browse the xNFT library" - onClick={() => window.open(XNFT_GG_LINK, "_blank")} + {BACKPACK_FEATURE_XNFT ? + } + title="Browse the xNFT library" + onClick={() => window.open(XNFT_GG_LINK, "_blank")} /> - - )} + : null} } diff --git a/packages/app-extension/src/components/common/Layout/ActionCard.tsx b/packages/app-extension/src/components/common/Layout/ActionCard.tsx index 6c14252f6..62a940dd8 100644 --- a/packages/app-extension/src/components/common/Layout/ActionCard.tsx +++ b/packages/app-extension/src/components/common/Layout/ActionCard.tsx @@ -44,7 +44,7 @@ export function ActionCard({ }} > - {icon && {icon}} + {icon ? {icon} : null} - {cancelButtonLabel && ( + {cancelButtonLabel ? ( - )} - {buttonLabel && ( + ) : null} + {buttonLabel ? ( - )} + ) : null} diff --git a/packages/app-extension/src/components/common/Layout/Drawer.tsx b/packages/app-extension/src/components/common/Layout/Drawer.tsx index a3a61d431..f8981328b 100644 --- a/packages/app-extension/src/components/common/Layout/Drawer.tsx +++ b/packages/app-extension/src/components/common/Layout/Drawer.tsx @@ -82,7 +82,7 @@ export function WithDrawer( return ( setOpenDrawer(false)} classes={{ @@ -122,7 +122,7 @@ export function WithMiniDrawer(props: any) { return ( (onClose ? onClose() : setOpenDrawer(false))} classes={{ @@ -190,7 +190,7 @@ export function WithDrawerNoHeader(props: any) { height: EXTENSION_HEIGHT - NAV_BAR_HEIGHT, }, }} - anchor={"bottom"} + anchor="bottom" open={openDrawer} onClose={() => setOpenDrawer(false)} classes={{ @@ -199,15 +199,13 @@ export function WithDrawerNoHeader(props: any) { >
{children}
- {!props.skipFooter && ( - - )} + Close + : null}
); diff --git a/packages/app-extension/src/components/common/Layout/Nav.tsx b/packages/app-extension/src/components/common/Layout/Nav.tsx index 2e3a2aed2..4e16c055f 100644 --- a/packages/app-extension/src/components/common/Layout/Nav.tsx +++ b/packages/app-extension/src/components/common/Layout/Nav.tsx @@ -228,44 +228,73 @@ function CenterDisplay({ const notchViewComponentWithProps = notchViewComponent ? React.cloneElement(notchViewComponent, { setOpenDrawer: setNotchEnabled }) : null; + const theme = useCustomTheme(); + const handleOpenDrawer = () => { + setNotchEnabled((x) => !x); + }; return ( - }> + }>
{}} > - {image && ( - - )} - - {notchViewComponent && ( + onClick={handleOpenDrawer} + > + + + ) : null} + + {notchViewComponent ? ( setNotchEnabled((x) => !x)} + onClick={handleOpenDrawer} style={{ cursor: "pointer", color: theme.custom.colors.fontColor }} /> - )} - {notchEnabled && notchViewComponentWithProps && ( + ) : null} + {notchEnabled && notchViewComponentWithProps ? ( <>{notchViewComponentWithProps} - )} - {isVerified && ( + ) : null} + {isVerified ? ( - )} + ) : null}
); @@ -307,5 +336,5 @@ export function NavTitleLabel({ title }: any) { export function DummyButton() { const classes = useStyles(); - return
; + return
; } diff --git a/packages/app-extension/src/components/common/Layout/Router.tsx b/packages/app-extension/src/components/common/Layout/Router.tsx index 3015eb5ed..03d54d302 100644 --- a/packages/app-extension/src/components/common/Layout/Router.tsx +++ b/packages/app-extension/src/components/common/Layout/Router.tsx @@ -8,14 +8,10 @@ import { } from "react-router-dom"; import type { SubscriptionType } from "@coral-xyz/common"; import { - MESSAGE_IFRAME_ENABLED, + BACKPACK_TEAM, MESSAGING_COMMUNICATION_FETCH_RESPONSE, NAV_COMPONENT_MESSAGE_PROFILE, } from "@coral-xyz/common"; -import { - MESSAGING_COMMUNICATION_FETCH, - MESSAGING_COMMUNICATION_PUSH, -} from "@coral-xyz/common/src/constants"; import { ChatScreen, Inbox, @@ -23,12 +19,11 @@ import { ProfileScreen, RequestsScreen, } from "@coral-xyz/message-sdk"; -import { useUsersMetadata } from "@coral-xyz/react-common"; +import { useBreakpoints, useUsersMetadata } from "@coral-xyz/react-common"; import type { SearchParamsFor } from "@coral-xyz/recoil"; import { useDarkMode, useDecodedSearchParams, - useFeatureGates, useNavigation, useRedirectUrl, useUser, @@ -50,7 +45,6 @@ import { NftOptionsButton, NftsDetail } from "../../Unlocked/Nfts/Detail"; import { NftChat, NftsExperience } from "../../Unlocked/Nfts/Experience"; import { SettingsButton } from "../../Unlocked/Settings"; -import { useBreakpoints } from "./hooks"; import { NavBackButton, WithNav } from "./Nav"; import { WithMotion } from "./NavStack"; import { Scrollbar } from "./Scrollbar"; @@ -71,12 +65,12 @@ export function Router() { } /> } /> } /> - {!isXs && ( + {!isXs ? ( <> } /> } /> - )} + ) : null} {/* Auto-lock functionality is dependent on checking if the URL contains "xnft", if this changes then please verify that it still works @@ -112,7 +106,7 @@ export function Redirect() { export function RedirectXs() { let url = useRedirectUrl(); if (url.startsWith("/notifications") || url.startsWith("/recent-activity")) { - return ; + return ; } return ; } @@ -122,7 +116,7 @@ function BalancesPage() { } function NftsPage() { - return } />; + return } />; } function NftsChatPage() { @@ -156,16 +150,6 @@ function NftsDetailPage() { } function Messages() { - const featureGates = useFeatureGates(); - - if (featureGates[MESSAGE_IFRAME_ENABLED]) { - return ; - } - - return ; -} - -function MessagesNative() { const { push, pop } = useNavigation(); const { isXs } = useBreakpoints(); @@ -184,18 +168,18 @@ function MessagesNative() { function MessageNativeInner() { const isDarkMode = useDarkMode(); const hash = location.hash.slice(1); - const { uuid, username } = useUser(); + const { uuid } = useUser(); const { props } = useDecodedSearchParams(); const { isXs } = useBreakpoints(); if (hash.startsWith("/messages/requests")) { - return } />; + return } />; } if (hash.startsWith("/messages/chat")) { return ( } /> ); @@ -219,18 +203,15 @@ function MessageNativeInner() { if (hash.startsWith("/messages/profile")) { return ( - } - /> + } /> ); } if (!isXs) { - return <>; + return
; } - return } />; + return } />; } function FullChatPage() { @@ -272,90 +253,6 @@ function FullChatPage() { ); } -function MessagesIframe() { - const MESSAGING_URL = "http://localhost:3000"; - const iframeRef = useRef(); - const { push } = useNavigation(); - const location = useLocation(); - const { props }: any = useDecodedSearchParams(); - const { uuid, username } = useUser(); - const isDarkMode = useDarkMode(); - - useEffect(() => { - if (iframeRef && iframeRef.current) { - window.addEventListener( - "message", - async (event) => { - if (event.origin !== MESSAGING_URL) return; - - if (event.data.type === MESSAGING_COMMUNICATION_FETCH) { - try { - const response = await fetch( - event.data.payload.url, - event.data.payload.args - ); - iframeRef.current?.contentWindow?.postMessage( - { - type: MESSAGING_COMMUNICATION_FETCH_RESPONSE, - payload: { - counter: event.data.payload.counter, - data: await response.json(), - success: true, - }, - }, - "*" - ); - } catch (e) { - iframeRef.current?.contentWindow?.postMessage( - { - type: MESSAGING_COMMUNICATION_FETCH_RESPONSE, - payload: { - counter: event.data.payload.counter, - success: false, - }, - }, - "*" - ); - } - } - if (event.data.type === MESSAGING_COMMUNICATION_PUSH) { - push(event.data.payload); - } - }, - false - ); - } - }, [iframeRef]); - - const route = location.pathname; - - return ( - - - ) : null; -} - -const isValidSecureUrl = (url: string): boolean => { - try { - const { protocol, hostname } = new URL(url); - if (["localhost", "0.0.0.0", "127.0.0.1"].includes(hostname)) { - // allow http:// or https:// for localhost urls during development - return ["http:", "https:"].includes(protocol); - } else { - // only allow https:// for external urls - return protocol === "https:"; - } - } catch (e) { - return false; - } -}; - -function NavAnimation({ props, children }: any) { - return ( - - - {children && - children.map((c: Element) => )} - - - ); -} - -export function BalancesTable({ - props, - style, - children, - childrenRenderer, -}: any) { - const classes = useStyles(); - return ( - - - {children ?? - childrenRenderer.map((c: Element) => ( - - ))} - - - ); -} - -function BalancesTableProvider(props: any) { - const [showContent, setShowContent] = useState(true); - return ( - <_BalancesTableContext.Provider - value={{ - showContent, - setShowContent, - }} - > - {props.children} - - ); -} - -type BalancesContext = { - showContent: boolean; - setShowContent: (b: boolean) => void; -}; -const _BalancesTableContext = React.createContext(null); - -export function useBalancesContext() { - const ctx = React.useContext(_BalancesTableContext); - if (ctx === null) { - throw new Error("Context not available"); - } - return ctx; -} - -export function BalancesTableHead({ props, style }: any) { - const { subtitle, title, iconUrl, disableToggle } = props; - const classes = useStyles(); - const { showContent, setShowContent } = useBalancesContext(); - return ( - - ); -} - -export function BalancesTableContent({ - props, - style, - children, - childrenRenderer, -}: any) { - const classes = useStyles(); - const { showContent } = useBalancesContext(); - return ( - - - {children ?? - childrenRenderer.map((c: Element) => ( - - ))} - - - ); -} - -export function BalancesTableRow({ - id, - props, - style, - children, - childrenRenderer, - onClick, -}: any) { - return ( - <__BalancesTableRow - id={id} - props={props} - style={style} - children={children} - childrenRenderer={childrenRenderer} - onClick={onClick} - /> - ); -} - -function _BalancesTableRow({ - id, - props, - style, - children, - childrenRenderer, -}: any) { - return ( - <__BalancesTableRow - id={id} - props={props} - style={style} - children={children} - childrenRenderer={childrenRenderer} - onClick={props.onClick} - /> - ); -} - -function __BalancesTableRow({ - id, - props, - style, - children, - childrenRenderer, - onClick, -}: any) { - const classes = useStyles(); - return ( - - {children ?? - childrenRenderer.map((c: Element) => ( - - ))} - - ); -} - -export function BalancesTableCell({ props, style }: any) { - const { icon, title, subtitle, usdValue, percentChange } = props; - const classes = useStyles(); - - const positive = percentChange && percentChange > 0 ? true : false; - const negative = percentChange && percentChange < 0 ? true : false; - const neutral = percentChange && percentChange === 0 ? true : false; - - return ( -
- {!!icon && ( - - (event.currentTarget.style.display = "none")} - /> - - )} -
-
- {title} - {usdValue && ( - - {formatUSD(usdValue)} - - )} -
-
- {subtitle && ( - {subtitle} - )} - {percentChange !== undefined && positive && ( - - +{formatUSD(percentChange.toLocaleString())} - - )} - {percentChange !== undefined && negative && ( - - {formatUSD(percentChange.toLocaleString())} - - )} - {percentChange !== undefined && neutral && ( - - {formatUSD(percentChange.toLocaleString())} - - )} -
-
-
- ); -} - -export function BalancesTableFooter({ props, style, children }: any) { - return ( -
- {children.map((c: Element) => ( - - ))} -
- ); -} - -function View({ id, props, style, children }: any) { - return ( -
- {children.map((c: Element) => ( - - ))} -
- ); -} - -function Table({ props, style, children }: any) { - return <>; -} - -function Text({ props, children, style }: any) { - const defaultClasses = useDefaultClasses(); - return ( -

- {children.map((c: Element) => ( - - ))} -

- ); -} - -function _TextField({ id, props, children, style }: any) { - if (props.multiline) { - return ( -
{ debouncedInit(searchFilter, Math.max(offset - 1, 0)); }} @@ -137,7 +151,13 @@ export const ChatDrawer = ({ setOpenDrawer }: { setOpenDrawer: any }) => { {/* TODO: clean up this logic */} {members.length === LIMIT && (
{ debouncedInit(searchFilter, offset + 1); }} @@ -157,6 +177,15 @@ export const ChatDrawer = ({ setOpenDrawer }: { setOpenDrawer: any }) => { .includes(searchFilter?.toLocaleLowerCase()) ).length !== 0 ? ( x.username @@ -183,17 +212,32 @@ function MembersList({ members: RemoteUserData[]; }) { const theme = useCustomTheme(); + const countText = count >= 1000 ? `${(count / 1000).toFixed(1)}k` : count; return (
- {members.map((member) => ( - + {members.map((member, idx) => ( + 0 ? { marginLeft: "-12px" } : {}), + }} + /> ))}
- {count} members + {countText} members
); diff --git a/packages/app-extension/src/components/Unlocked/Messages/Contacts.tsx b/packages/app-extension/src/components/Unlocked/Messages/Contacts.tsx index c8aa1065a..d0d7c2bd6 100644 --- a/packages/app-extension/src/components/Unlocked/Messages/Contacts.tsx +++ b/packages/app-extension/src/components/Unlocked/Messages/Contacts.tsx @@ -1,19 +1,102 @@ -import { useEffect } from "react"; +import { type ReactNode, useEffect, useState } from "react"; +import { type RemoteUserData, BACKEND_API_URL } from "@coral-xyz/common"; +import { useContacts } from "@coral-xyz/db"; +import { UserList } from "@coral-xyz/message-sdk"; +import { useUser } from "@coral-xyz/recoil"; +import { useCustomTheme } from "@coral-xyz/themes"; +import { Typography } from "@mui/material"; import { useNavStack } from "../../common/Layout/NavStack"; -import { Requests } from "./Requests"; import { SearchUsers } from "./SearchUsers"; +import { useStyles } from "./styles"; + +async function getRequests(): Promise<{ + received: RemoteUserData[]; + sent: RemoteUserData[]; +}> { + const [received, sent] = await Promise.all([ + fetch(`${BACKEND_API_URL}/friends/requests`).then((res) => res.json()), + fetch(`${BACKEND_API_URL}/friends/sent`).then((res) => res.json()), + ]); + + return { received: received.requests, sent: sent.requests }; +} export const Contacts = () => { const nav = useNavStack(); + const { uuid } = useUser(); + const allChats = useContacts(uuid); + const [requests, setRequests] = useState< + Record<"received" | "sent", RemoteUserData[]> + >({ received: [], sent: [] }); + + useEffect(() => { + getRequests().then(setRequests).catch(console.error); + }, []); + useEffect(() => { nav.setTitle("Contacts"); }, [nav]); return (
- + +
+ ); +}; + +export const ContactRequests = ({ + description, + isSent, + requests, +}: { + description: ReactNode; + isSent?: boolean; + requests: { received: RemoteUserData[]; sent: RemoteUserData[] }; +}) => { + const nav = useNavStack(); + const classes = useStyles(); + const theme = useCustomTheme(); + + useEffect(() => { + nav.setTitle(`Requests ${isSent ? "Sent" : "Received"}`); + }, [nav]); + + return ( +
+ + {description} + +
+ {!isSent && requests.sent.length > 0 && ( + + nav.push("contact-requests-sent", { + description: ( + <> + People you added as contacts. +
Click someone to view their profile. + + ), + isSent: true, + requests, + }) + } + > + Sent ({requests.sent.length}) + + )} + +
); }; diff --git a/packages/app-extension/src/components/Unlocked/Messages/MessageOptions.tsx b/packages/app-extension/src/components/Unlocked/Messages/MessageOptions.tsx index 0d6931b0f..bb28ccb9e 100644 --- a/packages/app-extension/src/components/Unlocked/Messages/MessageOptions.tsx +++ b/packages/app-extension/src/components/Unlocked/Messages/MessageOptions.tsx @@ -9,10 +9,11 @@ import { toast } from "@coral-xyz/react-common"; import { friendship, useDecodedSearchParams } from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; import MoreHorizIcon from "@mui/icons-material/MoreHoriz"; -import { Fade, Menu, MenuItem } from "@mui/material"; -import Divider from "@mui/material/Divider"; +import { Fade } from "@mui/material"; import { useRecoilState } from "recoil"; +import PopoverMenu from "../../common/PopoverMenu"; + import { useStyles } from "./styles"; export const MessageOptions = () => { @@ -54,20 +55,15 @@ export const MessageOptions = () => { onClick={handleClick} style={{ cursor: "pointer", color: theme.custom.colors.icon }} /> - -
- + { if (friendshipValue?.areFriends) { @@ -103,10 +99,10 @@ export const MessageOptions = () => { : friendshipValue?.remoteRequested ? "Accept Contact Request" : "Add to contacts"} - - - + + + { const updatedValue = !friendshipValue?.blocked; @@ -132,9 +128,8 @@ export const MessageOptions = () => { }} > {friendshipValue?.blocked ? "Unblock" : "Block"} - - + { const updatedValue = !friendshipValue?.spam; await fetch(`${BACKEND_API_URL}/friends/spam`, { @@ -152,9 +147,9 @@ export const MessageOptions = () => { }} > {friendshipValue?.spam ? `Remove spam` : `Mark as spam`} - -
- + + +
); }; diff --git a/packages/app-extension/src/components/Unlocked/Messages/Requests.tsx b/packages/app-extension/src/components/Unlocked/Messages/Requests.tsx index 4f0e33fe4..f32f9677d 100644 --- a/packages/app-extension/src/components/Unlocked/Messages/Requests.tsx +++ b/packages/app-extension/src/components/Unlocked/Messages/Requests.tsx @@ -2,20 +2,11 @@ import { useEffect, useState } from "react"; import type { RemoteUserData } from "@coral-xyz/common"; import { BACKEND_API_URL } from "@coral-xyz/common"; import { UserList } from "@coral-xyz/message-sdk"; -import { - isFirstLastListItemStyle, - Loading, - TextInput, -} from "@coral-xyz/react-common"; +import { isFirstLastListItemStyle } from "@coral-xyz/react-common"; import { useCustomTheme } from "@coral-xyz/themes"; import { Skeleton } from "@mui/material"; -import { useNavStack } from "../../common/Layout/NavStack"; - -import { useStyles } from "./styles"; - export const Requests = ({ searchFilter }: { searchFilter: string }) => { - const classes = useStyles(); const [requests, setRequests] = useState([]); const [loading, setLoading] = useState(true); const theme = useCustomTheme(); diff --git a/packages/app-extension/src/components/Unlocked/Messages/SearchBox.tsx b/packages/app-extension/src/components/Unlocked/Messages/SearchBox.tsx index bd703b9dc..e2aa7efa2 100644 --- a/packages/app-extension/src/components/Unlocked/Messages/SearchBox.tsx +++ b/packages/app-extension/src/components/Unlocked/Messages/SearchBox.tsx @@ -6,7 +6,7 @@ import InputAdornment from "@mui/material/InputAdornment"; export const useStyles = styles((theme) => ({ searchField: { - marginTop: "0px", + marginTop: "10px", marginBottom: "16px", width: "inherit", display: "flex", @@ -22,7 +22,13 @@ export const useStyles = styles((theme) => ({ }, })); -export const SearchBox = ({ onChange }: { onChange: any }) => { +export const SearchBox = ({ + onChange, + placeholder, +}: { + onChange: any; + placeholder?: string; +}) => { const classes = useStyles(); const theme = useCustomTheme(); const [searchFilter, setSearchFilter] = useState(""); @@ -30,7 +36,7 @@ export const SearchBox = ({ onChange }: { onChange: any }) => { return ( diff --git a/packages/app-extension/src/components/Unlocked/Messages/SearchUsers.tsx b/packages/app-extension/src/components/Unlocked/Messages/SearchUsers.tsx index bf1fc4a8a..0c8f055b1 100644 --- a/packages/app-extension/src/components/Unlocked/Messages/SearchUsers.tsx +++ b/packages/app-extension/src/components/Unlocked/Messages/SearchUsers.tsx @@ -1,32 +1,38 @@ -import { useEffect, useState } from "react"; +import { useState } from "react"; import type { EnrichedInboxDb, RemoteUserData } from "@coral-xyz/common"; -import { BACKEND_API_URL } from "@coral-xyz/common"; -import { useContacts } from "@coral-xyz/db"; import { UserList } from "@coral-xyz/message-sdk"; -import { TextInput } from "@coral-xyz/react-common"; -import { useFriendships, useUser } from "@coral-xyz/recoil"; +import { ContactsIcon, EmptyState, TextInput } from "@coral-xyz/react-common"; import { useCustomTheme } from "@coral-xyz/themes"; +import SearchIcon from "@mui/icons-material/Search"; +import { Typography } from "@mui/material"; import { useNavStack } from "../../common/Layout/NavStack"; -import { Requests } from "./Requests"; +// import { Requests } from "./Requests"; import { useStyles } from "./styles"; -export const SearchUsers = () => { - const { uuid } = useUser(); +export const SearchUsers = ({ + allChats, + requests, +}: { + allChats: EnrichedInboxDb[]; + requests: { received: RemoteUserData[]; sent: RemoteUserData[] }; +}) => { + const nav = useNavStack(); const classes = useStyles(); const [searchFilter, setSearchFilter] = useState(""); - const allChats = useContacts(uuid); - const contacts = allChats.filter((x: any) => x.areFriends === 1); + const friends = allChats.filter((x: any) => x.areFriends === 1); const theme = useCustomTheme(); - const filteredContacts = contacts + const filteredFriends = friends .filter((x: EnrichedInboxDb) => x.remoteUsername.includes(searchFilter)) .map((x: EnrichedInboxDb) => ({ image: x.remoteUserImage, id: x.remoteUserId, username: x.remoteUsername, areFriends: x.areFriends ? true : false, + requested: x.requested ? true : false, + remoteRequested: x.remoteRequested ? true : false, })); return ( @@ -34,6 +40,9 @@ export const SearchUsers = () => { + } value={searchFilter} setValue={async (e) => { const prefix = e.target.value; @@ -45,12 +54,58 @@ export const SearchUsers = () => { }, }} /> - {filteredContacts.length !== 0 && ( - + {filteredFriends.length > 0 ? ( +
+
+ + Your contacts + + {requests.received.length > 0 && ( + + nav.push("contact-requests", { + description: ( + <> + These people wanted to add you as a contact. +
Click someone to view their profile. + + ), + requests, + }) + } + > + Requests ({requests.received.length}) + + )} +
+ +
+ ) : ( + ( + + )} + title={ + searchFilter === "" + ? "No contacts" + : `No results for '${searchFilter}'` + } + subtitle={searchFilter === "" ? "Search for people to add." : ""} + /> )} -
+ {/*
Requests
- + */}
); }; diff --git a/packages/app-extension/src/components/Unlocked/Nfts/Detail.tsx b/packages/app-extension/src/components/Unlocked/Nfts/Detail.tsx index 00b28952d..67868bcde 100644 --- a/packages/app-extension/src/components/Unlocked/Nfts/Detail.tsx +++ b/packages/app-extension/src/components/Unlocked/Nfts/Detail.tsx @@ -1,5 +1,6 @@ import { useEffect, useState } from "react"; import { + AVATAR_BASE_URL, BACKEND_API_URL, Blockchain, confirmTransaction, @@ -12,10 +13,7 @@ import { UI_RPC_METHOD_NAVIGATION_TO_ROOT, WHITELISTED_CHAT_COLLECTIONS, } from "@coral-xyz/common"; -import { NAV_COMPONENT_NFT_CHAT } from "@coral-xyz/common/dist/esm/constants"; import { - List, - ListItem, NegativeButton, PrimaryButton, ProxyImage, @@ -24,6 +22,7 @@ import { } from "@coral-xyz/react-common"; import { collectibleXnft, + newAvatarAtom, nftById, useAnchorContext, useBackgroundClient, @@ -33,14 +32,15 @@ import { useOpenPlugin, useSolanaCtx, useSolanaExplorer, + useUser, } from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; -import { CallMade, Whatshot } from "@mui/icons-material"; +import { Whatshot } from "@mui/icons-material"; import MoreHorizIcon from "@mui/icons-material/MoreHoriz"; -import { IconButton, Popover, Typography } from "@mui/material"; +import { IconButton, Typography } from "@mui/material"; import { PublicKey } from "@solana/web3.js"; import { BigNumber } from "ethers"; -import { useRecoilValueLoadable } from "recoil"; +import { useRecoilValueLoadable, useSetRecoilState } from "recoil"; import { ApproveTransactionDrawer } from "../../common/ApproveTransactionDrawer"; import { @@ -52,6 +52,7 @@ import { NavStackEphemeral, NavStackScreen, } from "../../common/Layout/NavStack"; +import PopoverMenu from "../../common/PopoverMenu"; import { SendEthereumConfirmationCard } from "../Balances/TokensWidget/Ethereum"; import { Error as ErrorConfirmation, @@ -467,6 +468,8 @@ function Attributes({ nft }: { nft: any }) { export function NftOptionsButton() { const theme = useCustomTheme(); const background = useBackgroundClient(); + const { username } = useUser(); + const setNewAvatar = useSetRecoilState(newAvatarAtom(username)); const [anchorEl, setAnchorEl] = useState(null); const [openDrawer, setOpenDrawer] = useState(false); const searchParams = useDecodedSearchParams(); @@ -516,6 +519,24 @@ export function NftOptionsButton() { setOpenDrawer(true); }; + const onSetPfp = async () => { + if (nft) { + const id = `${nft.blockchain}/${ + nft.blockchain === "solana" ? nft.mint : nft.id + }`; + + await fetch(BACKEND_API_URL + "/users/avatar", { + headers: { + "Content-Type": "application/json", + }, + method: "POST", + body: JSON.stringify({ avatar: id }), + }); + await fetch(`${AVATAR_BASE_URL}/${username}?bust_cache=1`); + setNewAvatar({ id, url: nft.imageUrl }); + } + }; + return ( <> - -
- + { + const url = explorerNftUrl(explorer, nft, connectionUrl); + window.open(url, "_blank"); }} > - { - const url = explorerNftUrl(explorer, nft, connectionUrl); - window.open(url, "_blank"); - }} - > - - View on Explorer - - - - {!isEthereum && ( - onBurn()} - > - - Burn Token - - - )} - -
- + View on Explorer + + Set as PFP + + + + Burn Token + + + ({ blockchainCard: { @@ -34,7 +33,6 @@ const useStyles = styles((theme) => ({ zIndex: "1", height: "117px", width: "547px", - backgroundImage: "url(https://xnft.wao.gg/one-entry-bg.png)", backgroundSize: "547px 234px", backgroundRepeat: "no-repeat", backgroundPosition: "0px 0px", @@ -68,7 +66,7 @@ const useStyles = styles((theme) => ({ export default function EntryONE() { const [imageLoaded, setImageLoaded] = useState(false); const ref = useRef(null); - const isONELive = useIsONELive(); + const isONELive = useRecoilValue(isOneLive); const classes = useStyles(); const openPlugin = useOpenPlugin(); @@ -90,10 +88,12 @@ export default function EntryONE() { }; }, []); - const isLoading = false || !imageLoaded || isONELive === "loading"; + const isLoading = false || !imageLoaded; const openXNFT = () => { - openPlugin("CkqWjTWzRMAtYN3CSs8Gp4K9H891htmaN1ysNXqcULc8"); + if (isONELive.isLive) { + openPlugin("CkqWjTWzRMAtYN3CSs8Gp4K9H891htmaN1ysNXqcULc8"); + } }; return ( @@ -106,12 +106,17 @@ export default function EntryONE() { isLoading ? classes.hidden : "" }`} > -
+
); diff --git a/packages/app-extension/src/components/Unlocked/Nfts/index.tsx b/packages/app-extension/src/components/Unlocked/Nfts/index.tsx index ac6b11c44..7c7191c8a 100644 --- a/packages/app-extension/src/components/Unlocked/Nfts/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Nfts/index.tsx @@ -2,6 +2,7 @@ import { useMemo } from "react"; import { EmptyState } from "@coral-xyz/react-common"; import { isAggregateWallets, + isOneLive, nftCollectionsWithIds, useActiveWallet, useAllWalletsDisplayed, @@ -9,14 +10,13 @@ import { import { Image as ImageIcon } from "@mui/icons-material"; import { useRecoilValue, useRecoilValueLoadable } from "recoil"; -import { useIsONELive } from "../../../hooks/useIsONELive"; import { _BalancesTableHead } from "../Balances/Balances"; import EntryONE from "./EntryONE"; import { NftTable } from "./NftTable"; export function Nfts() { - const isONELive = useIsONELive(); + const isONELive = useRecoilValue(isOneLive); const activeWallet = useActiveWallet(); const wallets = useAllWalletsDisplayed(); const _isAggregateWallets = useRecoilValue(isAggregateWallets); @@ -28,7 +28,7 @@ export function Nfts() { return ( }] : [] } @@ -59,7 +59,7 @@ export function Nfts() { > {isEmpty ? ( <> - {isONELive && } + {isONELive.isLive && } } title={"No NFTs"} diff --git a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ConnectHardware/ConnectHardwareSearching.tsx b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ConnectHardware/ConnectHardwareSearching.tsx index 2e7232b62..da5d61435 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ConnectHardware/ConnectHardwareSearching.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ConnectHardware/ConnectHardwareSearching.tsx @@ -30,12 +30,14 @@ export function ConnectHardwareSearching({ useEffect(() => { // @ts-ignore const connectListener = navigator.hid.addEventListener("connect", () => { + console.log("refreshing connect"); setNavigatorStateChange((prev) => prev + 1); }); // @ts-ignore const disconnectListener = navigator.hid.addEventListener( "disconnect", async () => { + console.log("refreshing disconnect"); setNavigatorStateChange((prev) => prev + 1); } ); @@ -53,29 +55,30 @@ export function ConnectHardwareSearching({ useEffect(() => { (async () => { if (transport === null && !connectFailure) { - TransportWebHid.create() - .then(setTransport) - .catch(async (err) => { - if (err.message === "The device is already open.") { - const devices = await TransportWebHid.list(); - // Close all open devices - await Promise.all(devices.map((d) => d.close())); - // Reload - setNavigatorStateChange(() => navigatorStateChange + 1); - } else if (err.message === "Access denied to use Ledger device") { - // User cancelled the permissions screen, or no device available in screen - setTimeout(() => setConnectFailure(true), 2000); - } else { - console.error(err); - setTimeout(() => setConnectFailure(true), 2000); - } - }); + try { + setTransport(await TransportWebHid.create()); + } catch (error: any) { + if (error.message === "The device is already open.") { + const devices = await TransportWebHid.list(); + // Close all open devices + await Promise.all(devices.map((d) => d.close())); + // Reload to retry + setNavigatorStateChange(() => navigatorStateChange + 1); + } else if (error.message === "Access denied to use Ledger device") { + // User cancelled the permissions screen, or no device available in screen + console.debug("access denied to ledger device"); + setTimeout(() => setConnectFailure(true), 2000); + } else { + console.debug("ledger error", error); + setTimeout(() => setConnectFailure(true), 2000); + } + } } })(); }, [connectFailure, navigatorStateChange]); useEffect(() => { - // Auto advance is transport set + // Auto advance if transport set if (transport) { setTimeout(() => setConnectSuccess(true), 2000); } diff --git a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ConnectHardware/index.tsx b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ConnectHardware/index.tsx index 27a7f7c01..b6ec925df 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ConnectHardware/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ConnectHardware/index.tsx @@ -1,4 +1,4 @@ -import type { Blockchain, BlockchainKeyringInit } from "@coral-xyz/common"; +import type { Blockchain, SignedWalletDescriptor } from "@coral-xyz/common"; import { getAddMessage, UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_ADD, @@ -24,31 +24,17 @@ export function ConnectHardware({ const background = useBackgroundClient(); const handleHardwareOnboardComplete = async ( - keyringInit: BlockchainKeyringInit + signedWalletDescriptor: SignedWalletDescriptor ) => { - if (createKeyring) { - await background.request({ - method: UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_ADD, - params: [ - keyringInit.blockchain, - keyringInit.derivationPath, - keyringInit.accountIndex, - keyringInit.publicKey, - keyringInit.signature, - ], - }); - } else { - await background.request({ - method: UI_RPC_METHOD_LEDGER_IMPORT, - params: [ - keyringInit.blockchain, - keyringInit.derivationPath, - keyringInit.accountIndex, - keyringInit.publicKey, - keyringInit.signature, - ], - }); - } + const method = createKeyring + ? // Create the keyring + UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_ADD + : // Just import the wallet because the keyring already exists + UI_RPC_METHOD_LEDGER_IMPORT; + await background.request({ + method, + params: [blockchain, signedWalletDescriptor], + }); }; return ( diff --git a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/index.tsx b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/index.tsx index 277d80a74..a9c37abdc 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/index.tsx @@ -1,13 +1,13 @@ import { useEffect, useState } from "react"; import type { Blockchain } from "@coral-xyz/common"; import { - DerivationPath, openAddUserAccount, openConnectHardware, TAB_APPS, TAB_BALANCES, UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_ADD, UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_READ, + UI_RPC_METHOD_FIND_SIGNED_WALLET_DESCRIPTOR, UI_RPC_METHOD_KEYRING_DERIVE_WALLET, UI_RPC_METHOD_NAVIGATION_ACTIVE_TAB_UPDATE, } from "@coral-xyz/common"; @@ -160,13 +160,17 @@ export function AddConnectWalletMenu({ return ( ); } else { return ( - + ); } } @@ -174,9 +178,11 @@ export function AddConnectWalletMenu({ export function AddWalletMenu({ blockchain, keyringExists, + setKeyringExists, }: { blockchain: Blockchain; keyringExists: boolean; + setKeyringExists: (exists: boolean) => void; }) { const nav = useNavStack(); const background = useBackgroundClient(); @@ -184,33 +190,35 @@ export function AddWalletMenu({ const theme = useCustomTheme(); const [newPublicKey, setNewPublicKey] = useState(""); const [openDrawer, setOpenDrawer] = useState(false); - const [error, setError] = useState(null); // Lock to ensure that the create new wallet button cannot be accidentally // spammed or double clicked, which is undesireable as it creates more wallets // than the user expects. const [lockCreateButton, setLockCreateButton] = useState(false); - const createNewDerived = async () => { + const createNew = async () => { + // Mnemonic based keyring. This is the simple case because we don't + // need to prompt for the user to open their Ledger app to get the + // required public key. We also don't need a signature to prove + // ownership of the public key because that can't be done + // transparently by the backend. if (lockCreateButton) { return; } setLockCreateButton(true); let newPublicKey; if (!keyringExists) { - // Mnemonic based keyring. This is the simple case because we don't - // need to prompt for the user to open their Ledger app to get the - // required public key. We also don't need a signature to prove - // ownership of the public key because that can't be done - // transparently by the backend. - try { - newPublicKey = await background.request({ - method: UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_ADD, - params: [blockchain, DerivationPath.Default, 0], - }); - } catch (error) { - setError("Wallet address is used by another Backpack account."); - } + const signedWalletDescriptor = await background.request({ + method: UI_RPC_METHOD_FIND_SIGNED_WALLET_DESCRIPTOR, + params: [blockchain, 0], + }); + await background.request({ + method: UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_ADD, + params: [blockchain, signedWalletDescriptor], + }); + newPublicKey = signedWalletDescriptor.publicKey; + // Keyring now exists, toggle to other options + setKeyringExists(true); } else { newPublicKey = await background.request({ method: UI_RPC_METHOD_KEYRING_DERIVE_WALLET, @@ -250,7 +258,7 @@ export function AddWalletMenu({ /> } text="Create a new wallet" - onClick={createNewDerived} + onClick={createNew} /> )} diff --git a/packages/app-extension/src/components/Unlocked/Settings/AvatarHeader/UpdateProfilePicture.tsx b/packages/app-extension/src/components/Unlocked/Settings/AvatarHeader/UpdateProfilePicture.tsx index 88ebf777d..089b38459 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/AvatarHeader/UpdateProfilePicture.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/AvatarHeader/UpdateProfilePicture.tsx @@ -1,4 +1,4 @@ -import React, { useMemo, useState } from "react"; +import React, { useEffect, useMemo, useState } from "react"; import type { NftCollection } from "@coral-xyz/common"; import { AVATAR_BASE_URL, @@ -26,7 +26,8 @@ import { useUser, } from "@coral-xyz/recoil"; import { styled, useCustomTheme } from "@coral-xyz/themes"; -import { CircularProgress, Grid } from "@mui/material"; +import DeleteIcon from "@mui/icons-material/Delete"; +import { CircularProgress, Grid, IconButton } from "@mui/material"; import Collapse from "@mui/material/Collapse"; import Typography from "@mui/material/Typography"; import { @@ -57,10 +58,30 @@ export function UpdateProfilePicture({ const setNewAvatar = useSetRecoilState(newAvatarAtom(username)); const theme = useCustomTheme(); const { contents, state } = useRecoilValueLoadable(nftCollectionsWithIds); + const [isDefaultAvatar, setIsDefaultAvatar] = useState(true); + + useEffect(() => { + if (!avatarUrl || avatarUrl === "" || !username || username === "") return; + + Promise.all([ + fetch(avatarUrl).then((res) => res.text()), + fetch(`https://avatars.xnfts.dev/v1/${username}?size=500`).then((res) => + res.text() + ), + ]) + .then((avatars) => { + if (avatars[0] !== avatars[1]) { + setIsDefaultAvatar(false); + } + }) + .catch(console.error); + }, [avatarUrl, username]); + const allWalletCollections: Array<{ publicKey: string; collections: Array; }> = (state === "hasValue" && contents) || []; + const numberOfNFTs = allWalletCollections.reduce( (acc, c) => acc + (c.collections ?? []).length, 0 @@ -68,9 +89,34 @@ export function UpdateProfilePicture({ return ( - - - +
+
+ + + + {!isDefaultAvatar && ( + + setTempAvatar({ + id: "", + url: `https://avatars.xnfts.dev/v1/${username}`, + }) + } + > + + + )} +
+
), - [nft] + [nft, nftId, tempAvatar] ); } diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/index.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/index.tsx index c402f3f87..0827ee741 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/index.tsx @@ -1,6 +1,5 @@ -import { useEffect } from "react"; +import { useEffect, useState } from "react"; import { - BACKPACK_CONFIG_VERSION, BACKPACK_FEATURE_AGGREGATE_WALLETS, BACKPACK_FEATURE_LIGHT_MODE, Blockchain, @@ -15,19 +14,34 @@ import { useDeveloperMode, useIsAggregateWallets, } from "@coral-xyz/recoil"; -import { styles, useCustomTheme } from "@coral-xyz/themes"; -import { Switch, Typography } from "@mui/material"; +import { styles } from "@coral-xyz/themes"; +import { Switch } from "@mui/material"; +import { + deleteSubscription, + hasActiveSubscription, + unregisterNotificationServiceWorker, +} from "../../../../permissions/utils"; import { useNavStack } from "../../../common/Layout/NavStack"; import { SettingsList } from "../../../common/Settings/List"; export function Preferences() { - const theme = useCustomTheme(); const nav = useNavStack(); const background = useBackgroundClient(); const isDarkMode = useDarkMode(); const isDeveloperMode = useDeveloperMode(); const isAggregateWallets = useIsAggregateWallets(); + const [isNotificationsOn, setIsNotificationsOn] = useState(false); + + useEffect(() => { + hasActiveSubscription() + .then((status) => { + setIsNotificationsOn( + window.Notification.permission === "granted" && status + ); + }) + .catch(console.error); + }, [window.Notification.permission]); const onDarkModeSwitch = async (isDarkMode: boolean) => { await background.request({ @@ -50,6 +64,21 @@ export function Preferences() { }); }; + const onNotificationsSwitch = async (isNotificationsEnabled: boolean) => { + if (isNotificationsEnabled) { + setIsNotificationsOn(true); + window.open( + "/permissions.html?notifications=true", + "_blank", + "noreferrer" + ); + } else { + await deleteSubscription(); + await unregisterNotificationServiceWorker(); + setIsNotificationsOn(false); + } + }; + // // Global. // @@ -87,6 +116,16 @@ export function Preferences() { ), }; + menuItems["Notifications"] = { + onClick: () => onNotificationsSwitch(!isNotificationsOn), + detail: ( + onNotificationsSwitch(enabled)} + /> + ), + }; + if (BACKPACK_FEATURE_AGGREGATE_WALLETS) { menuItems["Aggregate Wallets"] = { onClick: () => onAggregateWalletsSwitch(!isAggregateWallets), @@ -168,9 +207,9 @@ export function SwitchToggle({ const classes = useStyles(); return ( ({ switchBase: { "&:hover": { - backgroundColor: "transparent", + backgroundColor: "transparent !important", "@media (hover: none)": { - backgroundColor: "transparent", + backgroundColor: "transparent !important", }, }, }, diff --git a/packages/app-extension/src/components/Unlocked/Settings/SettingsNavStackDrawer.tsx b/packages/app-extension/src/components/Unlocked/Settings/SettingsNavStackDrawer.tsx index 341533844..b1b236141 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/SettingsNavStackDrawer.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/SettingsNavStackDrawer.tsx @@ -10,7 +10,7 @@ import { } from "../../common/Layout/NavStack"; import { Logout, ResetWarning } from "../../Locked/Reset/ResetWarning"; import { ResetWelcome } from "../../Locked/Reset/ResetWelcome"; -import { Contacts } from "../Messages/Contacts"; +import { ContactRequests, Contacts } from "../Messages/Contacts"; import { Requests } from "../Messages/Requests"; import { ImportSecretKey } from "./AddConnectWallet/ImportSecretKey"; @@ -216,7 +216,14 @@ export function SettingsNavStackDrawer({ name={"contacts"} component={(props: any) => } /> - + } + /> + } + /> } diff --git a/packages/app-extension/src/components/Unlocked/Settings/Xnfts/Detail.tsx b/packages/app-extension/src/components/Unlocked/Settings/Xnfts/Detail.tsx index d84afa3cd..5196d140c 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Xnfts/Detail.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Xnfts/Detail.tsx @@ -26,7 +26,6 @@ import { } from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; import { Button, Typography } from "@mui/material"; -import { PublicKey } from "@solana/web3.js"; import { useRecoilValue } from "recoil"; import { updateRemotePreference } from "../../../../api/preferences"; @@ -49,7 +48,10 @@ export const XnftDetail: React.FC<{ xnft: any }> = ({ xnft }) => { const background = useBackgroundClient(); const { username } = useUser(); - const isDisabled = xnft.install.publicKey === PublicKey.default.toString(); + // Using the raw string here instead of PublicKey.default.toString() because + // typescript sucks and is throwing inexplicable errors. + const isDisabled = + xnft.install.publicKey === "11111111111111111111111111111111"; useEffect(() => { nav.setTitle(xnft.title); diff --git a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/EditWallets/WalletDetail.tsx b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/EditWallets/WalletDetail.tsx index 9c8ed5b0b..4a7fec9e3 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/EditWallets/WalletDetail.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/EditWallets/WalletDetail.tsx @@ -1,10 +1,9 @@ import React, { useEffect, useState } from "react"; -import { useRecoilValue } from "recoil"; +import type { Blockchain } from "@coral-xyz/common"; import { - Blockchain, UI_RPC_METHOD_KEY_IS_COLD_UPDATE, + UI_RPC_METHOD_KEYNAME_READ, } from "@coral-xyz/common"; -import { UI_RPC_METHOD_KEYNAME_READ } from "@coral-xyz/common"; import { isKeyCold, useBackgroundClient, @@ -13,6 +12,7 @@ import { import { useCustomTheme } from "@coral-xyz/themes"; import { ContentCopy } from "@mui/icons-material"; import { Typography } from "@mui/material"; +import { useRecoilValue } from "recoil"; import { useNavStack } from "../../../../common/Layout/NavStack"; import { SettingsList } from "../../../../common/Settings/List"; @@ -135,10 +135,10 @@ export const WalletDetail: React.FC<{ detail: ( { + onSwitch={async () => { await background.request({ method: UI_RPC_METHOD_KEY_IS_COLD_UPDATE, - params: [publicKey, enabled], + params: [publicKey, !isCold], }); }} /> @@ -153,7 +153,7 @@ export const WalletDetail: React.FC<{
- {type !== "dehyrdrated" && } + {type !== "dehydrated" && } {type !== "hardware" && type !== "dehydrated" && ( )} diff --git a/packages/app-extension/src/components/Unlocked/WithAuth.tsx b/packages/app-extension/src/components/Unlocked/WithAuth.tsx index c18a3b453..2c26ad793 100644 --- a/packages/app-extension/src/components/Unlocked/WithAuth.tsx +++ b/packages/app-extension/src/components/Unlocked/WithAuth.tsx @@ -1,11 +1,10 @@ import { useEffect, useState } from "react"; -import type { Blockchain, BlockchainKeyringInit } from "@coral-xyz/common"; +import type { Blockchain, SignedWalletDescriptor } from "@coral-xyz/common"; import { getAuthMessage, UI_RPC_METHOD_SIGN_MESSAGE_FOR_PUBLIC_KEY, UI_RPC_METHOD_USER_JWT_UPDATE, } from "@coral-xyz/common"; -import { Loading } from "@coral-xyz/react-common"; import { useBackgroundClient, useUser } from "@coral-xyz/recoil"; import { ethers } from "ethers"; @@ -13,10 +12,6 @@ import { useAuthentication } from "../../hooks/useAuthentication"; import { WithDrawer } from "../common/Layout/Drawer"; import { HardwareOnboard } from "../Onboarding/pages/HardwareOnboard"; -import { WithSyncAccount } from "./WithSyncAccount"; - -const { base58 } = ethers.utils; - export function WithAuth({ children }: { children: React.ReactElement }) { const { authenticate, checkAuthentication, getAuthSigner } = useAuthentication(); @@ -31,7 +26,6 @@ export function WithAuth({ children }: { children: React.ReactElement }) { userId: string; } | null>(null); const [authSignature, setAuthSignature] = useState(null); - const [loading, setLoading] = useState(true); const [openDrawer, setOpenDrawer] = useState(false); const [serverAccountState, setServerAccountState] = useState<{ isAuthenticated: boolean; @@ -90,7 +84,9 @@ export function WithAuth({ children }: { children: React.ReactElement }) { method: UI_RPC_METHOD_SIGN_MESSAGE_FOR_PUBLIC_KEY, params: [ authData.blockchain, - base58.encode(Buffer.from(authData.message, "utf-8")), + ethers.utils.base58.encode( + Buffer.from(authData.message, "utf-8") + ), authData.publicKey, ], }); @@ -125,9 +121,6 @@ export function WithAuth({ children }: { children: React.ReactElement }) { return ( <> - {serverAccountState && ( - - )} {children} {authData && ( { - setAuthSignature(keyringInit.signature); + onComplete={(signedWalletDescriptor: SignedWalletDescriptor) => { + setAuthSignature(signedWalletDescriptor.signature); }} /> diff --git a/packages/app-extension/src/components/Unlocked/WithSyncAccount.tsx b/packages/app-extension/src/components/Unlocked/WithSyncAccount.tsx deleted file mode 100644 index 364e95c0d..000000000 --- a/packages/app-extension/src/components/Unlocked/WithSyncAccount.tsx +++ /dev/null @@ -1,108 +0,0 @@ -import type React from "react"; -import { useEffect, useState } from "react"; -import type { Blockchain } from "@coral-xyz/common"; -import { - UI_RPC_METHOD_KEYRING_KEY_DELETE, - UI_RPC_METHOD_KEYRING_STORE_MNEMONIC_SYNC, - UI_RPC_METHOD_USER_ACCOUNT_PUBLIC_KEY_CREATE, -} from "@coral-xyz/common"; -import { - useBackgroundClient, - useDehydratedWallets, - useKeyringType, -} from "@coral-xyz/recoil"; - -import { useAuthentication } from "../../hooks/useAuthentication"; - -export function WithSyncAccount({ - serverPublicKeys, -}: { - serverPublicKeys: Array<{ blockchain: Blockchain; publicKey: string }>; -}) { - const background = useBackgroundClient(); - const { getSigners } = useAuthentication(); - const dehydratedWallets = useDehydratedWallets(); - const keyringType = useKeyringType(); - const [clientPublicKeys, setClientPublicKeys] = useState< - Array<{ blockchain: Blockchain; publicKey: string; hardware: boolean }> - >([]); - const [syncAttempted, setSyncAttempted] = useState(false); - - useEffect(() => { - (async () => { - setClientPublicKeys(await getSigners()); - })(); - }, []); - - /** - * Sign all transparently signable add messages with the required public keys. - */ - useEffect(() => { - (async () => { - // Public key/signature pairs that are required to sync the state of the - // server public key data with the client data. - const danglingPublicKeys = clientPublicKeys.filter((c) => { - // Filter to client public keys that don't exist on the server - const existsServer = serverPublicKeys.find( - (s) => s.blockchain === c.blockchain && s.publicKey === c.publicKey - ); - return !existsServer; - }); - - for (const danglingPublicKey of danglingPublicKeys) { - if (danglingPublicKey.hardware) { - // Remove hardware public keys if they are not on the server - // They can be added again through settings to capture the - // signature - try { - await background.request({ - method: UI_RPC_METHOD_KEYRING_KEY_DELETE, - params: [ - danglingPublicKey.blockchain, - danglingPublicKey.publicKey, - ], - }); - } catch { - // If the delete fails for some reason, don't error out because - // the wallet will not be accessible - } - } else { - // Sync all transparently signable public keys by adding them - // to the server - background.request({ - method: UI_RPC_METHOD_USER_ACCOUNT_PUBLIC_KEY_CREATE, - params: [danglingPublicKey.blockchain, danglingPublicKey.publicKey], - }); - } - } - })(); - }, [clientPublicKeys]); - - // - // Attempt to find any dehydrated wallets on the mnemonic if a mnemonic is in use. - // - useEffect(() => { - (async () => { - try { - if ( - keyringType === "mnemonic" && - dehydratedWallets.length > 0 && - !syncAttempted - ) { - // We need to only do this once, the dehydrated wallets array will change - // if we find wallets and successfully load them and we don't want to - // trigger this function for smaller and smaller dehydratedWallets arrays - setSyncAttempted(true); - await background.request({ - method: UI_RPC_METHOD_KEYRING_STORE_MNEMONIC_SYNC, - params: [dehydratedWallets], - }); - } - } catch (error) { - console.log("sync error", error); - } - })(); - }, [keyringType, dehydratedWallets, syncAttempted]); - - return null; -} diff --git a/packages/app-extension/src/components/Unlocked/WithVersion.tsx b/packages/app-extension/src/components/Unlocked/WithVersion.tsx new file mode 100644 index 000000000..ef4b666f0 --- /dev/null +++ b/packages/app-extension/src/components/Unlocked/WithVersion.tsx @@ -0,0 +1,64 @@ +import { useEffect, useState } from "react"; +import { + BACKPACK_CONFIG_GITHUB_RUN_NUMBER, + BACKPACK_FEATURE_FORCE_LATEST_VERSION, +} from "@coral-xyz/common"; +import { EmptyState } from "@coral-xyz/react-common"; +import { Block } from "@mui/icons-material"; + +import { WithDrawer } from "../common/Layout/Drawer"; + +/** + * WithVersion does a check to make sure the app is running with the latest version + * as determinied by a remote worker. If the app is not on the latest version, then + * we present a drawer to force the user to update. + */ +export function WithVersion({ children }: { children: any }) { + const [openDrawer, setOpenDrawer] = useState(false); + + useEffect(() => { + (async () => { + const { version } = await ( + await fetch("https://version.backpack.workers.dev/") + ).json(); + if (BACKPACK_FEATURE_FORCE_LATEST_VERSION) { + let buildNumber: number | undefined; + try { + buildNumber = parseInt(BACKPACK_CONFIG_GITHUB_RUN_NUMBER); + if (buildNumber < version) { + setOpenDrawer(true); + } + } catch (err) { + // Do nothing because the version is "development". + setOpenDrawer(true); + } + } + })(); + }, []); + + return ( + <> + {children} + + + + + ); +} + +function VersionWarning() { + return ( +
+ } + title={"Please upgrade your Backpack"} + subtitle={`During the duration of the beta program, Backpack + requires users to use the most up to date version of the extension.`} + /> +
+ ); +} diff --git a/packages/app-extension/src/components/Unlocked/index.tsx b/packages/app-extension/src/components/Unlocked/index.tsx index e7a27502a..1c6b1ecf8 100644 --- a/packages/app-extension/src/components/Unlocked/index.tsx +++ b/packages/app-extension/src/components/Unlocked/index.tsx @@ -4,6 +4,7 @@ import { Router } from "../common/Layout/Router"; import { WithTabs } from "../common/Layout/Tab"; import { ApproveTransactionRequest } from "./ApproveTransactionRequest"; +import { WithVersion } from "./WithVersion"; // // The main nav persistent stack. @@ -12,17 +13,19 @@ export function Unlocked() { useBootstrapFast(); return ( - -
- - -
- + + +
+ + +
+ + ); } diff --git a/packages/app-extension/src/components/common/Layout/XnftAppStack.tsx b/packages/app-extension/src/components/common/Layout/XnftAppStack.tsx index 2b3da579c..c37024b0a 100644 --- a/packages/app-extension/src/components/common/Layout/XnftAppStack.tsx +++ b/packages/app-extension/src/components/common/Layout/XnftAppStack.tsx @@ -9,10 +9,12 @@ import { PluginApp } from "../../Unlocked/Apps/Plugin"; export function XnftAppStack() { let { xnftAddress } = useParams(); + const location = useLocation(); const closePlugin = useClosePlugin(); const [searchParams] = useSearchParams(); const navAction = searchParams.get("nav"); const theme = useCustomTheme(); + const deepXnftPath = location.pathname.split(xnftAddress ?? "")[1] ?? ""; return ( { closePlugin(); }} diff --git a/packages/app-extension/src/hooks/useIsONELive.ts b/packages/app-extension/src/hooks/useIsONELive.ts deleted file mode 100644 index 923b75f99..000000000 --- a/packages/app-extension/src/hooks/useIsONELive.ts +++ /dev/null @@ -1,17 +0,0 @@ -import { useEffect, useState } from "react"; -import { useActiveSolanaWallet } from "@coral-xyz/recoil"; - -export function useIsONELive() { - const [isLive, setIsLive] = useState("loading"); - const wallet = useActiveSolanaWallet(); - useEffect(() => { - fetch("https://one.xnfts.dev/api/isLive") - .then((r) => r.json()) - .catch(() => ({ isLive: false })) - .then((response) => { - setIsLive(response.isLive); - }); - }, []); - - return wallet && isLive; -} diff --git a/packages/app-extension/src/hooks/useSignMessageForWallet.tsx b/packages/app-extension/src/hooks/useSignMessageForWallet.tsx new file mode 100644 index 000000000..6dd92a65e --- /dev/null +++ b/packages/app-extension/src/hooks/useSignMessageForWallet.tsx @@ -0,0 +1,29 @@ +import type { WalletDescriptor } from "@coral-xyz/common"; +import { + getBlockchainFromPath, + UI_RPC_METHOD_SIGN_MESSAGE_FOR_PUBLIC_KEY, +} from "@coral-xyz/common"; +import { useBackgroundClient } from "@coral-xyz/recoil"; +import { ethers } from "ethers"; + +export const useSignMessageForWallet = (mnemonic?: string) => { + const background = useBackgroundClient(); + + const signMessageForWallet = async ( + walletDescriptor: WalletDescriptor, + message: string + ) => { + const blockchain = getBlockchainFromPath(walletDescriptor.derivationPath); + return await background.request({ + method: UI_RPC_METHOD_SIGN_MESSAGE_FOR_PUBLIC_KEY, + params: [ + blockchain, + walletDescriptor.publicKey, + ethers.utils.base58.encode(Buffer.from(message, "utf-8")), + [mnemonic, [walletDescriptor.derivationPath]], + ], + }); + }; + + return signMessageForWallet; +}; diff --git a/packages/app-extension/src/permissions/NotificationPermissions.tsx b/packages/app-extension/src/permissions/NotificationPermissions.tsx index 704073b06..463df0314 100644 --- a/packages/app-extension/src/permissions/NotificationPermissions.tsx +++ b/packages/app-extension/src/permissions/NotificationPermissions.tsx @@ -1,6 +1,4 @@ import { useEffect, useState } from "react"; -import { BACKEND_API_URL } from "@coral-xyz/common"; -import { useUser } from "@coral-xyz/recoil"; import NotificationsIcon from "@mui/icons-material/Notifications"; import NotificationsOffIcon from "@mui/icons-material/NotificationsOff"; @@ -21,20 +19,19 @@ export const NotificationPermissions = () => { }; const registerSubscription = async () => { - registerNotificationServiceWorker() - .then(async function (subscription) { - if (!subscription) { - // Set appropriate app states. - return; - } - await saveSubscription(subscription); - setPermissionGranted(true); - setInProgress(false); - }) - .catch(function () { - setPermissionGranted(false); - setInProgress(false); - }); + try { + const sub = await registerNotificationServiceWorker(); + if (!sub) { + return; + } + await saveSubscription(sub); + setPermissionGranted(true); + } catch (err) { + console.error(err); + setPermissionGranted(false); + } finally { + setInProgress(false); + } }; const init = async () => { diff --git a/packages/app-extension/src/permissions/Permissions.tsx b/packages/app-extension/src/permissions/Permissions.tsx index 7fe442164..60ff288d3 100644 --- a/packages/app-extension/src/permissions/Permissions.tsx +++ b/packages/app-extension/src/permissions/Permissions.tsx @@ -7,7 +7,7 @@ import { NotificationPermissions } from "./NotificationPermissions"; const Permissions = () => { const params = new URLSearchParams(window.location.search); - const notifications = params.get("notifications") || false; + const notifications = params.get("notifications") === "true" || false; if (notifications) { return ; From df6cac766dfae7a3891222481af8435fb2deac1d Mon Sep 17 00:00:00 2001 From: mj221 Date: Fri, 3 Feb 2023 13:50:49 +1000 Subject: [PATCH 10/36] WIP Merge branch 'master' of https://github.com/mjLabrys/backpack into mj/domain-content-resolver-revised --- .../app-extension/src/permissions/utils.ts | 31 +++ .../app-extension/src/plugin/Renderer.tsx | 46 +++- .../BottomDrawerSolanaConfirmation.tsx | 10 +- .../app-mobile/src/hooks/useIsONELive.tsx | 27 +- packages/background/src/backend/core.ts | 252 ++++++++---------- .../background/src/backend/keyring/index.ts | 134 ++++------ .../background/src/backend/store/index.ts | 2 +- .../background/src/backend/store/keyname.ts | 15 +- .../background/src/backend/store/keyring.ts | 3 + .../store/migrations/migrate_0_2_0_2408.ts | 79 ++++++ .../src/frontend/server-injected.ts | 86 ++---- packages/background/src/frontend/server-ui.ts | 115 +++----- packages/blockchains/common/src/index.ts | 2 +- packages/blockchains/evm/src/keyring/index.ts | 178 +++++++------ packages/blockchains/evm/src/util.ts | 32 +-- .../blockchains/keyring/src/blockchain.ts | 81 +++--- packages/blockchains/keyring/src/ledger.ts | 41 ++- packages/blockchains/keyring/src/types.ts | 26 +- .../blockchains/solana/src/keyring/index.ts | 200 ++++++++------ packages/blockchains/solana/src/util.ts | 60 +---- 20 files changed, 698 insertions(+), 722 deletions(-) create mode 100644 packages/background/src/backend/store/migrations/migrate_0_2_0_2408.ts diff --git a/packages/app-extension/src/permissions/utils.ts b/packages/app-extension/src/permissions/utils.ts index 73c515a22..3a9f7488f 100644 --- a/packages/app-extension/src/permissions/utils.ts +++ b/packages/app-extension/src/permissions/utils.ts @@ -27,6 +27,37 @@ export const registerNotificationServiceWorker = () => { ); }; +export const unregisterNotificationServiceWorker = () => { + return navigator.serviceWorker.ready.then( + async (serviceWorkerRegistration) => { + const applicationServerKey = urlB64ToUint8Array( + BACKPACK_NOTIFICATION_PUBKEY + ); + const sub = await serviceWorkerRegistration.pushManager.getSubscription(); + if (sub && sub.options.applicationServerKey === applicationServerKey) { + await sub.unsubscribe(); + } + } + ); +}; + +export const hasActiveSubscription = async (): Promise => { + const response = await fetch( + `${BACKEND_API_URL}/notifications/subscriptions` + ); + const json = await response.json(); + return json.auth_notification_subscriptions + ? json.auth_notification_subscriptions.length > 0 + : false; +}; + +export const deleteSubscription = async () => { + const response = await fetch(`${BACKEND_API_URL}/notifications`, { + method: "DELETE", + }); + return response.json(); +}; + export const saveSubscription = async (subscription: any) => { const response = await fetch(`${BACKEND_API_URL}/notifications/register`, { method: "post", diff --git a/packages/app-extension/src/plugin/Renderer.tsx b/packages/app-extension/src/plugin/Renderer.tsx index 7b4b02a68..45dae3e10 100644 --- a/packages/app-extension/src/plugin/Renderer.tsx +++ b/packages/app-extension/src/plugin/Renderer.tsx @@ -1,5 +1,9 @@ import { useEffect, useRef, useState } from "react"; -import type { XnftPreference } from "@coral-xyz/common"; +import type { Plugin, XnftPreference } from "@coral-xyz/common"; +import { + BACKPACK_CONFIG_GITHUB_RUN_NUMBER, + BACKPACK_FEATURE_FORCE_LATEST_VERSION, +} from "@coral-xyz/common"; import { Loading } from "@coral-xyz/react-common"; import { useAvatarUrl, @@ -8,30 +12,42 @@ import { useXnftJwt, } from "@coral-xyz/recoil"; +const buildNumber = BACKPACK_FEATURE_FORCE_LATEST_VERSION + ? parseInt(BACKPACK_CONFIG_GITHUB_RUN_NUMBER) + : -1; + export function PluginRenderer({ plugin, xnftPreference, + deepXnftPath, }: { - plugin: any; + plugin: Plugin; xnftPreference: XnftPreference | null; + deepXnftPath: string; }) { - const ref = useRef(); + const ref = useRef(null); const [loaded, setLoaded] = useState(false); - const { username } = useUser(); + const { username, uuid } = useUser(); const isDarkMode = useDarkMode(); const avatarUrl = useAvatarUrl(100); - const jwt = useXnftJwt(plugin.xnftAddress); - + const jwt = useXnftJwt(plugin.xnftAddress.toString()); useEffect(() => { if (plugin && ref && ref.current) { - plugin.mount(xnftPreference); + plugin.mount(xnftPreference, deepXnftPath); plugin.didFinishSetup!.then(() => { - plugin.pushAppUiMetadata({ isDarkMode, username, avatarUrl, jwt }); - plugin.iframeRoot.style.display = ""; + plugin.pushAppUiMetadata({ + isDarkMode, + username, + userId: uuid, + avatarUrl, + jwt, + version: buildNumber, + }); + plugin.iframeRoot!.style.display = ""; setLoaded(true); }); - plugin.iframeRoot.style.display = "none"; - ref.current.appendChild(plugin.iframeRoot); + plugin.iframeRoot!.style.display = "none"; + ref.current.appendChild(plugin.iframeRoot!); return () => { plugin.unmount(); }; @@ -40,7 +56,13 @@ export function PluginRenderer({ }, [plugin, ref]); useEffect(() => { - plugin.pushAppUiMetadata({ isDarkMode, username, avatarUrl }); + plugin.pushAppUiMetadata({ + isDarkMode, + username, + userId: uuid, + avatarUrl, + version: buildNumber, + }); }, [username, isDarkMode, avatarUrl]); return ( diff --git a/packages/app-mobile/src/components/BottomDrawerSolanaConfirmation.tsx b/packages/app-mobile/src/components/BottomDrawerSolanaConfirmation.tsx index 50f967e17..2defd8506 100644 --- a/packages/app-mobile/src/components/BottomDrawerSolanaConfirmation.tsx +++ b/packages/app-mobile/src/components/BottomDrawerSolanaConfirmation.tsx @@ -14,6 +14,10 @@ import { metadataAddress, } from "@coral-xyz/common"; import { useSolanaCtx } from "@coral-xyz/recoil"; +import { + Metadata, + TokenStandard, +} from "@metaplex-foundation/mpl-token-metadata"; import { SettingsList } from "@screens/Unlocked/Settings/components/SettingsMenuList"; import { PublicKey } from "@solana/web3.js"; @@ -25,7 +29,6 @@ import { } from "@components/BottomDrawerCards"; import { Margin, PrimaryButton, TokenAmountHeader } from "@components/index"; import { useTheme } from "@hooks/index"; -import { Metadata, TokenStandard } from "@metaplex-foundation/mpl-token-metadata"; type Step = "confirm" | "sending" | "complete" | "error"; @@ -90,8 +93,7 @@ export function SendSolanaConfirmationCard({ solanaCtx.connection, token.mint?.toString() as string ) - ) - { + ) { txSig = await Solana.transferProgrammableNft(solanaCtx, { destination: new PublicKey(destinationAddress), mint: new PublicKey(token.mint!), @@ -278,5 +280,5 @@ const isProgrammableNftToken = async ( // most likely this happens if the metadata account does not exist console.log(error); return false; - } + } }; diff --git a/packages/app-mobile/src/hooks/useIsONELive.tsx b/packages/app-mobile/src/hooks/useIsONELive.tsx index 4152994ce..6fe446fcd 100644 --- a/packages/app-mobile/src/hooks/useIsONELive.tsx +++ b/packages/app-mobile/src/hooks/useIsONELive.tsx @@ -1,32 +1,23 @@ // TODO(shared) import { useEffect, useState } from "react"; -import { useActiveSolanaWallet } from "@coral-xyz/recoil"; - const isLiveCheck = fetch("https://xnft.wao.gg/api/isLive") .then((r) => r.json()) .catch(() => ({ isLive: false })); -const whitelist = [ - "4m39tDyZcK9dgqYaBaX7PiTp1kjAKrMhNYmxDcVu3hNp", - "46YogwAHj4Yi4gZ4Rkyta1dRqKKcKZJy7YC5iJJHDvnw", - "GqRzxLfxUmuQPh48K3cq7M6uy8bScJV9qVmXcfbmT5jD", - "2CqD4M1kJb3rHB5ZM25NVQibdJ6v6cryi7GHDaXhac46", - "34UpQDG2R66u5XL9BFwNhsdzT6sqzat1Js9Yd7PmEXG2", - "8HNkdh4KDmQcP7f7kNsSFLjDRp2vEYPLBdhHeD7U9q2S", - "DcpYXJsWBgkV6kck4a7cWBg6B4epPeFRCMZJjxudGKh4", - "GvjRMX5NHiFM7Tbkg3styoamkrnBZmThAwhdJMrPmCso", -]; +let isLiveCache: boolean | "loading" = "loading"; export function useIsONELive() { - const [isLive, setIsLive] = useState("loading"); - const wallet = useActiveSolanaWallet(); + const [isLive, setIsLive] = useState(isLiveCache); useEffect(() => { - isLiveCheck.then((response) => { - setIsLive(response.isLive); - }); + if (isLive !== true) { + isLiveCheck.then((response) => { + isLiveCache = response.isLive; + setIsLive(response.isLive); + }); + } }, []); - return wallet && (isLive || whitelist.includes(wallet?.publicKey)); + return isLive; } diff --git a/packages/background/src/backend/core.ts b/packages/background/src/backend/core.ts index 88fb7a6a7..45a847a68 100644 --- a/packages/background/src/backend/core.ts +++ b/packages/background/src/backend/core.ts @@ -7,6 +7,8 @@ import type { KeyringInit, KeyringType, Preferences, + SignedWalletDescriptor, + WalletDescriptor, XnftPreference, } from "@coral-xyz/common"; import { @@ -16,11 +18,13 @@ import { DEFAULT_DARK_MODE, DEFAULT_GATEWAY, defaultPreferences, - DerivationPath, deserializeTransaction, EthereumConnectionUrl, EthereumExplorer, + getAccountRecoveryPaths, getAddMessage, + getCreateMessage, + getRecoveryPaths, LOAD_PUBLIC_KEY_AMOUNT, NOTIFICATION_ACTIVE_BLOCKCHAIN_UPDATED, NOTIFICATION_AGGREGATE_WALLETS_UPDATED, @@ -91,11 +95,6 @@ import { getWalletDataForUser, setUser, setWalletDataForUser } from "./store"; const { base58: bs58 } = ethers.utils; -export const DERIVATION_PATHS = [ - DerivationPath.Bip44, - DerivationPath.Bip44Change, -]; - export function start( events: EventEmitter, solanaB: SolanaConnectionBackend, @@ -482,13 +481,11 @@ export class Backend { */ async signMessageForPublicKey( blockchain: Blockchain, - msg: string, publicKey: string, - keyringInit?: { - derivationPath: DerivationPath; - accountIndex: number; - mnemonic?: string; - } + msg: string, + keyringInit?: + | Parameters + | Parameters ) { if ( !keyringInit && @@ -500,37 +497,23 @@ export class Backend { } let blockchainKeyring: BlockchainKeyring; - // If keyring init parameters were provided then init the keyring if (keyringInit) { // Create an empty keyring to init blockchainKeyring = keyringForBlockchain(blockchain); - if (keyringInit.mnemonic) { - // Using a mnemonic - blockchainKeyring.initFromMnemonic( - keyringInit.mnemonic, - keyringInit.derivationPath, - [keyringInit.accountIndex] - ); + if (keyringInit.length === 2) { + blockchainKeyring.initFromMnemonic(keyringInit[0], keyringInit[1]); } else { // Using a ledger - blockchainKeyring.initFromLedger([ - { - path: keyringInit.derivationPath, - account: keyringInit.accountIndex, - publicKey, - }, - ]); + blockchainKeyring.initFromLedger(keyringInit[0]); } } else { blockchainKeyring = this.keyringStore.activeUserKeyring.keyringForBlockchain(blockchain); } - // Check if the keyring was initialised properly or if the existing stored - // keyring has the correct public key if (!blockchainKeyring.hasPublicKey(publicKey)) { - throw new Error("invalid public key or keyring init"); + throw new Error("could not find public key for signing"); } if (blockchain === Blockchain.SOLANA) { @@ -834,8 +817,13 @@ export class Backend { * Add a new wallet to the keyring using the next derived wallet for the mnemonic. * @param blockchain - Blockchain to add the wallet for */ - async keyringDeriveWallet(blockchain: Blockchain): Promise { - const [publicKey, name] = await this.keyringStore.deriveNextKey(blockchain); + async keyringDeriveWallet( + blockchain: Blockchain, + retries = 0 + ): Promise { + const { publicKey, name } = await this.keyringStore.deriveNextKey( + blockchain + ); try { await this.userAccountPublicKeyCreate(blockchain, publicKey); @@ -845,6 +833,11 @@ export class Backend { // the next account index gets incremented. This is the correct behaviour // because it should allow for sensible retries on conflicts. await this.keyringKeyDelete(blockchain, publicKey); + if (retries < 10) { + // Key conflict with already exist account, retry + // Last key will be skipped because the wallet index will have incremented + return await this.keyringDeriveWallet(blockchain, retries); + } throw error; } @@ -852,7 +845,7 @@ export class Backend { name: NOTIFICATION_KEYRING_DERIVED_WALLET, data: { blockchain, - publicKey: publicKey.toString(), + publicKey, name, }, }); @@ -959,13 +952,7 @@ export class Backend { // Remove the public key from the Backpack API await this.userAccountPublicKeyDelete(blockchain, publicKey); - try { - await this.keyringStore.keyDelete(blockchain, publicKey); - } catch (error) { - // Add the public key back, i.e. revert the delete from above - await this.userAccountPublicKeyCreate(blockchain, publicKey); - throw error; - } + await this.keyringStore.keyDelete(blockchain, publicKey); this.events.emit(BACKEND_EVENT, { name: NOTIFICATION_KEYRING_KEY_DELETE, @@ -1119,17 +1106,11 @@ export class Backend { async ledgerImport( blockchain: Blockchain, - derivationPath: string, - account: number, - publicKey: string, - signature?: string + signedWalletDescriptor: SignedWalletDescriptor ) { - await this.keyringStore.ledgerImport( - blockchain, - derivationPath, - account, - publicKey - ); + const { signature, ...walletDescriptor } = signedWalletDescriptor; + const { publicKey } = walletDescriptor; + await this.keyringStore.ledgerImport(blockchain, walletDescriptor); try { await this.userAccountPublicKeyCreate(blockchain, publicKey, signature); } catch (error) { @@ -1151,69 +1132,6 @@ export class Backend { return this.keyringStore.createMnemonic(strength); } - async mnemonicSync( - serverPublicKeys: Array<{ blockchain: Blockchain; publicKey: string }> - ) { - const blockchains = [...new Set(serverPublicKeys.map((x) => x.blockchain))]; - for (const blockchain of blockchains) { - for (const derivationPath of DERIVATION_PATHS) { - const publicKeys = await this.previewPubkeys( - blockchain, - this.keyringStore.activeUserKeyring.exportMnemonic(), - derivationPath, - LOAD_PUBLIC_KEY_AMOUNT - ); - const searchPublicKeys = serverPublicKeys - .filter((b) => b.blockchain === blockchain) - .map((p) => p.publicKey); - - for (const searchPublicKey of searchPublicKeys) { - const accountIndex = publicKeys.findIndex( - (p: string) => p === searchPublicKey - ); - if (accountIndex !== -1) { - let blockchainKeyring: BlockchainKeyring | undefined = undefined; - try { - blockchainKeyring = - this.keyringStore.activeUserKeyring.keyringForBlockchain( - blockchain - ); - } catch { - // Pass - } - if (blockchainKeyring) { - if (blockchainKeyring.derivationPath() !== derivationPath) { - // We can't sync anything that is on a different path than the - // one that is in use for the blockchain keyring, keyring does - // not support multiple derivation paths - continue; - } - const [publicKey, name] = - await this.keyringStore.activeUserKeyring - .keyringForBlockchain(blockchain) - .importAccountIndex(accountIndex); - this.events.emit(BACKEND_EVENT, { - name: NOTIFICATION_KEYRING_DERIVED_WALLET, - data: { - blockchain, - publicKey: publicKey.toString(), - name, - }, - }); - } else { - // Create blockchain keyring - await this.blockchainKeyringsAdd( - blockchain, - derivationPath, - accountIndex - ); - } - } - } - } - } - } - keyringTypeRead(): KeyringType { return this.keyringStore.activeUserKeyring.hasMnemonic() ? "mnemonic" @@ -1223,14 +1141,12 @@ export class Backend { async previewPubkeys( blockchain: Blockchain, mnemonic: string, - derivationPath: DerivationPath, - numberOfAccounts: number + derivationPaths: Array ) { return this.keyringStore.previewPubkeys( blockchain, mnemonic, - derivationPath, - numberOfAccounts + derivationPaths ); } @@ -1247,10 +1163,11 @@ export class Backend { // Signature should only be undefined for non hardware wallets signature = await this.signMessageForPublicKey( blockchain, - bs58.encode(Buffer.from(getAddMessage(publicKey), "utf-8")), - publicKey + publicKey, + bs58.encode(Buffer.from(getAddMessage(publicKey), "utf-8")) ); } + const response = await fetch(`${BACKEND_API_URL}/users/publicKeys`, { method: "POST", body: JSON.stringify({ @@ -1419,6 +1336,70 @@ export class Backend { return json; } + /** + * Find a `SignedWalletDescriptor` that can be used to create a new account. + * This requires that the sub wallets on the account index are not used by a + * existing user account. This is checked by querying the Backpack API. + */ + async findSignedWalletDescriptor( + blockchain: Blockchain, + accountIndex = 0, + create = false, + mnemonic?: string + ): Promise { + // If mnemonic is not passed as an argument, use the keyring store stored mnemonic. + // Wallet must be unlocked. + if (!mnemonic) + mnemonic = this.keyringStore.activeUserKeyring.exportMnemonic(); + const recoveryPaths = getAccountRecoveryPaths(blockchain, accountIndex); + const publicKeys = await this.previewPubkeys( + blockchain, + mnemonic, + recoveryPaths + ); + const response = await fetch(`${BACKEND_API_URL}/publicKeys`, { + method: "POST", + body: JSON.stringify( + publicKeys.map((publicKey) => ({ + blockchain, + publicKey, + })) + ), + headers: { + "Content-Type": "application/json", + }, + }); + const json = await response.json(); + if (json.length === 0) { + // No users for any of the passed public keys, good to go + // Take the root for the public key path + const publicKey = publicKeys[0]; + const derivationPath = recoveryPaths[0]; + // TODO remove this, signing different messages is just extra friction + const message = create + ? getCreateMessage(publicKey) + : getAddMessage(publicKey); + return { + publicKey, + derivationPath, + signature: await this.signMessageForPublicKey( + blockchain, + publicKey, + bs58.encode(Buffer.from(message, "utf-8")), + [mnemonic, [derivationPath]] + ), + }; + } else { + // Iterate on account index + return this.findSignedWalletDescriptor( + blockchain, + accountIndex + 1, + create, + mnemonic + ); + } + } + /////////////////////////////////////////////////////////////////////////////// // Preferences. /////////////////////////////////////////////////////////////////////////////// @@ -1570,25 +1551,18 @@ export class Backend { */ async blockchainKeyringsAdd( blockchain: Blockchain, - derivationPath: DerivationPath, - accountIndex: number, - publicKey?: string, - signature?: string + signedWalletDescriptor: SignedWalletDescriptor ): Promise { - const newPublicKey = await this.keyringStore.blockchainKeyringAdd( + await this.keyringStore.blockchainKeyringAdd( blockchain, - derivationPath, - accountIndex, - publicKey + signedWalletDescriptor as WalletDescriptor ); + const { signature, publicKey } = signedWalletDescriptor; + // Add the new public key to the API try { - await this.userAccountPublicKeyCreate( - blockchain, - newPublicKey, - signature - ); + await this.userAccountPublicKeyCreate(blockchain, publicKey, signature); } catch (error) { // Roll back the added blockchain keyring await this.keyringStore.blockchainKeyringRemove(blockchain); @@ -1601,12 +1575,12 @@ export class Backend { name: NOTIFICATION_BLOCKCHAIN_KEYRING_CREATED, data: { blockchain, - activeWallet: newPublicKey, + activeWallet: publicKey, publicKeyData, }, }); - return newPublicKey; + return publicKey; } /** @@ -1658,7 +1632,11 @@ export class Backend { // Navigation. /////////////////////////////////////////////////////////////////////////////// - async navigationPush(url: string, tab?: string): Promise { + async navigationPush( + url: string, + tab?: string, + pushAboveRoot?: boolean + ): Promise { let nav = await store.getNav(); if (!nav) { throw new Error("nav not found"); @@ -1673,6 +1651,10 @@ export class Backend { return SUCCESS_RESPONSE; } + if (pushAboveRoot && nav.data[targetTab].urls[0]) { + nav.data[targetTab].urls = [nav.data[targetTab].urls[0]]; + } + nav.data[targetTab].urls.push(url); await store.setNav(nav); diff --git a/packages/background/src/backend/keyring/index.ts b/packages/background/src/backend/keyring/index.ts index 240af7dfc..53c0b109d 100644 --- a/packages/background/src/backend/keyring/index.ts +++ b/packages/background/src/backend/keyring/index.ts @@ -6,15 +6,16 @@ import type { BlockchainKeyring } from "@coral-xyz/blockchain-keyring"; import type { AutolockSettingsOption, Blockchain, - DerivationPath, EventEmitter, KeyringInit, + WalletDescriptor, } from "@coral-xyz/common"; import { BACKEND_API_URL, BACKEND_EVENT, DEFAULT_AUTO_LOCK_INTERVAL_SECS, defaultPreferences, + getBlockchainFromPath, NOTIFICATION_KEYRING_STORE_LOCKED, } from "@coral-xyz/common"; import type { KeyringStoreState } from "@coral-xyz/recoil"; @@ -317,16 +318,10 @@ export class KeyringStore { public previewPubkeys( blockchain: Blockchain, mnemonic: string, - derivationPath: DerivationPath, - numberOfAccounts: number + derivationPaths: Array ): string[] { const factory = hdFactoryForBlockchain(blockchain); - const hdKeyring = factory.fromMnemonic(mnemonic, derivationPath, [ - ...Array(numberOfAccounts).keys(), - ]); - return [...Array(numberOfAccounts).keys()].map((i) => - hdKeyring.getPublicKey(i) - ); + return factory.init(mnemonic, derivationPaths).publicKeys(); } public reset() { @@ -402,23 +397,17 @@ export class KeyringStore { */ public async blockchainKeyringAdd( blockchain: Blockchain, - derivationPath: DerivationPath, - accountIndex: number, - publicKey?: string, + walletDescriptor: WalletDescriptor, persist = true ): Promise { - // If this is a mnemonic based keyring the public key being returned is - // unknown, if it is a ledger it will just be the same as `publicKey` - const newPublicKey = await this.activeUserKeyring.blockchainKeyringAdd( + await this.activeUserKeyring.blockchainKeyringAdd( blockchain, - derivationPath, - accountIndex, - publicKey + walletDescriptor ); if (persist) { await this.persist(); } - return newPublicKey; + return walletDescriptor.publicKey; } /** @@ -457,30 +446,26 @@ export class KeyringStore { // Derive the next key for the given blockchain. public async deriveNextKey( blockchain: Blockchain - ): Promise<[string, string]> { + ): Promise<{ publicKey: string; derivationPath: string; name: string }> { return await this.withUnlockAndPersist(async () => { return await this.activeUserKeyring.deriveNextKey(blockchain); }); } - public async keyDelete(blockchain: Blockchain, pubkey: string) { + public async keyDelete(blockchain: Blockchain, publicKey: string) { return await this.withUnlockAndPersist(async () => { - return await this.activeUserKeyring.keyDelete(blockchain, pubkey); + return await this.activeUserKeyring.keyDelete(blockchain, publicKey); }); } public async ledgerImport( blockchain: Blockchain, - dPath: string, - account: number, - pubkey: string + walletDescriptor: WalletDescriptor ) { return await this.withUnlockAndPersist(async () => { return await this.activeUserKeyring.ledgerImport( blockchain, - dPath, - account, - pubkey + walletDescriptor ); }); } @@ -644,27 +629,32 @@ class UserKeyring { keyringInit: KeyringInit, uuid: string ): Promise { - const kr = new UserKeyring(); - kr.uuid = uuid; - kr.username = username; - kr.mnemonic = keyringInit.mnemonic; - - for (const blockchainKeyring of keyringInit.blockchainKeyrings) { - await kr.blockchainKeyringAdd( - blockchainKeyring.blockchain, - blockchainKeyring.derivationPath, - blockchainKeyring.accountIndex, - blockchainKeyring.publicKey + const keyring = new UserKeyring(); + keyring.uuid = uuid; + keyring.username = username; + keyring.mnemonic = keyringInit.mnemonic; + for (const signedWalletDescriptor of keyringInit.signedWalletDescriptors) { + const blockchainKeyring = keyring.blockchains.get( + getBlockchainFromPath(signedWalletDescriptor.derivationPath) ); + if (blockchainKeyring) { + // Blockchain keyring already exists, just add the derivation path + await blockchainKeyring.addDerivationPath( + signedWalletDescriptor.derivationPath + ); + } else { + // No blockchain keyring, create it + await keyring.blockchainKeyringAdd( + getBlockchainFromPath(signedWalletDescriptor.derivationPath), + signedWalletDescriptor + ); + } } - - // // Set the active wallet to be the first keyring. - // - const { blockchain } = keyringInit.blockchainKeyrings[0]; - kr.activeBlockchain = blockchain; - - return kr; + keyring.activeBlockchain = getBlockchainFromPath( + keyringInit.signedWalletDescriptors[0].derivationPath + ); + return keyring; } /////////////////////////////////////////////////////////////////////////////// @@ -746,40 +736,20 @@ class UserKeyring { public async blockchainKeyringAdd( blockchain: Blockchain, - derivationPath: DerivationPath, - accountIndex: number, - publicKey?: string + walletDescriptor: WalletDescriptor ): Promise { const keyring = keyringForBlockchain(blockchain); - let newPublicKey: string; if (this.mnemonic) { // Initialising using a mnemonic - const wallets = await keyring.initFromMnemonic( - this.mnemonic, - derivationPath, - [accountIndex] - ); - // Set the newly created public key for return - newPublicKey = wallets[0][0]; + await keyring.initFromMnemonic(this.mnemonic, [ + walletDescriptor.derivationPath, + ]); } else { - if (!publicKey) - throw new Error( - "initialising keyring with hardware wallet requires publickey" - ); // Initialising using a hardware wallet - await keyring.initFromLedger([ - { - path: derivationPath, - account: accountIndex, - publicKey, - }, - ]); - // This is the same as the public key that was passed in, it is returned - // unchanged - newPublicKey = publicKey; + await keyring.initFromLedger([walletDescriptor]); } this.blockchains.set(blockchain, keyring); - return newPublicKey; + return walletDescriptor.publicKey; } public async blockchainKeyringRemove(blockchain: Blockchain): Promise { @@ -814,14 +784,12 @@ class UserKeyring { */ public async deriveNextKey( blockchain: Blockchain - ): Promise<[string, string]> { + ): Promise<{ publicKey: string; derivationPath: string; name: string }> { let blockchainKeyring = this.blockchains.get(blockchain); if (!blockchainKeyring) { throw new Error("blockchain keyring not initialised"); } else { - // Derive the next key. - const [publicKey, name] = await blockchainKeyring.importAccountIndex(); - return [publicKey, name]; + return await blockchainKeyring.deriveNextKey(); } } @@ -837,16 +805,16 @@ class UserKeyring { public async ledgerImport( blockchain: Blockchain, - dPath: string, - account: number, - pubkey: string + walletDescriptor: WalletDescriptor ) { const blockchainKeyring = this.blockchains.get(blockchain); const ledgerKeyring = blockchainKeyring!.ledgerKeyring!; - const name = DefaultKeyname.defaultLedger(ledgerKeyring.keyCount()); - await ledgerKeyring.ledgerImport(dPath, account, pubkey); - await store.setKeyname(pubkey, name); - await store.setIsCold(pubkey, true); + await ledgerKeyring.add(walletDescriptor); + const name = DefaultKeyname.defaultLedger( + ledgerKeyring.publicKeys().length + ); + await store.setKeyname(walletDescriptor.publicKey, name); + await store.setIsCold(walletDescriptor.publicKey, true); } public async keyDelete(blockchain: Blockchain, pubkey: string) { diff --git a/packages/background/src/backend/store/index.ts b/packages/background/src/backend/store/index.ts index e1bd37168..6f628f053 100644 --- a/packages/background/src/backend/store/index.ts +++ b/packages/background/src/backend/store/index.ts @@ -5,13 +5,13 @@ import { LocalStorageDb } from "./db"; export * from "./db"; export * from "./feature-gates"; +export * from "./isCold"; export * from "./keyname"; export * from "./keyring"; export * from "./navigation"; export * from "./preferences"; export * from "./usernames"; export * from "./xnft-preferences"; -export * from "./isCold"; export function reset() { return LocalStorageDb.reset(); diff --git a/packages/background/src/backend/store/keyname.ts b/packages/background/src/backend/store/keyname.ts index c3684b38b..9eeb99be1 100644 --- a/packages/background/src/backend/store/keyname.ts +++ b/packages/background/src/backend/store/keyname.ts @@ -22,7 +22,8 @@ export async function getKeyname(publicKey: string): Promise { const names = await LocalStorageDb.get(key()); const name = names[publicKey]; if (!name) { - throw new Error(`unable to find name for key: ${publicKey.toString()}`); + console.error(`unable to find name for key: ${publicKey.toString()}`); + return ""; } return name; } @@ -32,13 +33,13 @@ function key() { } export const DefaultKeyname = { - defaultDerived(accountIndex: number): string { - return `Wallet ${accountIndex + 1}`; + defaultDerived(index: number): string { + return `Wallet ${index}`; }, - defaultImported(accountIndex: number): string { - return `Imported Wallet ${accountIndex + 1}`; + defaultImported(index: number): string { + return `Imported Wallet ${index}`; }, - defaultLedger(accountIndex: number): string { - return `Ledger ${accountIndex + 1}`; + defaultLedger(index: number): string { + return `Ledger ${index}`; }, }; diff --git a/packages/background/src/backend/store/keyring.ts b/packages/background/src/backend/store/keyring.ts index 62470cc37..bd22daf14 100644 --- a/packages/background/src/backend/store/keyring.ts +++ b/packages/background/src/backend/store/keyring.ts @@ -3,6 +3,7 @@ import type { Blockchain, BlockchainKeyringJson } from "@coral-xyz/common"; import type { SecretPayload } from "../keyring/crypto"; import * as crypto from "../keyring/crypto"; +import { migrate_0_2_0_2408 } from "./migrations/migrate_0_2_0_2408"; import { LocalStorageDb } from "./db"; const KEY_KEYRING_STORE = "keyring-store"; @@ -43,6 +44,8 @@ export async function getKeyringStore( return json; } + migrate_0_2_0_2408(json); + // // Migrate user from single username -> multi username account management. // diff --git a/packages/background/src/backend/store/migrations/migrate_0_2_0_2408.ts b/packages/background/src/backend/store/migrations/migrate_0_2_0_2408.ts new file mode 100644 index 000000000..d739b82c1 --- /dev/null +++ b/packages/background/src/backend/store/migrations/migrate_0_2_0_2408.ts @@ -0,0 +1,79 @@ +// Migration: 0.2.0-latest-beta-2408. +// +// We make a best effort to migrate gracefully. This is not atomic. +// +// In the event of failure, the user must re-onboard. + +import type { Blockchain } from "@coral-xyz/common"; +import { + derivationPathsToIndexes, + legacyBip44ChangeIndexed, + legacyBip44Indexed, + legacySolletIndexed, +} from "@coral-xyz/common"; + +export async function migrate_0_2_0_2408(json: any) { + for (const [user, userData] of Object.entries(json.users)) { + for (const [blockchain, blockchainKeyring] of Object.entries( + // @ts-ignore + userData.blockchains + )) { + // Migrate hd keyring + // Remaps old style DerivationPath and accountIndices to a flat array + // of derivation paths + // @ts-ignore + let hdKeyring = blockchainKeyring.hdKeyring; + if (hdKeyring && hdKeyring.accountIndices !== undefined) { + const derivationPaths = hdKeyring.accountIndices.map((i: number) => { + if (hdKeyring.derivationPath === "bip44") { + return legacyBip44Indexed(blockchain as Blockchain, i); + } else if (hdKeyring.derivationPath === "bip44change") { + return legacyBip44ChangeIndexed(blockchain as Blockchain, i); + } else { + return legacySolletIndexed(i); + } + }); + const { accountIndex, walletIndex } = + derivationPathsToIndexes(derivationPaths); + json.users[user].blockchains[blockchain].hdKeyring = { + mnemonic: hdKeyring.mnemonic, + seed: hdKeyring.seed, + derivationPaths, + accountIndex, + walletIndex, + }; + } + + // Migrate ledger keyring + // @ts-ignore + let ledgerKeyring = blockchainKeyring.ledgerKeyring; + if (ledgerKeyring.derivationPaths !== undefined) { + const walletDescriptors = ledgerKeyring.derivationPaths.map( + (d: { path: string; account: number; publicKey: string }) => { + let derivationPath: string; + if (d.path === "bip44") { + derivationPath = legacyBip44Indexed( + blockchain as Blockchain, + d.account + ); + } else if (d.path === "bip44change") { + derivationPath = legacyBip44ChangeIndexed( + blockchain as Blockchain, + d.account + ); + } else { + derivationPath = legacySolletIndexed(d.account); + } + return { + derivationPath, + publicKey: d.publicKey, + }; + } + ); + json.users[user].blockchains[blockchain].ledgerKeyring = { + walletDescriptors, + }; + } + } + } +} diff --git a/packages/background/src/frontend/server-injected.ts b/packages/background/src/frontend/server-injected.ts index 8c471132b..e3905f75e 100644 --- a/packages/background/src/frontend/server-injected.ts +++ b/packages/background/src/frontend/server-injected.ts @@ -33,11 +33,11 @@ import { NOTIFICATION_SOLANA_CONNECTED, NOTIFICATION_SOLANA_CONNECTION_URL_UPDATED, NOTIFICATION_SOLANA_DISCONNECTED, - openColdPopupWindow, openApprovalPopupWindow, openApproveAllTransactionsPopupWindow, openApproveMessagePopupWindow, openApproveTransactionPopupWindow, + openLockedApprovalPopupWindow, openLockedPopupWindow, openOnboarding, openPopupWindow, @@ -66,6 +66,8 @@ const whitelistedOrigins = [ /^http:\/\/localhost:[0-9]{4}$/, /^https:\/\/one-nft\.vercel\.app$/, /^https:\/\/xnft\.wao\.gg$/, + /^https:\/\/one\.xnfts\.dev$/, + /^https:\/\/rafffle\.famousfoxes\.com$/, ]; export function start(cfg: Config, events: EventEmitter, b: Backend): Handle { @@ -233,20 +235,30 @@ async function handleConnect( let didApprove = false; let resp: any; - if ( - keyringStoreState === "locked" && - (await ctx.backend.isApprovedOrigin(origin)) - ) { - logger.debug("origin approved but need to unlock"); - resp = await RequestManager.requestUiAction((requestId: number) => { - return openLockedPopupWindow( - ctx.sender.origin, - getTabTitle(ctx), - requestId, - blockchain - ); - }); - didApprove = !resp.windowClosed && resp.result.didApprove; + if (keyringStoreState === "locked") { + if (await ctx.backend.isApprovedOrigin(origin)) { + logger.debug("origin approved but need to unlock"); + resp = await RequestManager.requestUiAction((requestId: number) => { + return openLockedPopupWindow( + ctx.sender.origin, + getTabTitle(ctx), + requestId, + blockchain + ); + }); + didApprove = !resp.windowClosed && resp.result; + } else { + logger.debug("origin not apporved and needs to unlock"); + resp = await RequestManager.requestUiAction((requestId: number) => { + return openLockedApprovalPopupWindow( + ctx.sender.origin, + getTabTitle(ctx), + requestId, + blockchain + ); + }); + didApprove = !resp.windowClosed && resp.result.didApprove; + } } else { if (await ctx.backend.isApprovedOrigin(origin)) { logger.debug("origin approved so automatically connecting"); @@ -334,20 +346,6 @@ async function handleSolanaSignAndSendTx( walletAddress: string, options?: SendOptions ): Promise> { - if (await ctx.backend.keyIsCold(walletAddress)) { - const _uiResp = await RequestManager.requestUiAction( - (requestId: number) => { - return openColdPopupWindow( - ctx.sender.origin, - getTabTitle(ctx), - requestId, - walletAddress - ); - } - ); - return [undefined, "external site cannot sign for a cold wallet"]; - } - // Get user approval. const uiResp = await RequestManager.requestUiAction((requestId: number) => { return openApproveTransactionPopupWindow( @@ -397,20 +395,6 @@ async function handleSolanaSignTx( tx: string, walletAddress: string ): Promise> { - if (await ctx.backend.keyIsCold(walletAddress)) { - const _uiResp = await RequestManager.requestUiAction( - (requestId: number) => { - return openColdPopupWindow( - ctx.sender.origin, - getTabTitle(ctx), - requestId, - walletAddress - ); - } - ); - return [undefined, "external site cannot sign for a cold wallet"]; - } - const uiResp = await RequestManager.requestUiAction((requestId: number) => { return openApproveTransactionPopupWindow( ctx.sender.origin, @@ -459,20 +443,6 @@ async function handleSolanaSignAllTxs( txs: Array, walletAddress: string ): Promise>> { - if (await ctx.backend.keyIsCold(walletAddress)) { - const _uiResp = await RequestManager.requestUiAction( - (requestId: number) => { - return openColdPopupWindow( - ctx.sender.origin, - getTabTitle(ctx), - requestId, - walletAddress - ); - } - ); - return [undefined, "external site cannot sign for a cold wallet"]; - } - const uiResp = await RequestManager.requestUiAction((requestId: number) => { return openApproveAllTransactionsPopupWindow( ctx.sender.origin, @@ -575,7 +545,7 @@ async function handleSolanaOpenXnft( ): Promise> { const url = `xnft/${xnftAddress}`; await ctx.backend.navigationPush(url, TAB_XNFT); - await openPopupWindow(`popup.html#/${url}`); + await openPopupWindow(`popup.html`); return ["success"]; } diff --git a/packages/background/src/frontend/server-ui.ts b/packages/background/src/frontend/server-ui.ts index 9d5c66e09..d0a7fea59 100644 --- a/packages/background/src/frontend/server-ui.ts +++ b/packages/background/src/frontend/server-ui.ts @@ -5,12 +5,12 @@ import type { AutolockSettingsOption, Blockchain, Context, - DerivationPath, EventEmitter, FEATURE_GATES_MAP, Preferences, RpcRequest, RpcResponse, + SignedWalletDescriptor, XnftPreference, } from "@coral-xyz/common"; import { @@ -36,6 +36,7 @@ import { UI_RPC_METHOD_ETHEREUM_SIGN_AND_SEND_TRANSACTION, UI_RPC_METHOD_ETHEREUM_SIGN_MESSAGE, UI_RPC_METHOD_ETHEREUM_SIGN_TRANSACTION, + UI_RPC_METHOD_FIND_SIGNED_WALLET_DESCRIPTOR, UI_RPC_METHOD_GET_FEATURE_GATES, UI_RPC_METHOD_GET_XNFT_PREFERENCES, UI_RPC_METHOD_KEY_IS_COLD_UPDATE, @@ -55,7 +56,6 @@ import { UI_RPC_METHOD_KEYRING_STORE_KEEP_ALIVE, UI_RPC_METHOD_KEYRING_STORE_LOCK, UI_RPC_METHOD_KEYRING_STORE_MNEMONIC_CREATE, - UI_RPC_METHOD_KEYRING_STORE_MNEMONIC_SYNC, UI_RPC_METHOD_KEYRING_STORE_READ_ALL_PUBKEY_DATA, UI_RPC_METHOD_KEYRING_STORE_READ_ALL_PUBKEYS, UI_RPC_METHOD_KEYRING_STORE_STATE, @@ -211,17 +211,13 @@ async function handle( ); case UI_RPC_METHOD_KEYRING_STORE_MNEMONIC_CREATE: return await handleMnemonicCreate(ctx, params[0]); - case UI_RPC_METHOD_KEYRING_STORE_MNEMONIC_SYNC: - return await handleMnemonicSync(ctx, params[0]); case UI_RPC_METHOD_KEYRING_TYPE_READ: return await handleKeyringTypeRead(ctx); case UI_RPC_METHOD_PREVIEW_PUBKEYS: return await handlePreviewPubkeys( ctx, - params[0], - params[1], - params[2], - params[3] + // @ts-ignore + ...params ); case UI_RPC_METHOD_KEYRING_RESET: return await handleKeyringReset(ctx); @@ -231,17 +227,14 @@ async function handle( case UI_RPC_METHOD_LEDGER_IMPORT: return await handleKeyringLedgerImport( ctx, - params[0], - params[1], - params[2], - params[3], - params[4] + // @ts-ignore + ...params ); // // Navigation. // case UI_RPC_METHOD_NAVIGATION_PUSH: - return await handleNavigationPush(ctx, params[0], params[1]); + return await handleNavigationPush(ctx, params[0], params[1], params[2]); case UI_RPC_METHOD_NAVIGATION_POP: return await handleNavigationPop(ctx, params[0]); case UI_RPC_METHOD_NAVIGATION_CURRENT_URL_UPDATE: @@ -312,11 +305,8 @@ async function handle( case UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_ADD: return await handleBlockchainKeyringsAdd( ctx, - params[0], - params[1], - params[2], - params[3], - params[4] + // @ts-ignore + ...params ); case UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_READ: return await handleBlockchainKeyringsRead(ctx); @@ -365,6 +355,9 @@ async function handle( case UI_RPC_METHOD_USER_ACCOUNT_READ: // @ts-ignore return await handleUserAccountRead(ctx, ...params); + case UI_RPC_METHOD_FIND_SIGNED_WALLET_DESCRIPTOR: + // @ts-ignore + return await handleFindSignedWalletDescriptor(ctx, ...params); // // Password. // @@ -439,13 +432,8 @@ async function handle( case UI_RPC_METHOD_ETHEREUM_SIGN_MESSAGE: return await handleEthereumSignMessage(ctx, params[0], params[1]); case UI_RPC_METHOD_SIGN_MESSAGE_FOR_PUBLIC_KEY: - return await handleSignMessageForPublicKey( - ctx, - params[0], - params[1], - params[2], - params[3] - ); + // @ts-ignore + return await handleSignMessageForPublicKey(ctx, ...params); default: throw new Error(`unexpected ui rpc method: ${method}`); } @@ -654,6 +642,14 @@ async function handleUserAccountRead( return [resp]; } +async function handleFindSignedWalletDescriptor( + ctx: Context, + ...args: Parameters +): Promise> { + const resp = await ctx.backend.findSignedWalletDescriptor(...args); + return [resp]; +} + async function handlePasswordUpdate( ctx: Context, currentPassword: string, @@ -734,14 +730,6 @@ async function handleMnemonicCreate( return [resp]; } -async function handleMnemonicSync( - ctx: Context, - serverPublicKeys: Array<{ blockchain: Blockchain; publicKey: string }> -) { - const resp = await ctx.backend.mnemonicSync(serverPublicKeys); - return [resp]; -} - async function handleKeyringTypeRead(ctx: Context) { const resp = ctx.backend.keyringTypeRead(); return [resp]; @@ -750,9 +738,10 @@ async function handleKeyringTypeRead(ctx: Context) { async function handleNavigationPush( ctx: Context, url: string, - tab?: string + tab?: string, + pushAboveRoot?: boolean ): Promise> { - const resp = await ctx.backend.navigationPush(url, tab); + const resp = await ctx.backend.navigationPush(url, tab, pushAboveRoot); return [resp]; } @@ -1042,21 +1031,9 @@ async function handleEthereumSignMessage( async function handleSignMessageForPublicKey( ctx: Context, - blockchain: Blockchain, - msg: string, - publicKey: string, - keyringInit?: { - derivationPath: DerivationPath; - accountIndex: number; - mnemonic?: string; - } -) { - const resp = await ctx.backend.signMessageForPublicKey( - blockchain, - msg, - publicKey, - keyringInit - ); + ...args: Parameters +): Promise> { + const resp = await ctx.backend.signMessageForPublicKey(...args); return [resp]; } @@ -1114,17 +1091,11 @@ async function handleSetXnftPreferences( async function handleBlockchainKeyringsAdd( ctx: Context, blockchain: Blockchain, - derivationPath: DerivationPath, - accountIndex: number, - publicKey?: string, - signature?: string + signedWalletDescriptor: SignedWalletDescriptor ): Promise>> { const resp = await ctx.backend.blockchainKeyringsAdd( blockchain, - derivationPath, - accountIndex, - publicKey, - signature + signedWalletDescriptor ); return [resp]; } @@ -1138,35 +1109,17 @@ async function handleBlockchainKeyringsRead( async function handleKeyringLedgerImport( ctx: Context, - blockchain: Blockchain, - derivationPath: string, - account: number, - publicKey: string, - signature?: string + ...args: Parameters ): Promise> { - const resp = await ctx.backend.ledgerImport( - blockchain, - derivationPath, - account, - publicKey, - signature - ); + const resp = await ctx.backend.ledgerImport(...args); return [resp]; } async function handlePreviewPubkeys( ctx: Context, - blockchain: Blockchain, - mnemonic: string, - derivationPath: DerivationPath, - numberOfAccounts: number + ...args: Parameters ): Promise> { - const resp = await ctx.backend.previewPubkeys( - blockchain, - mnemonic, - derivationPath, - numberOfAccounts - ); + const resp = await ctx.backend.previewPubkeys(...args); return [resp]; } diff --git a/packages/blockchains/common/src/index.ts b/packages/blockchains/common/src/index.ts index a775ccb7e..be611bfa2 100644 --- a/packages/blockchains/common/src/index.ts +++ b/packages/blockchains/common/src/index.ts @@ -9,7 +9,7 @@ import { SolanaKeyringFactory, SolanaLedgerKeyringFactory, } from "@coral-xyz/blockchain-solana"; -import { Blockchain, DerivationPath } from "@coral-xyz/common"; +import { Blockchain } from "@coral-xyz/common"; export function hdFactoryForBlockchain(blockchain: Blockchain) { return { diff --git a/packages/blockchains/evm/src/keyring/index.ts b/packages/blockchains/evm/src/keyring/index.ts index 2e15d0f31..fc2ea916d 100644 --- a/packages/blockchains/evm/src/keyring/index.ts +++ b/packages/blockchains/evm/src/keyring/index.ts @@ -2,7 +2,6 @@ import type { HdKeyring, HdKeyringFactory, HdKeyringJson, - ImportedDerivationPath, Keyring, KeyringFactory, KeyringJson, @@ -10,8 +9,11 @@ import type { LedgerKeyringJson, } from "@coral-xyz/blockchain-keyring"; import { LedgerKeyringBase } from "@coral-xyz/blockchain-keyring"; +import type { WalletDescriptor } from "@coral-xyz/common"; import { - DerivationPath, + Blockchain, + derivationPathsToIndexes, + getIndexedPath, LEDGER_METHOD_ETHEREUM_SIGN_MESSAGE, LEDGER_METHOD_ETHEREUM_SIGN_TRANSACTION, } from "@coral-xyz/common"; @@ -19,19 +21,19 @@ import { mnemonicToSeedSync, validateMnemonic } from "bip39"; import type { Wallet } from "ethers"; import { ethers } from "ethers"; -import { deriveEthereumWallet, deriveEthereumWallets } from "../util"; +import { deriveEthereumWallet } from "../util"; export class EthereumKeyringFactory implements KeyringFactory { - fromJson(payload: KeyringJson): Keyring { - const wallets = payload.secretKeys.map((secret: string) => { - return new ethers.Wallet(Buffer.from(secret, "hex").toString()); + init(secretKeys: Array): Keyring { + const wallets = secretKeys.map((secretKey) => { + return new ethers.Wallet(secretKey); }); return new EthereumKeyring(wallets); } - fromSecretKeys(secretKeys: Array): Keyring { - const wallets = secretKeys.map((secretKey) => { - return new ethers.Wallet(secretKey); + fromJson(payload: KeyringJson): Keyring { + const wallets = payload.secretKeys.map((secret: string) => { + return new ethers.Wallet(Buffer.from(secret, "hex").toString()); }); return new EthereumKeyring(wallets); } @@ -97,114 +99,130 @@ export class EthereumKeyring implements Keyring { } export class EthereumHdKeyringFactory implements HdKeyringFactory { - public fromMnemonic( - mnemonic: string, - derivationPath?: DerivationPath, - accountIndices: Array = [0] - ): HdKeyring { - if (!derivationPath) { - derivationPath = DerivationPath.Default; - } + public init(mnemonic: string, derivationPaths: Array): HdKeyring { if (!validateMnemonic(mnemonic)) { throw new Error("Invalid seed words"); } const seed = mnemonicToSeedSync(mnemonic); - const wallets = deriveEthereumWallets(seed, derivationPath, accountIndices); return new EthereumHdKeyring({ mnemonic, seed, - accountIndices, - wallets, - derivationPath, + derivationPaths, }); } // @ts-ignore - public fromJson(obj: HdKeyringJson): HdKeyring { - const { mnemonic, seed: seedStr, accountIndices, derivationPath } = obj; - const seed = Buffer.from(seedStr, "hex"); - const wallets = deriveEthereumWallets(seed, derivationPath, accountIndices); + public fromJson({ + mnemonic, + seed, + derivationPaths, + accountIndex, + walletIndex, + }: HdKeyringJson): HdKeyring { return new EthereumHdKeyring({ mnemonic, - seed, - accountIndices, - wallets, - derivationPath, + seed: Buffer.from(seed, "hex"), + derivationPaths, + accountIndex, + walletIndex, }); } } export class EthereumHdKeyring extends EthereumKeyring implements HdKeyring { readonly mnemonic: string; - readonly derivationPath: DerivationPath; + private derivationPaths: Array; private seed: Buffer; - private accountIndices: Array; + private accountIndex?: number; + private walletIndex?: number; constructor({ mnemonic, seed, - accountIndices, - wallets, - derivationPath, + derivationPaths, + accountIndex, + walletIndex, }: { mnemonic: string; seed: Buffer; - accountIndices: Array; - wallets: Array; - derivationPath: DerivationPath; + derivationPaths: Array; + accountIndex?: number; + walletIndex?: number; }) { + const wallets = derivationPaths.map((d) => deriveEthereumWallet(seed, d)); super(wallets); this.mnemonic = mnemonic; this.seed = seed; - this.accountIndices = accountIndices; - this.derivationPath = derivationPath; + this.derivationPaths = derivationPaths; + this.accountIndex = accountIndex; + this.walletIndex = walletIndex; } - /** - * Import a new wallet using an account index. if the account index is not - * given the next available account index is used. - */ - public importAccountIndex(accountIndex?: number): [string, number] { - if (accountIndex === undefined) { - accountIndex = Math.max(...this.accountIndices) + 1; - } - const wallet = deriveEthereumWallet( - this.seed, - accountIndex, - this.derivationPath + deriveNextKey(): { + publicKey: string; + derivationPath: string; + } { + this.ensureIndices(); + // Move to the next wallet index for the derivation + this.walletIndex! += 1; + const derivationPath = getIndexedPath( + Blockchain.ETHEREUM, + this.accountIndex, + this.walletIndex ); - this.wallets.push(wallet); - this.accountIndices.push(accountIndex); - return [wallet.address, accountIndex]; + if (this.derivationPaths.includes(derivationPath)) { + // This key is already included for some reason, try again with + // incremented walletIndex + return this.deriveNextKey(); + } + const publicKey = this.addDerivationPath(derivationPath); + return { + publicKey, + derivationPath, + }; } - // @ts-ignore - public getPublicKey(accountIndex: number): string { - if (this.wallets.length !== this.accountIndices.length) { - throw new Error("invariant violation"); + addDerivationPath(derivationPath: string): string { + const wallet = ethers.Wallet.fromMnemonic(this.mnemonic, derivationPath); + if (!this.derivationPaths.includes(derivationPath)) { + // Don't persist duplicate public keys + this.derivationPaths.push(derivationPath); + this.wallets.push(wallet); } - const wallet = this.wallets[this.accountIndices.indexOf(accountIndex)]; return wallet.address; } + ensureIndices() { + // If account index and wallet index don't exist, make a best guess based + // on the existing derivation paths for the keyring + if (this.accountIndex === undefined || this.walletIndex === undefined) { + const { accountIndex, walletIndex } = derivationPathsToIndexes( + this.derivationPaths + ); + if (!this.accountIndex) this.accountIndex = accountIndex; + if (!this.walletIndex) this.walletIndex = walletIndex; + } + } + // @ts-ignore public toJson(): HdKeyringJson { return { mnemonic: this.mnemonic, seed: this.seed.toString("hex"), - accountIndices: this.accountIndices, - derivationPath: this.derivationPath, + derivationPaths: this.derivationPaths, + accountIndex: this.accountIndex, + walletIndex: this.walletIndex, }; } } export class EthereumLedgerKeyringFactory { - public fromAccounts(accounts: Array): LedgerKeyring { - return new EthereumLedgerKeyring(accounts); + public init(walletDescriptors: Array): LedgerKeyring { + return new EthereumLedgerKeyring(walletDescriptors); } public fromJson(obj: LedgerKeyringJson): LedgerKeyring { - return new EthereumLedgerKeyring(obj.derivationPaths); + return new EthereumLedgerKeyring(obj.walletDescriptors); } } @@ -214,35 +232,33 @@ export class EthereumLedgerKeyring { public async signTransaction( serializedTx: Buffer, - address: string + publicKey: string ): Promise { - const path = this.derivationPaths.find((p) => p.publicKey === address); - if (!path) { - throw new Error("ledger address not found"); + const walletDescriptor = this.walletDescriptors.find( + (p) => p.publicKey === publicKey + ); + if (!walletDescriptor) { + throw new Error("ledger public key not found"); } const tx = ethers.utils.parseTransaction( ethers.utils.hexlify(serializedTx) ); - const result = await this.request({ + return await this.request({ method: LEDGER_METHOD_ETHEREUM_SIGN_TRANSACTION, - params: [tx, path.path, path.account], + params: [tx, walletDescriptor.derivationPath], }); - return result; } - public async signMessage(msg: Buffer, address: string): Promise { - const path = this.derivationPaths.find((p) => p.publicKey === address); - if (!path) { - throw new Error("ledger address not found"); + public async signMessage(msg: Buffer, publicKey: string): Promise { + const walletDescriptor = this.walletDescriptors.find( + (p) => p.publicKey === publicKey + ); + if (!walletDescriptor) { + throw new Error("ledger public key not found"); } return await this.request({ method: LEDGER_METHOD_ETHEREUM_SIGN_MESSAGE, - params: [msg, path.path, path.account], + params: [msg, walletDescriptor.derivationPath], }); } - - public static fromString(str: string): EthereumLedgerKeyring { - const { derivationPaths } = JSON.parse(str); - return new EthereumLedgerKeyring(derivationPaths); - } } diff --git a/packages/blockchains/evm/src/util.ts b/packages/blockchains/evm/src/util.ts index 66a237fbe..a1ad3a358 100644 --- a/packages/blockchains/evm/src/util.ts +++ b/packages/blockchains/evm/src/util.ts @@ -1,39 +1,11 @@ -import { DerivationPath } from "@coral-xyz/common"; import type { Wallet } from "ethers"; import { ethers } from "ethers"; -export function deriveEthereumWallets( - seed: Buffer, - derivationPath: DerivationPath, - accountIndices: Array -): Array { - const wallets: Array = []; - for (const accountIndex of accountIndices) { - wallets.push(deriveEthereumWallet(seed, accountIndex, derivationPath)); - } - return wallets; -} - export function deriveEthereumWallet( seed: Buffer, - accountIndex: number, - derivationPath: DerivationPath + derivationPath: string ): Wallet { const hdNode = ethers.utils.HDNode.fromSeed(seed); - const path = derivePathStr(derivationPath, accountIndex); - const child = hdNode.derivePath(path); + const child = hdNode.derivePath(derivationPath); return new ethers.Wallet(child.privateKey); } - -function derivePathStr(derivationPath: DerivationPath, accountIndex: number) { - switch (derivationPath) { - case DerivationPath.Bip44: - return accountIndex === 0 - ? `m/44'/60'` - : `m/44'/60'/${accountIndex - 1}'`; - case DerivationPath.Bip44Change: - return `m/44'/60'/${accountIndex}'/0'`; - default: - throw new Error(`invalid derivation path: ${derivationPath}`); - } -} diff --git a/packages/blockchains/keyring/src/blockchain.ts b/packages/blockchains/keyring/src/blockchain.ts index 34dfc28b0..e6f2f71ff 100644 --- a/packages/blockchains/keyring/src/blockchain.ts +++ b/packages/blockchains/keyring/src/blockchain.ts @@ -1,13 +1,15 @@ import * as store from "@coral-xyz/background/src/backend/store"; import { DefaultKeyname } from "@coral-xyz/background/src/backend/store"; -import type { BlockchainKeyringJson, DerivationPath } from "@coral-xyz/common"; +import type { + BlockchainKeyringJson, + WalletDescriptor, +} from "@coral-xyz/common"; import { getLogger } from "@coral-xyz/common"; import * as bs58 from "bs58"; import type { HdKeyring, HdKeyringFactory, - ImportedDerivationPath, Keyring, KeyringFactory, LedgerKeyring, @@ -58,50 +60,44 @@ export class BlockchainKeyring { public async initFromMnemonic( mnemonic: string, - derivationPath: DerivationPath, - accountIndices: Array + derivationPaths: Array ): Promise> { // Initialize keyrings. - this.hdKeyring = this.hdKeyringFactory.fromMnemonic( - mnemonic, - derivationPath, - accountIndices - ); + this.hdKeyring = this.hdKeyringFactory.init(mnemonic, derivationPaths); // Empty ledger keyring to hold one off ledger imports - this.ledgerKeyring = this.ledgerKeyringFactory.fromAccounts([]); + this.ledgerKeyring = this.ledgerKeyringFactory.init([]); // Empty imported keyring to hold imported secret keys - this.importedKeyring = this.keyringFactory.fromSecretKeys([]); - this.activeWallet = this.hdKeyring.getPublicKey(accountIndices[0]); + this.importedKeyring = this.keyringFactory.init([]); + this.activeWallet = this.hdKeyring.publicKeys()[0]; this.deletedWallets = []; // Persist a given name for this wallet. const newAccounts: Array<[string, string]> = []; - for (const index of accountIndices) { - const name = DefaultKeyname.defaultDerived(index); - const pubkey = this.hdKeyring.getPublicKey(index); - await store.setKeyname(pubkey, name); - newAccounts.push([pubkey, name]); + for (const [index, publicKey] of this.hdKeyring.publicKeys().entries()) { + const name = DefaultKeyname.defaultDerived(index + 1); + await store.setKeyname(publicKey, name); + newAccounts.push([publicKey, name]); } return newAccounts; } public async initFromLedger( - accounts: Array + walletDescriptors: Array ): Promise> { // Empty ledger keyring to hold one off ledger imports - this.ledgerKeyring = this.ledgerKeyringFactory.fromAccounts(accounts); + this.ledgerKeyring = this.ledgerKeyringFactory.init(walletDescriptors); // Empty imported keyring to hold imported secret keys - this.importedKeyring = this.keyringFactory.fromSecretKeys([]); - this.activeWallet = accounts[0].publicKey; + this.importedKeyring = this.keyringFactory.init([]); + this.activeWallet = this.ledgerKeyring.publicKeys()[0]; this.deletedWallets = []; // Persist a given name for this wallet. const newAccounts: Array<[string, string]> = []; - for (const account of accounts) { - const name = DefaultKeyname.defaultLedger(account.account); - await store.setKeyname(account.publicKey, name); - await store.setIsCold(account.publicKey, true); - newAccounts.push([account.publicKey, name]); + for (const [index, walletDescriptor] of walletDescriptors.entries()) { + const name = DefaultKeyname.defaultLedger(index + 1); + await store.setKeyname(walletDescriptor.publicKey, name); + await store.setIsCold(walletDescriptor.publicKey, true); + newAccounts.push([walletDescriptor.publicKey, name]); } return newAccounts; } @@ -122,21 +118,35 @@ export class BlockchainKeyring { return this.hdKeyring!.mnemonic; } - public derivationPath(): string { - return this.hdKeyring!.derivationPath; + public async deriveNextKey(): Promise<{ + publicKey: string; + derivationPath: string; + name: string; + }> { + const { publicKey, derivationPath } = this.hdKeyring!.deriveNextKey(); + // Save a default name. + const name = DefaultKeyname.defaultDerived( + this.hdKeyring!.publicKeys().length + ); + await store.setKeyname(publicKey, name); + return { publicKey, derivationPath, name }; } - public async importAccountIndex( - _accountIndex?: number - ): Promise<[string, string, number]> { - const [publicKey, accountIndex] = - this.hdKeyring!.importAccountIndex(_accountIndex); + public async addDerivationPath( + derivationPath: string + ): Promise<{ publicKey: string; name: string }> { + const publicKey = this.hdKeyring!.addDerivationPath(derivationPath); // Save a default name. - const name = DefaultKeyname.defaultDerived(accountIndex); + const name = DefaultKeyname.defaultDerived( + this.hdKeyring!.publicKeys().length + ); await store.setKeyname(publicKey, name); - return [publicKey, name, accountIndex]; + return { + publicKey, + name, + }; } public async importSecretKey( @@ -169,7 +179,6 @@ export class BlockchainKeyring { ); throw new Error("public key not found"); } - keyring.deletePublicKey(publicKey); } diff --git a/packages/blockchains/keyring/src/ledger.ts b/packages/blockchains/keyring/src/ledger.ts index 2ec0c2f54..743ad3b29 100644 --- a/packages/blockchains/keyring/src/ledger.ts +++ b/packages/blockchains/keyring/src/ledger.ts @@ -1,40 +1,37 @@ +import type { WalletDescriptor } from "@coral-xyz/common"; import { generateUniqueId, LEDGER_INJECTED_CHANNEL_REQUEST, LEDGER_INJECTED_CHANNEL_RESPONSE, } from "@coral-xyz/common"; -import type { ImportedDerivationPath, LedgerKeyringJson } from "./types"; +import type { LedgerKeyringJson } from "./types"; export class LedgerKeyringBase { - protected derivationPaths: Array; + protected walletDescriptors: Array; - constructor(derivationPaths: Array) { - this.derivationPaths = derivationPaths; - } - - public keyCount(): number { - return this.derivationPaths.length; + constructor(walletDescriptors: Array) { + this.walletDescriptors = walletDescriptors; } public deletePublicKey(publicKey: string) { - this.derivationPaths = this.derivationPaths.filter( - (dp) => dp.publicKey !== publicKey + this.walletDescriptors = this.walletDescriptors.filter( + (x) => x.publicKey !== publicKey ); } - public async ledgerImport(path: string, account: number, publicKey: string) { - const found = this.derivationPaths.find( - ({ publicKey: pk }) => publicKey === pk + public async add(walletDescriptor: WalletDescriptor) { + const found = this.walletDescriptors.find( + (x) => x.publicKey === walletDescriptor.publicKey ); if (found) { throw new Error("ledger account already exists"); } - this.derivationPaths.push({ path, account, publicKey }); + this.walletDescriptors.push(walletDescriptor); } public publicKeys(): Array { - return this.derivationPaths.map((dp) => dp.publicKey); + return this.walletDescriptors.map((x) => x.publicKey); } exportSecretKey(): string | null { @@ -47,14 +44,13 @@ export class LedgerKeyringBase { public toString(): string { return JSON.stringify({ - // TODO: does this need to be plural? - derivationPath: this.derivationPaths, + walletDescriptors: this.walletDescriptors, }); } public toJson(): LedgerKeyringJson { return { - derivationPaths: this.derivationPaths, + walletDescriptors: this.walletDescriptors, }; } @@ -72,7 +68,7 @@ export class LedgerKeyringBase { ...req, }, }; - postMessageToIframe(msg); + postMessageToIframe(msg, true); }); } } @@ -82,7 +78,8 @@ export class LedgerKeyringBase { * @param message object with message data */ export const postMessageToIframe = ( - message: Record & { type: any } + message: Record & { type: any }, + requiresFocus = false ) => { globalThis.clients .matchAll({ @@ -93,7 +90,9 @@ export const postMessageToIframe = ( }) .then((clients) => { clients.forEach((client) => { - client.postMessage(message); + if (!requiresFocus || client.focused) { + client.postMessage(message); + } }); }); }; diff --git a/packages/blockchains/keyring/src/types.ts b/packages/blockchains/keyring/src/types.ts index 469361b03..b059388ae 100644 --- a/packages/blockchains/keyring/src/types.ts +++ b/packages/blockchains/keyring/src/types.ts @@ -1,23 +1,21 @@ import type { - DerivationPath, HdKeyringJson, - ImportedDerivationPath, KeyringJson, LedgerKeyringJson, + WalletDescriptor, } from "@coral-xyz/common"; import type { LedgerKeyringBase } from "./ledger"; export type { HdKeyringJson, - ImportedDerivationPath, KeyringJson, LedgerKeyringJson, } from "@coral-xyz/common"; export interface KeyringFactory { + init(secretKeys: Array): Keyring; fromJson(payload: KeyringJson): Keyring; - fromSecretKeys(secretKeys: Array): Keyring; } export interface Keyring { @@ -34,33 +32,29 @@ export interface Keyring { // HD keyring types // export interface HdKeyringFactory { - fromMnemonic( - mnemonic: string, - derivationPath?: DerivationPath, - accountIndices?: Array - ): HdKeyring; + init(mnemonic: string, derivationPaths: Array): HdKeyring; fromJson(obj: HdKeyringJson): HdKeyring; } export interface HdKeyring extends Keyring { readonly mnemonic: string; - readonly derivationPath: string; - importAccountIndex(accountIndex?: number): [string, number]; - getPublicKey(accountIndex: number): string; + addDerivationPath(derivationPath: string): string; + deriveNextKey(): { + publicKey: string; + derivationPath: string; + }; } // // Ledger keyring types // - export interface LedgerKeyringFactory { - fromAccounts(accounts: Array): LedgerKeyring; + init(walletDescriptors: Array): LedgerKeyring; fromJson(obj: LedgerKeyringJson): LedgerKeyring; } export interface LedgerKeyring extends LedgerKeyringBase { signTransaction(tx: Buffer, address: string): Promise; signMessage(tx: Buffer, address: string): Promise; - keyCount(): number; - ledgerImport(path: string, account: number, publicKey: string): Promise; + add(walletDescriptor: WalletDescriptor): Promise; } diff --git a/packages/blockchains/solana/src/keyring/index.ts b/packages/blockchains/solana/src/keyring/index.ts index bce99ad83..5be0a78ed 100644 --- a/packages/blockchains/solana/src/keyring/index.ts +++ b/packages/blockchains/solana/src/keyring/index.ts @@ -2,7 +2,6 @@ import type { HdKeyring, HdKeyringFactory, HdKeyringJson, - ImportedDerivationPath, Keyring, KeyringFactory, KeyringJson, @@ -10,8 +9,11 @@ import type { LedgerKeyringJson, } from "@coral-xyz/blockchain-keyring"; import { LedgerKeyringBase } from "@coral-xyz/blockchain-keyring"; +import type { WalletDescriptor } from "@coral-xyz/common"; import { - DerivationPath, + Blockchain, + derivationPathsToIndexes, + getIndexedPath, LEDGER_METHOD_SOLANA_SIGN_MESSAGE, LEDGER_METHOD_SOLANA_SIGN_TRANSACTION, } from "@coral-xyz/common"; @@ -20,21 +22,18 @@ import { mnemonicToSeedSync, validateMnemonic } from "bip39"; import * as bs58 from "bs58"; import nacl from "tweetnacl"; -import { deriveSolanaKeypair, deriveSolanaKeypairs } from "../util"; +import { deriveSolanaKeypair } from "../util"; export class SolanaKeyringFactory implements KeyringFactory { - /** - * - */ - public fromJson(payload: KeyringJson): SolanaKeyring { - const keypairs = payload.secretKeys.map((secret: string) => + public init(secretKeys: Array): SolanaKeyring { + const keypairs = secretKeys.map((secret: string) => Keypair.fromSecretKey(Buffer.from(secret, "hex")) ); return new SolanaKeyring(keypairs); } - public fromSecretKeys(secretKeys: Array): SolanaKeyring { - const keypairs = secretKeys.map((secret: string) => + public fromJson(payload: KeyringJson): SolanaKeyring { + const keypairs = payload.secretKeys.map((secret: string) => Keypair.fromSecretKey(Buffer.from(secret, "hex")) ); return new SolanaKeyring(keypairs); @@ -96,128 +95,148 @@ class SolanaKeyring implements Keyring { } export class SolanaHdKeyringFactory implements HdKeyringFactory { - public fromMnemonic( + public init( mnemonic: string, - derivationPath?: DerivationPath, - accountIndices: Array = [0] + derivationPaths: Array, + accountIndex?: number, + walletIndex?: number ): HdKeyring { - if (!derivationPath) { - derivationPath = DerivationPath.Default; - } if (!validateMnemonic(mnemonic)) { throw new Error("Invalid seed words"); } - const seed = mnemonicToSeedSync(mnemonic); - const keypairs = deriveSolanaKeypairs(seed, derivationPath, accountIndices); return new SolanaHdKeyring({ mnemonic, - seed, - accountIndices, - keypairs, - derivationPath, + seed: mnemonicToSeedSync(mnemonic), + derivationPaths, + accountIndex, + walletIndex, }); } - public fromJson(obj: HdKeyringJson): HdKeyring { - const { mnemonic, seed: seedStr, accountIndices, derivationPath } = obj; - const seed = Buffer.from(seedStr, "hex"); - const keypairs = deriveSolanaKeypairs(seed, derivationPath, accountIndices); + public fromJson({ + mnemonic, + seed, + derivationPaths, + accountIndex, + walletIndex, + }: HdKeyringJson): HdKeyring { return new SolanaHdKeyring({ mnemonic, - seed, - derivationPath, - keypairs, - accountIndices, + seed: Buffer.from(seed, "hex"), + derivationPaths, + accountIndex, + walletIndex, }); } } class SolanaHdKeyring extends SolanaKeyring implements HdKeyring { readonly mnemonic: string; - readonly derivationPath: DerivationPath; private seed: Buffer; - // Invariant: the order of these indices *must* match the order of these - // super classes' keypairs. - private accountIndices: Array; + private derivationPaths: Array; + private accountIndex?: number; + private walletIndex?: number; constructor({ mnemonic, seed, - accountIndices, - keypairs, - derivationPath, + derivationPaths, + accountIndex, + walletIndex, }: { mnemonic: string; seed: Buffer; - keypairs: Array; - derivationPath: DerivationPath; - accountIndices: Array; + derivationPaths: Array; + accountIndex?: number; + walletIndex?: number; }) { + const keypairs = derivationPaths.map((d) => deriveSolanaKeypair(seed, d)); super(keypairs); this.mnemonic = mnemonic; this.seed = seed; - this.derivationPath = derivationPath; - this.accountIndices = accountIndices; + this.derivationPaths = derivationPaths; + this.accountIndex = accountIndex; + this.walletIndex = walletIndex; } public deletePublicKey(publicKey: string) { - const idx = this.keypairs.findIndex( + const index = this.keypairs.findIndex( (kp) => kp.publicKey.toString() === publicKey ); - if (idx < 0) { + if (index < 0) { return; } - this.accountIndices = this.accountIndices - .slice(0, idx) - .concat(this.accountIndices.slice(idx + 1)); + this.derivationPaths = this.derivationPaths + .slice(0, index) + .concat(this.derivationPaths.slice(index + 1)); super.deletePublicKey(publicKey); } - /** - * Import a new wallet using an account index. if the account index is not - * given the next available account index is used. - */ - public importAccountIndex(accountIndex?: number): [string, number] { - if (accountIndex === undefined) { - accountIndex = Math.max(...this.accountIndices) + 1; - } - const kp = deriveSolanaKeypair( - this.seed.toString("hex"), - accountIndex, - this.derivationPath + public deriveNextKey(): { + publicKey: string; + derivationPath: string; + } { + this.ensureIndices(); + // Move to the next wallet index for the derivation + this.walletIndex! += 1; + const derivationPath = getIndexedPath( + Blockchain.SOLANA, + this.accountIndex, + this.walletIndex ); - this.keypairs.push(kp); - this.accountIndices.push(accountIndex); - return [kp.publicKey.toString(), accountIndex]; + if (this.derivationPaths.includes(derivationPath)) { + // This key is already included for some reason, try again with + // incremented walletIndex + return this.deriveNextKey(); + } + const publicKey = this.addDerivationPath(derivationPath); + return { + publicKey, + derivationPath, + }; } - public getPublicKey(accountIndex: number): string { - // This might not be true once we implement account deletion. - // One solution is to simply make that a UI detail. - if (this.keypairs.length !== this.accountIndices.length) { - throw new Error("invariant violation"); + public addDerivationPath(derivationPath: string): string { + const keypair = deriveSolanaKeypair(this.seed, derivationPath); + if (!this.derivationPaths.includes(derivationPath)) { + // Don't persist duplicate public keys + this.keypairs.push(keypair); + this.derivationPaths.push(derivationPath); + } + return keypair.publicKey.toString(); + } + + // TODO duplicated in the evm keyring + ensureIndices() { + // If account index and wallet index don't exist, make a best guess based + // on the existing derivation paths for the keyring + if (this.accountIndex === undefined || this.walletIndex === undefined) { + const { accountIndex, walletIndex } = derivationPathsToIndexes( + this.derivationPaths + ); + if (!this.accountIndex) this.accountIndex = accountIndex; + if (!this.walletIndex) this.walletIndex = walletIndex; } - const kp = this.keypairs[this.accountIndices.indexOf(accountIndex)]; - return kp.publicKey.toString(); } public toJson(): HdKeyringJson { return { mnemonic: this.mnemonic, seed: this.seed.toString("hex"), - accountIndices: this.accountIndices, - derivationPath: this.derivationPath, + derivationPaths: this.derivationPaths, + accountIndex: this.accountIndex, + walletIndex: this.walletIndex, }; } } export class SolanaLedgerKeyringFactory { - public fromAccounts(accounts: Array): LedgerKeyring { - return new SolanaLedgerKeyring(accounts); + public init(walletDescriptors: Array): LedgerKeyring { + return new SolanaLedgerKeyring(walletDescriptors); } public fromJson(obj: LedgerKeyringJson): LedgerKeyring { - return new SolanaLedgerKeyring(obj.derivationPaths); + return new SolanaLedgerKeyring(obj.walletDescriptors); } } @@ -225,30 +244,35 @@ export class SolanaLedgerKeyring extends LedgerKeyringBase implements LedgerKeyring { - public async signTransaction(tx: Buffer, address: string): Promise { - const path = this.derivationPaths.find((p) => p.publicKey === address); - if (!path) { + public async signTransaction(tx: Buffer, publicKey: string): Promise { + const walletDescriptor = this.walletDescriptors.find( + (p) => p.publicKey === publicKey + ); + if (!walletDescriptor) { throw new Error("ledger address not found"); } return await this.request({ method: LEDGER_METHOD_SOLANA_SIGN_TRANSACTION, - params: [bs58.encode(tx), path.path, path.account], + params: [ + bs58.encode(tx), + walletDescriptor.derivationPath.replace("m/", ""), + ], }); } - public async signMessage(msg: Buffer, address: string): Promise { - const path = this.derivationPaths.find((p) => p.publicKey === address); - if (!path) { - throw new Error("ledger address not found"); + public async signMessage(msg: Buffer, publicKey: string): Promise { + const walletDescriptor = this.walletDescriptors.find( + (p) => p.publicKey === publicKey + ); + if (!walletDescriptor) { + throw new Error("ledger public key not found"); } return await this.request({ method: LEDGER_METHOD_SOLANA_SIGN_MESSAGE, - params: [bs58.encode(msg), path.path, path.account], + params: [ + bs58.encode(msg), + walletDescriptor.derivationPath.replace("m/", ""), + ], }); } - - public static fromString(str: string): SolanaLedgerKeyring { - const { derivationPaths } = JSON.parse(str); - return new SolanaLedgerKeyring(derivationPaths); - } } diff --git a/packages/blockchains/solana/src/util.ts b/packages/blockchains/solana/src/util.ts index a42bebde6..c71c569f1 100644 --- a/packages/blockchains/solana/src/util.ts +++ b/packages/blockchains/solana/src/util.ts @@ -1,60 +1,20 @@ -import { DerivationPath } from "@coral-xyz/common"; import { Keypair } from "@solana/web3.js"; import * as bip32 from "bip32"; import { derivePath } from "ed25519-hd-key"; import nacl from "tweetnacl"; -export function deriveSolanaKeypairs( - seed: Buffer, - derivationPath: DerivationPath, - accountIndices: Array -): Array { - const kps: Array = []; - const seedHex = seed.toString("hex"); - for (const accountIndex of accountIndices) { - const kp = deriveSolanaKeypair(seedHex, accountIndex, derivationPath); - kps.push(kp); - } - return kps; -} - // Returns the account Keypair for the given seed and derivation path. export function deriveSolanaKeypair( - seedHex: string, - accountIndex: number, - derivationPath: DerivationPath + seed: Buffer, + derivationPath: string ): Keypair { - let dSeed = deriveSeed(seedHex, derivationPath, accountIndex); - const secret = nacl.sign.keyPair.fromSeed(dSeed).secretKey; - return Keypair.fromSecretKey(secret); -} - -function deriveSeed( - seedHex: string, - derivationPath: DerivationPath, - accountIndex: number -): any { - const pathStr = derivePathStr(derivationPath, accountIndex); - switch (derivationPath) { - case DerivationPath.SolletDeprecated: - return bip32.fromSeed(Buffer.from(seedHex, "hex")).derivePath(pathStr) - .privateKey; - default: - return derivePath(pathStr, seedHex).key; - } -} - -function derivePathStr(derivationPath: DerivationPath, accountIndex: number) { - switch (derivationPath) { - case DerivationPath.Bip44: - return accountIndex === 0 - ? `m/44'/501'` - : `m/44'/501'/${accountIndex - 1}'`; - case DerivationPath.Bip44Change: - return `m/44'/501'/${accountIndex}'/0'`; - case DerivationPath.SolletDeprecated: - return `m/501'/${accountIndex}'/0/0`; - default: - throw new Error(`invalid derivation path: ${derivationPath}`); + let derivedSeed: Buffer; + if (derivationPath.startsWith("501'")) { + // Sollet deprecated path + derivedSeed = bip32.fromSeed(seed).derivePath(derivationPath).privateKey!; + } else { + derivedSeed = derivePath(derivationPath, seed.toString("hex")).key; } + const secret = nacl.sign.keyPair.fromSeed(derivedSeed).secretKey; + return Keypair.fromSecretKey(secret); } From c135d25b93199c6e4b13bc169042ccdd51ecf284 Mon Sep 17 00:00:00 2001 From: mj221 Date: Fri, 3 Feb 2023 13:51:23 +1000 Subject: [PATCH 11/36] WIP Merge branch 'master' of https://github.com/mjLabrys/backpack into mj/domain-content-resolver-revised --- .../chat-sdk/src/components/Attatchment.tsx | 8 +- packages/chat-sdk/src/components/ChatRoom.tsx | 9 +- .../chat-sdk/src/components/EmojiPicker.tsx | 12 +- .../src/components/FullScreenChat.tsx | 146 ++++++++----- .../chat-sdk/src/components/GifPicker.tsx | 12 +- .../chat-sdk/src/components/MediaContent.tsx | 87 +++++--- packages/chat-sdk/src/components/Message.tsx | 58 +++-- .../src/components/ReplyContainer.tsx | 20 +- .../src/components/SecureTransfer.tsx | 19 +- .../chat-sdk/src/components/SendMessage.tsx | 185 ++++++++-------- .../components/messageInput/MessageInput.tsx | 113 ++++------ .../messageInput/MessageInputProvider.tsx | 53 ++++- packages/common-public/src/types.ts | 2 + packages/common/package.json | 1 + packages/common/scripts/config.sh | 2 + packages/common/src/browser/extension.ts | 12 +- packages/common/src/channel/plugin.ts | 7 +- packages/common/src/constants.ts | 6 +- packages/common/src/crypto.ts | 199 ++++++++++++++---- packages/common/src/feature-gates.ts | 2 + packages/common/src/index.ts | 7 + packages/common/src/messages/toServer.ts | 2 + packages/common/src/notifications.ts | 1 + packages/common/src/plugin.ts | 31 +-- packages/common/src/solana/index.ts | 30 +-- packages/common/src/solana/programs/token.ts | 5 +- packages/common/src/solana/programs/xnft.ts | 40 +++- packages/common/src/types.ts | 34 +-- packages/db/src/api/RecoilSync.tsx | 43 ++++ packages/db/src/api/users.ts | 10 +- packages/ledger-injection/src/index.ts | 50 ++--- .../src/ParentCommunicationManager.ts | 7 +- 32 files changed, 771 insertions(+), 442 deletions(-) diff --git a/packages/chat-sdk/src/components/Attatchment.tsx b/packages/chat-sdk/src/components/Attatchment.tsx index 1cc616c74..a02b98969 100644 --- a/packages/chat-sdk/src/components/Attatchment.tsx +++ b/packages/chat-sdk/src/components/Attatchment.tsx @@ -34,7 +34,13 @@ export const Attatchment = ({ > { hiddenInputRef.current.click(); }} diff --git a/packages/chat-sdk/src/components/ChatRoom.tsx b/packages/chat-sdk/src/components/ChatRoom.tsx index 4006e66f0..e79a89a6c 100644 --- a/packages/chat-sdk/src/components/ChatRoom.tsx +++ b/packages/chat-sdk/src/components/ChatRoom.tsx @@ -1,9 +1,6 @@ -import React, { useEffect, useLayoutEffect, useRef, useState } from "react"; -import type { - EnrichedMessageWithMetadata, - SubscriptionType, -} from "@coral-xyz/common"; -import { EnrichedMessage, SUBSCRIBE, UNSUBSCRIBE } from "@coral-xyz/common"; +import { useEffect, useLayoutEffect, useRef, useState } from "react"; +import type { SubscriptionType } from "@coral-xyz/common"; +import { SUBSCRIBE } from "@coral-xyz/common"; import { refreshChatsFor, SignalingManager, diff --git a/packages/chat-sdk/src/components/EmojiPicker.tsx b/packages/chat-sdk/src/components/EmojiPicker.tsx index ac891f6ae..b7ff6cf11 100644 --- a/packages/chat-sdk/src/components/EmojiPicker.tsx +++ b/packages/chat-sdk/src/components/EmojiPicker.tsx @@ -1,6 +1,6 @@ import { useState } from "react"; import { useCustomTheme } from "@coral-xyz/themes"; -import SentimentVerySatisfiedIcon from "@mui/icons-material/SentimentVerySatisfied"; +import InsertEmoticonIcon from "@mui/icons-material/InsertEmoticonRounded"; import { IconButton } from "@mui/material"; import Popover from "@mui/material/Popover"; import EmojiPicker, { Theme } from "emoji-picker-react"; @@ -28,7 +28,13 @@ export const EmojiPickerComponent = ({ > { setEmojiPicker((x) => !x); if (!emojiPicker) { @@ -38,7 +44,7 @@ export const EmojiPickerComponent = ({ }} > {" "} - {" "} diff --git a/packages/chat-sdk/src/components/FullScreenChat.tsx b/packages/chat-sdk/src/components/FullScreenChat.tsx index 294a9a181..04b4d3f58 100644 --- a/packages/chat-sdk/src/components/FullScreenChat.tsx +++ b/packages/chat-sdk/src/components/FullScreenChat.tsx @@ -1,12 +1,12 @@ import { useEffect, useRef, useState } from "react"; -import Dropzone from "react-dropzone"; +import { useDropzone } from "react-dropzone"; import type { EnrichedMessageWithMetadata } from "@coral-xyz/common"; import { BACKEND_API_URL } from "@coral-xyz/common"; -import { fetchMoreChatsFor, Loading } from "@coral-xyz/react-common"; +import { fetchMoreChatsFor } from "@coral-xyz/react-common"; import { useCustomTheme } from "@coral-xyz/themes"; -import { Loader } from "@giphy/react-components"; import ArrowDownwardIcon from "@mui/icons-material/ArrowDownward"; -import { CircularProgress } from "@mui/material"; +import FileUploadIcon from "@mui/icons-material/FileUploadRounded"; +import { CircularProgress, Typography } from "@mui/material"; import { base64ToArrayBuffer } from "../utils/imageUploadUtils"; @@ -39,6 +39,13 @@ export const FullScreenChat = ({ const [uploadingFile, setUploadingFile] = useState(false); const [uploadedImageUri, setUploadedImageUri] = useState(""); + const { getRootProps, getInputProps, isDragAccept } = useDropzone({ + onDrop: (files) => { + const selectedFile = files[0]; + onMediaSelect(selectedFile); + }, + }); + useEffect(() => { if (messageRef && autoScroll) { if ( @@ -95,20 +102,18 @@ export const FullScreenChat = ({ return (
event.stopPropagation(), + style: { + display: "flex", + flexFlow: "column", + height: "100%", + background: theme.custom.colors.chatFadeGradient, + }, + })} > -
+ {isDragAccept && } +
{ // @ts-ignore @@ -158,47 +163,31 @@ export const FullScreenChat = ({ } }} setRef={setMessageRef} - height={"calc(100% - 40px)"} + height={"calc(100% - 50px)"} >
- { - const selectedFile = files[0]; - onMediaSelect(selectedFile); - }} - > - {({ getRootProps, getInputProps, isFocused }) => ( -
event.stopPropagation(), - })} - > - -
- {fetchingMoreChats && ( -
- {" "} - {" "} -
- )} - - {loading && } - {!loading && chats?.length === 0 && } - {!loading && chats?.length !== 0 && } +
+ +
+ {fetchingMoreChats && ( +
+ {" "} + {" "}
-
- )} - + )} + + {loading && } + {!loading && chats?.length === 0 && } + {!loading && chats?.length !== 0 && } +
+
@@ -261,3 +250,50 @@ export const FullScreenChat = ({
); }; + +function DropzonePopup() { + const theme = useCustomTheme(); + return ( +
+
+ + + Upload + + + Drop photos, GIFs, and videos anywhere to upload. + +
+
+ ); +} diff --git a/packages/chat-sdk/src/components/GifPicker.tsx b/packages/chat-sdk/src/components/GifPicker.tsx index f7029ac2d..6f74b2d83 100644 --- a/packages/chat-sdk/src/components/GifPicker.tsx +++ b/packages/chat-sdk/src/components/GifPicker.tsx @@ -2,8 +2,8 @@ import { useEffect, useState } from "react"; import { TextInput } from "@coral-xyz/react-common"; import { styles, useCustomTheme } from "@coral-xyz/themes"; import { GiphyFetch } from "@giphy/js-fetch-api"; -import { Carousel, SearchContextManager } from "@giphy/react-components"; -import GifIcon from "@mui/icons-material/Gif"; +import { Carousel } from "@giphy/react-components"; +import GifIcon from "@mui/icons-material/GifBoxOutlined"; import SearchIcon from "@mui/icons-material/Search"; import { IconButton } from "@mui/material"; import InputAdornment from "@mui/material/InputAdornment"; @@ -73,7 +73,13 @@ export const GifPicker = ({ > { setGifPicker((x) => !x); if (!gifPicker) { diff --git a/packages/chat-sdk/src/components/MediaContent.tsx b/packages/chat-sdk/src/components/MediaContent.tsx index e31467261..5caba959f 100644 --- a/packages/chat-sdk/src/components/MediaContent.tsx +++ b/packages/chat-sdk/src/components/MediaContent.tsx @@ -1,9 +1,10 @@ -import React, { useState } from "react"; +import { useState } from "react"; import { useBreakpoints } from "@coral-xyz/app-extension/src/components/common/Layout/hooks"; import { useCustomTheme } from "@coral-xyz/themes"; +import CloseIcon from "@mui/icons-material/Close"; import DownloadIcon from "@mui/icons-material/Download"; import OpenInFullIcon from "@mui/icons-material/OpenInFull"; -import { Box, Modal, Typography } from "@mui/material"; +import { Modal } from "@mui/material"; export const MediaContent = ({ mediaLink, @@ -19,26 +20,46 @@ export const MediaContent = ({ return ( <> {modalOpen && ( - setModalOpen(false)}> - + setModalOpen(false)} + componentsProps={{ + root: { + style: { + display: "flex", + flexDirection: "column", + justifyContent: "space-between", + alignItems: "center", + padding: "0 10px", + height: "100vh", + gap: 4, + }, + }, + backdrop: { + style: { + background: "rgba(24, 24, 27, 0.9)", + backdropFilter: "blur(5px)", + }, + }, + }} + > + <> + setModalOpen(false)} + /> {mediaKind === "video" ? ( - + setModalOpen(false)} + /> + + )}
diff --git a/packages/chat-sdk/src/components/Message.tsx b/packages/chat-sdk/src/components/Message.tsx index a7a876dcd..7530fa2da 100644 --- a/packages/chat-sdk/src/components/Message.tsx +++ b/packages/chat-sdk/src/components/Message.tsx @@ -1,11 +1,11 @@ -import React, { useCallback, useEffect, useState } from "react"; +import { useCallback, useEffect, useState } from "react"; import { BACKEND_API_URL, Blockchain, NAV_COMPONENT_MESSAGE_PROFILE, NEW_COLORS, } from "@coral-xyz/common"; -import { refreshIndividualChatsFor } from "@coral-xyz/react-common"; +import { LocalImage, refreshIndividualChatsFor } from "@coral-xyz/react-common"; import { blockchainTokenData, SOL_LOGO_URI, @@ -52,7 +52,7 @@ const useStyles = makeStyles((theme: any) => width: "100%", textAlign: "left", fontSize: "14px", - color: theme.custom.colors.fontColor2, + color: theme.custom.colors.fontColor, }, messageContent: { padding: 0, @@ -66,10 +66,11 @@ const useStyles = makeStyles((theme: any) => minWidth: 63, display: "flex", flexDirection: "row-reverse", + opacity: 0.5, }, avatar: { - width: 40, - height: 40, + width: 32, + height: 32, cursor: "pointer", borderRadius: "50%", }, @@ -232,7 +233,7 @@ export const MessageLine = (props) => {
@@ -316,22 +317,38 @@ export const MessageLine = (props) => {
) : ( <> - {photoURL ? ( - openProfilePage({ uuid: props.uuid })} - alt={displayName} - className={classes.avatar} - src={`${photoURL}?size=25`} - > - ) : ( - - )} +
+ {photoURL ? ( + openProfilePage({ uuid: props.uuid })} + alt={displayName} + className={classes.avatar} + style={{ width: 32, height: 32 }} + src={photoURL} + > + ) : ( + + )} +
openProfilePage({ uuid: props.uuid })} className={classes.displayName} style={{ + display: "inline-flex", + paddingBottom: "4px", color: props.colorIndex || props.colorIndex === 0 ? NEW_COLORS[props.colorIndex || 0][ @@ -345,8 +362,8 @@ export const MessageLine = (props) => { `@${displayName}` ) : ( )} @@ -724,11 +741,13 @@ export function ChatMessages() { {chats.map((chat, index) => { return ( 0 && index < chats.length && - chats[index]?.username === chats[index - 1]?.username + chats[index]?.uuid === chats[index - 1]?.uuid } parent_message_author_username={chat.parent_message_author_username} parent_message_text={chat.parent_message_text} @@ -737,7 +756,6 @@ export function ChatMessages() { color={chat.color || theme.custom.colors.fontColor2} colorIndex={chat.colorIndex} timestamp={chat.created_at} - key={chat.client_generated_uuid} message={chat.message} messageKind={chat.message_kind} image={chat.image} diff --git a/packages/chat-sdk/src/components/ReplyContainer.tsx b/packages/chat-sdk/src/components/ReplyContainer.tsx index 2fda5f8ec..24402f10b 100644 --- a/packages/chat-sdk/src/components/ReplyContainer.tsx +++ b/packages/chat-sdk/src/components/ReplyContainer.tsx @@ -1,4 +1,3 @@ -import React from "react"; import Close from "@mui/icons-material/Close"; import { createStyles, makeStyles } from "@mui/styles"; @@ -19,6 +18,12 @@ const useStyles = makeStyles((theme: any) => color: theme.custom.colors.icon, width: "0.8em", }, + replyTo: { + color: theme.custom.colors.fontColor3, + fontWeight: 500, + fontSize: 14, + marginBottom: 8, + }, }) ); @@ -31,8 +36,8 @@ export const ReplyContainer = ({ align = "left", }) => { const { setActiveReply } = useChatContext(); - const classes = useStyles(); + return (
-
- Replying to {parent_username || ""} +
+ Replying to{" "} + {parent_username || ""}
diff --git a/packages/chat-sdk/src/components/SecureTransfer.tsx b/packages/chat-sdk/src/components/SecureTransfer.tsx index fb9a70516..f18ff171a 100644 --- a/packages/chat-sdk/src/components/SecureTransfer.tsx +++ b/packages/chat-sdk/src/components/SecureTransfer.tsx @@ -18,19 +18,17 @@ import { useActiveSolanaWallet, useAnchorContext, useBackgroundClient, - useBlockchainTokenAccount, useLoader, } from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; +import AttachMoneyIcon from "@mui/icons-material/AttachMoney"; import CheckIcon from "@mui/icons-material/Check"; -import MonetizationOnIcon from "@mui/icons-material/MonetizationOn"; import { IconButton } from "@mui/material"; import Backdrop from "@mui/material/Backdrop"; import Box from "@mui/material/Box"; import Modal from "@mui/material/Modal"; import Typography from "@mui/material/Typography"; import { LAMPORTS_PER_SOL, PublicKey } from "@solana/web3.js"; -import { BigNumber } from "ethers"; import { createEscrow } from "../utils/secure-transfer/secureTransfer"; @@ -107,11 +105,18 @@ export const SecureTransfer = ({ > - setModal(true)} + setModal(true)} /> createStyles({ outerDiv: { padding: 2, - background: theme.custom.colors.textInputBackground, + background: theme.custom.colors.listItemHover, backdropFilter: "blur(6px)", - borderTopLeftRadius: 10, - borderTopRightRadius: 10, + borderRadius: 8, + margin: 12, }, text: { color: theme.custom.colors.fontColor2, @@ -243,7 +242,10 @@ export const SendMessage = ({ return Object.keys(userMap).map((uuid) => userMap[uuid]); }; return ( - +
{selectedFile && (
@@ -323,94 +325,89 @@ export const SendMessage = ({ text={activeReply.text} /> )} - +
- <> - {emojiMenuOpen ? ( -
-
- - - - {/*{activeSolanaWallet?.publicKey && (*/} - {/* {*/} - {/* sendMessage("Secure transfer", "secure-transfer", {*/} - {/* signature,*/} - {/* counter,*/} - {/* escrow,*/} - {/* current_state: "pending",*/} - {/* });*/} - {/* }}*/} - {/* />*/} - {/*)}*/} - {/**/} - {/* {" "}*/} - {/* sendMessage(messageContent)}*/} - {/* />{" "}*/} - {/**/} -
- ) : ( -
- { - setEmojiMenuOpen(true); - }} - > - - -
- )} - +
+ { + setEmojiMenuOpen(!emojiMenuOpen); + }} + > + {emojiMenuOpen ? ( + + ) : ( + + )} + +
+ {emojiMenuOpen && ( +
+
+ + + + {activeSolanaWallet?.publicKey && ( + { + sendMessage("Secure transfer", "secure-transfer", { + signature, + counter, + escrow, + current_state: "pending", + }); + }} + /> + )} +
+ )}
); diff --git a/packages/chat-sdk/src/components/messageInput/MessageInput.tsx b/packages/chat-sdk/src/components/messageInput/MessageInput.tsx index 83b48c6c4..6c8b4a209 100644 --- a/packages/chat-sdk/src/components/messageInput/MessageInput.tsx +++ b/packages/chat-sdk/src/components/messageInput/MessageInput.tsx @@ -1,4 +1,4 @@ -import { Fragment, useContext, useEffect, useRef, useState } from "react"; +import { useContext, useMemo } from "react"; import { RichMentionsContext, RichMentionsInput } from "react-rich-mentions"; import { useUsersMetadata } from "@coral-xyz/react-common"; import { styles, useCustomTheme } from "@coral-xyz/themes"; @@ -18,16 +18,24 @@ export function MessageInput({ setEmojiMenuOpen }: { setEmojiMenuOpen: any }) { const defaultValue = ""; const classes = useStyles(); const theme = useCustomTheme(); - const { type, remoteUsername } = useChatContext(); + const { type, remoteUsername, activeReply } = useChatContext(); + const { activeSearch } = useContext(RichMentionsContext); return (
{ + if (event.key === "Enter" && activeSearch) { + event.stopPropagation(); + } + }} className={classes.input} onClick={() => setEmojiMenuOpen(false)} placeholder={ type === "individual" ? `Message @${remoteUsername}` + : activeReply?.parent_username + ? "Reply" : "Write a message..." } style={{ @@ -41,83 +49,44 @@ export function MessageInput({ setEmojiMenuOpen }: { setEmojiMenuOpen: any }) { ); } -export const CustomAutoComplete = ({ - offlineMembers, -}: { - offlineMembers: { username: string; uuid: string; image: string }[]; -}) => { +export const CustomAutoComplete = () => { const theme = useCustomTheme(); - const { loading, results, activeSearch, selectItem } = + const { loading, results, activeSearch, selectItem, index } = useContext(RichMentionsContext); + const cursor = index; + + const shownResults = useMemo(() => results, [results]); const users = useUsersMetadata({ remoteUserIds: results.map((r) => r.id) }); return (
- {activeSearch !== "" && activeSearch && activeSearch.length !== 0 && ( -
- {" "} - {offlineMembers - .filter((x) => x.username.includes(activeSearch.slice(1))) - .map((item) => ( - - ))} -
- )} - - {results - .filter((x) => !offlineMembers.map((x) => x.uuid).includes(x.id)) - .map((item, i) => ( - - ))} + {shownResults.map((item, index) => ( + + ))} {activeSearch !== "" && activeSearch && activeSearch.length !== 0 && diff --git a/packages/chat-sdk/src/components/messageInput/MessageInputProvider.tsx b/packages/chat-sdk/src/components/messageInput/MessageInputProvider.tsx index 017248440..1baf5558b 100644 --- a/packages/chat-sdk/src/components/messageInput/MessageInputProvider.tsx +++ b/packages/chat-sdk/src/components/messageInput/MessageInputProvider.tsx @@ -1,3 +1,4 @@ +import { useEffect, useState } from "react"; import { RichMentionsProvider } from "react-rich-mentions"; import { useLocation } from "react-router-dom"; import type { RemoteUserData } from "@coral-xyz/common"; @@ -5,7 +6,6 @@ import { BACKEND_API_URL } from "@coral-xyz/common"; import { useActiveSolanaWallet, useDecodedSearchParams, - useUser, } from "@coral-xyz/recoil"; import { useChatContext } from "../ChatContext"; @@ -13,14 +13,18 @@ import { useChatContext } from "../ChatContext"; export const MessageInputProvider = ({ inputRef, children, + offlineMembers, }: { inputRef: any; children: any; + offlineMembers: any[]; }) => { const pathname = useLocation().pathname; const { type, remoteUsername, remoteUserId } = useChatContext(); + const { roomId } = useChatContext(); const { props }: any = useDecodedSearchParams(); const { publicKey } = useActiveSolanaWallet(); + const [rerender, setRender] = useState(false); const configs: any = [ { query: /@([a-zA-Z0-9_-]+)?/, @@ -32,7 +36,22 @@ export const MessageInputProvider = ({ onMention: async (text) => { const search = text.substr(1); // remove '@' if (type === "individual") { - return []; + return offlineMembers + .map((x) => ({ + name: x.username, + id: x.uuid, + ref: `<@${x.username}|u${x.uuid}>`, + })) + .filter((x) => x.name.includes(search)); + } + if (search.length <= 1) { + return offlineMembers + .map((x) => ({ + name: x.username, + id: x.uuid, + ref: `<@${x.username}|u${x.uuid}>`, + })) + .filter((x) => x.name.includes(search)); } const response = await fetch( `${BACKEND_API_URL}/nft/members?room=${ @@ -47,11 +66,20 @@ export const MessageInputProvider = ({ try { const json = await response.json(); const members: RemoteUserData[] = json?.members || []; - return members.map((x) => ({ - name: x.username, - id: x.id, - ref: `<@${x.username}|u${x.id}>`, - })); + return [ + ...offlineMembers + .map((x) => ({ + name: x.username, + id: x.uuid, + ref: `<@${x.username}|u${x.uuid}>`, + })) + .filter((x) => x.name.includes(search)), + ...members.map((x) => ({ + name: x.username, + id: x.id, + ref: `<@${x.username}|u${x.id}>`, + })), + ]; } catch (e) { console.error(e); return []; @@ -60,6 +88,17 @@ export const MessageInputProvider = ({ }, ]; + useEffect(() => { + setRender(true); + setTimeout(() => { + setRender(false); + }, 10); + }, [roomId]); + + if (rerender || (offlineMembers.length && !offlineMembers[0]?.username)) { + return <>{children}; + } + return ( {children} diff --git a/packages/common-public/src/types.ts b/packages/common-public/src/types.ts index c571048df..dfa449219 100644 --- a/packages/common-public/src/types.ts +++ b/packages/common-public/src/types.ts @@ -9,6 +9,8 @@ export type Event = any; export interface XnftMetadata { isDarkMode: boolean; username?: string; + userId: string; avatarUrl: string; jwt?: string; + version: number; } diff --git a/packages/common/package.json b/packages/common/package.json index 4cd77fae2..8d6a80f52 100644 --- a/packages/common/package.json +++ b/packages/common/package.json @@ -27,6 +27,7 @@ "@solana/spl-token-registry": "^0.2.3225", "@solana/wallet-adapter-base": "^0.9.18", "@solana/web3.js": "^1.63.1", + "bip32-path": "^0.4.2", "bn.js": "^5.2.1", "bs58": "^5.0.0", "ethereum-multicall": "^2.14.1", diff --git a/packages/common/scripts/config.sh b/packages/common/scripts/config.sh index cb5f0f717..ff4ec24a9 100755 --- a/packages/common/scripts/config.sh +++ b/packages/common/scripts/config.sh @@ -36,12 +36,14 @@ main () { // Config for @coral-xyz/common. // export const BACKPACK_CONFIG_VERSION: "development" | "production" | string = "${BACKPACK_CONFIG_VERSION:=development}"; +export const BACKPACK_CONFIG_GITHUB_RUN_NUMBER: string = "${BACKPACK_CONFIG_GITHUB_RUN_NUMBER:=1}"; export const BACKPACK_CONFIG_XNFT_PROXY: "development" | "production" = "${BACKPACK_CONFIG_XNFT_PROXY:=production}"; export const BACKPACK_FEATURE_LIGHT_MODE = ${BACKPACK_FEATURE_LIGHT_MODE:=true}; export const BACKPACK_FEATURE_POP_MODE = ${BACKPACK_FEATURE_POP_MODE:=true}; export const BACKPACK_FEATURE_XNFT = ${BACKPACK_FEATURE_XNFT:=true}; export const BACKPACK_FEATURE_AGGREGATE_WALLETS = ${BACKPACK_FEATURE_AGGREGATE_WALLETS:=false}; export const BACKPACK_FEATURE_REFERRAL_FEES = ${BACKPACK_FEATURE_REFERRAL_FEES:=false}; +export const BACKPACK_FEATURE_FORCE_LATEST_VERSION = ${BACKPACK_FEATURE_FORCE_LATEST_VERSION:=false}; EOF } diff --git a/packages/common/src/browser/extension.ts b/packages/common/src/browser/extension.ts index 0a2384566..dccaede30 100644 --- a/packages/common/src/browser/extension.ts +++ b/packages/common/src/browser/extension.ts @@ -1,7 +1,6 @@ import { EXTENSION_HEIGHT, EXTENSION_WIDTH, - QUERY_COLD, QUERY_ADD_USER_ACCOUNT, QUERY_APPROVAL, QUERY_APPROVE_ALL_TRANSACTIONS, @@ -9,6 +8,7 @@ import { QUERY_APPROVE_TRANSACTION, QUERY_CONNECT_HARDWARE, QUERY_LOCKED, + QUERY_LOCKED_APPROVAL, QUERY_ONBOARDING, } from "../constants"; import type { Blockchain } from "../types"; @@ -135,25 +135,25 @@ export class BrowserRuntimeExtension { const POPUP_HTML = "popup.html"; const EXPANDED_HTML = "options.html"; -export async function openColdPopupWindow( +export async function openLockedPopupWindow( origin: string, title: string, requestId: number, - walletAddress: string + blockchain: Blockchain ): Promise { const encodedTitle = encodeURIComponent(title); - const url = `${POPUP_HTML}?${QUERY_COLD}&origin=${origin}&title=${encodedTitle}&requestId=${requestId}&wallet=${walletAddress}`; + const url = `${POPUP_HTML}?${QUERY_LOCKED}&origin=${origin}&title=${encodedTitle}&requestId=${requestId}&blockchain=${blockchain}`; return openPopupWindow(url); } -export async function openLockedPopupWindow( +export function openLockedApprovalPopupWindow( origin: string, title: string, requestId: number, blockchain: Blockchain ): Promise { const encodedTitle = encodeURIComponent(title); - const url = `${POPUP_HTML}?${QUERY_LOCKED}&origin=${origin}&title=${encodedTitle}&requestId=${requestId}&blockchain=${blockchain}`; + const url = `${POPUP_HTML}?${QUERY_LOCKED_APPROVAL}&origin=${origin}&title=${encodedTitle}&requestId=${requestId}&blockchain=${blockchain}`; return openPopupWindow(url); } diff --git a/packages/common/src/channel/plugin.ts b/packages/common/src/channel/plugin.ts index cb318251f..52b981cff 100644 --- a/packages/common/src/channel/plugin.ts +++ b/packages/common/src/channel/plugin.ts @@ -26,12 +26,13 @@ export class PluginServer { const url = new URL(this.url); if ( // TODO: hardcode allowed origin(s) - event.origin !== url.origin || - event.data.href !== url.href || + (!url.origin.startsWith("http://localhost:9933") && + (event.origin !== url.origin || event.data.href !== url.href)) || event.data.type !== this.requestChannel ) { - return; + throw new Error("Unknown Origin or channel"); } + const id = event.data.detail.id; const iframeIdentifiers = event.data.iframeIdentifiers; const [result, error] = await handlerFn(event); diff --git a/packages/common/src/constants.ts b/packages/common/src/constants.ts index a65d4a258..24e12c390 100644 --- a/packages/common/src/constants.ts +++ b/packages/common/src/constants.ts @@ -106,6 +106,8 @@ export const UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_ADD = "ui-rpc-method-blockchain-keyrings-add"; export const UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_READ = "ui-rpc-method-blockchain-keyrings-read"; +export const UI_RPC_METHOD_FIND_SIGNED_WALLET_DESCRIPTOR = + "ui-rpc-method-find-signed-public-key-path"; export const UI_RPC_METHOD_KEY_IS_COLD_UPDATE = "ui-rpc-method-key-is-cold-update"; export const UI_RPC_METHOD_KEYNAME_READ = "ui-rpc-method-keyname-read"; @@ -136,8 +138,6 @@ export const UI_RPC_METHOD_KEYRING_STORE_LOCK = "ui-rpc-method-keyring-store-lock"; export const UI_RPC_METHOD_KEYRING_STORE_MNEMONIC_CREATE = "ui-rpc-method-keyring-mnemonic-create"; -export const UI_RPC_METHOD_KEYRING_STORE_MNEMONIC_SYNC = - "ui-rpc-method-keyring-mnemonic-sync"; export const UI_RPC_METHOD_KEYRING_STORE_READ_ALL_PUBKEYS = "ui-rpc-method-keyring-read-all-pubkeys"; export const UI_RPC_METHOD_KEYRING_STORE_READ_ALL_PUBKEY_DATA = @@ -544,6 +544,7 @@ export const BACKEND_EVENT = "backend-event"; // Popup query routes. // export const QUERY_LOCKED = "locked=true"; +export const QUERY_LOCKED_APPROVAL = "locked-approval=true"; export const QUERY_APPROVAL = "approve-origin=true"; export const QUERY_APPROVE_TRANSACTION = "approve-tx=true"; export const QUERY_APPROVE_ALL_TRANSACTIONS = "approve-all-txs=true"; @@ -551,7 +552,6 @@ export const QUERY_APPROVE_MESSAGE = "approve-message=true"; export const QUERY_CONNECT_HARDWARE = "connect-hardware=true"; export const QUERY_ONBOARDING = "onboarding=true"; export const QUERY_ADD_USER_ACCOUNT = "add-user-account=true"; -export const QUERY_COLD = "cold=true"; export const SIMULATOR_PORT = 9933; diff --git a/packages/common/src/crypto.ts b/packages/common/src/crypto.ts index 45d5d6324..2f7975632 100644 --- a/packages/common/src/crypto.ts +++ b/packages/common/src/crypto.ts @@ -1,49 +1,176 @@ +import BIPPath from "bip32-path"; + +import { LOAD_PUBLIC_KEY_AMOUNT } from "./constants"; import { Blockchain } from "./types"; -export const DerivationPath: { [key: string]: DerivationPath } = { - Bip44: "bip44", - Bip44Change: "bip44-change", - SolletDeprecated: "sollet-deprecated", - Default: "bip44", +export const HARDENING = 0x80000000; + +// TODO could use SLIP44 +export const blockchainCoinType = { + [Blockchain.ETHEREUM]: 60, + [Blockchain.SOLANA]: 501, }; -export type DerivationPath = "bip44" | "bip44-change" | "sollet-deprecated"; +export const getCoinType = (blockchain: Blockchain) => { + const coinType = blockchainCoinType[blockchain]; + if (!coinType) { + throw new Error("Invalid blockchain"); + } + return coinType + HARDENING; +}; -export const derivationPathPrefix = ( +export const getBlockchainFromPath = (derivationPath: string): Blockchain => { + const coinType = BIPPath.fromString(derivationPath).toPathArray()[1]; + return Object.keys(blockchainCoinType).find( + (key) => + blockchainCoinType[key] === coinType || + blockchainCoinType[key] === coinType - HARDENING + ) as Blockchain; +}; + +export const legacyBip44Indexed = (blockchain: Blockchain, index: number) => { + const coinType = getCoinType(blockchain); + const path = [44 + HARDENING, coinType]; + if (index > 0) path.push(index - 1 + HARDENING); + return new BIPPath.fromPathArray(path).toString(); +}; + +export const legacyBip44ChangeIndexed = ( blockchain: Blockchain, - derivationPath: DerivationPath + index: number ) => { - const paths = { - [Blockchain.ETHEREUM]: { - [DerivationPath.Bip44]: "44'/60'", - [DerivationPath.Bip44Change]: "44'/60'/0'", - }, - [Blockchain.SOLANA]: { - [DerivationPath.Bip44]: "44'/501'", - [DerivationPath.Bip44Change]: "44'/501'/0'", - [DerivationPath.SolletDeprecated]: "501'/0'/0/0", - }, - }; - - if (!paths[blockchain] || !paths[blockchain][derivationPath]) { - throw new Error("derivation path prefix not found"); - } + const coinType = getCoinType(blockchain); + const path = [44 + HARDENING, coinType, index + HARDENING, 0 + HARDENING]; + return new BIPPath.fromPathArray(path).toString(); +}; - return paths[blockchain][derivationPath]; +export const legacySolletIndexed = (index: number) => { + const coinType = 501 + HARDENING; + const path = [coinType, index + HARDENING, 0, 0]; + return new BIPPath.fromPathArray(path).toString(); }; -/** - * Get the complete derivation path for an account. Note that account 0 is reindex to be the root, - * and account 1 becomes the 0th account. - */ -export const accountDerivationPath = ( +// Get the nth index account according to the Backpack derivation path scheme +export const getIndexedPath = ( blockchain: Blockchain, - derivationPath: DerivationPath, - account: number + accountIndex = 0, + walletIndex = 0 ) => { - if (account === 0) { - return derivationPathPrefix(blockchain, derivationPath); - } else { - return `${derivationPathPrefix(blockchain, derivationPath)}/${account - 1}`; - } + const coinType = getCoinType(blockchain); + const path = [ + 44 + HARDENING, + coinType, + accountIndex + HARDENING, + 0 + HARDENING, + ]; + // If walletIndex is 0, this is the same as legacyBip44ChangeIndexed + if (walletIndex > 0) path.push(walletIndex - 1 + HARDENING); + return new BIPPath.fromPathArray(path).toString(); +}; + +// +// Legacy scheme for newly created wallets +// +// m/44/501'/ and m/44/501'/{0...n} +// +export const legacyBip44RecoveryPaths = (blockchain: Blockchain) => { + return [...Array(LOAD_PUBLIC_KEY_AMOUNT).keys()].map((i) => + legacyBip44Indexed(blockchain, i) + ); +}; + +// +// Legacy scheme for newly created wallets +// +// m/44/501'/{0...n}'/0' +// +export const legacyBip44ChangeRecoveryPaths = (blockchain: Blockchain) => { + return [...Array(LOAD_PUBLIC_KEY_AMOUNT).keys()].map((i) => + legacyBip44ChangeIndexed(blockchain, i) + ); +}; + +// +// New derivation path scheme +// +export const getAccountRecoveryPaths = ( + blockchain: Blockchain, + accountIndex: number +) => { + return [...Array(LOAD_PUBLIC_KEY_AMOUNT).keys()].map((j) => + getIndexedPath(blockchain, accountIndex, j) + ); +}; + +// +// Get a sensible account and wallet index from a list of derivation paths. +// +export const derivationPathsToIndexes = ( + derivationPaths: Array +): { accountIndex: number; walletIndex: number } => { + const pathArrays = derivationPaths.map((x) => + BIPPath.fromString(x).toPathArray() + ); + const accountIndex = Math.max( + ...pathArrays + // Account index should be the element at index 2, this is not true for + // deprecated sollet paths but they are 0 anyway + .map((p: Array) => (p[2] ? p[2] : 0)) + .map((i: number) => (i >= HARDENING ? i - HARDENING : i)) + ); + const walletIndex = Math.max( + ...pathArrays + // Account index should be the element at index 2, this is not true for + // deprecated sollet paths but they are 0 anyway + .map((p: Array) => (p[4] ? p[4] + 1 : 0)) + .map((i: number) => (i >= HARDENING ? i - HARDENING : i)) + ); + return { accountIndex, walletIndex }; +}; + +export const getRecoveryPaths = (blockchain: Blockchain) => { + /** + * There is a fixed set of derivation paths we should check for wallets when + * doing recovery. + * + * Created wallets from the legacy derivation scheme used by Backpack were + * + * m/44/501'/ and m/44/501'/{0...n}' (bip44) + * + * It was possible to import and then derive more wallets from the paths: + * + * m/44/501'/ and m/44/501'/{0...n} (bip44) + * m/44/501'/{0...n}'/0' (bip44change) + * + * Under the new derivation path scheme created wallets use the derivation + * paths: + * + * 1st account: m/44/501'/, m/44/501'/0', and m/44/501'/0'/0/{0...n} + * 2nd account: m/44/501'/1'/0', and m/44/501'/1'/0'/{0...n} + * 3rd account: m/44/501'/2'/0', and m/44/501'/2'/0'/{0...n} + * etc + * + */ + // Build an array of derivation paths to search for recovery + let paths: Array = []; + // Legacy created/imported accounts (m/44/501'/ and m/44/501'/{0...n}) + paths = paths.concat(legacyBip44RecoveryPaths(blockchain)); + + // Legacy imported accounts (m/44/501'/0' and m/44/501'/0'/{0...n}) + paths = paths.concat(legacyBip44ChangeRecoveryPaths(blockchain)); + + // TODO + // How many accounts should be searched before giving up? It's possible that + // the user created up to the nth account and deleted all the rest + const numAccounts = 2; + // New derivation path scheme, search the first `LOAD_PUBLIC_KEY_AMOUNT` + // indexes on the first `numAccounts` account paths + paths = paths.concat( + [...Array(numAccounts).keys()] + .map((j) => getAccountRecoveryPaths(blockchain, j)) + .flat() + ); + + // Deduplicate and return + return [...new Set(paths)]; }; diff --git a/packages/common/src/feature-gates.ts b/packages/common/src/feature-gates.ts index 827279f0a..cddafe636 100644 --- a/packages/common/src/feature-gates.ts +++ b/packages/common/src/feature-gates.ts @@ -4,12 +4,14 @@ export const STRIPE_ENABLED = "STRIPE_ENABLED"; export const NOTIFICATIONS_ENABLED = "NOTIFICATIONS_ENABLED"; export const MESSAGES_ENABLED = "MESSAGES_ENABLED"; export const MESSAGE_IFRAME_ENABLED = "MESSAGE_IFRAME_ENABLED"; +export const OFFLINE_IMAGES = "OFFLINE_IMAGES"; export const DEFAULT_FEATURE_GATES: FEATURE_GATES_MAP = { STRIPE_ENABLED: false, NOTIFICATIONS_ENABLED: false, MESSAGES_ENABLED: true, MESSAGE_IFRAME_ENABLED: false, + OFFLINE_IMAGES: true, }; /* diff --git a/packages/common/src/index.ts b/packages/common/src/index.ts index 8a99e2324..8426c787f 100644 --- a/packages/common/src/index.ts +++ b/packages/common/src/index.ts @@ -56,6 +56,13 @@ export function walletAddressDisplay( )}`; } +export function usernameDisplay(username: string, maxLength = 8) { + if (username.length <= maxLength) { + return username; + } + return username.slice(0, maxLength - 3) + "..."; +} + /** * Message to be signed for authenticating a user. */ diff --git a/packages/common/src/messages/toServer.ts b/packages/common/src/messages/toServer.ts index 0db7c9af9..360dbc279 100644 --- a/packages/common/src/messages/toServer.ts +++ b/packages/common/src/messages/toServer.ts @@ -64,6 +64,8 @@ export interface RemoteUserData { requested: boolean; remoteRequested: boolean; username: string; + searchedSolPubKey?: string; // Returns a public key if it is searched for + searchedEthPubKey?: string; } export interface CollectionChatData { diff --git a/packages/common/src/notifications.ts b/packages/common/src/notifications.ts index 8d09d8d57..4d4a5bdd2 100644 --- a/packages/common/src/notifications.ts +++ b/packages/common/src/notifications.ts @@ -8,4 +8,5 @@ export interface DbNotification { body: string; xnft_id: string; timestamp: number; + id: number; } diff --git a/packages/common/src/plugin.ts b/packages/common/src/plugin.ts index 5c3285f4a..3847e9190 100644 --- a/packages/common/src/plugin.ts +++ b/packages/common/src/plugin.ts @@ -131,25 +131,32 @@ export class Plugin { // // Loads the plugin javascript code inside the iframe. // - public createIframe(preference?: XnftPreference) { + public createIframe( + preference: XnftPreference | null, + deepXnftPath?: string + ) { logger.debug("creating iframe element"); - + const url = new URL(this.iframeRootUrl); + if (deepXnftPath) { + // url.searchParams.set("deepXnftPath", deepXnftPath); + url.hash = deepXnftPath; + } this._nextRenderId = 0; this.iframeRoot = document.createElement("iframe"); this.iframeRoot.style.width = "100%"; this.iframeRoot.style.height = "100vh"; this.iframeRoot.style.border = "none"; - - if (preference?.mediaPermissions) { - this.iframeRoot.setAttribute( - "allow", - "camera;microphone;display-capture" - ); - } + this.iframeRoot.setAttribute( + "allow", + preference?.mediaPermissions + ? "camera;microphone;display-capture;fullscreen" + : "fullscreen" + ); this.iframeRoot.setAttribute("fetchpriority", "low"); - this.iframeRoot.src = this.iframeRootUrl; + this.iframeRoot.src = url.toString(); this.iframeRoot.sandbox.add("allow-same-origin"); this.iframeRoot.sandbox.add("allow-scripts"); + this.iframeRoot.sandbox.add("allow-forms"); this.iframeRoot.onload = () => this.handleRootIframeOnLoad(); } @@ -227,8 +234,8 @@ export class Plugin { // Rendering. ////////////////////////////////////////////////////////////////////////////// - public mount(preference?: XnftPreference) { - this.createIframe(preference); + public mount(preference: XnftPreference | null, deepXnftPath: string) { + this.createIframe(preference, deepXnftPath); this.didFinishSetup!.then(() => { this.pushMountNotification(); }); diff --git a/packages/common/src/solana/index.ts b/packages/common/src/solana/index.ts index 3fda9ff37..3d514d0c9 100644 --- a/packages/common/src/solana/index.ts +++ b/packages/common/src/solana/index.ts @@ -14,6 +14,16 @@ import { findFreezeAuthorityPk, findMintStatePk, } from "@magiceden-oss/open_creator_protocol"; +import type { + TransferInstructionAccounts, + TransferInstructionArgs, +} from "@metaplex-foundation/mpl-token-metadata"; +import { + createTransferInstruction as createTokenMetadataTransferInstruction, + Metadata, + TokenRecord, + TokenState, +} from "@metaplex-foundation/mpl-token-metadata"; import type { Program, SplToken } from "@project-serum/anchor"; import * as anchor from "@project-serum/anchor"; import { @@ -46,23 +56,14 @@ import * as assertOwner from "./programs/assert-owner"; import { ASSOCIATED_TOKEN_PROGRAM_ID, associatedTokenAddress, - metadataAddress, masterEditionAddress, - tokenRecordAddress, + metadataAddress, TOKEN_AUTH_RULES_ID, + tokenRecordAddress, } from "./programs/token"; import { xnftClient } from "./programs/xnft"; import { SolanaProvider } from "./provider"; -import { - TransferInstructionAccounts, - TransferInstructionArgs, - createTransferInstruction as createTokenMetadataTransferInstruction, - Metadata, - TokenRecord, - TokenState -} from "@metaplex-foundation/mpl-token-metadata"; - export * from "./background-connection"; export * from "./cluster"; export * from "./explorer"; @@ -457,13 +458,16 @@ export class Solana { const transferArgs: TransferInstructionArgs = { transferArgs: { - __kind: 'V1', + __kind: "V1", amount, authorizationData: null, }, }; - const transferIx = createTokenMetadataTransferInstruction(transferAcccounts, transferArgs); + const transferIx = createTokenMetadataTransferInstruction( + transferAcccounts, + transferArgs + ); const transaction: Transaction = new Transaction(); transaction.add(computeBudgetIx, transferIx); diff --git a/packages/common/src/solana/programs/token.ts b/packages/common/src/solana/programs/token.ts index d0c0a8a38..a28de98dc 100644 --- a/packages/common/src/solana/programs/token.ts +++ b/packages/common/src/solana/programs/token.ts @@ -355,7 +355,10 @@ export async function masterEditionAddress( )[0]; } -export async function tokenRecordAddress(mint: PublicKey, token: PublicKey): Promise { +export async function tokenRecordAddress( + mint: PublicKey, + token: PublicKey +): Promise { return ( await PublicKey.findProgramAddress( [ diff --git a/packages/common/src/solana/programs/xnft.ts b/packages/common/src/solana/programs/xnft.ts index 6b0e0681a..4b1530e31 100644 --- a/packages/common/src/solana/programs/xnft.ts +++ b/packages/common/src/solana/programs/xnft.ts @@ -5,6 +5,8 @@ import * as anchor from "@project-serum/anchor"; import { Program } from "@project-serum/anchor"; import { PublicKey } from "@solana/web3.js"; +import { BACKPACK_FEATURE_REFERRAL_FEES } from "../../generated-config"; + export const XNFT_PROGRAM_ID = new PublicKey( "xnft5aaToUM4UFETUQfj7NUDUBdvYHTVhNFThEYTm55" ); @@ -26,7 +28,7 @@ export async function fetchXnfts( }, ]); - /// HACK to get ONE xNft installed for everyone + // HACK to get ONE xNFT installed for everyone xnftInstalls.push({ // @ts-ignore publicKey: "CkqWjTWzRMAtYN3CSs8Gp4K9H891htmaN1ysNXqcULc8", @@ -42,7 +44,7 @@ export async function fetchXnfts( }, }); - /// HACK to get Explorer xNft installed for everyone + // HACK to get Explorer xNFT installed for everyone xnftInstalls.push({ // @ts-ignore publicKey: "oRN37pXigdDzpSPTe9ma5UWz9pZ4srKgS8To3juBNRi", @@ -58,6 +60,40 @@ export async function fetchXnfts( }, }); + // HACK to get Prices xNFT installed for everyone + xnftInstalls.push({ + // @ts-ignore + publicKey: "4GWq6KwrSmi3boGVayz4LM2Mz12GHQ3bpB1W2i7F5GRR", + // @ts-ignore + account: { + authority: PublicKey.default, + xnft: new PublicKey("4GWq6KwrSmi3boGVayz4LM2Mz12GHQ3bpB1W2i7F5GRR"), + masterMetadata: new PublicKey( + "9tHKPiFsXy4kpXL4es9PUJ5w9bnzu8rHPdMNF5WyfJSD" + ), + edition: new anchor.BN("00"), + reserved: Array(64).fill(0), + }, + }); + + if (BACKPACK_FEATURE_REFERRAL_FEES) { + // HACK to get Dropzone xNFT installed for everyone + xnftInstalls.push({ + // @ts-ignore + publicKey: "CVkbt7dscJdjAJFF2uKrtin6ve9M8DA4gsUccAjePUHH", + // @ts-ignore + account: { + authority: PublicKey.default, + xnft: new PublicKey("CVkbt7dscJdjAJFF2uKrtin6ve9M8DA4gsUccAjePUHH"), + masterMetadata: new PublicKey( + "3ir4m8m51eWdLTx5e1XSkiwzu6TF24DYEi5ar5XnYK9u" + ), + edition: new anchor.BN("00"), + reserved: Array(64).fill(0), + }, + }); + } + if (xnftInstalls.length === 0) { return []; } diff --git a/packages/common/src/types.ts b/packages/common/src/types.ts index 487817c95..1d8c5b048 100644 --- a/packages/common/src/types.ts +++ b/packages/common/src/types.ts @@ -1,7 +1,5 @@ import type { Commitment } from "@solana/web3.js"; -import type { DerivationPath } from "./crypto"; - export type Context = { sender: any; backend: Backend; @@ -92,17 +90,26 @@ export type NftAttribute = { export type KeyringType = "mnemonic" | "ledger"; export type KeyringInit = { + signedWalletDescriptors: Array; // No mnemonic means this is a hardware wallet keyring mnemonic?: string; - blockchainKeyrings: Array; }; -export type BlockchainKeyringInit = { - blockchain: Blockchain; - derivationPath: DerivationPath; - accountIndex: number; +// Location of a public key including the public key +export type WalletDescriptor = { + derivationPath: string; publicKey: string; +}; + +// Path to a public key including a signature from the public key +export type SignedWalletDescriptor = { signature: string; +} & WalletDescriptor; + +// The way public keys are stored on the API +export type ServerPublicKey = { + blockchain: Blockchain; + publicKey: string; }; export interface XnftPreference { @@ -134,18 +141,13 @@ export type KeyringJson = { export type HdKeyringJson = { mnemonic: string; seed: string; - accountIndices: Array; - derivationPath: DerivationPath; + derivationPaths: Array; + accountIndex?: number; + walletIndex?: number; }; export type LedgerKeyringJson = { - derivationPaths: Array; -}; - -export type ImportedDerivationPath = { - path: string; - account: number; - publicKey: string; + walletDescriptors: Array; }; export type SolanaFeeConfig = { computeUnits: number; priorityFee: bigint }; diff --git a/packages/db/src/api/RecoilSync.tsx b/packages/db/src/api/RecoilSync.tsx index 353b7e408..9f8e54714 100644 --- a/packages/db/src/api/RecoilSync.tsx +++ b/packages/db/src/api/RecoilSync.tsx @@ -2,6 +2,8 @@ import type { SubscriptionType } from "@coral-xyz/common"; import { getDb } from "../db"; +import { refreshUsers } from "./users"; + export class RecoilSync { private static instance: RecoilSync; private constructor() {} @@ -38,6 +40,47 @@ export class RecoilSync { return getDb(uuid).messages.toArray(); } + async refreshUsersMetadata(uuid: string) { + const users = await getDb(uuid).users.toArray(); + const newUsersMetadata = await refreshUsers( + uuid, + users.map((x) => x.uuid), + true + ); + const sortedUsersMetadata = newUsersMetadata?.sort((a) => { + if (localStorage.getItem(`img-${a.image}`)) { + return 1; + } + return -1; + }); + for (let i = 0; i < sortedUsersMetadata?.length; i++) { + await this.storeImageInLocalStorage(sortedUsersMetadata[i]?.image); + } + } + + async storeImageInLocalStorage(url: string) { + return new Promise((resolve, reject) => { + const canvas = document.createElement("canvas"); + //@ts-ignore + const context = canvas.getContext("2d"); + const base_image = new Image(); + base_image.onload = function () { + const aspectRatio = base_image.width / base_image.height; + canvas.width = 200; + canvas.height = 200 / aspectRatio; + //@ts-ignore + context.clearRect(0, 0, canvas.width, canvas.height); + //@ts-ignore + context.drawImage(base_image, 0, 0, canvas.width, canvas.height); + // @ts-ignore + const dataURL = canvas.toDataURL("image/webp"); + localStorage.setItem(`img-${url}`, dataURL); + resolve(""); + }; + base_image.src = url; + }); + } + getChatsForRoom(uuid: string, room: string, type: SubscriptionType) { return getDb(uuid).messages.where({ room, type }).sortBy("created_at"); } diff --git a/packages/db/src/api/users.ts b/packages/db/src/api/users.ts index 47d3dcc8e..21b232dec 100644 --- a/packages/db/src/api/users.ts +++ b/packages/db/src/api/users.ts @@ -6,8 +6,14 @@ import { import { bulkAddUsers, getNewUsers } from "../db/users"; -export const refreshUsers = async (uuid: string, uniqueUserIds: string[]) => { - const newUsers = await getNewUsers(uuid, uniqueUserIds); +export const refreshUsers = async ( + uuid: string, + uniqueUserIds: string[], + force?: boolean +) => { + const newUsers = force + ? uniqueUserIds + : await getNewUsers(uuid, uniqueUserIds); if (newUsers.length) { try { const response = await fetch(`${BACKEND_API_URL}/users/metadata`, { diff --git a/packages/ledger-injection/src/index.ts b/packages/ledger-injection/src/index.ts index 8a4293f1c..f59f6fff5 100644 --- a/packages/ledger-injection/src/index.ts +++ b/packages/ledger-injection/src/index.ts @@ -1,7 +1,4 @@ -import type { DerivationPath } from "@coral-xyz/common"; import { - accountDerivationPath, - Blockchain, getLogger, LEDGER_INJECTED_CHANNEL_REQUEST, LEDGER_INJECTED_CHANNEL_RESPONSE, @@ -54,29 +51,19 @@ class LedgerInjection { case LEDGER_METHOD_ETHEREUM_SIGN_TRANSACTION: result = await this.handleEthereumSignTransaction( params[0], - params[1], - params[2] + params[1] ); break; case LEDGER_METHOD_ETHEREUM_SIGN_MESSAGE: - result = await this.handleEthereumSignMessage( - params[0], - params[1], - params[2] - ); + result = await this.handleEthereumSignMessage(params[0], params[1]); break; case LEDGER_METHOD_ETHEREUM_SIGN_EIP712_MESSAGE: - result = await this.handleEthereumSignMessage( - params[0], - params[1], - params[2] - ); + result = await this.handleEthereumSignMessage(params[0], params[1]); break; case LEDGER_METHOD_SOLANA_SIGN_TRANSACTION: result = await this.handleSolanaSignTransaction( params[0], - params[1], - params[2] + params[1] ); break; case LEDGER_METHOD_SOLANA_SIGN_MESSAGE: @@ -111,12 +98,11 @@ class LedgerInjection { async handleEthereumSignTransaction( transaction: UnsignedTransaction, - derivationPath: DerivationPath, - account: number + derivationPath: string ) { await this.connectIfNeeded(); const result = await this.ethereum!.signTransaction( - accountDerivationPath(Blockchain.ETHEREUM, derivationPath, account), + derivationPath, ethers.utils.serializeTransaction(transaction).substring(2) ); return ethers.utils.serializeTransaction(transaction, { @@ -126,14 +112,10 @@ class LedgerInjection { }); } - async handleEthereumSignMessage( - message: string, - derivationPath: DerivationPath, - account: number - ) { + async handleEthereumSignMessage(message: string, derivationPath: string) { await this.connectIfNeeded(); const result = await this.ethereum!.signPersonalMessage( - accountDerivationPath(Blockchain.ETHEREUM, derivationPath, account), + derivationPath, message ); return ethers.utils.joinSignature({ @@ -143,27 +125,19 @@ class LedgerInjection { }); } - async handleEthereumSignEIP712Message( - message: any, - derivationPath: DerivationPath, - account: number - ) { + async handleEthereumSignEIP712Message(message: any, derivationPath: string) { await this.connectIfNeeded(); const result = await this.ethereum!.signEIP712Message( - accountDerivationPath(Blockchain.ETHEREUM, derivationPath, account), + derivationPath, message ); return result; } - async handleSolanaSignTransaction( - tx: string, - derivationPath: DerivationPath, - account: number - ) { + async handleSolanaSignTransaction(tx: string, derivationPath: string) { await this.connectIfNeeded(); const result = await this.solana!.signTransaction( - accountDerivationPath(Blockchain.SOLANA, derivationPath, account), + derivationPath, Buffer.from(bs58.decode(tx)) ); return bs58.encode(result.signature); diff --git a/packages/message-sdk/src/ParentCommunicationManager.ts b/packages/message-sdk/src/ParentCommunicationManager.ts index 604977ed9..43232df8d 100644 --- a/packages/message-sdk/src/ParentCommunicationManager.ts +++ b/packages/message-sdk/src/ParentCommunicationManager.ts @@ -87,7 +87,12 @@ export class ParentCommunicationManager { this.nativePop?.(); } - push(props: { title: string; componentId: string; componentProps: any }) { + push(props: { + title: string; + componentId: string; + componentProps: any; + pushAboveRoot?: boolean; + }) { if (IFRAME_HOSTED) { window.parent.postMessage( { From 92eb9d8eb95b0b9816aeb79b486818e303204363 Mon Sep 17 00:00:00 2001 From: mj221 Date: Fri, 3 Feb 2023 13:51:46 +1000 Subject: [PATCH 12/36] Merge branch 'master' of https://github.com/mjLabrys/backpack into mj/domain-content-resolver-revised --- packages/message-sdk/src/components/Inbox.tsx | 7 +- .../src/components/MessageList.tsx | 34 +- .../src/components/ProfileScreen.tsx | 18 +- .../src/components/RequestsScreen.tsx | 1 + .../message-sdk/src/components/UserList.tsx | 378 ++++++++++++------ .../message-sdk/src/components/styles.tsx | 5 +- packages/provider-core/src/provider-solana.ts | 2 +- .../provider-core/src/root-provider-xnft.ts | 7 + .../src/components/Icon/index.tsx | 6 +- .../src/components/base/EmptyState.tsx | 9 + .../react-common/src/components/base/List.tsx | 13 +- .../src/components/base/LocalImage.tsx | 23 ++ .../src/components/base/SuccessButton.tsx | 9 +- .../react-common/src/components/base/index.ts | 1 + .../react-xnft-dom-renderer/src/Component.tsx | 2 +- packages/recoil/src/atoms/index.tsx | 1 + .../atoms/preferences/xnft-preferences.tsx | 6 + packages/recoil/src/atoms/solana/index.tsx | 1 + .../recoil/src/atoms/solana/isONELive.tsx | 16 + packages/recoil/src/atoms/solana/xnft.tsx | 2 +- packages/recoil/src/atoms/unreadCount.tsx | 11 + packages/recoil/src/atoms/wallet.tsx | 3 +- packages/recoil/src/context/Swap.tsx | 2 +- packages/recoil/src/hooks/index.tsx | 1 + packages/recoil/src/hooks/navigation.tsx | 6 +- .../recoil/src/hooks/solana/usePlugins.tsx | 1 + packages/recoil/src/hooks/useUnreadCount.tsx | 7 + packages/recoil/src/types.ts | 5 - packages/themes/src/index.tsx | 15 +- packages/xnft-cli/new/getXnftWithGlobs.js | 3 + 30 files changed, 421 insertions(+), 174 deletions(-) create mode 100644 packages/react-common/src/components/base/LocalImage.tsx create mode 100644 packages/recoil/src/atoms/solana/isONELive.tsx create mode 100644 packages/recoil/src/atoms/unreadCount.tsx create mode 100644 packages/recoil/src/hooks/useUnreadCount.tsx diff --git a/packages/message-sdk/src/components/Inbox.tsx b/packages/message-sdk/src/components/Inbox.tsx index b42bd2c26..8c82612aa 100644 --- a/packages/message-sdk/src/components/Inbox.tsx +++ b/packages/message-sdk/src/components/Inbox.tsx @@ -39,7 +39,6 @@ export function InboxInner() { const groupCollections = useGroupCollections({ uuid }); const [searchResults, setSearchResults] = useState([]); const [searchFilter, setSearchFilter] = useState(""); - const [refreshing, setRefreshing] = useState(true); const getDefaultChats = () => { return groupCollections.filter((x) => x.name && x.image) || []; @@ -107,9 +106,9 @@ export function InboxInner() { debouncedInit(); }} /> - {(!allChats || (refreshing && !allChats.length)) && } + {(!allChats || !allChats.length) && } {allChats && - (allChats.length || !refreshing) && + allChats.length && (allChats.filter((x) => (x.chatType === "individual" ? x.chatProps.remoteUsername || "" @@ -142,7 +141,7 @@ export function InboxInner() {
)} {allChats && - (allChats.length || !refreshing) && + allChats.length && searchFilter.length < 3 && requestCount === 0 && allChats.length === 0 && ( diff --git a/packages/message-sdk/src/components/MessageList.tsx b/packages/message-sdk/src/components/MessageList.tsx index d74d3fb7e..a996375b7 100644 --- a/packages/message-sdk/src/components/MessageList.tsx +++ b/packages/message-sdk/src/components/MessageList.tsx @@ -13,28 +13,30 @@ import { import { NAV_COMPONENT_MESSAGE_GROUP_CHAT } from "@coral-xyz/common/src/constants"; import { isFirstLastListItemStyle, - ProxyImage, + LocalImage, useUsersMetadata, } from "@coral-xyz/react-common"; -import { useDecodedSearchParams, useUser } from "@coral-xyz/recoil"; +import { useDecodedSearchParams } from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; import MarkChatUnreadIcon from "@mui/icons-material/MarkChatUnread"; import VerifiedIcon from "@mui/icons-material/Verified"; import { List, ListItem } from "@mui/material"; -import { useRecoilState } from "recoil"; import { ParentCommunicationManager } from "../ParentCommunicationManager"; import { useStyles } from "./styles"; + export const MessageList = ({ activeChats, requestCount = 0, + toRoot = true, }: { activeChats: ( | { chatType: "individual"; chatProps: EnrichedInboxDb } | { chatType: "collection"; chatProps: CollectionChatData } )[]; requestCount?: number; + toRoot?: boolean; }) => { const theme = useCustomTheme(); @@ -52,11 +54,12 @@ export const MessageList = ({ )} - {activeChats.map((activeChat, index) => ( + {activeChats?.map((activeChat, index) => ( x.type === "tag").map((x) => x.value), @@ -161,6 +165,7 @@ export function ChatListItem({ id: id, fromInbox: true, }, + pushAboveRoot: toRoot, }); }} style={{ @@ -211,6 +216,8 @@ export function ChatListItem({ componentProps: { userId: id, }, + + pushAboveRoot: toRoot, }); }} image={image} @@ -234,7 +241,7 @@ export function ChatListItem({ style={{ fontSize: 19, marginLeft: 3, - color: theme.custom.colors.blue, + color: theme.custom.colors.verified, }} /> )} @@ -293,6 +300,7 @@ export function RequestsChatItem({ title: `Requests`, componentId: NAV_COMPONENT_MESSAGE_REQUESTS, componentProps: {}, + pushAboveRoot: true, }); }} style={{ @@ -372,5 +380,11 @@ export function RequestsChatItem({ function UserIcon({ image }: any) { const classes = useStyles(); - return ; + return ( + + ); } diff --git a/packages/message-sdk/src/components/ProfileScreen.tsx b/packages/message-sdk/src/components/ProfileScreen.tsx index 99445a87e..19215b375 100644 --- a/packages/message-sdk/src/components/ProfileScreen.tsx +++ b/packages/message-sdk/src/components/ProfileScreen.tsx @@ -4,15 +4,14 @@ import { NAV_COMPONENT_MESSAGE_CHAT, sendFriendRequest, } from "@coral-xyz/common"; -import { useDbUser } from "@coral-xyz/db"; import { Loading, - MessageIcon, + LocalImage, + MessageBubbleIcon, PrimaryButton, - ProxyImage, useUsersMetadata, } from "@coral-xyz/react-common"; -import { useNavigation, useUser } from "@coral-xyz/recoil"; +import { useNavigation } from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; import ArrowUpwardIcon from "@mui/icons-material/ArrowUpward"; import LockIcon from "@mui/icons-material/Lock"; @@ -24,7 +23,6 @@ import { ParentCommunicationManager } from "../ParentCommunicationManager"; import { useStyles } from "./styles"; export const ProfileScreen = ({ userId }: { userId: string }) => { - const { uuid } = useUser(); const [friendship, setFriendship] = useState(false); const [requestSent, setRequestSent] = useState(false); const [user, setUser] = useState<{ @@ -36,7 +34,7 @@ export const ProfileScreen = ({ userId }: { userId: string }) => { const classes = useStyles(); const theme = useCustomTheme(); const userMetadata = useUsersMetadata({ remoteUserIds: [userId] }); - const { push, toRoot } = useNavigation(); + const { push } = useNavigation(); async function getChatRoom() { const res = await ParentCommunicationManager.getInstance().fetch( @@ -84,9 +82,10 @@ export const ProfileScreen = ({ userId }: { userId: string }) => {
-
@@ -97,7 +96,6 @@ export const ProfileScreen = ({ userId }: { userId: string }) => { size={"large"} className={classes.icon} onClick={async () => { - await toRoot(); push({ title: `@${user.username}`, componentId: NAV_COMPONENT_MESSAGE_CHAT, @@ -108,7 +106,7 @@ export const ProfileScreen = ({ userId }: { userId: string }) => { }); }} > - @@ -131,7 +129,7 @@ export const ProfileScreen = ({ userId }: { userId: string }) => { className={classes.icon} >
{
{activeChats.length !== 0 && ( ({ chatType: "individual", chatProps: x, diff --git a/packages/message-sdk/src/components/UserList.tsx b/packages/message-sdk/src/components/UserList.tsx index 3ead427e1..10c7ecc8b 100644 --- a/packages/message-sdk/src/components/UserList.tsx +++ b/packages/message-sdk/src/components/UserList.tsx @@ -1,28 +1,35 @@ -import type { Friendship, RemoteUserData } from "@coral-xyz/common"; +import type { CSSProperties, MouseEvent } from "react"; +import type { RemoteUserData } from "@coral-xyz/common"; import { NAV_COMPONENT_MESSAGE_PROFILE, sendFriendRequest, unFriend, + usernameDisplay, + walletAddressDisplay, } from "@coral-xyz/common"; import { updateFriendshipIfExists } from "@coral-xyz/db"; import { isFirstLastListItemStyle, - ProxyImage, + LocalImage, SignalingManager, } from "@coral-xyz/react-common"; import { friendship, useNavigation, useUser } from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; import { List, ListItem } from "@mui/material"; -import { useRecoilState } from "recoil"; +import { useRecoilCallback } from "recoil"; import { useStyles } from "./styles"; export const UserList = ({ users, setMembers, + style, + itemStyle, }: { users: RemoteUserData[]; setMembers?: React.Dispatch>; + style?: CSSProperties; + itemStyle?: CSSProperties; }) => { const theme = useCustomTheme(); @@ -33,14 +40,17 @@ export const UserList = ({ paddingBottom: 0, borderRadius: "14px", border: `${theme.custom.colors.borderFull}`, + ...style, }} > {users.map((user, index) => ( ))} @@ -52,18 +62,176 @@ function UserListItem({ isFirst, isLast, setMembers, + style, }: { user: RemoteUserData; isFirst: boolean; isLast: boolean; setMembers?: React.Dispatch>; + style?: CSSProperties; }) { const theme = useCustomTheme(); const { push } = useNavigation(); const classes = useStyles(); const { uuid } = useUser(); - const [friendshipValue, setFriendshipValue] = - useRecoilState(friendship({ userId: user.id })); + const setFriendshipValue = useUpdateFriendships(); + + const onUnfriend = async (ev: MouseEvent) => { + ev.stopPropagation(); + await unFriend({ to: user.id }); + await updateFriendshipIfExists(uuid, user.id, { + areFriends: 0, + requested: 0, + }); + setFriendshipValue({ + userId: user.id, + friendshipValue: { + requested: false, + areFriends: false, + }, + }); + setMembers?.((members) => + members.map((m) => { + if (m.id === user.id) { + return { + ...m, + areFriends: false, + requested: false, + remoteRequested: false, + }; + } + return m; + }) + ); + SignalingManager.getInstance().onUpdateRecoil({ + type: "friendship", + }); + }; + + const onCancelRequest = async (ev: MouseEvent) => { + ev.stopPropagation(); + await sendFriendRequest({ to: user.id, sendRequest: false }); + await updateFriendshipIfExists(uuid, user.id, { + requested: 0, + }); + + setFriendshipValue({ + userId: user.id, + friendshipValue: { + requested: false, + }, + }); + setMembers?.((members) => + members.map((m) => { + if (m.id === user.id) { + return { + ...m, + requested: false, + }; + } + return m; + }) + ); + SignalingManager.getInstance().onUpdateRecoil({ + type: "friendship", + }); + }; + + const onAccept = async (ev: MouseEvent) => { + ev.stopPropagation(); + await sendFriendRequest({ to: user.id, sendRequest: true }); + await updateFriendshipIfExists(uuid, user.id, { + requested: 0, + areFriends: 1, + }); + + setFriendshipValue({ + userId: user.id, + friendshipValue: { + requested: false, + areFriends: true, + }, + }); + setMembers?.((members) => + members.map((m) => { + if (m.id === user.id) { + return { + ...m, + requested: false, + remoteRequested: false, + areFriends: true, + }; + } + return m; + }) + ); + SignalingManager.getInstance().onUpdateRecoil({ + type: "friendship", + }); + }; + + const onDecline = async (ev: MouseEvent) => { + ev.stopPropagation(); + await sendFriendRequest({ to: user.id, sendRequest: true }); + await updateFriendshipIfExists(uuid, user.id, { + requested: 0, + areFriends: 0, + }); + + setFriendshipValue({ + userId: user.id, + friendshipValue: { + requested: false, + areFriends: false, + }, + }); + setMembers?.((members) => + members.map((m) => { + if (m.id === user.id) { + return { + ...m, + requested: false, + remoteRequested: false, + areFriends: false, + }; + } + return m; + }) + ); + SignalingManager.getInstance().onUpdateRecoil({ + type: "friendship", + }); + }; + + const onSendRequest = async (ev: MouseEvent) => { + ev.stopPropagation(); + await sendFriendRequest({ to: user.id, sendRequest: true }); + await updateFriendshipIfExists(uuid, user.id, { + requested: 1, + }); + + setFriendshipValue({ + userId: user.id, + friendshipValue: { + requested: true, + }, + }); + setMembers?.((members) => + members.map((m) => { + if (m.id === user.id) { + return { + ...m, + requested: true, + }; + } + return m; + }) + ); + SignalingManager.getInstance().onUpdateRecoil({ + type: "friendship", + }); + }; + return (
-
{user.username}
+
+ {usernameDisplay(user.username)}{" "} + {user.searchedSolPubKey ? ( + <> ({walletAddressDisplay(user.searchedSolPubKey, 2)}) + ) : ( + "" + )}{" "} + {user.searchedEthPubKey ? ( + <>({walletAddressDisplay(user.searchedEthPubKey, 2)}) + ) : ( + "" + )} +
-
{ - e.stopPropagation(); - if (user.areFriends) { - await unFriend({ to: user.id }); - await updateFriendshipIfExists(uuid, user.id, { - areFriends: 0, - requested: 0, - }); - setFriendshipValue((x: any) => ({ - ...x, - requested: false, - areFriends: false, - })); - setMembers?.((members) => - members.map((m) => { - if (m.id === user.id) { - return { - ...m, - areFriends: false, - requested: false, - remoteRequested: false, - }; - } - return m; - }) - ); - } else if (user.requested) { - await sendFriendRequest({ to: user.id, sendRequest: false }); - await updateFriendshipIfExists(uuid, user.id, { - requested: 0, - }); - setFriendshipValue((x: any) => ({ - ...x, - requested: false, - })); - setMembers?.((members) => - members.map((m) => { - if (m.id === user.id) { - return { - ...m, - requested: false, - }; - } - return m; - }) - ); - } else if (user.remoteRequested) { - await sendFriendRequest({ to: user.id, sendRequest: true }); - await updateFriendshipIfExists(uuid, user.id, { - requested: 0, - areFriends: 1, - }); - setFriendshipValue((x: any) => ({ - ...x, - requested: false, - areFriends: true, - })); - setMembers?.((members) => - members.map((m) => { - if (m.id === user.id) { - return { - ...m, - requested: false, - remoteRequested: false, - areFriends: true, - }; - } - return m; - }) - ); - } else { - await sendFriendRequest({ to: user.id, sendRequest: true }); - await updateFriendshipIfExists(uuid, user.id, { - requested: 1, - }); - setFriendshipValue((x: any) => ({ - ...x, - requested: true, - })); - setMembers?.((members) => - members.map((m) => { - if (m.id === user.id) { - return { - ...m, - requested: true, - }; - } - return m; - }) - ); - } - SignalingManager.getInstance().onUpdateRecoil({ - type: "friendship", - }); - }} - > - {user.areFriends - ? "Unfriend" - : user.requested - ? "Cancel Request" - : user.remoteRequested - ? "Accept Request" - : "Send Request"}{" "} -
+ {user.areFriends ? ( + + ) : user.requested ? ( + + ) : user.remoteRequested ? ( +
+ + +
+ ) : ( + + )}
@@ -233,13 +323,59 @@ function UserListItem({ ); } +function UserAction({ + text, + onClick, + style, +}: { + text: string; + onClick: (ev: MouseEvent) => void; + style?: CSSProperties; +}) { + const classes = useStyles(); + return ( +
+ {text} +
+ ); +} + function UserIcon({ image }: any) { const classes = useStyles(); return ( - ); } + +export const useUpdateFriendships = () => + useRecoilCallback( + ({ set, snapshot }: any) => + async ({ + friendshipValue, + userId, + }: { + friendshipValue: any; + userId: string; + }) => { + const currentFriendship = snapshot.getLoadable(friendship({ userId })); + set(friendship({ userId }), { + ...(currentFriendship.valueMaybe() || {}), + ...friendshipValue, + }); + } + ); diff --git a/packages/message-sdk/src/components/styles.tsx b/packages/message-sdk/src/components/styles.tsx index 464dd4bee..9282d8fb3 100644 --- a/packages/message-sdk/src/components/styles.tsx +++ b/packages/message-sdk/src/components/styles.tsx @@ -31,6 +31,7 @@ export const useStyles = styles((theme) => ({ topImageOuter: { width: 150, height: 150, + border: `solid 3px ${theme.custom.colors.avatarIconBackground}`, borderRadius: "50%", display: "inline-block", overflow: "hidden", @@ -65,7 +66,7 @@ export const useStyles = styles((theme) => ({ iconCircular: { width: "32px", height: "32px", - borderRadius: "16px", + borderRadius: "50%", marginRight: "8px", color: theme.custom.colors.positive, }, @@ -101,7 +102,7 @@ export const useStyles = styles((theme) => ({ color: theme.custom.colors.fontColor2, }, userRequestText: { - color: theme.custom.colors.fontColor2, + color: theme.custom.colors.textPlaceholder, }, timestamp: { fontSize: 14, diff --git a/packages/provider-core/src/provider-solana.ts b/packages/provider-core/src/provider-solana.ts index 184425ef0..5b19c730c 100644 --- a/packages/provider-core/src/provider-solana.ts +++ b/packages/provider-core/src/provider-solana.ts @@ -161,7 +161,7 @@ export class ProviderSolanaInjection this.#connection = this.defaultConnection(); } - async openXnft(xnftAddress: PublicKey) { + async openXnft(xnftAddress: string | PublicKey) { await this.#requestManager.request({ method: SOLANA_RPC_METHOD_OPEN_XNFT, params: [xnftAddress.toString()], diff --git a/packages/provider-core/src/root-provider-xnft.ts b/packages/provider-core/src/root-provider-xnft.ts index 17ddf4fd6..7b2647fdb 100644 --- a/packages/provider-core/src/root-provider-xnft.ts +++ b/packages/provider-core/src/root-provider-xnft.ts @@ -121,6 +121,13 @@ export class ProviderRootXnftInjection extends PrivateEventEmitter { ); } + if (this.#cachedNotifications[PLUGIN_NOTIFICATION_UPDATE_METADATA]) { + iframeEl.contentWindow?.postMessage( + this.#cachedNotifications[PLUGIN_NOTIFICATION_UPDATE_METADATA], + "*" + ); + } + this.#requestManager.addChildIframe({ element: iframeEl, url, diff --git a/packages/react-common/src/components/Icon/index.tsx b/packages/react-common/src/components/Icon/index.tsx index 2b7ca0ffe..7203a4a5c 100644 --- a/packages/react-common/src/components/Icon/index.tsx +++ b/packages/react-common/src/components/Icon/index.tsx @@ -460,9 +460,9 @@ export function MessageBubbleIcon({ fill = "#99A4B4", ...props }) { return ( diff --git a/packages/react-common/src/components/base/EmptyState.tsx b/packages/react-common/src/components/base/EmptyState.tsx index 5ad8499e5..fdbb4638a 100644 --- a/packages/react-common/src/components/base/EmptyState.tsx +++ b/packages/react-common/src/components/base/EmptyState.tsx @@ -101,6 +101,15 @@ export const EmptyState: React.FC<{ label={buttonText} style={{ marginTop: "40px", + ...(window.matchMedia("(max-width: 650px)").matches + ? {} + : { + display: "block", + marginLeft: "auto", + marginRight: "auto", + width: "max-content", + padding: "0 24px", + }), }} /> )} diff --git a/packages/react-common/src/components/base/List.tsx b/packages/react-common/src/components/base/List.tsx index 2ebe96027..582de165e 100644 --- a/packages/react-common/src/components/base/List.tsx +++ b/packages/react-common/src/components/base/List.tsx @@ -1,4 +1,5 @@ -import { HOVER_OPACITY, styles, useCustomTheme } from "@coral-xyz/themes"; +import { type MouseEvent, useCallback } from "react"; +import { styles, useCustomTheme } from "@coral-xyz/themes"; import { CallMade, ChevronRight } from "@mui/icons-material"; import { Divider, @@ -65,6 +66,14 @@ export function ListItem({ const _classes = useStyles(); const theme = useCustomTheme(); const buttonProps = button ? { disableRipple: true } : {}; + const handleClick = useCallback( + (ev: MouseEvent) => { + ev.preventDefault(); + onClick(ev); + }, + [onClick] + ); + return ( <> { + const featureGates = useFeatureGates(); + + return ( + + ); +}; diff --git a/packages/react-common/src/components/base/SuccessButton.tsx b/packages/react-common/src/components/base/SuccessButton.tsx index db30711a8..3f5207e7d 100644 --- a/packages/react-common/src/components/base/SuccessButton.tsx +++ b/packages/react-common/src/components/base/SuccessButton.tsx @@ -1,10 +1,5 @@ -import type { - CustomTheme} from "@coral-xyz/themes"; -import { - HOVER_OPACITY, - styles, - useCustomTheme, -} from "@coral-xyz/themes"; +import type { CustomTheme } from "@coral-xyz/themes"; +import { HOVER_OPACITY, styles, useCustomTheme } from "@coral-xyz/themes"; import { PrimaryButton } from "./PrimaryButton"; diff --git a/packages/react-common/src/components/base/index.ts b/packages/react-common/src/components/base/index.ts index f68c952a1..b0e6b3735 100644 --- a/packages/react-common/src/components/base/index.ts +++ b/packages/react-common/src/components/base/index.ts @@ -4,6 +4,7 @@ export * from "./Inputs"; export * from "./Labels"; export * from "./List"; export * from "./Loading"; +export * from "./LocalImage"; export * from "./NegativeButton"; export * from "./PrimaryButton"; export * from "./ProxyImage"; diff --git a/packages/react-xnft-dom-renderer/src/Component.tsx b/packages/react-xnft-dom-renderer/src/Component.tsx index b13f6d9b6..58289e4bf 100644 --- a/packages/react-xnft-dom-renderer/src/Component.tsx +++ b/packages/react-xnft-dom-renderer/src/Component.tsx @@ -358,7 +358,7 @@ function Iframe({ props, style }: any) {
-
    -
  • New messages
    • -
  • Contact requests
    • -
-
- - You can change this later in preferences. + + These appear for messages and contact requests. + + + void }) => { ); }; + +const SkeletonNotifications = ({ style }: { style?: CSSProperties }) => ( + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +); diff --git a/packages/app-extension/src/components/Onboarding/pages/OnboardAccount.tsx b/packages/app-extension/src/components/Onboarding/pages/OnboardAccount.tsx index f8e8fefd7..cfe5e9a4c 100644 --- a/packages/app-extension/src/components/Onboarding/pages/OnboardAccount.tsx +++ b/packages/app-extension/src/components/Onboarding/pages/OnboardAccount.tsx @@ -8,14 +8,16 @@ import type { import { getBlockchainFromPath, getCreateMessage, - UI_RPC_METHOD_FIND_SIGNED_WALLET_DESCRIPTOR, + UI_RPC_METHOD_FIND_WALLET_DESCRIPTOR, + UI_RPC_METHOD_SIGN_MESSAGE_FOR_PUBLIC_KEY, } from "@coral-xyz/common"; import { useBackgroundClient } from "@coral-xyz/recoil"; +import { ethers } from "ethers"; import { useSignMessageForWallet } from "../../../hooks/useSignMessageForWallet"; import { useSteps } from "../../../hooks/useSteps"; import { CreatePassword } from "../../common/Account/CreatePassword"; -import { ImportAccounts } from "../../common/Account/ImportAccounts"; +import { ImportWallets } from "../../common/Account/ImportWallets"; import { MnemonicInput } from "../../common/Account/MnemonicInput"; import { WithContaineredDrawer } from "../../common/Layout/Drawer"; import { NavBackButton, WithNav } from "../../common/Layout/Nav"; @@ -30,6 +32,8 @@ import { KeyringTypeSelector } from "./KeyringTypeSelector"; import { NotificationsPermission } from "./NotificationsPermission"; import { UsernameForm } from "./UsernameForm"; +const { base58 } = ethers.utils; + export const OnboardAccount = ({ onWaiting, onRecover, @@ -94,13 +98,27 @@ export const OnboardAccount = ({ setBlockchain(blockchain); setOpenDrawer(true); } else if (action === "create") { - const signedWalletDescriptor = await background.request({ - method: UI_RPC_METHOD_FIND_SIGNED_WALLET_DESCRIPTOR, - params: [blockchain, 0, true, mnemonic], + const walletDescriptor = await background.request({ + method: UI_RPC_METHOD_FIND_WALLET_DESCRIPTOR, + params: [blockchain, 0, mnemonic], + }); + const signature = await background.request({ + method: UI_RPC_METHOD_SIGN_MESSAGE_FOR_PUBLIC_KEY, + params: [ + blockchain, + walletDescriptor.publicKey, + base58.encode( + Buffer.from(getCreateMessage(walletDescriptor.publicKey), "utf-8") + ), + [mnemonic, [walletDescriptor.derivationPath]], + ], }); setSignedWalletDescriptors([ ...signedWalletDescriptors, - signedWalletDescriptor, + { + ...walletDescriptor, + signature, + }, ]); } } @@ -216,7 +234,7 @@ export const OnboardAccount = ({ onClose={() => setOpenDrawer(false)} /> ) : ( - ; } return ; @@ -145,17 +146,21 @@ function PluginControl({ closePlugin }: any) { >
+ {/*
+ */}
-
{getTimeStr(notification.timestamp)}
+
+
+ {getTimeStr(notification.timestamp)} +
+
+ {!notification.viewed && ( + + )} +
+
); } +function AcceptRejectRequest({ userId }: { userId: string }) { + const friendshipValue = useFriendship({ userId }); + const { uuid } = useUser(); + const setFriendshipValue = useUpdateFriendships(); + const [inProgress, setInProgress] = useState(false); + + if (friendshipValue?.remoteRequested && !friendshipValue?.areFriends) { + return ( +
+ { + e.stopPropagation(); + setInProgress(true); + await sendFriendRequest({ to: userId, sendRequest: true }); + await updateFriendshipIfExists(uuid, userId, { + requested: 0, + areFriends: 1, + }); + setFriendshipValue({ + userId: userId, + friendshipValue: { + requested: false, + areFriends: true, + remoteRequested: false, + }, + }); + setInProgress(false); + }} + /> + { + e.stopPropagation(); + setInProgress(true); + await sendFriendRequest({ to: userId, sendRequest: false }); + await updateFriendshipIfExists(uuid, userId, { + requested: 0, + areFriends: 0, + remoteRequested: 0, + }); + setFriendshipValue({ + userId: userId, + friendshipValue: { + requested: false, + areFriends: false, + remoteRequested: false, + }, + }); + setInProgress(false); + }} + /> +
+ ); + } + return
; +} + function parseJson(body: string) { try { return JSON.parse(body); @@ -479,17 +608,22 @@ function FriendRequestListItem({ isFirst, isLast, onOpenDrawer, + title, }: { notification: EnrichedNotification; isFirst: boolean; isLast: boolean; onOpenDrawer?: () => void; + title: string; }) { const { isXs } = useBreakpoints(); - const nav = isXs ? useNavStack() : undefined; + const nav = isXs ? useNavigation() : undefined; const user = useUserMetadata({ remoteUserId: parseJson(notification.body).from, }); + const friendshipValue = useFriendship({ + userId: parseJson(notification.body).from, + }); const classes = useStyles(); const theme = useCustomTheme(); @@ -504,11 +638,10 @@ function FriendRequestListItem({ paddingTop: "10px", paddingBottom: "10px", display: "flex", - height: "68px", backgroundColor: theme.custom.colors.nav, borderBottom: isLast ? undefined - : `solid 1pt ${theme.custom.colors.border}`, + : `solid 1pt ${theme.custom.colors.border1}`, ...isFirstLastListItemStyle(isFirst, isLast, 12), }} > @@ -530,21 +663,35 @@ function FriendRequestListItem({ >
-
- Contact request +
+
+
+ {title} +
+
+ {getTimeStr(notification.timestamp)} +
+
@{user.username} +
-
- {getTimeStr(notification.timestamp)} - View +
+ {friendshipValue?.remoteRequested && !friendshipValue?.areFriends && ( + + )}
@@ -576,7 +723,7 @@ function NoNotificationsLabel({ minimize }: { minimize: boolean }) { title={"No Notifications"} subtitle={"You don't have any notifications yet."} buttonText={"Browse the xNFT Library"} - onClick={() => window.open("https://xnft.gg")} + onClick={() => window.open(XNFT_GG_LINK)} innerStyle={{ marginBottom: minimize !== true ? "64px" : 0, // Tab height offset. }} diff --git a/packages/app-extension/src/components/Unlocked/Balances/RecentActivity.tsx b/packages/app-extension/src/components/Unlocked/Balances/RecentActivity.tsx index b655e0d23..b59b72974 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/RecentActivity.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/RecentActivity.tsx @@ -1,5 +1,5 @@ import { Suspense, useState } from "react"; -import { Blockchain, explorerUrl } from "@coral-xyz/common"; +import { Blockchain, explorerUrl, XNFT_GG_LINK } from "@coral-xyz/common"; import { EmptyState, isFirstLastListItemStyle, @@ -25,6 +25,8 @@ import { NavStackScreen, } from "../../common/Layout/NavStack"; +import { _RecentSolanaActivityList } from "./RecentSolanaActivity/RecentSolanaActivityList"; + const useStyles = styles((theme) => ({ recentActivityLabel: { color: theme.custom.colors.fontColor, @@ -111,7 +113,7 @@ export function RecentActivityButton() {
({ title: "Recent Activity" })} + options={() => ({ title: "Transactions" })} navButtonLeft={ setOpenDrawer(false)} />} > b.date.getTime() - a.date.getTime() + })) ?? []; + + // Used since Solana transactions have a timestamp and Ethereum transactions have a date. + const extractTime = (tx: any) => { + if (tx?.timestamp) { + return tx.timestamp; + } else if (tx?.date) { + return tx.date.getTime(); + } + return 0; + }; + + const mergedTransactions = [...recentTransactions].sort((a, b) => + extractTime(a) > extractTime(b) ? -1 : 1 ); return ( }> - <_RecentActivityList transactions={mergedTransactions} /> + {activeWallet.blockchain === Blockchain.SOLANA ? ( + <_RecentSolanaActivityList transactions={mergedTransactions} /> + ) : ( + <_RecentActivityList transactions={mergedTransactions} /> + )} ); } @@ -264,11 +282,9 @@ function RecentActivityListItem({ transaction, isFirst, isLast }: any) { const explorer = useBlockchainExplorer(transaction.blockchain); const connectionUrl = useBlockchainConnectionUrl(transaction.blockchain); const blockchainLogo = useBlockchainLogo(transaction.blockchain); - const onClick = () => { window.open(explorerUrl(explorer!, transaction.signature, connectionUrl!)); }; - return ( - {transaction.date.toLocaleDateString()} + {new Date(transaction.timestamp * 1000).toLocaleDateString()}
@@ -352,6 +368,7 @@ function RecentActivityListItemIcon({ transaction }: any) { function NoRecentActivityLabel({ minimize }: { minimize: boolean }) { const theme = useCustomTheme(); + return (
window.open("https://xnft.gg")} + onClick={() => window.open(XNFT_GG_LINK)} contentStyle={{ color: minimize ? theme.custom.colors.secondary : "inherit", }} diff --git a/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/Icons.tsx b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/Icons.tsx new file mode 100644 index 000000000..dc10dd2c2 --- /dev/null +++ b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/Icons.tsx @@ -0,0 +1,213 @@ +import { SOL_LOGO_URI } from "@coral-xyz/recoil"; +import { + ArrowDownwardRounded, + Check, + ClearRounded, + Image, + SendRounded, + WhatshotRounded, +} from "@mui/icons-material"; + +// TODO: move reused styles into classes +export const ListItemIcons = { + SWAP: ({ + tokenLogoOne, + tokenLogoTwo, + }: { + tokenLogoOne?: string; + tokenLogoTwo?: string; + }) => { + return ( +
+ + +
+ ); + }, + TRANSFER: ({ tokenLogo }: { tokenLogo?: string }) => { + return ( + + ); + }, + SOL: () => { + return ( + + ); + }, + NFT: ({ nftUrl }: { nftUrl?: string }) => { + return ( + + ); + }, + SENT: () => { + return ( +
+ +
+ ); + }, + RECEIVED: () => { + return ( +
+ +
+ ); + }, + NFT_DEFAULT: () => { + return ( + + ); + }, + ERROR: () => { + return ( +
+ +
+ ); + }, + BURN: () => { + return ( +
+ +
+ ); + }, + DEFAULT: () => { + return ( +
+ +
+ ); + }, +}; diff --git a/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/ListItem.tsx b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/ListItem.tsx new file mode 100644 index 000000000..e0bf61b25 --- /dev/null +++ b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/ListItem.tsx @@ -0,0 +1,347 @@ +import { useMemo } from "react"; +import { isFirstLastListItemStyle } from "@coral-xyz/react-common"; +import { + metadataForRecentSolanaTransaction, + useActiveWallet, +} from "@coral-xyz/recoil"; +import { styles, useCustomTheme } from "@coral-xyz/themes"; +import { ListItem, Skeleton, Typography } from "@mui/material"; +import type { TokenInfo } from "@solana/spl-token-registry"; +import { Source, TransactionType } from "helius-sdk/dist/types"; +import { useRecoilValueLoadable } from "recoil"; + +import { + getTokenData, + getTransactionCaption, + getTransactionTitle, + getTruncatedAddress, + isNFTTransaction, + isUserTxnSender, +} from "./detail-parser"; +import { ListItemIcons } from "./Icons"; +import type { HeliusParsedTransaction } from "./types"; + +// TODO: clean this up. lot of duplicate styling, more efficient way to write this. +const useStyles = styles((theme) => ({ + title: { + color: theme.custom.colors.fontColor, + fontSize: "16px", + fontWeight: 500, + lineHeight: "24px", + }, + caption: { + color: theme.custom.colors.secondary, + fontSize: "12px", + fontWeight: 500, + lineHeight: "24px", + whiteSpace: "nowrap", + overflow: "hidden", + }, + textReceived: { + fontSize: "16px", + color: theme.custom.colors.positive, + lineHeight: "24px", + textAlign: "end", + }, + textSent: { + fontSize: "16px", + color: theme.custom.colors.negative, + lineHeight: "24px", + textAlign: "end", + }, + textSecondary: { + fontSize: "16px", + color: theme.custom.colors.secondary, + lineHeight: "24px", + textAlign: "end", + }, + lineDataWrapper: { + display: "flex", + flexDirection: "column", + justifyContent: "center", + }, +})); + +export function SolanaTransactionListItem({ + transaction, + isFirst, + isLast, + setMetadata, + setTransactionDetail, +}: any) { + const classes = useStyles(); + const theme = useCustomTheme(); + const { contents, state } = useRecoilValueLoadable( + metadataForRecentSolanaTransaction({ transaction }) + ); + const activeWallet = useActiveWallet(); + const tokenData = getTokenData(transaction); + const metadata = (state === "hasValue" && contents) || undefined; + + const onClick = () => { + setMetadata(metadata); + setTransactionDetail(transaction); + }; + + const transactionTitle = getTransactionTitle( + activeWallet, + transaction, + metadata + ); + + return ( + +
+
+
+ +
+
+ + {transactionTitle} + + + {getTransactionCaption( + activeWallet, + transaction, + tokenData, + metadata + )} + +
+
+
+ +
+
+ + ); +} + +// Controls left icon on 'Transactions' list. Created in a way +// that may be easily extended to further/future Helius types +// To add a new ruleset for helius parsed TXN type or source +// 1.) add desired icon to ListItemIcons in "./Icons"; +// 2.) map txn to icon below +function RecentActivityListItemIcon({ + loading, + transaction, + tokenData, + metadata, +}: { + loading: boolean; + transaction: HeliusParsedTransaction; + tokenData: (TokenInfo | undefined)[]; + metadata?: any; +}) { + const activeWallet = useActiveWallet(); + if (loading) { + return ( + + ); + } + + if (transaction?.transactionError) return ; + + if (transaction.type === TransactionType.SWAP) { + return ( + + ); + } + + // if NFT url available, display it. Check on-chain data first + const nftImage = undefined; + // TODO: metadata?.onChaindata?.data?.uri || metadata?.offChainData?.image; + + if (isNFTTransaction(transaction) && nftImage) { + return ; + } + + if (transaction.type === TransactionType.TRANSFER) { + //SOL transfer + if (transaction.source === Source.SYSTEM_PROGRAM) { + return ; + } + + // other SPL token Transfer. Check tokenRegistry first, then Helius metadata + const transferIcon = undefined; + // FIXME: tokenData[0]?.logoURI || + // metadata?.onChaindata?.data?.uri || + // metadata?.offChainData?.image; + + if (transferIcon) + return ; + + // if it is an NFT transfer and no NFT image was found above, show default Icon + if (transaction?.tokenTransfers?.[0]?.tokenStandard === "NonFungible") { + return ; + } + // default + if (isUserTxnSender(transaction, activeWallet)) + return ; + return ; + } + + if ( + transaction?.type === TransactionType.BURN || + transaction?.type === TransactionType.BURN_NFT + ) + return ; + + return ; +} + +// Controls data displayed on right side of 'Transactions' list +function RecentActivityListItemData({ + transaction, + tokenData, + metadata, +}: { + transaction: HeliusParsedTransaction; + tokenData: (TokenInfo | undefined)[]; + metadata?: any; +}) { + const activeWallet = useActiveWallet(); + const classes = useStyles(); + + // FAILURE + if (transaction?.transactionError) { + return
Failed
; + } + + if (transaction.type === TransactionType.SWAP) { + return ( + <> +
+ {"+ " + + transaction?.tokenTransfers?.[1]?.tokenAmount.toFixed(5) + + " " + + tokenData[1]?.symbol || + getTruncatedAddress(transaction?.tokenTransfers?.[1]?.mint)} +
+
+ {"- " + + transaction?.tokenTransfers[0]?.tokenAmount.toFixed(5) + + " " + + tokenData[0]?.symbol || + getTruncatedAddress(transaction?.tokenTransfers?.[0]?.mint)} +
+ + ); + } + // BURN + if ( + transaction?.type === TransactionType.BURN || + transaction?.type === TransactionType.BURN_NFT + ) { + return ( +
+ {transaction?.tokenTransfers[0]?.tokenAmount} +
+ ); + } + + // finish + if (isNFTTransaction(transaction)) { + return
; + } + + if ( + transaction.type === TransactionType.TRANSFER + // || transaction.type === TransactionType.UNKNOWN + ) { + // USER === SENDER + if (isUserTxnSender(transaction, activeWallet)) { + // SOL Transfer + if (transaction.source === Source.SYSTEM_PROGRAM) { + return ( +
+ - {transaction?.nativeTransfers[0]?.amount / 10 ** 9 + " SOL"} +
+ ); + } + return ( +
+ -{" "} + {new Number( + transaction?.tokenTransfers?.[0]?.tokenAmount.toFixed(5) + ) + + " " + + (tokenData[0]?.symbol || + metadata?.onChainMetadata?.metadata?.data?.symbol || + metadata?.offChainData?.symbol || + "")} +
+ ); + + // USER === RECEIVER + } else if (isUserTxnSender(transaction, activeWallet) === false) { + // SOL Transfer + if (transaction.source === Source.SYSTEM_PROGRAM) { + return ( +
+ + {transaction?.nativeTransfers[0]?.amount / 10 ** 9 + " SOL"} +
+ ); + } + return ( +
+ +{" "} + {new Number( + transaction?.tokenTransfers?.[0]?.tokenAmount.toFixed(5) + ) + + " " + + (tokenData[0]?.symbol || + metadata?.onChainMetadata?.metadata?.data?.symbol || + metadata?.offChainData?.symbol || + "")} +
+ ); + } + } + + // default + return
; +} diff --git a/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/NoRecentActivity.tsx b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/NoRecentActivity.tsx new file mode 100644 index 000000000..aa66a76de --- /dev/null +++ b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/NoRecentActivity.tsx @@ -0,0 +1,32 @@ +import { XNFT_GG_LINK } from "@coral-xyz/common"; +import { EmptyState } from "@coral-xyz/react-common"; +import { useCustomTheme } from "@coral-xyz/themes"; +import { Bolt } from "@mui/icons-material"; + +// User has no transactions +export function NoRecentActivityLabel({ minimize }: { minimize: boolean }) { + const theme = useCustomTheme(); + return ( +
+ } + title={"No Recent Activity"} + subtitle={"Get started by adding your first xNFT"} + onClick={() => window.open(XNFT_GG_LINK)} + buttonText={"Browse the xNFT Library"} + contentStyle={{ + color: minimize ? theme.custom.colors.secondary : "inherit", + }} + innerStyle={{ + marginBottom: minimize !== true ? "64px" : 0, // Tab height offset. + }} + minimize={minimize} + /> +
+ ); +} diff --git a/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/RecentSolanaActivityList.tsx b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/RecentSolanaActivityList.tsx new file mode 100644 index 000000000..e086b6c23 --- /dev/null +++ b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/RecentSolanaActivityList.tsx @@ -0,0 +1,104 @@ +import { Fragment, useState } from "react"; +import type { Blockchain } from "@coral-xyz/common"; +import { useRecentTransactions } from "@coral-xyz/recoil"; +import { useCustomTheme } from "@coral-xyz/themes"; +import { List } from "@mui/material"; + +import { formatTimestampListView, groupTxnsByDate } from "./detail-parser"; +import { SolanaTransactionListItem } from "./ListItem"; +import { NoRecentActivityLabel } from "./NoRecentActivity"; +import { TransactionDetail } from "./TransactionDetail"; +import type { HeliusParsedTransaction } from "./types"; + +export function _RecentSolanaActivityList({ + blockchain, + address, + contractAddresses, + transactions: _transactions, + style, + minimize, +}: { + blockchain?: Blockchain; + address?: string; + contractAddresses?: Array; + transactions?: Array; + style?: any; + minimize?: boolean; +}) { + const theme = useCustomTheme(); + const [transactionDetail, setTransactionDetail] = useState(null); + const [metadata, setMetadata] = useState(null); + + // Load transactions if not passed in as a prop + const transactions = _transactions + ? _transactions + : useRecentTransactions({ + blockchain: blockchain!, + address: address!, + contractAddresses: contractAddresses!, + }); + + if (transactionDetail) { + return ( + + ); + } + + const txnsGroupedByDate = groupTxnsByDate(transactions); + + return transactions?.length > 0 ? ( +
+ {txnsGroupedByDate.map((group: HeliusParsedTransaction[], i: number) => { + return ( + +
+ {formatTimestampListView(group[0].timestamp)} +
+ + {group.map((tx: HeliusParsedTransaction, idx: number) => ( + + ))} + + + ); + })} +
+ ) : ( + + ); +} diff --git a/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/TransactionDetail.tsx b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/TransactionDetail.tsx new file mode 100644 index 000000000..29c616ccb --- /dev/null +++ b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/TransactionDetail.tsx @@ -0,0 +1,608 @@ +import type { Dispatch, SetStateAction } from "react"; +import { useState } from "react"; +import { useNavigate } from "react-router-dom"; +import { Blockchain, explorerUrl } from "@coral-xyz/common"; +import { PrimaryButton } from "@coral-xyz/react-common"; +import { + SOL_LOGO_URI, + useActiveWallet, + useBlockchainConnectionUrl, + useBlockchainExplorer, +} from "@coral-xyz/recoil"; +import { styles, useCustomTheme } from "@coral-xyz/themes"; +import { + ArrowDownwardRounded, + ArrowRightAltRounded, + CallMade, + CancelTwoTone, + CheckCircleTwoTone, + Image, + SendRounded, + WhatshotRounded, +} from "@mui/icons-material"; +import { Card, List } from "@mui/material"; +import type { TokenInfo } from "@solana/spl-token-registry"; +import { Source, TransactionType } from "helius-sdk/dist/types"; + +import { WithDrawer } from "../../../common/Layout/Drawer"; +import { NavBackButton } from "../../../common/Layout/Nav"; +import { + NavStackEphemeral, + NavStackScreen, +} from "../../../common/Layout/NavStack"; + +import { + formatTimestamp, + getTokenData, + getTransactionDetailTitle, + getTransactionTitle, + getTruncatedAddress, + isNFTTransaction, + isUserTxnSender, +} from "./detail-parser"; +import type { HeliusParsedTransaction } from "./types"; + +const useStyles = styles((theme) => ({ + transactionCard: { + display: "flex", + padding: "16px", + paddingTop: "24px", + flexDirection: "column", + height: "100%", + alignItems: "center", + backgroundColor: theme.custom.colors.background, + }, + nft: { + borderRadius: "2px", + width: "168px", + height: "168px", + }, + ctaButton: { + margin: "16px", + width: "100%", + color: theme.custom.colors.fontColor, + backgrounColor: theme.custom.colors.secondaryButton, + }, + detailList: { + marginTop: "16px", + paddingTop: 0, + paddingBottom: 0, + marginLeft: "16px", + marginRight: "16px", + borderRadius: "14px", + width: "100%", + fontSize: "14px", + border: `${theme.custom.colors.borderFull}`, + }, + firstRow: { + paddingLeft: "12px", + paddingRight: "12px", + paddingTop: "10px", + paddingBottom: "10px", + display: "flex", + borderBottom: `solid 1pt ${theme.custom.colors.border}`, + borderTopLeftRadius: "12px", + borderTopRightRadius: "12px", + backgroundColor: theme.custom.colors.nav, + }, + middleRow: { + paddingLeft: "12px", + paddingRight: "12px", + paddingTop: "10px", + paddingBottom: "10px", + display: "flex", + borderBottom: `solid 1pt ${theme.custom.colors.border}`, + backgroundColor: theme.custom.colors.nav, + }, + lastRow: { + paddingLeft: "12px", + paddingRight: "12px", + paddingTop: "10px", + paddingBottom: "10px", + display: "flex", + borderBottomLeftRadius: "12px", + borderBottomRightRadius: "12px", + backgroundColor: theme.custom.colors.nav, + "&:hover": { + cursor: "pointer", + }, + }, + cell: { + width: "100%", + display: "flex", + justifyContent: "space-between", + }, + cellValue: { + display: "flex", + alignItems: "center", + fontWeight: 500, + color: theme.custom.colors.fontColor, + }, + confirmedStatus: { + color: "#35A63A", + }, + failedStatus: { + color: "#E95050", + }, + label: { color: theme.custom.colors.secondary }, + transferAmount: { + fontSize: "30px", + color: theme.custom.colors.fontColor, + fontWeight: 600, + marginTop: "8px", + }, + tokenLogo: { + borderRadius: "50%", + width: "56px", + height: "56px", + }, +})); + +export function TransactionDetail({ + metadata, + transaction, + setMetadata, + setTransactionDetail, +}: { + metadata: any; + transaction: HeliusParsedTransaction; + setMetadata: Dispatch>; + setTransactionDetail: Dispatch>; +}) { + const theme = useCustomTheme(); + const classes = useStyles(); + const activeWallet = useActiveWallet(); + const navigate = useNavigate(); + const [openDrawer, setOpenDrawer] = useState(true); + + // TODO - this is duplicated in ListItem.tsx, better to pass in setTransactionDetail state + const tokenData = getTokenData(transaction); + + return ( + +
+ { + return { + title: getTransactionDetailTitle( + activeWallet, + transaction, + activeWallet?.publicKey + ), + }; + }} + navButtonLeft={ + { + setTransactionDetail(null); + setMetadata(null); + setOpenDrawer(false); + }} + /> + } + > + ( + +
+ +
+ + {/* TODO - Default to check/error */} + + {/* TODO - add other functionality for this CTA button. Will need to + create mappings for 'verified' sites to determine correct URL*/} + {transaction?.type === TransactionType.NFT_SALE && + transaction?.events?.nft?.buyer === + activeWallet.publicKey && ( + { + navigate("/nfts"); + }} + /> + )} + + + + )} + /> + +
+ + ); +} + +// similar to RecentActivityListItemIcon in ListItem.tsx. Controls graphic displayed in +// top-half of detail card. May be best to further abstract to icon Object map (like in RecentSolanaActivity/Icons.tsx) +function DetailCardHeader({ + transaction, + tokenData, + metadata, +}: { + transaction: HeliusParsedTransaction; + tokenData: (TokenInfo | undefined)[]; + metadata?: any; +}) { + const classes = useStyles(); + const theme = useCustomTheme(); + const activeWallet = useActiveWallet(); + if (transaction?.transactionError) + return ( + + ); + + if (transaction.type === TransactionType.SWAP) { + return ( +
+
+ + +
+ {transaction?.tokenTransfers[0]?.tokenAmount.toFixed(5) + + " " + + tokenData[0]?.symbol || + getTruncatedAddress(transaction?.tokenTransfers?.[0]?.mint) || + "UNKWN"} +
+
+ + + +
+ +
+ {transaction?.tokenTransfers[1]?.tokenAmount.toFixed(5) + + " " + + tokenData[1]?.symbol || + getTruncatedAddress(transaction?.tokenTransfers?.[0]?.mint) || + "UNKWN"} +
+
+
+ ); + } + + // if NFT url available, display it. Check on-chain data first + const nftImage = undefined; + // FIXME: metadata?.onChainMetadata?.metadata?.data?.uri || metadata?.offChainData?.image; + + const nftPrice = transaction?.events?.nft?.amount + ? transaction?.events?.nft?.amount / 10 ** 9 + : null; + + if (isNFTTransaction(transaction) && nftImage) { + return ( + <> + +
+ {getTransactionTitle(activeWallet, transaction)} +
+ {nftPrice && ( +
+ +
+ {nftPrice + " SOL"} +
+
+ )} + + ); + } + + if (transaction.type === TransactionType.TRANSFER) { + //SOL transfer + if (transaction.source === Source.SYSTEM_PROGRAM) { + return ( + <> + +
+ {isUserTxnSender(transaction, activeWallet) + ? "- " + + transaction?.nativeTransfers?.[0]?.amount / 10 ** 9 + + " SOL" + : "+ " + + transaction?.nativeTransfers?.[0]?.amount / 10 ** 9 + + " SOL"} +
+ + ); + } + // other SPL token Transfer. Check tokenRegistry first, then Helius metadata + const transferIcon = undefined; + // FIXME: tokenData[0]?.logoURI || + // metadata?.onChaindata?.data?.uri || + // metadata?.offChainData?.image; + + const transferSymbol = + tokenData[0]?.symbol || metadata?.onChainMetadata?.metadata?.data?.symbol; + // FIXME: || metadata?.offChainData?.symbol; + + if (transferIcon) { + return ( + <> + +
+ {isUserTxnSender(transaction, activeWallet) + ? "- " + + transaction?.tokenTransfers?.[0]?.tokenAmount + + " " + + (transferSymbol && transferSymbol) + : "+ " + + transaction?.tokenTransfers?.[0]?.tokenAmount + + " " + + (transferSymbol && transferSymbol)} +
+ + ); + } + + // if it is an NFT transfer and no NFT image was found above, show default Icon + if (transaction?.tokenTransfers?.[0]?.tokenStandard === "NonFungible") { + return ( + + ); + } + // default + if (isUserTxnSender(transaction, activeWallet)) + return ( + + ); + return ( + + ); + } + + if ( + transaction?.type === TransactionType.BURN || + transaction?.type === TransactionType.BURN + ) + return ( + + ); + + return ( + + ); +} + +function DetailTable({ + transaction, + tokenData, +}: { + transaction: HeliusParsedTransaction; + tokenData: (TokenInfo | undefined)[]; +}) { + const classes = useStyles(); + const theme = useCustomTheme(); + const explorer = useBlockchainExplorer(Blockchain.SOLANA); + const connectionUrl = useBlockchainConnectionUrl(Blockchain.SOLANA); + const activeWallet = useActiveWallet(); + + return ( + +
+
+
Date
+ +
+ {formatTimestamp(transaction?.timestamp)} +
+
+
+ + {(transaction?.type === TransactionType.UNKNOWN || + transaction.type === TransactionType.TRANSFER) && + isUserTxnSender(transaction, activeWallet) && ( +
+
+
To
+ +
+ {getTruncatedAddress( + transaction?.tokenTransfers?.[0]?.toUserAccount || + transaction?.nativeTransfers?.[0]?.toUserAccount + )} +
+
+
+ )} + {(transaction?.type === TransactionType.UNKNOWN || + transaction.type === TransactionType.TRANSFER) && + isUserTxnSender(transaction, activeWallet) === false && ( +
+
+
From
+ +
+ {getTruncatedAddress( + transaction?.tokenTransfers?.[0]?.fromUserAccount || + transaction?.nativeTransfers?.[0]?.fromUserAccount + )} +
+
+
+ )} + + {transaction?.type === TransactionType.SWAP && ( + <> +
+
+
You paid
+ +
+ {transaction?.tokenTransfers[0]?.tokenAmount.toFixed(5) + + " " + + tokenData[0]?.symbol || + getTruncatedAddress(transaction?.tokenTransfers?.[0]?.mint) || + "UKNWN"} +
+
+
+
+
+
You Received
+ +
+ {transaction?.tokenTransfers[1]?.tokenAmount.toFixed(5) + + " " + + tokenData[1]?.symbol || + getTruncatedAddress(transaction?.tokenTransfers?.[0]?.mint) || + "UNKWN"} +
+
+
+ + )} + {/* ALL txn types have first row (Date) rest of data + rows below (Network Fee, Status, Signature)*/} +
+
+
Network Fee
+ +
+ {transaction?.fee / 10 ** 9} SOL +
+
+
+
+
+
Status
+ + {transaction?.transactionError ? ( +
Failed
+ ) : ( +
Confirmed
+ )} +
+
+
{ + window.open( + explorerUrl(explorer!, transaction.signature, connectionUrl!) + ); + }} + > +
+
Signature
+ +
+ {getTruncatedAddress(transaction?.signature)} + +
+
+
+ + ); +} diff --git a/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/detail-parser.ts b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/detail-parser.ts new file mode 100644 index 000000000..5016177c0 --- /dev/null +++ b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/detail-parser.ts @@ -0,0 +1,307 @@ +import { SOL_NATIVE_MINT } from "@coral-xyz/common"; +import { useActiveWallet, useSplTokenRegistry } from "@coral-xyz/recoil"; +import type { TokenInfo } from "@solana/spl-token-registry"; +import { NftEventTypes, Source, TransactionType } from "helius-sdk/dist/types"; + +import type { HeliusParsedTransaction } from "./types"; + +export const isNFTTransaction = ( + transaction: HeliusParsedTransaction +): boolean => { + return ( + NftEventTypes.includes(transaction?.type as TransactionType) || + transaction?.tokenTransfers[0]?.tokenStandard === "NonFungible" + ); +}; + +export const formatTimestamp = (timestamp: number): string => { + const date = new Date(timestamp * 1000); + let hours = date.getHours(); + let minutes: string | number = date.getMinutes(); + let ampm = hours >= 12 ? "pm" : "am"; + hours = hours % 12; + hours = hours ? hours : 12; // the hour '0' should be '12' + minutes = minutes < 10 ? "0" + minutes : minutes; + return ( + date.getDate() + + " " + + new Intl.DateTimeFormat("en-US", { month: "long" }).format(date) + + ", at " + + hours + + ":" + + minutes + + " " + + ampm + ); +}; + +export const formatTimestampListView = (timestamp: number): string => { + const date = new Date(timestamp * 1000); + return ( + date.getDate() + + " " + + new Intl.DateTimeFormat("en-US", { month: "long" }).format(date) + + ", " + + date.getFullYear() + ); +}; + +export const groupTxnsByDate = ( + arr: HeliusParsedTransaction[] +): HeliusParsedTransaction[][] => { + const result: HeliusParsedTransaction[][] = []; + let currentDate = ""; + + for (const item of arr) { + const date = new Date(item?.timestamp * 1000).toDateString(); + if (date !== currentDate) { + currentDate = date; + result.push([]); + } + result[result.length - 1].push(item); + } + return result; +}; + +export const getSourceOrTypeFormatted = (sourceOrType: string): string => { + return sourceOrType + .replaceAll("_", " ") + .split(" ") + .map((word) => word.charAt(0) + word.slice(1).toLowerCase()) + .join(" "); +}; + +export const getTruncatedAddress = (address: string): string => { + return `${address?.slice(0, 5)}...${address?.slice(address?.length - 5)}`; +}; + +export const isUserTxnSender = ( + transaction: HeliusParsedTransaction, + activeWallet: any +) => { + if ( + transaction?.tokenTransfers[0]?.fromUserAccount === + activeWallet.publicKey || + transaction?.nativeTransfers[0]?.fromUserAccount === activeWallet.publicKey + ) + return true; + + if ( + transaction?.tokenTransfers[0]?.toUserAccount === activeWallet.publicKey || + transaction?.nativeTransfers[0]?.toUserAccount === activeWallet.publicKey + ) + return false; + + return null; +}; + +export function getTransactionTitle( + activeWallet: any, + transaction: HeliusParsedTransaction, + metadata?: any +): string { + switch (transaction.type) { + case TransactionType.BURN: + case TransactionType.BURN_NFT: + return "Burned"; + case TransactionType.TRANSFER: + // send/receive NFT's are returned as TransactionType.TRANSFER + const nftName = metadata?.onChainMetadata?.metadata?.data?.name; // FIXME: || metadata?.offChainData?.name; + if (isNFTTransaction(transaction) && nftName) { + return nftName; + } else if (isUserTxnSender(transaction, activeWallet)) { + return "Sent"; + } else if (isUserTxnSender(transaction, activeWallet) === false) { + return "Received"; + } else { + return "App Interaction"; + } + case TransactionType.SWAP: + return "Token Swap"; + case TransactionType.NFT_MINT: { + const nftName = metadata?.onChainMetadata?.metadata?.data?.name; // FIXME: || metadata?.offChainData?.name; + return `Minted: ${nftName}`; + } + default: + let title = "App Interaction"; + + // if (transaction?.source) title = "App Interaction"; + // if transaction is of type NFT and was not caught above under 'TRANSFER' case + // TODO: test this case to see if it is necessary + const nonTransferNftName = + metadata?.onChainMetadata?.metadata?.data?.name; + // FIXME: || metadata?.offChainData?.name; + + if (isNFTTransaction(transaction) && nonTransferNftName) { + return nonTransferNftName; + } + + // txn has a transactionError + if (transaction?.transactionError) { + title = "Failed"; + } + + // if we have a type, format it and set it as the title + // if (transaction?.type && transaction?.type !== TransactionType.UNKNOWN) { + // title = getSourceOrTypeFormatted(transaction.type); + // return title; + // } + + return title; + } +} + +export const getTransactionDetailTitle = ( + activeWallet: any, + transaction: HeliusParsedTransaction, + publicKey: string +) => { + switch (transaction.type) { + case TransactionType.BURN: + case TransactionType.BURN_NFT: + return "Burned"; + + case TransactionType.TRANSFER: + if (isUserTxnSender(transaction, activeWallet)) return "Sent"; + else if (isUserTxnSender(transaction, activeWallet) === false) + return "Received"; + return "App Interaction"; + + case TransactionType.SWAP: + return "Swap"; + + case TransactionType.NFT_SALE: + return transaction?.events?.nft?.seller === publicKey ? "Sold" : "Bought"; + + case TransactionType.NFT_LISTING: + return "Listed"; + + case TransactionType.NFT_CANCEL_LISTING: + return "Listed Canceled"; + + case TransactionType.NFT_MINT: + return "Minted NFT"; + + default: + let title = "App Interaction"; + + if (transaction?.transactionError) { + title = "Failed"; + } + + return title; + } +}; + +// used to display txn caption in list view +export const getTransactionCaption = ( + activeWallet: any, + transaction: HeliusParsedTransaction, + tokenData: (TokenInfo | undefined)[], + metadata?: any +): string => { + switch (transaction.type) { + // case TransactionType.UNKNOWN: + case TransactionType.TRANSFER: + if (isUserTxnSender(transaction, activeWallet)) { + return `To: ${getTruncatedAddress( + transaction?.tokenTransfers[0]?.toUserAccount || + transaction?.nativeTransfers[0]?.toUserAccount + )}`; + } else if (isUserTxnSender(transaction, activeWallet) === false) { + return `From: ${getTruncatedAddress( + transaction?.tokenTransfers[0]?.fromUserAccount || + transaction?.nativeTransfers[0]?.fromUserAccount + )}`; + } + // if (TransactionType.TRANSFER) return "Transferred"; + return transaction?.source && + transaction?.source !== TransactionType.UNKNOWN + ? getSourceOrTypeFormatted(transaction?.source) + : ""; + + case TransactionType.SWAP: + // fallback to truncated mint address if token metadata was not found + return `${ + tokenData?.[0]?.symbol ?? + getTruncatedAddress(transaction?.tokenTransfers?.[0]?.mint) + } -> ${ + tokenData?.[1]?.symbol ?? + getTruncatedAddress(transaction?.tokenTransfers?.[1]?.mint) + }`; + + case TransactionType.NFT_LISTING: + return `Listed on ${getSourceOrTypeFormatted(transaction.source)}`; + + case TransactionType.NFT_SALE: + return `${ + transaction?.events?.nft?.buyer === activeWallet.publicKey + ? "Bought" + : "Sold" + } on ${getSourceOrTypeFormatted(transaction.source)}`; + + case TransactionType.NFT_CANCEL_LISTING: + return `Canceled listing on ${getSourceOrTypeFormatted( + transaction.source + )}`; + + // case TransactionType.BURN: + // return transaction?. + case TransactionType.NFT_MINT: + return getTruncatedAddress( + metadata?.onChainMetadata?.metadata?.collection?.key + ); + + default: + if (transaction?.source === Source.CARDINAL_RENT) return "Rent Paid"; + + // disable additional cases for now. Can uncomment/extend when needed + // if (transaction?.description) + // return transaction?.description.split(" ")?.slice(1).join(" "); + + // if ( + // transaction?.source && + // transaction?.source !== TransactionType.UNKNOWN + // ) + // return getSourceOrTypeFormatted(transaction.source); + return getTruncatedAddress(transaction?.instructions[0].programId); + } +}; + +export const getTokenData = ( + transaction: HeliusParsedTransaction +): (TokenInfo | undefined)[] => { + const tokenRegistry = useSplTokenRegistry(); + + let tokenData: (TokenInfo | undefined)[] = []; + + if (transaction.type === TransactionType.SWAP) { + // if token is isNativeInput/isNativeOutput, token swap is to/from SOL + let tokenInput, tokenOutput; + const isNativeInput = transaction.events?.swap?.nativeInput; + const isNativeOutput = transaction.events?.swap?.nativeOutput; + tokenInput = isNativeInput + ? SOL_NATIVE_MINT + : transaction.events?.swap?.tokenInputs?.[0]?.mint; + tokenOutput = isNativeOutput + ? SOL_NATIVE_MINT + : transaction.events?.swap?.tokenOutputs?.[0]?.mint; + + if (tokenInput && tokenRegistry.get(tokenInput)) { + tokenData.push(tokenRegistry.get(tokenInput)); + } + if (tokenOutput && tokenRegistry.get(tokenOutput)) { + tokenData.push(tokenRegistry.get(tokenOutput)); + } + } + + // add appropriate token metadata + if (transaction.type === TransactionType.TRANSFER) { + const transferredToken = transaction.tokenTransfers?.[0]?.mint; + if (transferredToken && tokenRegistry.get(transferredToken)) { + tokenData.push(tokenRegistry.get(transferredToken)); + } + } + + return tokenData; +}; diff --git a/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/types.ts b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/types.ts new file mode 100644 index 000000000..7dfa30a02 --- /dev/null +++ b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/types.ts @@ -0,0 +1,41 @@ +export type Instruction = { + accounts: Array; + data: string; + programId: string; + innerInstructions: Array; +}; + +export type TokenTransfer = { + fromTokenAccount: string; + fromUserAccount: string; + mint: string; + toTokenAccount: string; + toUserAccount: string; + tokenAmount: number; + tokenStandard: string; +}; + +export type AccountData = { + accounts: string; + nativeBalanceChange: number; + tokenBalanceChanges: Array; + innerInstructions: Array; +}; + +export type HeliusParsedTransaction = { + accountData: Array; + blockchain: string; + description: string; + events: any; + fee: number; + feePayer: string; + instructions: Array; + nativeTransfers: Array; + signature: string; + slot: number; + source: string; + timestamp: number; + tokenTransfers: Array; + transactionError: string | null; + type: string; +}; diff --git a/packages/app-extension/src/components/Unlocked/Balances/StripeRamp.tsx b/packages/app-extension/src/components/Unlocked/Balances/StripeRamp.tsx index f368ed3c2..6633a2982 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/StripeRamp.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/StripeRamp.tsx @@ -5,7 +5,7 @@ import type { CustomTheme } from "@coral-xyz/themes"; import { styles } from "@coral-xyz/themes"; import { Typography } from "@mui/material"; -import { useNavStack } from "../../common/Layout/NavStack"; +import { useDrawerContext } from "../../common/Layout/Drawer"; const STRIP_RAMP_URL = "https://auth.xnfts.dev"; @@ -35,10 +35,10 @@ export const StripeRamp = ({ blockchain: Blockchain; publicKey: string; }) => { + const { close } = useDrawerContext(); const [, setLoading] = useState(false); const [err, setErr] = useState(""); const [, setClientSecret] = useState(false); - const nav = useNavStack(); const classes = useStyles(); const fetchToken = () => { @@ -66,7 +66,7 @@ export const StripeRamp = ({ width=400, height=600` ); - nav.close(); + close(); }) .catch((e) => { console.error(e); diff --git a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Deposit.tsx b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Deposit.tsx index ed381d6a2..5579a787e 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Deposit.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Deposit.tsx @@ -1,8 +1,7 @@ -import { useEffect, useState } from "react"; +import { useState } from "react"; import { Blockchain } from "@coral-xyz/common"; import { SecondaryButton } from "@coral-xyz/react-common"; import { - useActiveWallets, useAllWalletsDisplayed, useBlockchainLogo, useWalletName, @@ -14,7 +13,6 @@ import { IconButton, Modal, Typography } from "@mui/material"; import { TextField, walletAddressDisplay } from "../../../common"; import { CloseButton, useDrawerContext } from "../../../common/Layout/Drawer"; -import { useNavStack } from "../../../common/Layout/NavStack"; import { WithCopyTooltip } from "../../../common/WithCopyTooltip"; export function Deposit({ ...props }: any) { @@ -32,15 +30,9 @@ export function Deposit({ ...props }: any) { } function DepositMultiWallet() { - const nav = useNavStack(); const { close } = useDrawerContext(); const activeWallets = useAllWalletsDisplayed(); - useEffect(() => { - nav.setStyle({ - borderBottom: "none", - }); - }, []); return (
@@ -325,7 +325,7 @@ function TransferButton({ } function SendToken() { - const { push } = useNavStack(); + const { push } = useNavigation(); const onClickRow = (blockchain: Blockchain, token: Token) => { push("send", { blockchain, token }); diff --git a/packages/app-extension/src/components/Unlocked/Swap.tsx b/packages/app-extension/src/components/Unlocked/Swap.tsx index 5b7d35f25..b4a78fc87 100644 --- a/packages/app-extension/src/components/Unlocked/Swap.tsx +++ b/packages/app-extension/src/components/Unlocked/Swap.tsx @@ -18,6 +18,7 @@ import { } from "@coral-xyz/react-common"; import { useActiveWallet, + useDarkMode, useJupiterOutputMints, useSplTokenRegistry, useSwapContext, @@ -32,7 +33,7 @@ import { TextField } from "../common"; import { ApproveTransactionDrawer } from "../common/ApproveTransactionDrawer"; import { BottomCard } from "../common/Layout/BottomCard"; import { useDrawerContext } from "../common/Layout/Drawer"; -import { useNavStack } from "../common/Layout/NavStack"; +import { useNavigation } from "../common/Layout/NavStack"; import { TokenAmountHeader } from "../common/TokenAmountHeader"; import { TokenInputField } from "../common/TokenInput"; import type { Token } from "../common/TokenTable"; @@ -203,9 +204,13 @@ enum SwapState { } export function Swap({ blockchain }: { blockchain: Blockchain }) { - const nav = useNavStack(); + const isDark = useDarkMode(); + const nav = useNavigation(); useEffect(() => { - nav.setTitle("Swap"); + nav.setOptions({ + headerTitle: "Swap", + style: isDark ? { background: "#1D1D20" } : undefined, + }); }, [nav]); if (blockchain && blockchain !== Blockchain.SOLANA) { @@ -216,6 +221,7 @@ export function Swap({ blockchain }: { blockchain: Blockchain }) { } function _Swap() { + const isDark = useDarkMode(); const classes = useStyles(); const { swapToFromMints } = useSwapContext(); const [openDrawer, setOpenDrawer] = useState(false); @@ -237,7 +243,12 @@ function _Swap() { return ( <> -
+
boolean; input: boolean; }) { - const nav = useNavStack(); + const isDark = useDarkMode(); + const theme = useCustomTheme(); + const nav = useNavigation(); const { fromMint, inputTokenAccounts } = useSwapContext(); const tokenAccounts = !input ? useJupiterOutputMints(fromMint) @@ -832,7 +845,12 @@ export function SwapSelectToken({ }; useEffect(() => { - nav.setTitle("Select Token"); + nav.setOptions({ + headerTitle: "Select Token", + style: isDark + ? { background: theme.custom.colors.background } + : undefined, + }); }, [nav]); return ( diff --git a/packages/app-extension/src/components/Unlocked/WithAuth.tsx b/packages/app-extension/src/components/Unlocked/WithAuth.tsx index 2c26ad793..daea9328a 100644 --- a/packages/app-extension/src/components/Unlocked/WithAuth.tsx +++ b/packages/app-extension/src/components/Unlocked/WithAuth.tsx @@ -84,10 +84,10 @@ export function WithAuth({ children }: { children: React.ReactElement }) { method: UI_RPC_METHOD_SIGN_MESSAGE_FOR_PUBLIC_KEY, params: [ authData.blockchain, + authData.publicKey, ethers.utils.base58.encode( Buffer.from(authData.message, "utf-8") ), - authData.publicKey, ], }); setAuthSignature(signature); diff --git a/packages/app-extension/src/components/Unlocked/index.tsx b/packages/app-extension/src/components/Unlocked/index.tsx index 1c6b1ecf8..7ad49da02 100644 --- a/packages/app-extension/src/components/Unlocked/index.tsx +++ b/packages/app-extension/src/components/Unlocked/index.tsx @@ -2,6 +2,7 @@ import { useBootstrapFast } from "@coral-xyz/recoil"; import { Router } from "../common/Layout/Router"; import { WithTabs } from "../common/Layout/Tab"; +import { WalletDrawerProvider } from "../common/WalletList"; import { ApproveTransactionRequest } from "./ApproveTransactionRequest"; import { WithVersion } from "./WithVersion"; @@ -15,16 +16,18 @@ export function Unlocked() { return ( -
- - -
+ +
+ + +
+ ); diff --git a/packages/app-extension/src/components/common/Account/ImportAccounts.tsx b/packages/app-extension/src/components/common/Account/ImportWallets.tsx similarity index 90% rename from packages/app-extension/src/components/common/Account/ImportAccounts.tsx rename to packages/app-extension/src/components/common/Account/ImportWallets.tsx index 1bd018bfc..8de928922 100644 --- a/packages/app-extension/src/components/common/Account/ImportAccounts.tsx +++ b/packages/app-extension/src/components/common/Account/ImportWallets.tsx @@ -4,10 +4,14 @@ import { Blockchain, DEFAULT_SOLANA_CLUSTER, EthereumConnectionUrl, + ethereumIndexed, legacyBip44ChangeIndexed, legacyBip44Indexed, + legacyLedgerIndexed, + legacyLedgerLiveIndexed, legacySolletIndexed, LOAD_PUBLIC_KEY_AMOUNT, + UI_RPC_METHOD_FIND_SERVER_PUBLIC_KEY_CONFLICTS, UI_RPC_METHOD_KEYRING_STORE_READ_ALL_PUBKEYS, UI_RPC_METHOD_PREVIEW_PUBKEYS, } from "@coral-xyz/common"; @@ -28,7 +32,6 @@ import * as anchor from "@project-serum/anchor"; import { Connection as SolanaConnection, PublicKey } from "@solana/web3.js"; import { BigNumber, ethers } from "ethers"; -import { useConflictQuery } from "../../../hooks/useConflictQuery"; import { Checkbox, Header, @@ -40,7 +43,7 @@ const { base58: bs58 } = ethers.utils; const DISPLAY_PUBKEY_AMOUNT = 5; -export function ImportAccounts({ +export function ImportWallets({ blockchain, mnemonic, transport, @@ -49,14 +52,13 @@ export function ImportAccounts({ allowMultiple = true, }: { blockchain: Blockchain; - mnemonic?: string; - transport?: Transport | null; + mnemonic?: string | true; + transport?: Transport; onNext: (walletDescriptor: Array) => void; onError?: (error: Error) => void; allowMultiple?: boolean; }) { const background = useBackgroundClient(); - const checkPublicKeyConflicts = useConflictQuery(); const theme = useCustomTheme(); // Loaded balances for each public key @@ -116,25 +118,37 @@ export function ImportAccounts({ : [] ), [Blockchain.ETHEREUM]: [ + /** + // Used in older versions of Backpack { path: (i: number) => legacyBip44Indexed(Blockchain.ETHEREUM, i), - label: "m/44/501'/", + label: "m/44/60'/", + }, + **/ + { + path: (i: number) => legacyLedgerLiveIndexed(i), + label: "m/44/60' - Ledger Live", }, + /** + // Used in older versions of Backpack { path: (i: number) => legacyBip44ChangeIndexed(Blockchain.ETHEREUM, i), - label: "m/44/501'/0'", + label: "m/44/60'/0'", }, + **/ { - path: (i: number) => - legacyBip44ChangeIndexed(Blockchain.ETHEREUM, i) + "/0'", - label: "m/44/501'/0'/0'", + path: (i: number) => legacyLedgerIndexed(i), + label: "m/44/60'/0' - Ledger", }, - /** { - path: (i: number) => getIndexedPath(Blockchain.SOLANA, i), - label: "Backpack", + path: (i: number) => ethereumIndexed(i), + label: "m/44/60'/0'/0 - Ethereum Standard", + }, + { + path: (i: number) => + legacyBip44ChangeIndexed(Blockchain.ETHEREUM, i) + "/0'", + label: "m/44/60'/0'/0'", }, - **/ ], }[blockchain]; @@ -158,7 +172,7 @@ export function ImportAccounts({ .flat() .map((a: any) => a.publicKey) ); - } catch { + } catch (error) { // Keyring store locked, either onboarding or left open } })(); @@ -171,13 +185,21 @@ export function ImportAccounts({ (async () => { if (walletDescriptors.length === 0) return; try { - const response = await checkPublicKeyConflicts( - walletDescriptors.map((a) => ({ - blockchain, - publicKey: a.publicKey, - })) + const response = await background.request({ + method: UI_RPC_METHOD_FIND_SERVER_PUBLIC_KEY_CONFLICTS, + params: [ + walletDescriptors.map((w) => ({ + publicKey: w.publicKey, + blockchain, + })), + ], + }); + setConflictingPublicKeys( + response.map( + (r: { user_id: string; public_key: string; blockchain: string }) => + r.public_key + ) ); - setConflictingPublicKeys(response.map((r: any) => r.public_key)); } catch { // If the query failed assume all are valid } @@ -193,6 +215,8 @@ export function ImportAccounts({ setCheckedWalletDescriptors([]); let loaderFn; + // `mnemonic` can be true here if we aren't passing the mnemonic then it + // can be taken from the unlocked keyring on the backend if (mnemonic) { // Loading accounts from a mnemonic loaderFn = (derivationPaths: Array) => @@ -202,7 +226,7 @@ export function ImportAccounts({ loaderFn = (derivationPaths: Array) => loadLedgerPublicKeys(transport, derivationPaths); } else { - return; + throw new Error("no public key loader found"); } loaderFn(derivationPaths) @@ -302,11 +326,11 @@ export function ImportAccounts({ }; // - // Load accounts for the given mnemonic. This is passed to the ImportAccounts + // Load accounts for the given mnemonic. This is passed to the ImportWallets // component and called whenever the derivation path is changed with the selector. // const loadMnemonicPublicKeys = async ( - mnemonic: string, + mnemonic: string | true, derivationPaths: Array ) => { return await background.request({ @@ -398,9 +422,9 @@ export function ImportAccounts({ marginTop: "24px", }} > -
+
- Select which account{allowMultiple ? "s" : ""} you'd like to import. + Select which wallet{allowMultiple ? "s" : ""} you'd like to import.
@@ -513,7 +537,7 @@ export function ImportAccounts({ }} > onNext(checkedWalletDescriptors)} disabled={walletDescriptors.length === 0} /> diff --git a/packages/app-extension/src/components/common/Account/MnemonicInput.tsx b/packages/app-extension/src/components/common/Account/MnemonicInput.tsx index 453a7c3a8..10f269308 100644 --- a/packages/app-extension/src/components/common/Account/MnemonicInput.tsx +++ b/packages/app-extension/src/components/common/Account/MnemonicInput.tsx @@ -59,6 +59,7 @@ const useStyles = makeStyles((theme: any) => ({ errorMsg: { color: "red", marginBottom: "12px", + textAlign: "center", }, })); diff --git a/packages/app-extension/src/components/common/Layout/ActionCard.tsx b/packages/app-extension/src/components/common/Layout/ActionCard.tsx index a711087cf..6c14252f6 100644 --- a/packages/app-extension/src/components/common/Layout/ActionCard.tsx +++ b/packages/app-extension/src/components/common/Layout/ActionCard.tsx @@ -1,16 +1,18 @@ import { useCustomTheme } from "@coral-xyz/themes"; -import { Box, Button, Card, CardContent } from "@mui/material"; +import { Box, Button, Card, CardContent, Typography } from "@mui/material"; export function ActionCard({ icon, text, textAdornment, + subtext, onClick, disabled = false, }: { - icon: any; + icon?: any; text: string; textAdornment?: React.ReactNode; + subtext?: string; onClick: () => void; disabled?: boolean; }) { @@ -42,7 +44,7 @@ export function ActionCard({ }} > - {icon} + {icon && {icon}} {text} {textAdornment} + {subtext ? ( + + {subtext} + + ) : null} diff --git a/packages/app-extension/src/components/common/Layout/NavStack.tsx b/packages/app-extension/src/components/common/Layout/NavStack.tsx index ad0114739..16abf682d 100644 --- a/packages/app-extension/src/components/common/Layout/NavStack.tsx +++ b/packages/app-extension/src/components/common/Layout/NavStack.tsx @@ -1,4 +1,4 @@ -import React, { useContext, useState } from "react"; +import React, { type CSSProperties, useContext, useState } from "react"; import { AnimatePresence } from "framer-motion"; import { WithMotion } from "../../../plugin/Component"; @@ -15,18 +15,14 @@ export function NavStackEphemeral({ initialRoute, children, options, - style, navButtonRight, navButtonLeft, - onClose, }: { initialRoute: { name: string; title?: string; props?: any }; children: any; options: NavStackOptions; - style?: React.CSSProperties; navButtonRight?: React.ReactNode; navButtonLeft?: React.ReactNode; - onClose?: () => void; }) { const isArray = children && children.length !== undefined; const navScreens = @@ -34,10 +30,8 @@ export function NavStackEphemeral({ return ( @@ -57,10 +51,9 @@ function NavStackInner({ pop, navButtonRight, navButtonLeft, + navStyle, title, - style, - contentStyle, - } = useNavStack(); + } = useNavigation(); const _navButtonLeft = navButtonLeft && isRoot ? ( navButtonLeft @@ -84,8 +77,7 @@ function NavStackInner({ title={title} navButtonLeft={_navButtonLeft} navButtonRight={navButtonRight} - navbarStyle={style} - navContentStyle={contentStyle} + navbarStyle={navStyle} > {activeScreen.props.component({ ...(activeRoute.props ?? {}) })} @@ -98,9 +90,7 @@ function NavStackProvider({ initialRoute, navButtonRight, navButtonLeft, - style, children, - onClose, }: any) { const [stack, setStack] = useState([{ navAction: "push", ...initialRoute }]); const [titleOverride, setTitleOverride] = useState(initialRoute.title); @@ -108,8 +98,7 @@ function NavStackProvider({ useState(navButtonRight); const [navButtonLeftOverride, setNavButtonLeftOverride] = useState(navButtonLeft); - const [_style, setStyle] = useState(style); - const [contentStyle, setContentStyle] = useState({}); + const [navStyleOverride, setNavStyleOverride] = useState({}); const push = (route: string, props: any) => { setStack([...stack, { name: route, props, navAction: "push" }]); @@ -120,8 +109,30 @@ function NavStackProvider({ newStack[newStack.length - 1]["navAction"] = "pop"; setStack(newStack); }; - const toRoot = () => { - setStack([stack[0]]); + + const setOptions = ({ + headerLeft, + headerTitle, + headerRight, + style, + }: { + headerLeft?: React.ReactElement | null; + headerTitle?: string | React.ReactElement; + headerRight?: React.ReactElement | null; + style?: CSSProperties; + }) => { + if (headerLeft !== undefined) { + setNavButtonLeftOverride(headerLeft); + } + if (headerTitle !== undefined) { + setTitleOverride(headerTitle); + } + if (headerRight !== undefined) { + setNavButtonRightOverride(headerRight); + } + if (style !== undefined) { + setNavStyleOverride(style); + } }; return ( @@ -131,18 +142,11 @@ function NavStackProvider({ push, pop, isRoot: stack.length === 1, - toRoot, title: titleOverride, - setTitle: setTitleOverride, navButtonRight: navButtonRightOverride, - setNavButtonRight: setNavButtonRightOverride, navButtonLeft: navButtonLeftOverride, - setNavButtonLeft: setNavButtonLeftOverride, - style: _style, - setStyle, - contentStyle, - setContentStyle, - close: onClose, + navStyle: navStyleOverride, + setOptions, }} > {children} @@ -166,24 +170,27 @@ type NavStackContext = { activeRoute: { name: string; props?: any; navAction?: "push" | "pop" }; push: (route: string, props?: any) => void; pop: (count?: number) => void; - close: () => void; isRoot: boolean; - toRoot: () => void; title: string; - setTitle: any; navButtonRight: any; - setNavButtonRight: any; navButtonLeft: any; - setNavButtonLeft: any; - style: any; - setStyle: any; - contentStyle: any; - setContentStyle: any; + navStyle: CSSProperties; + setOptions: ({ + headerLeft, + headerTitle, + headerRight, + style, + }: { + headerLeft?: React.ReactElement | null; + headerTitle?: string | React.ReactElement; + headerRight?: React.ReactElement | null; + style?: CSSProperties; + }) => void; }; const _NavStackContext = React.createContext(null); -export function useNavStack(): NavStackContext { +export function useNavigation(): NavStackContext { const ctx = useContext(_NavStackContext); if (ctx === null) { throw new Error("Context not available"); diff --git a/packages/app-extension/src/components/common/Layout/Router.tsx b/packages/app-extension/src/components/common/Layout/Router.tsx index 392f997b8..3015eb5ed 100644 --- a/packages/app-extension/src/components/common/Layout/Router.tsx +++ b/packages/app-extension/src/components/common/Layout/Router.tsx @@ -189,12 +189,13 @@ function MessageNativeInner() { const { isXs } = useBreakpoints(); if (hash.startsWith("/messages/requests")) { - return } />; + return } />; } if (hash.startsWith("/messages/chat")) { return ( } /> + } + /> ); } if (hash.startsWith("/messages/profile")) { - return } />; + return ( + } + /> + ); } if (!isXs) { return <>; } - return } />; + return } />; } function FullChatPage() { @@ -359,6 +368,7 @@ function TokenPage() { function NavScreen({ component, noScrollbars, + noMotion, }: { noScrollbars?: boolean; component: React.ReactNode; @@ -367,6 +377,7 @@ function NavScreen({ remoteUuid?: string; room?: string; }; + noMotion?: boolean; }) { const { title, isRoot, pop } = useNavigation(); @@ -386,37 +397,81 @@ function NavScreen({ pop()} /> ); + if (noMotion) { + return ( + + ); + } return ( -
- - {component} - -
+ ); } +function NavScreenInner({ + title, + image, + onClick, + notchViewComponent, + navButtonLeft, + navButtonRight, + navbarStyle, + noScrollbars, + isVerified, + component, +}: any) { + return ( +
+ + {component} + +
+ ); +} + function WithMotionWrapper({ children }: { children: any }) { const location = useLocation(); const [searchParams] = useSearchParams(); @@ -444,8 +499,9 @@ function useNavBar() { let navStyle = { fontSize: "18px", } as React.CSSProperties; + if (pathname === "/messages/chat" || pathname === "/messages/groupchat") { - navStyle.background = theme.custom.colors.bg3; + navStyle.background = theme.custom.colors.chatFadeGradientStart; } if (isRoot) { diff --git a/packages/app-extension/src/components/common/Layout/Tab.tsx b/packages/app-extension/src/components/common/Layout/Tab.tsx index e7e36af4d..6fe9e23cd 100644 --- a/packages/app-extension/src/components/common/Layout/Tab.tsx +++ b/packages/app-extension/src/components/common/Layout/Tab.tsx @@ -20,10 +20,10 @@ import { MessageBubbleUnreadIcon, } from "@coral-xyz/react-common"; import { + useAuthenticatedUser, useBackgroundClient, useFeatureGates, useTab, - useUser, } from "@coral-xyz/recoil"; import { styles, useCustomTheme } from "@coral-xyz/themes"; import FormatListBulletedIcon from "@mui/icons-material/FormatListBulleted"; @@ -130,21 +130,23 @@ export function WithTabs(props: any) { function TabBar() { const classes = useStyles(); const theme = useCustomTheme(); - const { uuid } = useUser(); + const authenticatedUser = useAuthenticatedUser(); const tab = useTab(); const background = useBackgroundClient(); const featureGates = useFeatureGates(); - const messagesUnread = useUnreadGlobal(uuid); + const messagesUnread = useUnreadGlobal( + authenticatedUser ? authenticatedUser.uuid : null + ); const { isXs } = useBreakpoints(); - const onTabClick = (tabValue: string) => { + const onTabClick = async (tabValue: string) => { if (tabValue === tab) { - background.request({ + await background.request({ method: UI_RPC_METHOD_NAVIGATION_TO_ROOT, params: [], }); } else { - background.request({ + await background.request({ method: UI_RPC_METHOD_NAVIGATION_ACTIVE_TAB_UPDATE, params: [tabValue], }); diff --git a/packages/app-extension/src/components/common/Settings/List.tsx b/packages/app-extension/src/components/common/Settings/List.tsx index 311a9a1ef..b660d4bc7 100644 --- a/packages/app-extension/src/components/common/Settings/List.tsx +++ b/packages/app-extension/src/components/common/Settings/List.tsx @@ -21,6 +21,7 @@ export function SettingsList({ button?: boolean; icon?: React.ReactNode; label?: string; + allowOnclickPropagation?: boolean; }; }; className?: string; @@ -52,11 +53,29 @@ export function SettingsList({ classes={val.classes} detail={val.detail ?? } borderColor={borderColor} + allowOnclickPropagation={val.allowOnclickPropagation} > - {val.icon && val.icon()} - - {val.label ?? key} - +
+ {val.icon && + val.icon({ + style: { + color: theme.custom.colors.icon, + height: "24px", + width: "24px", + marginRight: "8px", + }, + fill: theme.custom.colors.icon, + })} + + {val.label ?? key} + +
))} diff --git a/packages/app-extension/src/components/common/WaitingRoom.tsx b/packages/app-extension/src/components/common/WaitingRoom.tsx index fb2b409ba..69372d90d 100644 --- a/packages/app-extension/src/components/common/WaitingRoom.tsx +++ b/packages/app-extension/src/components/common/WaitingRoom.tsx @@ -3,7 +3,7 @@ import { useDarkMode, useUser } from "@coral-xyz/recoil"; import { WithNav } from "../common/Layout/Nav"; -import { useNavStack } from "./Layout/NavStack"; +import { useNavigation } from "./Layout/NavStack"; import SocialNavbarButtons from "./SocialNavbarButtons"; const WAITLIST_RES_ID_KEY = "waitlist-form-res-id"; @@ -17,24 +17,25 @@ export const getWaitlistId = () => const WaitingRoom = ({ onboarded }: { onboarded?: boolean }) => { const isDarkMode = useDarkMode(); - let nav: ReturnType; + let nav: ReturnType; if (onboarded) { - nav = useNavStack(); + nav = useNavigation(); } useEffect(() => { let previousTitle: string; if (onboarded && nav) { previousTitle = nav.title; - nav.setTitle(""); - nav.setNavButtonRight(); + nav.setOptions({ + headerTitle: "", + headerRight: , + }); } return () => { if (onboarded && nav) { - nav.setTitle(previousTitle); - nav.setNavButtonRight(); + nav.setOptions({ headerTitle: previousTitle, headerRight: null }); } }; }, []); diff --git a/packages/app-extension/src/components/common/WalletList.tsx b/packages/app-extension/src/components/common/WalletList.tsx index 0940cbfcf..25ae6464f 100644 --- a/packages/app-extension/src/components/common/WalletList.tsx +++ b/packages/app-extension/src/components/common/WalletList.tsx @@ -1,10 +1,16 @@ -import { useEffect, useState } from "react"; +import React, { useContext, useEffect, useState } from "react"; import { Blockchain, UI_RPC_METHOD_KEYRING_ACTIVE_WALLET_UPDATE, walletAddressDisplay, } from "@coral-xyz/common"; -import { List, ListItem } from "@coral-xyz/react-common"; +import { + HardwareIcon, + List, + ListItem, + MnemonicIcon, + SecretKeyIcon, +} from "@coral-xyz/react-common"; import { useActiveWallet, useAllWallets, @@ -15,15 +21,12 @@ import { import { styles, useCustomTheme } from "@coral-xyz/themes"; import { Add, ExpandMore, MoreHoriz } from "@mui/icons-material"; import ContentCopyIcon from "@mui/icons-material/ContentCopy"; -import ErrorIcon from "@mui/icons-material/Error"; import InfoIcon from "@mui/icons-material/Info"; import { Box, Button, Grid, Tooltip, Typography } from "@mui/material"; +import type { SxProps, Theme } from "@mui/material/styles"; import { EthereumIconOnboarding as EthereumIcon, - HardwareIcon, - ImportedIcon, - MnemonicIcon, SolanaIconOnboarding as SolanaIcon, } from "../common/Icon"; import { ActionCard } from "../common/Layout/ActionCard"; @@ -31,12 +34,15 @@ import { useDrawerContext, WithMiniDrawer } from "../common/Layout/Drawer"; import { NavStackEphemeral, NavStackScreen, - useNavStack, + useNavigation, } from "../common/Layout/NavStack"; import { AddConnectPreview, AddConnectWalletMenu, } from "../Unlocked/Settings/AddConnectWallet"; +import { CreateMenu } from "../Unlocked/Settings/AddConnectWallet/CreateMenu"; +import { ImportMenu } from "../Unlocked/Settings/AddConnectWallet/ImportMenu"; +import { ImportMnemonic } from "../Unlocked/Settings/AddConnectWallet/ImportMnemonic"; import { ImportSecretKey } from "../Unlocked/Settings/AddConnectWallet/ImportSecretKey"; import { RemoveWallet } from "../Unlocked/Settings/YourAccount/EditWallets/RemoveWallet"; import { RenameWallet } from "../Unlocked/Settings/YourAccount/EditWallets/RenameWallet"; @@ -73,23 +79,16 @@ export function WalletDrawerButton({ wallet: { name: string; publicKey: string }; style?: React.CSSProperties; }) { - const [openDrawer, setOpenDrawer] = useState(false); - + const { setOpen } = useWalletDrawerContext(); return ( - <> - { - e.stopPropagation(); - setOpenDrawer(true); - }} - style={style} - /> - - + { + e.stopPropagation(); + setOpen(true); + }} + style={style} + /> ); } @@ -106,10 +105,10 @@ function WalletButton({ const theme = useCustomTheme(); const [tooltipOpen, setTooltipOpen] = useState(false); - const onCopy = () => { + const onCopy = async () => { setTooltipOpen(true); setTimeout(() => setTooltipOpen(false), 1000); - navigator.clipboard.writeText(wallet.publicKey.toString()); + await navigator.clipboard.writeText(wallet.publicKey.toString()); }; return ( @@ -140,9 +139,9 @@ function WalletButton({ minWidth: "16px", }} className={classes.addressButton} - onClick={(e) => { + onClick={async (e) => { e.stopPropagation(); - onCopy(); + await onCopy(); }} > } /> } + /> + } + /> + } + /> + } /> boolean }) { - const { setTitle, setNavButtonRight } = useNavStack(); + const nav = useNavigation(); const activeWallet = useActiveWallet(); const wallets = useAllWallets().filter(filter ? filter : () => true); const activeWallets = wallets.filter((w) => !w.isCold); @@ -278,10 +289,12 @@ export function AllWalletsList({ filter }: { filter?: (w: any) => boolean }) { })); useEffect(() => { - setNavButtonRight(); - setTitle("Wallets"); + nav.setOptions({ + headerTitle: "Wallets", + headerRight: , + }); return () => { - setNavButtonRight(null); + nav.setOptions({ headerRight: null }); }; }, []); @@ -296,7 +309,7 @@ export function AllWalletsList({ filter }: { filter?: (w: any) => boolean }) { function WalletSettingsButton() { const theme = useCustomTheme(); - const { push } = useNavStack(); + const { push } = useNavigation(); return (
- - Disable app signing in wallet info -
{ + clickWallet={async (wallet) => { if (wallet.type !== "dehydrated") { - onChange(wallet); + await onChange(wallet); close(); } }} @@ -653,8 +656,8 @@ export function WalletListItem({ inverted?: boolean; }) { const theme = useCustomTheme(); - const nav = useNavStack(); - const { publicKey, name, blockchain, type, isCold } = wallet; + const nav = useNavigation(); + const { publicKey, name, blockchain, type } = wallet; return ( @@ -740,13 +744,25 @@ export function WalletListItem({ justifyContent: "center", }} > - { - navigator.clipboard.writeText(publicKey); - }} - /> + {type === "dehydrated" ? ( + { + nav.push("add-connect-wallet", { + blockchain: wallet.blockchain, + publicKey: wallet.publicKey, + isRecovery: true, + }); + }} + /> + ) : ( + { + await navigator.clipboard.writeText(publicKey); + }} + /> + )}
- { nav.push("edit-wallets-wallet-detail", { ...wallet, @@ -771,16 +786,17 @@ export function WalletListItem({ ); } -function CopyButton({ +function WalletListButtonBase({ onClick, - isEditWallets, inverted, + sx, + children, }: { - onClick: () => void; - isEditWallets: boolean; + onClick: (e: any) => void; inverted?: boolean; + sx?: SxProps; + children: React.ReactElement; }) { - const [isCopying, setIsCopying] = useState(false); const theme = useCustomTheme(); return ( + ); +} + +function CopyButton({ + onClick, + inverted, +}: { + onClick: () => void; + inverted?: boolean; +}) { + const [isCopying, setIsCopying] = useState(false); + return ( + { e.stopPropagation(); setIsCopying(true); setTimeout(() => setIsCopying(false), 1000); onClick(); }} + inverted={inverted} > - {isEditWallets ? ( - - ) : ( - <>{isCopying ? "Copied!" : "Copy"} - )} - + <>{isCopying ? "Copied!" : "Copy"} + + ); +} + +function EditWalletsButton({ + onClick, + inverted, +}: { + onClick: () => void; + inverted?: boolean; +}) { + const theme = useCustomTheme(); + return ( + { + e.stopPropagation(); + onClick(); + }} + inverted={inverted} + sx={{ + padding: "4px", + minWidth: "32px", + }} + > + + + ); +} + +function RecoverButton({ + onClick, + inverted, +}: { + onClick: () => void; + inverted?: boolean; +}) { + return ( + { + e.stopPropagation(); + onClick(); + }} + inverted={inverted} + > + <>Recover + ); } @@ -829,14 +902,12 @@ export function StackedWalletAddress({ publicKey, name, type, - isCold, isSelected = false, inverted, }: { publicKey: string; name: string; type: string; - isCold?: boolean; isSelected?: boolean; inverted?: boolean; }) { @@ -847,9 +918,10 @@ export function StackedWalletAddress({ style={{ fontSize: "16px", fontWeight: isSelected ? 600 : 500, + color: type === "dehydrated" ? theme.custom.colors.negative : "", }} > - {name} + {type === "dehydrated" ? "Import error" : name}
; + return ; case "hardware": - return ; - case "dehydrated": - return ( - - ); + return ; + case "derived": + return ; default: - return ; + return null; } } @@ -955,3 +1018,37 @@ function NetworkIcon({ const blockchainLogo = useBlockchainLogo(blockchain); return ; } + +type WalletDrawerContext = { + open: boolean; + setOpen: any; +}; + +const _WalletDrawerContext = React.createContext( + null +); + +export function WalletDrawerProvider({ children }: any) { + const [open, setOpen] = useState(false); + return ( + <_WalletDrawerContext.Provider + value={{ + open, + setOpen, + }} + > + <> + {children} + + + + ); +} + +export function useWalletDrawerContext(): WalletDrawerContext { + const ctx = useContext(_WalletDrawerContext); + if (ctx === null) { + throw new Error("Context not available"); + } + return ctx; +} diff --git a/packages/app-extension/src/index.css b/packages/app-extension/src/index.css index 5f2d9a4de..1a3b14c90 100644 --- a/packages/app-extension/src/index.css +++ b/packages/app-extension/src/index.css @@ -28,3 +28,7 @@ input[type="number"] { #root { overflow: hidden; } + +.MuiCircularProgress-circle { + stroke-linecap: round; +} diff --git a/packages/app-extension/webpack.config.js b/packages/app-extension/webpack.config.js index 4041665b4..6272d5741 100644 --- a/packages/app-extension/webpack.config.js +++ b/packages/app-extension/webpack.config.js @@ -7,6 +7,7 @@ const ForkTsCheckerWebpackPlugin = require("fork-ts-checker-webpack-plugin"); const MiniCssExtractPlugin = require("mini-css-extract-plugin"); const path = require("path"); const ReactRefreshWebpackPlugin = require("@pmmmwh/react-refresh-webpack-plugin"); +const fs = require("fs"); const EXTENSION_NAME = process.env.NODE_ENV === "development" ? "(DEV) Backpack" : "Backpack"; @@ -33,6 +34,17 @@ const { dir: "dev", devServer: { // watchFiles: ['src/**/*', 'webpack.config.js'], + host: "localhost", + port: 9997, + server: fs.existsSync("localhost.pem") + ? { + type: "https", + options: { + key: "localhost-key.pem", + cert: "localhost.pem", + }, + } + : {}, compress: false, static: { directory: path.join(__dirname, "../dev"), From 94b25358e09926926fab7f22eb0c58ca02be1bc1 Mon Sep 17 00:00:00 2001 From: mj221 Date: Sun, 12 Feb 2023 11:30:26 +1000 Subject: [PATCH 14/36] WIP resolve merge conflict with 'master' of https://github.com/coral-xyz/backpack into mj/domain-content-resolver --- .../Unlocked/Balances/TokensWidget/Ramp.tsx | 4 +- .../Unlocked/Balances/TokensWidget/Send.tsx | 10 +- .../Unlocked/Balances/TokensWidget/Token.tsx | 1 - .../Unlocked/Messages/ChatDrawer.tsx | 3 +- .../components/Unlocked/Messages/Contacts.tsx | 26 +- .../Unlocked/Messages/MessageOptions.tsx | 54 +- .../Unlocked/Messages/SearchUsers.tsx | 86 ++-- .../src/components/Unlocked/Nfts/Common.tsx | 107 +++- .../src/components/Unlocked/Nfts/Detail.tsx | 200 +++++--- .../src/components/Unlocked/Nfts/NftTable.tsx | 30 +- .../Unlocked/Settings/AboutBackpack/index.tsx | 8 +- .../ConnectHardwareSearching.tsx | 2 - .../ConnectHardware/index.tsx | 22 +- .../Settings/AddConnectWallet/CreateMenu.tsx | 203 ++++++++ .../Settings/AddConnectWallet/ImportMenu.tsx | 124 +++++ .../AddConnectWallet/ImportMnemonic.tsx | 195 ++++++++ .../AddConnectWallet/ImportSecretKey.tsx | 34 +- .../Settings/AddConnectWallet/index.tsx | 466 ++++++------------ .../Settings/AvatarHeader/AvatarHeader.tsx | 1 - .../Settings/Preferences/AutoLock.tsx | 6 +- .../IpfsGatewayCustom.tsx | 8 +- .../IpfsGatewaySwitch.tsx | 6 +- .../DomainContentResolver/index.tsx | 6 +- .../Preferences/Ethereum/Connection.tsx | 6 +- .../Preferences/Ethereum/CustomRpcUrl.tsx | 8 +- .../Settings/Preferences/Ethereum/index.tsx | 6 +- .../Preferences/Solana/Commitment.tsx | 6 +- .../Preferences/Solana/ConnectionSwitch.tsx | 6 +- .../Preferences/Solana/CustomRpcUrl.tsx | 8 +- .../Settings/Preferences/Solana/Explorer.tsx | 6 +- .../Settings/Preferences/Solana/index.tsx | 6 +- .../Settings/Preferences/TrustedSites.tsx | 13 +- .../Unlocked/Settings/Preferences/index.tsx | 12 +- .../Settings/SettingsNavStackDrawer.tsx | 18 +- .../Unlocked/Settings/Xnfts/Detail.tsx | 18 +- .../Unlocked/Settings/Xnfts/index.tsx | 13 +- .../Settings/YourAccount/ChangePassword.tsx | 8 +- .../Unlocked/Settings/YourAccount/index.tsx | 12 +- .../components/Unlocked/Settings/index.tsx | 24 +- 39 files changed, 1159 insertions(+), 613 deletions(-) create mode 100644 packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/CreateMenu.tsx create mode 100644 packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportMenu.tsx create mode 100644 packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportMnemonic.tsx diff --git a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Ramp.tsx b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Ramp.tsx index ae3812ccd..84a839719 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Ramp.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Ramp.tsx @@ -14,7 +14,7 @@ import { ListItemIcon, Typography } from "@mui/material"; import { useRecoilValue } from "recoil"; import { TextField } from "../../../common"; -import { useNavStack } from "../../../common/Layout/NavStack"; +import { useNavigation } from "../../../common/Layout/NavStack"; import { BalancesTable, BalancesTableContent, @@ -119,7 +119,7 @@ export function Ramp({ }) { const wallets = useAllWalletsDisplayed(); const [searchFilter, setSearchFilter] = useState(""); - const { push } = useNavStack(); + const { push } = useNavigation(); const classes = useStyles(); // If prop one is undefined, both must be undefined. diff --git a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Send.tsx b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Send.tsx index 2edfda719..3ad011124 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Send.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Send.tsx @@ -45,7 +45,7 @@ import { BigNumber, ethers } from "ethers"; import { ApproveTransactionDrawer } from "../../../common/ApproveTransactionDrawer"; import { useDrawerContext } from "../../../common/Layout/Drawer"; -import { useNavStack } from "../../../common/Layout/NavStack"; +import { useNavigation as useNavigationEphemeral } from "../../../common/Layout/NavStack"; import { TokenAmountHeader } from "../../../common/TokenAmountHeader"; import { TokenInputField } from "../../../common/TokenInput"; @@ -176,7 +176,7 @@ export function Send({ token: TokenData; }) { const classes = useStyles() as any; - const { title, setTitle } = useNavStack(); + const nav = useNavigationEphemeral(); const { provider: solanaProvider } = useAnchorContext(); const ethereumCtx = useEthereumCtx(); const [openDrawer, setOpenDrawer] = useState(false); @@ -185,10 +185,10 @@ export function Send({ const [feeOffset, setFeeOffset] = useState(BigNumber.from(0)); useEffect(() => { - const prev = title; - setTitle(`Send ${token.ticker}`); + const prev = nav.title; + nav.setOptions({ headerTitle: `Send ${token.ticker}` }); return () => { - setTitle(prev); + nav.setOptions({ headerTitle: prev }); }; }, []); diff --git a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Token.tsx b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Token.tsx index 533691718..eea26595f 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Token.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Token.tsx @@ -173,7 +173,6 @@ export function WithHeaderButton({ initialRoute={initialRoute} options={(args) => routeOptions(routes, args)} navButtonLeft={ setOpenDrawer(false)} />} - onClose={() => setOpenDrawer(false)} > {routes.map((r: any) => ( { const isDark = useDarkMode(); const classes = useStyles(isDark)(); const { props, title }: any = useDecodedSearchParams(); - const { publicKey } = useActiveSolanaWallet(); const [members, setMembers] = useState([]); const [searchFilter, setSearchFilter] = useState(""); const [offset, setOffset] = useState(0); @@ -86,7 +85,7 @@ export const ChatDrawer = ({ setOpenDrawer }: { setOpenDrawer: any }) => { pathname === "/messages/groupchat" ? props.id : props.collectionId }&mint=${ props.nftMint - }&publicKey=${publicKey}&type=collection&limit=${LIMIT}&offset=${offset}&prefix=${prefix}` + }&type=collection&limit=${LIMIT}&offset=${offset}&prefix=${prefix}` ); const json = await response.json(); setMembers(json.members); diff --git a/packages/app-extension/src/components/Unlocked/Messages/Contacts.tsx b/packages/app-extension/src/components/Unlocked/Messages/Contacts.tsx index d0d7c2bd6..b05eda7b8 100644 --- a/packages/app-extension/src/components/Unlocked/Messages/Contacts.tsx +++ b/packages/app-extension/src/components/Unlocked/Messages/Contacts.tsx @@ -6,7 +6,7 @@ import { useUser } from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; import { Typography } from "@mui/material"; -import { useNavStack } from "../../common/Layout/NavStack"; +import { useNavigation } from "../../common/Layout/NavStack"; import { SearchUsers } from "./SearchUsers"; import { useStyles } from "./styles"; @@ -24,7 +24,7 @@ async function getRequests(): Promise<{ } export const Contacts = () => { - const nav = useNavStack(); + const nav = useNavigation(); const { uuid } = useUser(); const allChats = useContacts(uuid); const [requests, setRequests] = useState< @@ -36,7 +36,7 @@ export const Contacts = () => { }, []); useEffect(() => { - nav.setTitle("Contacts"); + nav.setOptions({ headerTitle: "Contacts" }); }, [nav]); return ( @@ -55,12 +55,23 @@ export const ContactRequests = ({ isSent?: boolean; requests: { received: RemoteUserData[]; sent: RemoteUserData[] }; }) => { - const nav = useNavStack(); + const nav = useNavigation(); const classes = useStyles(); const theme = useCustomTheme(); + const [localSentRequests, setLocalSentRequests] = useState( + [] + ); + const [localReceivedRequests, setLocalReceivedRequests] = useState< + RemoteUserData[] + >([]); + + useEffect(() => { + setLocalReceivedRequests(requests.received); + setLocalSentRequests(requests.sent); + }, [requests]); useEffect(() => { - nav.setTitle(`Requests ${isSent ? "Sent" : "Received"}`); + nav.setOptions({ headerTitle: `Requests ${isSent ? "Sent" : "Received"}` }); }, [nav]); return ( @@ -95,7 +106,10 @@ export const ContactRequests = ({ Sent ({requests.sent.length}) )} - +
); diff --git a/packages/app-extension/src/components/Unlocked/Messages/MessageOptions.tsx b/packages/app-extension/src/components/Unlocked/Messages/MessageOptions.tsx index bb28ccb9e..63a3b1702 100644 --- a/packages/app-extension/src/components/Unlocked/Messages/MessageOptions.tsx +++ b/packages/app-extension/src/components/Unlocked/Messages/MessageOptions.tsx @@ -1,16 +1,18 @@ import { useState } from "react"; -import type { Friendship } from "@coral-xyz/common"; import { BACKEND_API_URL, sendFriendRequest, unFriend, } from "@coral-xyz/common"; import { toast } from "@coral-xyz/react-common"; -import { friendship, useDecodedSearchParams } from "@coral-xyz/recoil"; +import { + useDecodedSearchParams, + useFriendship, + useUpdateFriendships, +} from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; import MoreHorizIcon from "@mui/icons-material/MoreHoriz"; import { Fade } from "@mui/material"; -import { useRecoilState } from "recoil"; import PopoverMenu from "../../common/PopoverMenu"; @@ -20,8 +22,8 @@ export const MessageOptions = () => { const { props }: any = useDecodedSearchParams(); const userId = props.userId; const remoteUsername = props.username; - const [friendshipValue, setFriendshipValue] = - useRecoilState(friendship({ userId })); + const friendshipValue = useFriendship({ userId }); + const setFriendshipValue = useUpdateFriendships(); const theme = useCustomTheme(); const [anchorEl, setAnchorEl] = useState(null); @@ -36,10 +38,12 @@ export const MessageOptions = () => { const send = async (sendRequest: boolean) => { await sendFriendRequest({ to: userId, sendRequest }); - setFriendshipValue((x: any) => ({ - ...x, - requested: sendRequest, - })); + setFriendshipValue({ + userId: userId, + friendshipValue: { + requested: sendRequest, + }, + }); handleClose(); }; @@ -68,10 +72,12 @@ export const MessageOptions = () => { onClick={async () => { if (friendshipValue?.areFriends) { await unFriend({ to: userId }); - setFriendshipValue((x: any) => ({ - ...x, - areFriends: false, - })); + setFriendshipValue({ + userId: userId, + friendshipValue: { + areFriends: false, + }, + }); toast.success( "Contact removed", `We've removed @${remoteUsername} from your contacts.` @@ -106,11 +112,13 @@ export const MessageOptions = () => { disabled={friendshipValue?.spam} onClick={async () => { const updatedValue = !friendshipValue?.blocked; - setFriendshipValue((x: any) => ({ - ...x, - blocked: updatedValue, - requested: updatedValue ? false : x.requested, - })); + setFriendshipValue({ + userId: userId, + friendshipValue: { + blocked: updatedValue, + requested: updatedValue ? false : friendshipValue.requested, + }, + }); await fetch(`${BACKEND_API_URL}/friends/block`, { method: "POST", headers: { @@ -139,10 +147,12 @@ export const MessageOptions = () => { }, body: JSON.stringify({ to: userId, spam: updatedValue }), }); - setFriendshipValue((x: any) => ({ - ...x, - spam: updatedValue, - })); + setFriendshipValue({ + userId: userId, + friendshipValue: { + spam: updatedValue, + }, + }); handleClose(); }} > diff --git a/packages/app-extension/src/components/Unlocked/Messages/SearchUsers.tsx b/packages/app-extension/src/components/Unlocked/Messages/SearchUsers.tsx index 0c8f055b1..4a57e7bb1 100644 --- a/packages/app-extension/src/components/Unlocked/Messages/SearchUsers.tsx +++ b/packages/app-extension/src/components/Unlocked/Messages/SearchUsers.tsx @@ -6,7 +6,7 @@ import { useCustomTheme } from "@coral-xyz/themes"; import SearchIcon from "@mui/icons-material/Search"; import { Typography } from "@mui/material"; -import { useNavStack } from "../../common/Layout/NavStack"; +import { useNavigation } from "../../common/Layout/NavStack"; // import { Requests } from "./Requests"; import { useStyles } from "./styles"; @@ -18,7 +18,6 @@ export const SearchUsers = ({ allChats: EnrichedInboxDb[]; requests: { received: RemoteUserData[]; sent: RemoteUserData[] }; }) => { - const nav = useNavStack(); const classes = useStyles(); const [searchFilter, setSearchFilter] = useState(""); const friends = allChats.filter((x: any) => x.areFriends === 1); @@ -68,40 +67,38 @@ export const SearchUsers = ({ Your contacts {requests.received.length > 0 && ( - - nav.push("contact-requests", { - description: ( - <> - These people wanted to add you as a contact. -
Click someone to view their profile. - - ), - requests, - }) - } - > - Requests ({requests.received.length}) - + )}
) : ( - ( - + <> + {requests.received.length > 0 && ( +
+
+ +
)} - title={ - searchFilter === "" - ? "No contacts" - : `No results for '${searchFilter}'` - } - subtitle={searchFilter === "" ? "Search for people to add." : ""} - /> + ( + + )} + title={ + searchFilter === "" + ? "No contacts" + : `No results for '${searchFilter}'` + } + subtitle={searchFilter === "" ? "Search for people to add." : ""} + /> + )} {/*
Requests
@@ -109,3 +106,32 @@ export const SearchUsers = ({
); }; + +const RequestHeader = ({ + requests, +}: { + requests: { received: RemoteUserData[]; sent: RemoteUserData[] }; +}) => { + const theme = useCustomTheme(); + const nav = useNavigation(); + return ( + + nav.push("contact-requests", { + description: ( + <> + These people wanted to add you as a contact. +
Click someone to view their profile. + + ), + requests, + }) + } + > + Requests ({requests.received.length}) + + ); +}; diff --git a/packages/app-extension/src/components/Unlocked/Nfts/Common.tsx b/packages/app-extension/src/components/Unlocked/Nfts/Common.tsx index 304c4d4d6..da04afeba 100644 --- a/packages/app-extension/src/components/Unlocked/Nfts/Common.tsx +++ b/packages/app-extension/src/components/Unlocked/Nfts/Common.tsx @@ -1,10 +1,17 @@ +import type { MouseEvent } from "react"; import { UNKNOWN_NFT_ICON_SRC } from "@coral-xyz/common"; import { NAV_COMPONENT_NFT_CHAT } from "@coral-xyz/common/dist/esm/constants"; import { MessageBubbleUnreadIcon, ProxyImage } from "@coral-xyz/react-common"; -import { useNavigation } from "@coral-xyz/recoil"; +import { + collectibleXnft, + useNavigation, + useOpenPlugin, +} from "@coral-xyz/recoil"; import { HOVER_OPACITY, styles, useCustomTheme } from "@coral-xyz/themes"; import CircleIcon from "@mui/icons-material/Circle"; -import { Button, Typography } from "@mui/material"; +import RocketLaunchIcon from "@mui/icons-material/RocketLaunch"; +import { Button, IconButton, Typography } from "@mui/material"; +import { useRecoilValueLoadable } from "recoil"; const useStyles = styles(() => ({ button: { @@ -24,6 +31,24 @@ export function GridCard({ const classes = useStyles(); const theme = useCustomTheme(); const { push } = useNavigation(); + const openPlugin = useOpenPlugin(); + + const { contents, state } = subtitle + ? useRecoilValueLoadable( + collectibleXnft( + nft ? { collection: nft.metadataCollectionId, mint: nft.mint } : null + ) + ) + : { contents: undefined, state: "hasValue" }; + + const xnft = (state === "hasValue" && contents) || null; + + const onClickAction = (e: MouseEvent) => { + e.stopPropagation(); + if (xnft) { + openPlugin(xnft); + } + }; if (!nft) { return null; @@ -109,48 +134,80 @@ export function GridCard({ {subtitle && (
- -
- {subtitle.name} -
- + {subtitle.name} +
+ + {subtitle.length} + + +
+ {xnft && ( + - {subtitle.length} - - + + + )}
)} diff --git a/packages/app-extension/src/components/Unlocked/Nfts/Detail.tsx b/packages/app-extension/src/components/Unlocked/Nfts/Detail.tsx index 67868bcde..97a94171b 100644 --- a/packages/app-extension/src/components/Unlocked/Nfts/Detail.tsx +++ b/packages/app-extension/src/components/Unlocked/Nfts/Detail.tsx @@ -1,4 +1,4 @@ -import { useEffect, useState } from "react"; +import { type CSSProperties, useEffect, useState } from "react"; import { AVATAR_BASE_URL, BACKEND_API_URL, @@ -21,6 +21,7 @@ import { TextInput, } from "@coral-xyz/react-common"; import { + appStoreMetaTags, collectibleXnft, newAvatarAtom, nftById, @@ -37,7 +38,7 @@ import { import { useCustomTheme } from "@coral-xyz/themes"; import { Whatshot } from "@mui/icons-material"; import MoreHorizIcon from "@mui/icons-material/MoreHoriz"; -import { IconButton, Typography } from "@mui/material"; +import { Button, IconButton, Typography } from "@mui/material"; import { PublicKey } from "@solana/web3.js"; import { BigNumber } from "ethers"; import { useRecoilValueLoadable, useSetRecoilState } from "recoil"; @@ -72,6 +73,8 @@ export function NftsDetail({ connectionUrl: string; nftId: string; }) { + const theme = useCustomTheme(); + const background = useBackgroundClient(); const { contents, state } = useRecoilValueLoadable( nftById({ publicKey, connectionUrl, nftId }) ); @@ -89,7 +92,6 @@ export function NftsDetail({ const [chatJoined, setChatJoined] = useState(false); const [joiningChat, setJoiningChat] = useState(false); let whitelistedChatCollectionId = whitelistedChatCollection?.collectionId; - const background = useBackgroundClient(); if (whitelistedChatCollection) { Object.keys(whitelistedChatCollection.attributeMapping || {}).forEach( @@ -131,39 +133,59 @@ export function NftsDetail({ }} > - - - {xnft && } - {whitelistedChatCollectionId && ( - { - setJoiningChat(true); - await fetch(`${BACKEND_API_URL}/nft/bulk`, { - method: "POST", - headers: { "Content-Type": "application/json" }, - body: JSON.stringify({ - publicKey: publicKey, - nfts: [ - { - collectionId: whitelistedChatCollection?.collectionId, - nftId: nft?.mint, - centralizedGroup: whitelistedChatCollection?.id, - }, - ], - }), - }); - setJoiningChat(false); - background.request({ - method: UI_RPC_METHOD_NAVIGATION_ACTIVE_TAB_UPDATE, - params: [TAB_MESSAGES], - }); - setChatJoined(true); - }} +
+ {whitelistedChatCollectionId && ( + { + setJoiningChat(true); + await fetch(`${BACKEND_API_URL}/nft/bulk`, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ + publicKey: publicKey, + nfts: [ + { + collectionId: whitelistedChatCollection?.collectionId, + nftId: nft?.mint, + centralizedGroup: whitelistedChatCollection?.id, + }, + ], + }), + }); + setJoiningChat(false); + background.request({ + method: UI_RPC_METHOD_NAVIGATION_ACTIVE_TAB_UPDATE, + params: [TAB_MESSAGES], + }); + setChatJoined(true); + }} + /> + )} + - )} +
+ {xnft && } + {nft.attributes && nft.attributes.length > 0 && }
); @@ -195,6 +217,88 @@ function Image({ nft }: { nft: any }) { ); } +function ApplicationButton({ xnft }: { xnft: string }) { + const theme = useCustomTheme(); + const openPlugin = useOpenPlugin(); + const { contents, state } = useRecoilValueLoadable(appStoreMetaTags(xnft)); + + const data = (state === "hasValue" && contents) || null; + + const handleClick = () => { + openPlugin(xnft); + }; + + return ( + data && ( +
+ + Application + +
+ +
+ + {data.name} + + + {data.description} + +
+ +
+
+ ) + ); +} + function Description({ nft }: { nft: any }) { const theme = useCustomTheme(); @@ -228,20 +332,14 @@ function Description({ nft }: { nft: any }) { ); } -function SendButton({ nft }: { nft: any }) { +function SendButton({ nft, style }: { nft: any; style?: CSSProperties }) { const [openDrawer, setOpenDrawer] = useState(false); const send = () => { setOpenDrawer(true); }; return ( <> - send()} - label={"Send"} - /> + send()} label={"Send"} />
{ - openPlugin(xnft); - }; - return ( - <> - - - ); -} - function SendScreen({ nft }: { nft: any }) { const background = useBackgroundClient(); const { close } = useDrawerContext(); diff --git a/packages/app-extension/src/components/Unlocked/Nfts/NftTable.tsx b/packages/app-extension/src/components/Unlocked/Nfts/NftTable.tsx index 96f48ab94..dcef181d2 100644 --- a/packages/app-extension/src/components/Unlocked/Nfts/NftTable.tsx +++ b/packages/app-extension/src/components/Unlocked/Nfts/NftTable.tsx @@ -1,15 +1,16 @@ import { Suspense, useCallback, useEffect, useRef, useState } from "react"; import Autosizer from "react-virtualized-auto-sizer"; import { VariableSizeList } from "react-window"; -import type { Blockchain, CollectionChatData,NftCollection } from "@coral-xyz/common"; +import type { + Blockchain, + CollectionChatData, + NftCollection, +} from "@coral-xyz/common"; import { BACKEND_API_URL, NAV_COMPONENT_NFT_COLLECTION, NAV_COMPONENT_NFT_DETAIL, - SolanaTokenAccountWithKey, - TokenMetadata, } from "@coral-xyz/common"; -import { NAV_COMPONENT_NFT_CHAT } from "@coral-xyz/common/dist/esm/constants"; import { Loading } from "@coral-xyz/react-common"; import { nftById, @@ -34,7 +35,6 @@ type AllWalletCollections = Array<{ }>; type CollapsedCollections = boolean[]; -const ONE_COLLECTION_ID = "3PMczHyeW2ds7ZWDZbDSF3d21HBqG6yR4tG7vP6qczfj"; type Row = { height: number; key: string; @@ -344,6 +344,7 @@ function NftCollectionCard({ nftId: collectionDisplayNftId, }) ); + const collectionsChatMetadata = useGroupCollections({ uuid }); const init = async () => { @@ -364,29 +365,14 @@ function NftCollectionCard({ }; useEffect(() => { - if (collection.metadataCollectionId !== ONE_COLLECTION_ID) { - return; - } init(); }, [collection.metadataCollectionId]); if (!collectionDisplayNft) { return null; } + const onClick = () => { - if (collection.metadataCollectionId === ONE_COLLECTION_ID) { - push({ - title: "ONE Holders Chat", - componentId: NAV_COMPONENT_NFT_CHAT, - componentProps: { - collectionId: collection.metadataCollectionId, - //@ts-ignore - nftMint: collectionDisplayNft?.mint, - title: "ONE Holders Chat", - }, - }); - return; - } if (collection.itemIds.length === 1) { if (!collectionDisplayNft.name || !collectionDisplayNft.id) { throw new Error("invalid NFT data"); @@ -426,8 +412,8 @@ function NftCollectionCard({ onClick={onClick} nft={collectionDisplayNft} subtitle={{ - name: collectionDisplayNft.collectionName, length: collection.itemIds.length, + name: collectionDisplayNft.collectionName, }} /> ); diff --git a/packages/app-extension/src/components/Unlocked/Settings/AboutBackpack/index.tsx b/packages/app-extension/src/components/Unlocked/Settings/AboutBackpack/index.tsx index 113f6dee4..bbed705d0 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/AboutBackpack/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/AboutBackpack/index.tsx @@ -19,15 +19,15 @@ import { GitHub, OpenInBrowser } from "@mui/icons-material"; import TwitterIcon from "@mui/icons-material/Twitter"; import { Typography } from "@mui/material"; -import { useNavStack } from "../../../common/Layout/NavStack"; +import { useNavigation } from "../../../common/Layout/NavStack"; export function AboutBackpack() { - const nav = useNavStack(); + const nav = useNavigation(); const theme = useCustomTheme(); useEffect(() => { - nav.setTitle("About"); - }, [nav.setTitle]); + nav.setOptions({ headerTitle: "About" }); + }, [nav.setOptions]); const settingsMenu = [ { diff --git a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ConnectHardware/ConnectHardwareSearching.tsx b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ConnectHardware/ConnectHardwareSearching.tsx index da5d61435..0dd9de763 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ConnectHardware/ConnectHardwareSearching.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ConnectHardware/ConnectHardwareSearching.tsx @@ -30,14 +30,12 @@ export function ConnectHardwareSearching({ useEffect(() => { // @ts-ignore const connectListener = navigator.hid.addEventListener("connect", () => { - console.log("refreshing connect"); setNavigatorStateChange((prev) => prev + 1); }); // @ts-ignore const disconnectListener = navigator.hid.addEventListener( "disconnect", async () => { - console.log("refreshing disconnect"); setNavigatorStateChange((prev) => prev + 1); } ); diff --git a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ConnectHardware/index.tsx b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ConnectHardware/index.tsx index b6ec925df..43c818e05 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ConnectHardware/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ConnectHardware/index.tsx @@ -2,6 +2,7 @@ import type { Blockchain, SignedWalletDescriptor } from "@coral-xyz/common"; import { getAddMessage, UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_ADD, + UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_READ, UI_RPC_METHOD_LEDGER_IMPORT, } from "@coral-xyz/common"; import { useBackgroundClient } from "@coral-xyz/recoil"; @@ -12,11 +13,12 @@ import { ConnectHardwareSuccess } from "./ConnectHardwareSuccess"; export function ConnectHardware({ blockchain, - createKeyring, + action, publicKey, onComplete, }: { blockchain: Blockchain; + action: "create" | "import" | "search"; createKeyring: boolean; publicKey?: string; onComplete: () => void; @@ -26,11 +28,17 @@ export function ConnectHardware({ const handleHardwareOnboardComplete = async ( signedWalletDescriptor: SignedWalletDescriptor ) => { - const method = createKeyring - ? // Create the keyring - UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_ADD - : // Just import the wallet because the keyring already exists - UI_RPC_METHOD_LEDGER_IMPORT; + const blockchainKeyrings = await background.request({ + method: UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_READ, + params: [], + }); + const keyringExists = blockchainKeyrings.includes(blockchain); + + const method = keyringExists + ? // Just import the wallet because the keyring already exists + UI_RPC_METHOD_LEDGER_IMPORT + : // Create the keyring + UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_ADD; await background.request({ method, params: [blockchain, signedWalletDescriptor], @@ -40,7 +48,7 @@ export function ConnectHardware({ return ( } diff --git a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/CreateMenu.tsx b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/CreateMenu.tsx new file mode 100644 index 000000000..4edea6c29 --- /dev/null +++ b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/CreateMenu.tsx @@ -0,0 +1,203 @@ +import { useEffect, useState } from "react"; +import type { Blockchain } from "@coral-xyz/common"; +import { + getAddMessage, + openConnectHardware, + UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_ADD, + UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_READ, + UI_RPC_METHOD_FIND_WALLET_DESCRIPTOR, + UI_RPC_METHOD_KEYRING_DERIVE_WALLET, + UI_RPC_METHOD_KEYRING_STORE_READ_ALL_PUBKEYS, + UI_RPC_METHOD_SIGN_MESSAGE_FOR_PUBLIC_KEY, +} from "@coral-xyz/common"; +import { + HardwareIcon, + MnemonicIcon, + PushDetail, +} from "@coral-xyz/react-common"; +import { + useBackgroundClient, + useKeyringHasMnemonic, + useUser, +} from "@coral-xyz/recoil"; +import { Box } from "@mui/material"; +import { ethers } from "ethers"; + +import { Header, SubtextParagraph } from "../../../common"; +import { + useDrawerContext, + WithMiniDrawer, +} from "../../../common/Layout/Drawer"; +import { useNavigation } from "../../../common/Layout/NavStack"; +import { SettingsList } from "../../../common/Settings/List"; + +import { ConfirmCreateWallet } from "./"; + +const { base58 } = ethers.utils; + +export function CreateMenu({ blockchain }: { blockchain: Blockchain }) { + const nav = useNavigation(); + const background = useBackgroundClient(); + const hasMnemonic = useKeyringHasMnemonic(); + const user = useUser(); + const [keyringExists, setKeyringExists] = useState(false); + const [newPublicKey, setNewPublicKey] = useState(""); + const [openDrawer, setOpenDrawer] = useState(false); + const [loading, setLoading] = useState(false); + const { close: closeParentDrawer } = useDrawerContext(); + + // If the keyring or if we don't have any public keys of the type we are + // adding then additional logic is required to select the account index of + // the first derivation path added + const [hasHdPublicKeys, setHasHdPublicKeys] = useState(false); + const [hasLedgerPublicKeys, setHasLedgerPublicKeys] = useState(false); + + useEffect(() => { + (async () => { + const publicKeys = await background.request({ + method: UI_RPC_METHOD_KEYRING_STORE_READ_ALL_PUBKEYS, + params: [], + }); + const blockchainPublicKeys = publicKeys[blockchain]; + if (blockchainPublicKeys) { + setHasHdPublicKeys(blockchainPublicKeys.hdPublicKeys.length > 0); + setHasLedgerPublicKeys( + blockchainPublicKeys.ledgerPublicKeys.length > 0 + ); + } + })(); + }, [blockchain]); + + useEffect(() => { + const prevTitle = nav.title; + nav.setOptions({ headerTitle: "" }); + return () => { + nav.setOptions({ headerTitle: prevTitle }); + }; + }, [nav.setOptions]); + + useEffect(() => { + (async () => { + const blockchainKeyrings = await background.request({ + method: UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_READ, + params: [], + }); + setKeyringExists(blockchainKeyrings.includes(blockchain)); + })(); + }, [blockchain]); + + const createNewWithPhrase = async () => { + // Mnemonic based keyring. This is the simple case because we don't + // need to prompt for the user to open their Ledger app to get the + // required public key. We also don't need a signature to prove + // ownership of the public key because that can't be done + // transparently by the backend. + if (loading) { + return; + } + setOpenDrawer(true); + setLoading(true); + let newPublicKey; + if (!keyringExists || !hasHdPublicKeys) { + // No keyring or no existing mnemonic public keys so can't derive next + const walletDescriptor = await background.request({ + method: UI_RPC_METHOD_FIND_WALLET_DESCRIPTOR, + params: [blockchain, 0], + }); + const signature = await background.request({ + method: UI_RPC_METHOD_SIGN_MESSAGE_FOR_PUBLIC_KEY, + params: [ + blockchain, + walletDescriptor.publicKey, + base58.encode( + Buffer.from(getAddMessage(walletDescriptor.publicKey), "utf-8") + ), + [true, [walletDescriptor.derivationPath]], + ], + }); + await background.request({ + method: UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_ADD, + params: [blockchain, { ...walletDescriptor, signature }], + }); + newPublicKey = walletDescriptor.publicKey; + // Keyring now exists, toggle to other options + setKeyringExists(true); + } else { + newPublicKey = await background.request({ + method: UI_RPC_METHOD_KEYRING_DERIVE_WALLET, + params: [blockchain], + }); + } + setNewPublicKey(newPublicKey); + setLoading(false); + }; + + const createMenu = { + ...(hasMnemonic + ? // TODO user should be guided through mnemonic creation flow if + // they don't have a mnemonic + // https://github.com/coral-xyz/backpack/issues/1464 + { + "Secret recovery phrase": { + onClick: createNewWithPhrase, + icon: (props: any) => , + detailIcon: , + }, + } + : {}), + "Hardware wallet": { + onClick: () => { + openConnectHardware( + blockchain, + // `create` gets a default account index for derivations + // where no wallets are used, `derive` just gets the next + // wallet in line given the existing derivation paths + keyringExists && hasLedgerPublicKeys ? "derive" : "create" + ); + window.close(); + }, + icon: (props: any) => , + detailIcon: , + }, + }; + + return ( + <> +
+ +
+ + Add a new wallet for @{user.username} using one of the following: + + + +
+ + { + setOpenDrawer(false); + closeParentDrawer(); + }} + isLoading={loading} + /> + + + ); +} diff --git a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportMenu.tsx b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportMenu.tsx new file mode 100644 index 000000000..b99fb240a --- /dev/null +++ b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportMenu.tsx @@ -0,0 +1,124 @@ +import { useEffect, useState } from "react"; +import type { Blockchain } from "@coral-xyz/common"; +import { + openConnectHardware, + UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_READ, +} from "@coral-xyz/common"; +import { + HardwareIcon, + MnemonicIcon, + PushDetail, + SecretKeyIcon, +} from "@coral-xyz/react-common"; +import { + useBackgroundClient, + useKeyringHasMnemonic, + useUser, +} from "@coral-xyz/recoil"; +import { Box } from "@mui/material"; + +import { Header, SubtextParagraph } from "../../../common"; +import { useNavigation } from "../../../common/Layout/NavStack"; +import { SettingsList } from "../../../common/Settings/List"; + +export function ImportMenu({ blockchain }: { blockchain: Blockchain }) { + const navigation = useNavigation(); + const background = useBackgroundClient(); + const hasMnemonic = useKeyringHasMnemonic(); + const user = useUser(); + const [keyringExists, setKeyringExists] = useState(false); + + // Can only init a new blockchain keyring if there is a mnemonic + const allowOwnPhrase = hasMnemonic; + // Can only do imports via secret key if there is no existing mnemonic on the keyring + const allowOtherPhrase = keyringExists; + + useEffect(() => { + const prevTitle = navigation.title; + navigation.setOptions({ headerTitle: "" }); + return () => { + navigation.setOptions({ headerTitle: prevTitle }); + }; + }, [navigation.setOptions]); + + useEffect(() => { + (async () => { + const blockchainKeyrings = await background.request({ + method: UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_READ, + params: [], + }); + setKeyringExists(blockchainKeyrings.includes(blockchain)); + })(); + }, [blockchain]); + + const importMenu = { + ...(allowOwnPhrase + ? { + "My secret recovery phrase": { + onClick: () => + navigation.push("import-from-mnemonic", { + blockchain, + keyringExists, + inputMnemonic: false, + }), + icon: (props: any) => , + detailIcon: , + }, + } + : {}), + ...(allowOtherPhrase + ? { + "Other secret recovery phrase": { + onClick: () => + navigation.push("import-from-mnemonic", { + blockchain, + keyringExists, + inputMnemonic: true, + }), + icon: (props: any) => , + detailIcon: , + }, + } + : {}), + "Hardware wallet": { + onClick: () => { + openConnectHardware(blockchain, "import"); + window.close(); + }, + + icon: (props: any) => , + detailIcon: , + }, + ...(keyringExists + ? // TODO allow creating a keyring from just a private key + // https://github.com/coral-xyz/backpack/issues/2164 + { + "Private key": { + onClick: () => + navigation.push("import-from-secret-key", { blockchain }), + icon: (props: any) => , + detailIcon: , + }, + } + : {}), + }; + + return ( +
+ +
+ + Import a wallet to @{user.username} on Backpack using one of the + following: + + + +
+ ); +} diff --git a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportMnemonic.tsx b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportMnemonic.tsx new file mode 100644 index 000000000..e4bdb6f76 --- /dev/null +++ b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportMnemonic.tsx @@ -0,0 +1,195 @@ +import { useEffect, useState } from "react"; +import { mnemonicPathToPrivateKey } from "@coral-xyz/blockchain-common"; +import type { + Blockchain, + SignedWalletDescriptor, + WalletDescriptor, +} from "@coral-xyz/common"; +import { + getAddMessage, + UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_ADD, + UI_RPC_METHOD_KEYRING_IMPORT_SECRET_KEY, + UI_RPC_METHOD_KEYRING_IMPORT_WALLET, +} from "@coral-xyz/common"; +import { PrimaryButton, TextInput } from "@coral-xyz/react-common"; +import { useBackgroundClient } from "@coral-xyz/recoil"; +import { useCustomTheme } from "@coral-xyz/themes"; +import { Box } from "@mui/material"; + +import { useSignMessageForWallet } from "../../../../hooks/useSignMessageForWallet"; +import { useSteps } from "../../../../hooks/useSteps"; +import { Header } from "../../../common"; +import { ImportWallets } from "../../../common/Account/ImportWallets"; +import { MnemonicInput } from "../../../common/Account/MnemonicInput"; +import { + useDrawerContext, + WithMiniDrawer, +} from "../../../common/Layout/Drawer"; +import { useNavigation } from "../../../common/Layout/NavStack"; + +import { ConfirmCreateWallet } from "./"; + +export function ImportMnemonic({ + blockchain, + keyringExists, + inputMnemonic, +}: { + blockchain: Blockchain; + keyringExists: boolean; + inputMnemonic: boolean; +}) { + const nav = useNavigation(); + const theme = useCustomTheme(); + const background = useBackgroundClient(); + const { step, nextStep } = useSteps(); + const { close: closeParentDrawer } = useDrawerContext(); + + const [openDrawer, setOpenDrawer] = useState(false); + const [mnemonic, setMnemonic] = useState(true); + const [publicKey, setPublicKey] = useState(null); + const [name, setName] = useState(null); + const signMessageForWallet = useSignMessageForWallet(mnemonic); + + useEffect(() => { + const prevTitle = nav.title; + nav.setOptions({ headerTitle: "" }); + return () => { + nav.setOptions({ headerTitle: prevTitle }); + }; + }, [theme]); + + // TODO replace the left nav button to go to the previous step if step > 0 + + const onComplete = async (signedWalletDescriptor: SignedWalletDescriptor) => { + let publicKey: string; + if (!inputMnemonic) { + if (keyringExists) { + // Using the keyring mnemonic and the blockchain keyring exists, just + // import the path + publicKey = await background.request({ + method: UI_RPC_METHOD_KEYRING_IMPORT_WALLET, + params: [blockchain, signedWalletDescriptor], + }); + } else { + // Blockchain keyring doesn't exist, init + publicKey = await background.request({ + method: UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_ADD, + params: [blockchain, signedWalletDescriptor], + }); + } + } else { + // Not using the keyring mnemonic, and the keyring only supports storing + // a singular mnemonic, so import as a private key + const privateKey = mnemonicPathToPrivateKey( + blockchain, + mnemonic as string, + signedWalletDescriptor.derivationPath + ); + publicKey = await background.request({ + method: UI_RPC_METHOD_KEYRING_IMPORT_SECRET_KEY, + params: [blockchain, privateKey, name], + }); + } + setPublicKey(publicKey); + setOpenDrawer(true); + }; + + const steps = [ + // Show the seed phrase if we are creating based on a mnemonic + ...(inputMnemonic + ? [ + { + setMnemonic(mnemonic); + nextStep(); + }} + />, + // Must prompt for a name if using an input mnemonic, because we can't + // easily generate one + { + setName(name); + nextStep(); + }} + />, + ] + : []), + ) => { + // Should only be one wallet descriptor + const walletDescriptor = walletDescriptors[0]; + const message = getAddMessage(walletDescriptor.publicKey); + const signature = await signMessageForWallet(walletDescriptor, message); + await onComplete({ + ...walletDescriptor, + signature, + }); + }} + />, + ]; + + return ( + <> + {steps[step]} + + { + setOpenDrawer(false); + closeParentDrawer(); + }} + /> + + + ); +} + +export function InputName({ onNext }: { onNext: (name: string) => void }) { + const [name, setName] = useState(""); + return ( + + +
+ + + + setName(e.target.value)} + /> + + + onNext(name)} + style={{ marginBottom: 16 }} + /> + + + ); +} diff --git a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportSecretKey.tsx b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportSecretKey.tsx index 05cf03df6..e3d209cdb 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportSecretKey.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportSecretKey.tsx @@ -14,8 +14,11 @@ import * as bs58 from "bs58"; import { ethers } from "ethers"; import { Header, SubtextParagraph } from "../../../common"; -import { WithMiniDrawer } from "../../../common/Layout/Drawer"; -import { useNavStack } from "../../../common/Layout/NavStack"; +import { + useDrawerContext, + WithMiniDrawer, +} from "../../../common/Layout/Drawer"; +import { useNavigation } from "../../../common/Layout/NavStack"; import { ConfirmCreateWallet } from "."; @@ -28,7 +31,7 @@ export function ImportSecretKey({ }) { const background = useBackgroundClient(); const existingPublicKeys = useWalletPublicKeys(); - const nav = useNavStack(); + const nav = useNavigation(); const theme = useCustomTheme(); const [name, setName] = useState(""); const [secretKey, setSecretKey] = useState(""); @@ -36,12 +39,13 @@ export function ImportSecretKey({ const [openDrawer, setOpenDrawer] = useState(false); const [newPublicKey, setNewPublicKey] = useState(""); const [loading, setLoading] = useState(false); + const { close: closeParentDrawer } = useDrawerContext(); useEffect(() => { const prevTitle = nav.title; - nav.setTitle(""); + nav.setOptions({ headerTitle: "" }); return () => { - nav.setTitle(prevTitle); + nav.setOptions({ headerTitle: prevTitle }); }; }, [theme]); @@ -76,12 +80,11 @@ export function ImportSecretKey({ if (privateKey) { try { - setNewPublicKey( - await background.request({ - method: UI_RPC_METHOD_KEYRING_IMPORT_SECRET_KEY, - params: [blockchain, privateKey, name], - }) - ); + const newPublicKey = await background.request({ + method: UI_RPC_METHOD_KEYRING_IMPORT_SECRET_KEY, + params: [blockchain, privateKey, name], + }); + setNewPublicKey(newPublicKey); setOpenDrawer(true); } catch (error) { setError("Wallet address is used by another Backpack account."); @@ -134,9 +137,9 @@ export function ImportSecretKey({ setValue={(e) => { setSecretKey(e.target.value); }} - onKeyDown={(e) => { + onKeyDown={async (e) => { if (e.key === "Enter") { - save(e); + await save(e); } }} rows={4} @@ -165,7 +168,10 @@ export function ImportSecretKey({ { + setOpenDrawer(false); + closeParentDrawer(); + }} /> diff --git a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/index.tsx b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/index.tsx index a9c37abdc..962e88cb6 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/index.tsx @@ -3,51 +3,43 @@ import type { Blockchain } from "@coral-xyz/common"; import { openAddUserAccount, openConnectHardware, - TAB_APPS, - TAB_BALANCES, - UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_ADD, UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_READ, - UI_RPC_METHOD_FIND_SIGNED_WALLET_DESCRIPTOR, - UI_RPC_METHOD_KEYRING_DERIVE_WALLET, - UI_RPC_METHOD_NAVIGATION_ACTIVE_TAB_UPDATE, } from "@coral-xyz/common"; import { CheckIcon, - HardwareWalletIcon, + HardwareIcon, + ImportedIcon, + Loading, + PlusCircleIcon, PrimaryButton, ProxyImage, + PushDetail, SecondaryButton, } from "@coral-xyz/react-common"; import { useAvatarUrl, useBackgroundClient, - useKeyringType, - useTab, useUser, useWalletName, } from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; -import { AddCircle, ArrowCircleDown } from "@mui/icons-material"; -import { Box, Grid, Typography } from "@mui/material"; +import { Box, Typography } from "@mui/material"; import { Header, SubtextParagraph } from "../../../common"; -import { ActionCard } from "../../../common/Layout/ActionCard"; -import { - useDrawerContext, - WithMiniDrawer, -} from "../../../common/Layout/Drawer"; -import { useNavStack } from "../../../common/Layout/NavStack"; +import { useDrawerContext } from "../../../common/Layout/Drawer"; +import { useNavigation } from "../../../common/Layout/NavStack"; +import { SettingsList } from "../../../common/Settings/List"; import { WalletListItem } from "../YourAccount/EditWallets"; export function AddConnectPreview() { - const nav = useNavStack(); + const nav = useNavigation(); const user = useUser(); const avatarUrl = useAvatarUrl(72, user.username); const theme = useCustomTheme(); const { close } = useDrawerContext(); useEffect(() => { - nav.setTitle(""); + nav.setOptions({ headerTitle: "" }); }, [nav]); return ( @@ -133,295 +125,133 @@ export function AddConnectWalletMenu({ blockchain: Blockchain; publicKey?: string; }) { - const nav = useNavStack(); - const background = useBackgroundClient(); - const [keyringExists, setKeyringExists] = useState(false); + const nav = useNavigation(); useEffect(() => { const prevTitle = nav.title; - nav.setTitle(""); + nav.setOptions({ headerTitle: "" }); return () => { - nav.setTitle(prevTitle); + nav.setOptions({ headerTitle: prevTitle }); }; - }, [nav.setContentStyle]); - - useEffect(() => { - (async () => { - const blockchainKeyrings = await background.request({ - method: UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_READ, - params: [], - }); - setKeyringExists(blockchainKeyrings.includes(blockchain)); - })(); - }, [blockchain]); + }, [nav.setOptions]); // If a public key prop exists then attempting to recover an existing wallet if (publicKey) { - return ( - - ); + return ; } else { - return ( - - ); + return ; } } -export function AddWalletMenu({ - blockchain, - keyringExists, - setKeyringExists, -}: { - blockchain: Blockchain; - keyringExists: boolean; - setKeyringExists: (exists: boolean) => void; -}) { - const nav = useNavStack(); - const background = useBackgroundClient(); - const keyringType = useKeyringType(); - const theme = useCustomTheme(); - const [newPublicKey, setNewPublicKey] = useState(""); - const [openDrawer, setOpenDrawer] = useState(false); - - // Lock to ensure that the create new wallet button cannot be accidentally - // spammed or double clicked, which is undesireable as it creates more wallets - // than the user expects. - const [lockCreateButton, setLockCreateButton] = useState(false); +export function AddWalletMenu({ blockchain }: { blockchain: Blockchain }) { + const navigation = useNavigation(); + const user = useUser(); - const createNew = async () => { - // Mnemonic based keyring. This is the simple case because we don't - // need to prompt for the user to open their Ledger app to get the - // required public key. We also don't need a signature to prove - // ownership of the public key because that can't be done - // transparently by the backend. - if (lockCreateButton) { - return; - } - setLockCreateButton(true); - let newPublicKey; - if (!keyringExists) { - const signedWalletDescriptor = await background.request({ - method: UI_RPC_METHOD_FIND_SIGNED_WALLET_DESCRIPTOR, - params: [blockchain, 0], - }); - await background.request({ - method: UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_ADD, - params: [blockchain, signedWalletDescriptor], - }); - newPublicKey = signedWalletDescriptor.publicKey; - // Keyring now exists, toggle to other options - setKeyringExists(true); - } else { - newPublicKey = await background.request({ - method: UI_RPC_METHOD_KEYRING_DERIVE_WALLET, - params: [blockchain], - }); - } - setNewPublicKey(newPublicKey); - setOpenDrawer(true); - setLockCreateButton(false); + const createOrImportMenu = { + "Create a new wallet": { + onClick: () => navigation.push("create-wallet", { blockchain }), + icon: (props: any) => , + detailIcon: , + }, + "Import an existing wallet": { + onClick: () => navigation.push("import-wallet", { blockchain }), + icon: (props: any) => , + detailIcon: , + }, }; return ( - <> -
- -
- - Add a new wallet associated with your Backpack account. - - - - - {keyringType === "mnemonic" && ( - - - } - text="Create a new wallet" - onClick={createNew} - /> - - )} - {keyringExists && ( - - - } - text="Import a private key" - onClick={() => nav.push("import-secret-key", { blockchain })} - /> - - )} - {(keyringType === "ledger" || keyringExists) && ( - - - } - text="Import from hardware wallet" - onClick={() => { - openConnectHardware(blockchain, !keyringExists); - window.close(); - }} - /> - - )} - - -
- - - - +
+ +
+ + Add a new wallet for @{user.username} on Backpack. + + + +
); } export function RecoverWalletMenu({ blockchain, - keyringExists, publicKey, }: { blockchain: Blockchain; - keyringExists: boolean; publicKey: string; }) { - const nav = useNavStack(); - const theme = useCustomTheme(); - const [openDrawer, setOpenDrawer] = useState(false); + const nav = useNavigation(); + const background = useBackgroundClient(); + const [keyringExists, setKeyringExists] = useState(false); - return ( - <> -
- -
- - Recover a wallet associated with your Backpack account. - - - - - {keyringExists && ( - - - } - text="Recover using private key" - onClick={() => - nav.push("import-secret-key", { - blockchain, - publicKey, - keyringExists, - }) - } - /> - - )} - - - } - text="Recover using hardware wallet" - onClick={() => { - openConnectHardware(blockchain, !keyringExists, publicKey); - window.close(); - }} - /> - - - -
- { + (async () => { + const blockchainKeyrings = await background.request({ + method: UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_READ, + params: [], + }); + setKeyringExists(blockchainKeyrings.includes(blockchain)); + })(); + }, [blockchain]); + + const recoverMenu = { + "Hardware wallet": { + onClick: () => { + openConnectHardware(blockchain, "search", publicKey); + window.close(); + }, + icon: (props: any) => , + detailIcon: , + }, + ...(keyringExists + ? { + "Private key": { + onClick: () => + nav.push("import-from-secret-key", { + blockchain, + publicKey, + }), + icon: (props: any) => , + detailIcon: , }, - }} - > - - - + } + : {}), + }; + + return ( +
+ +
+ + Recover a wallet using one of the following: + + + +
); } export const ConfirmCreateWallet: React.FC<{ blockchain: Blockchain; publicKey: string; - setOpenDrawer: (b: boolean) => void; -}> = ({ blockchain, publicKey, setOpenDrawer }) => { + onClose: () => void; + isLoading?: boolean; +}> = ({ blockchain, publicKey, onClose, isLoading = false }) => { const theme = useCustomTheme(); const walletName = useWalletName(publicKey); - const background = useBackgroundClient(); - const tab = useTab(); - const { close } = useDrawerContext(); + return (
-
- - Wallet Created - -
- -
-
-
- { - if (tab === TAB_BALANCES) { - // Experience won't go back to TAB_BALANCES so we poke it - background.request({ - method: UI_RPC_METHOD_NAVIGATION_ACTIVE_TAB_UPDATE, - params: [TAB_APPS], - }); - } - - background.request({ - method: UI_RPC_METHOD_NAVIGATION_ACTIVE_TAB_UPDATE, - params: [TAB_BALANCES], - }); - - // Close mini drawer. - setOpenDrawer(false); - // Close main drawer. - close(); - }} - /> -
+ {isLoading ? ( + + ) : ( + <> +
+ + Wallet Created + +
+ +
+
+
+ { + onClose(); + }} + /> +
+ + )}
); }; diff --git a/packages/app-extension/src/components/Unlocked/Settings/AvatarHeader/AvatarHeader.tsx b/packages/app-extension/src/components/Unlocked/Settings/AvatarHeader/AvatarHeader.tsx index 6aeb22187..bdf44b97a 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/AvatarHeader/AvatarHeader.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/AvatarHeader/AvatarHeader.tsx @@ -53,7 +53,6 @@ export function AvatarHeader() { title, }} navButtonLeft={ setOpenDrawer(false)} />} - onClose={() => setOpenDrawer(false)} > { - nav.setTitle("Auto-lock timer"); + nav.setOptions({ headerTitle: "Auto-lock timer" }); }, []); const onCancel = () => { diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewayCustom.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewayCustom.tsx index ca8a0c150..42763dd94 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewayCustom.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewayCustom.tsx @@ -5,7 +5,7 @@ import { InputListItem, Inputs, PrimaryButton } from "@coral-xyz/react-common"; import { useBackgroundClient } from "@coral-xyz/recoil"; import { styles } from "@coral-xyz/themes"; -import { useNavStack } from "../../../../common/Layout/NavStack"; +import { useNavigation } from "../../../../common/Layout/NavStack"; const useStyles = styles((theme) => ({ textFieldRoot: { @@ -30,7 +30,7 @@ const useStyles = styles((theme) => ({ })); export function PreferencesCustomIpfsGateway() { - const nav = useNavStack(); + const nav = useNavigation(); const background = useBackgroundClient(); const [gatewayUrl, setGatewayUrl] = useState(""); @@ -51,9 +51,9 @@ export function PreferencesCustomIpfsGateway() { useEffect(() => { const title = nav.title; - nav.setTitle("Change IPFS Gateway"); + nav.setOptions({ headerTitle: "Change IPFS Gateway" }); return () => { - nav.setTitle(title); + nav.setOptions({ headerTitle: title }); }; }, []); diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewaySwitch.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewaySwitch.tsx index 3f4c2c1dc..9cd10d804 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewaySwitch.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/IpfsGatewaySwitch.tsx @@ -8,7 +8,7 @@ import { useBackgroundClient, useIpfsGateway } from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; import { Check } from "@mui/icons-material"; -import { useNavStack } from "../../../../common/Layout/NavStack"; +import { useNavigation } from "../../../../common/Layout/NavStack"; import { SettingsList } from "../../../../common/Settings/List"; interface MenuItems { @@ -24,7 +24,7 @@ interface MenuItems { } import { setIPFSGateway } from "@coral-xyz/app-extension/src/redirects/ipfsBuilder"; export function PreferencesIpfsGateway() { - const nav = useNavStack(); + const nav = useNavigation(); const background = useBackgroundClient(); const currentIpfsGatewayUrl = useIpfsGateway(); @@ -44,7 +44,7 @@ export function PreferencesIpfsGateway() { }; useEffect(() => { - nav.setTitle("IPFS Gateway"); + nav.setOptions({ headerTitle: "IPFS Gateway" }); }, [nav]); const menuItems = DEFAULT_IPFS_GATEWAYS.reduce((acc, gateway) => { diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/index.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/index.tsx index 45d0e3df6..cd1030bfa 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/DomainContentResolver/index.tsx @@ -1,6 +1,6 @@ import { useEffect } from "react"; -import { useNavStack } from "../../../../common/Layout/NavStack"; +import { useNavigation } from "../../../../common/Layout/NavStack"; import { SettingsList } from "../../../../common/Settings/List"; export const PreferencesDomainContent: React.FC = () => { return ( @@ -11,14 +11,14 @@ export const PreferencesDomainContent: React.FC = () => { }; export const _PreferencesDomainResolverContent: React.FC = () => { - const nav = useNavStack(); + const nav = useNavigation(); const resolverMenuItems = { "IPFS Gateways": { onClick: () => nav.push("preferences-ipfs-gateway"), }, }; useEffect(() => { - nav.setTitle("Domain Content Resolver"); + nav.setOptions({ headerTitle: "Domain Website Resolver" }); }, [nav]); return ; diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Ethereum/Connection.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Ethereum/Connection.tsx index f0edfb5f0..689453785 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Ethereum/Connection.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Ethereum/Connection.tsx @@ -9,7 +9,7 @@ import { useCustomTheme } from "@coral-xyz/themes"; import { Check } from "@mui/icons-material"; import { useDrawerContext } from "../../../../common/Layout/Drawer"; -import { useNavStack } from "../../../../common/Layout/NavStack"; +import { useNavigation } from "../../../../common/Layout/NavStack"; import { SettingsList } from "../../../../common/Settings/List"; import { changeNetwork } from "./common"; @@ -18,10 +18,10 @@ export function PreferencesEthereumConnection() { const { close } = useDrawerContext(); const background = useBackgroundClient(); const currentUrl = useEthereumConnectionUrl(); - const nav = useNavStack(); + const nav = useNavigation(); useEffect(() => { - nav.setTitle("RPC Connection"); + nav.setOptions({ headerTitle: "RPC Connection" }); }, [nav]); const menuItems = { diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Ethereum/CustomRpcUrl.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Ethereum/CustomRpcUrl.tsx index fa9c6671f..59686b71e 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Ethereum/CustomRpcUrl.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Ethereum/CustomRpcUrl.tsx @@ -3,13 +3,13 @@ import { InputListItem, Inputs, PrimaryButton } from "@coral-xyz/react-common"; import { useBackgroundClient } from "@coral-xyz/recoil"; import { useDrawerContext } from "../../../../common/Layout/Drawer"; -import { useNavStack } from "../../../../common/Layout/NavStack"; +import { useNavigation } from "../../../../common/Layout/NavStack"; import { changeNetwork } from "./common"; export function PreferenceEthereumCustomRpcUrl() { const { close } = useDrawerContext(); - const nav = useNavStack(); + const nav = useNavigation(); const background = useBackgroundClient(); const [rpcUrl, setRpcUrl] = useState(""); const [chainId, setChainId] = useState(""); @@ -18,9 +18,9 @@ export function PreferenceEthereumCustomRpcUrl() { useEffect(() => { const title = nav.title; - nav.setTitle("Change RPC Connection"); + nav.setOptions({ headerTitle: "Change RPC Connection" }); return () => { - nav.setTitle(title); + nav.setOptions({ headerTitle: title }); }; }, []); diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Ethereum/index.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Ethereum/index.tsx index f6060dc1b..7647d2fac 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Ethereum/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Ethereum/index.tsx @@ -1,10 +1,10 @@ import { useEffect } from "react"; -import { useNavStack } from "../../../../common/Layout/NavStack"; +import { useNavigation } from "../../../../common/Layout/NavStack"; import { SettingsList } from "../../../../common/Settings/List"; export const PreferencesEthereum = () => { - const nav = useNavStack(); + const nav = useNavigation(); const ethereumMenuItems = { "RPC Connection": { onClick: () => nav.push("preferences-ethereum-rpc-connection"), @@ -12,7 +12,7 @@ export const PreferencesEthereum = () => { }; useEffect(() => { - nav.setTitle("Ethereum"); + nav.setOptions({ headerTitle: "Ethereum" }); }, [nav]); return ; diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/Commitment.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/Commitment.tsx index e08a2d8f0..3f2b61ea9 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/Commitment.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/Commitment.tsx @@ -3,18 +3,18 @@ import { UI_RPC_METHOD_SOLANA_COMMITMENT_UPDATE } from "@coral-xyz/common"; import { useBackgroundClient, useSolanaCommitment } from "@coral-xyz/recoil"; import type { Commitment } from "@solana/web3.js"; -import { useNavStack } from "../../../../common/Layout/NavStack"; +import { useNavigation } from "../../../../common/Layout/NavStack"; import { SettingsList } from "../../../../common/Settings/List"; import { Checkmark } from "./ConnectionSwitch"; export function PreferencesSolanaCommitment() { - const nav = useNavStack(); + const nav = useNavigation(); const commitment = useSolanaCommitment(); const background = useBackgroundClient(); useEffect(() => { - nav.setTitle("Confirmation Commitment"); + nav.setOptions({ headerTitle: "Confirmation Commitment" }); }, [nav]); const menuItems = { diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/ConnectionSwitch.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/ConnectionSwitch.tsx index f6eaa3ab9..a80d567f3 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/ConnectionSwitch.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/ConnectionSwitch.tsx @@ -9,17 +9,17 @@ import { useCustomTheme } from "@coral-xyz/themes"; import { Check } from "@mui/icons-material"; import { useDrawerContext } from "../../../../common/Layout/Drawer"; -import { useNavStack } from "../../../../common/Layout/NavStack"; +import { useNavigation } from "../../../../common/Layout/NavStack"; import { SettingsList } from "../../../../common/Settings/List"; export function PreferencesSolanaConnection() { const { close } = useDrawerContext(); const background = useBackgroundClient(); const currentUrl = useSolanaConnectionUrl(); - const nav = useNavStack(); + const nav = useNavigation(); useEffect(() => { - nav.setTitle("RPC Connection"); + nav.setOptions({ headerTitle: "RPC Connection" }); }, [nav]); const menuItems = { diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/CustomRpcUrl.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/CustomRpcUrl.tsx index e60a27591..6e602c546 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/CustomRpcUrl.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/CustomRpcUrl.tsx @@ -4,11 +4,11 @@ import { InputListItem, Inputs, PrimaryButton } from "@coral-xyz/react-common"; import { useBackgroundClient } from "@coral-xyz/recoil"; import { useDrawerContext } from "../../../../common/Layout/Drawer"; -import { useNavStack } from "../../../../common/Layout/NavStack"; +import { useNavigation } from "../../../../common/Layout/NavStack"; export function PreferenceSolanaCustomRpcUrl() { const { close } = useDrawerContext(); - const nav = useNavStack(); + const nav = useNavigation(); const background = useBackgroundClient(); const [rpcUrl, setRpcUrl] = useState(""); @@ -30,9 +30,9 @@ export function PreferenceSolanaCustomRpcUrl() { useEffect(() => { const title = nav.title; - nav.setTitle("Change RPC Connection"); + nav.setOptions({ headerTitle: "Change RPC Connection" }); return () => { - nav.setTitle(title); + nav.setOptions({ headerTitle: title }); }; }, []); diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/Explorer.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/Explorer.tsx index fbedba32d..bfb2ab129 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/Explorer.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/Explorer.tsx @@ -5,7 +5,7 @@ import { } from "@coral-xyz/common"; import { useBackgroundClient, useSolanaExplorer } from "@coral-xyz/recoil"; -import { useNavStack } from "../../../../common/Layout/NavStack"; +import { useNavigation } from "../../../../common/Layout/NavStack"; import { SettingsList } from "../../../../common/Settings/List"; import { Checkmark } from "./ConnectionSwitch"; @@ -13,10 +13,10 @@ import { Checkmark } from "./ConnectionSwitch"; export function PreferencesSolanaExplorer() { const background = useBackgroundClient(); const explorer = useSolanaExplorer(); - const nav = useNavStack(); + const nav = useNavigation(); useEffect(() => { - nav.setTitle("Explorer"); + nav.setOptions({ headerTitle: "Explorer" }); }, [nav]); const menuItems = { diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/index.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/index.tsx index 35e9204f7..c5b8ae5da 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/index.tsx @@ -1,10 +1,10 @@ import { useEffect } from "react"; -import { useNavStack } from "../../../../common/Layout/NavStack"; +import { useNavigation } from "../../../../common/Layout/NavStack"; import { SettingsList } from "../../../../common/Settings/List"; export const PreferencesSolana: React.FC = () => { - const nav = useNavStack(); + const nav = useNavigation(); const solanaMenuItems = { "RPC Connection": { onClick: () => nav.push("preferences-solana-rpc-connection"), @@ -18,7 +18,7 @@ export const PreferencesSolana: React.FC = () => { }; useEffect(() => { - nav.setTitle("Solana"); + nav.setOptions({ headerTitle: "Solana" }); }, [nav]); return ; diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/TrustedSites.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/TrustedSites.tsx index 703428590..4b02d05f4 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/TrustedSites.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/TrustedSites.tsx @@ -1,20 +1,25 @@ import { useEffect } from "react"; import { UI_RPC_METHOD_APPROVED_ORIGINS_DELETE } from "@coral-xyz/common"; -import { EmptyState,List, ListItem, PrimaryButton } from "@coral-xyz/react-common"; +import { + EmptyState, + List, + ListItem, + PrimaryButton, +} from "@coral-xyz/react-common"; import { useApprovedOrigins, useBackgroundClient } from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; import { GppBad } from "@mui/icons-material"; import { ListItemText } from "@mui/material"; -import { useNavStack } from "../../../common/Layout/NavStack"; +import { useNavigation } from "../../../common/Layout/NavStack"; export function PreferencesTrustedSites() { const theme = useCustomTheme(); - const nav = useNavStack(); + const nav = useNavigation(); const approvedOrigins = useApprovedOrigins(); useEffect(() => { - nav.setTitle("Trusted Sites"); + nav.setOptions({ headerTitle: "Trusted Sites" }); }, [nav]); return approvedOrigins.length === 0 ? ( diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/index.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/index.tsx index 0827ee741..18d8e1d23 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/index.tsx @@ -22,11 +22,11 @@ import { hasActiveSubscription, unregisterNotificationServiceWorker, } from "../../../../permissions/utils"; -import { useNavStack } from "../../../common/Layout/NavStack"; +import { useNavigation } from "../../../common/Layout/NavStack"; import { SettingsList } from "../../../common/Settings/List"; export function Preferences() { - const nav = useNavStack(); + const nav = useNavigation(); const background = useBackgroundClient(); const isDarkMode = useDarkMode(); const isDeveloperMode = useDeveloperMode(); @@ -89,7 +89,7 @@ export function Preferences() { "Trusted Sites": { onClick: () => nav.push("preferences-trusted-sites"), }, - "Domain Content Resolver": { + "Domain Website Resolver": { onClick: () => nav.push("preferences-domain-content-resolver"), }, }; @@ -149,7 +149,7 @@ export function Preferences() { style={{ width: "12px", height: "12px", - marginRight: "10px", + marginRight: "8px", }} /> ); @@ -165,7 +165,7 @@ export function Preferences() { style={{ width: "12px", height: "12px", - marginRight: "10px", + marginRight: "8px", }} /> ); @@ -174,7 +174,7 @@ export function Preferences() { }; useEffect(() => { - nav.setTitle("Preferences"); + nav.setOptions({ headerTitle: "Preferences" }); }, []); return ( diff --git a/packages/app-extension/src/components/Unlocked/Settings/SettingsNavStackDrawer.tsx b/packages/app-extension/src/components/Unlocked/Settings/SettingsNavStackDrawer.tsx index b1b236141..0b1fbafe7 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/SettingsNavStackDrawer.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/SettingsNavStackDrawer.tsx @@ -1,6 +1,5 @@ import { AllWalletsList, - WalletList as _WalletList, WalletListBlockchainSelector, } from "../../../components/common/WalletList"; import { CloseButton, WithDrawer } from "../../common/Layout/Drawer"; @@ -13,6 +12,9 @@ import { ResetWelcome } from "../../Locked/Reset/ResetWelcome"; import { ContactRequests, Contacts } from "../Messages/Contacts"; import { Requests } from "../Messages/Requests"; +import { CreateMenu } from "./AddConnectWallet/CreateMenu"; +import { ImportMenu } from "./AddConnectWallet/ImportMenu"; +import { ImportMnemonic } from "./AddConnectWallet/ImportMnemonic"; import { ImportSecretKey } from "./AddConnectWallet/ImportSecretKey"; import { PreferencesAutoLock } from "./Preferences/AutoLock"; import { PreferencesDomainContent } from "./Preferences/DomainContentResolver"; @@ -71,7 +73,19 @@ export function SettingsNavStackDrawer({ component={(props: any) => } /> } + /> + } + /> + } + /> + } /> = ({ xnft }) => { xnftPreferenceAtom(xnft.install.account.xnft.toString()) ); - const nav = useNavStack(); + const nav = useNavigationEphemeral(); const background = useBackgroundClient(); const { username } = useUser(); // Using the raw string here instead of PublicKey.default.toString() because // typescript sucks and is throwing inexplicable errors. - const isDisabled = - xnft.install.publicKey === "11111111111111111111111111111111"; + const isDisabled = xnft.install.publicKey === DEFAULT_PUBKEY_STR; useEffect(() => { - nav.setTitle(xnft.title); + nav.setOptions({ + headerTitle: xnft.title, + }); }, []); const menuItems = { @@ -66,6 +69,7 @@ export const XnftDetail: React.FC<{ xnft: any }> = ({ xnft }) => { style: { opacity: 0.5, }, + allowOnclickPropagation: true, }, MediaAccess: { label: "Cam/Mic/Display access", @@ -100,6 +104,7 @@ export const XnftDetail: React.FC<{ xnft: any }> = ({ xnft }) => { style: { opacity: 0.5, }, + allowOnclickPropagation: true, }, PushNotificationAccess: { label: "Push notifications", @@ -147,6 +152,7 @@ export const XnftDetail: React.FC<{ xnft: any }> = ({ xnft }) => { style: { opacity: 0.5, }, + allowOnclickPropagation: true, }, }; @@ -192,7 +198,7 @@ export const XnftDetail: React.FC<{ xnft: any }> = ({ xnft }) => { }} onClick={() => window.open( - `https://xnft.gg/app/${xnft.install.account.xnft.toString()}` + `${XNFT_GG_LINK}/app/${xnft.install.account.xnft.toString()}` ) } > diff --git a/packages/app-extension/src/components/Unlocked/Settings/Xnfts/index.tsx b/packages/app-extension/src/components/Unlocked/Settings/Xnfts/index.tsx index b6dfadb79..ac110e48d 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Xnfts/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Xnfts/index.tsx @@ -14,21 +14,22 @@ import { import { Apps } from "@mui/icons-material"; import { useRecoilValueLoadable } from "recoil"; -import { useNavStack } from "../../../common/Layout/NavStack"; +import { useNavigation } from "../../../common/Layout/NavStack"; import { SettingsList } from "../../../common/Settings/List"; export function XnftSettings() { - const nav = useNavStack(); + const nav = useNavigation(); // TODO: Aggregate view. - const { publicKey } = useActiveSolanaWallet(); + const activeSolanaWallet = useActiveSolanaWallet(); const connectionUrl = useSolanaConnectionUrl(); + const publicKey = activeSolanaWallet?.publicKey; const { contents, state } = useRecoilValueLoadable( filteredPlugins({ publicKey, connectionUrl }) ); useEffect(() => { - nav.setTitle("xNFTs"); - }, [nav.setTitle]); + nav.setOptions({ headerTitle: "xNFTs" }); + }, [nav.setOptions]); if (state !== "hasValue" && state === "loading") { return ( @@ -45,7 +46,7 @@ export function XnftSettings() { ); } - const xnfts = contents; + const xnfts = contents || []; const settingsMenu = {} as any; xnfts.forEach((xnft: any) => { const pubkeyStr = xnft.install.publicKey.toString(); diff --git a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/ChangePassword.tsx b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/ChangePassword.tsx index 1c210f915..2dde0518c 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/ChangePassword.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/ChangePassword.tsx @@ -10,12 +10,12 @@ import { Button, Typography } from "@mui/material"; import { SubtextParagraph } from "../../../common"; import { useDrawerContext } from "../../../common/Layout/Drawer"; -import { useNavStack } from "../../../common/Layout/NavStack"; +import { useNavigation } from "../../../common/Layout/NavStack"; export function ChangePassword() { const theme = useCustomTheme(); const { close } = useDrawerContext(); - const nav = useNavStack(); + const nav = useNavigation(); const background = useBackgroundClient(); const [currentPassword, setCurrentPassword] = useState(""); const [newPw1, setNewPw1] = useState(""); @@ -27,9 +27,9 @@ export function ChangePassword() { useEffect(() => { const title = nav.title; - nav.setTitle("Change password"); + nav.setOptions({ headerTitle: "Change password" }); return () => { - nav.setTitle(title); + nav.setOptions({ headerTitle: title }); }; }, []); diff --git a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/index.tsx b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/index.tsx index 58a742b14..9c3dfd382 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/index.tsx @@ -1,18 +1,18 @@ import { useEffect } from "react"; -import { useKeyringType } from "@coral-xyz/recoil"; +import { useKeyringHasMnemonic } from "@coral-xyz/recoil"; -import { useNavStack } from "../../../common/Layout/NavStack"; +import { useNavigation } from "../../../common/Layout/NavStack"; import { SettingsList } from "../../../common/Settings/List"; export function YourAccount() { - const nav = useNavStack(); - const keyringType = useKeyringType(); + const nav = useNavigation(); + const hasMnemonic = useKeyringHasMnemonic(); const menuItems = { "Change Password": { onClick: () => nav.push("change-password"), }, - ...(keyringType === "mnemonic" + ...(hasMnemonic ? { "Show Secret Recovery Phrase": { onClick: () => nav.push("show-secret-phrase-warning"), @@ -25,7 +25,7 @@ export function YourAccount() { }; useEffect(() => { - nav.setTitle("Your Account"); + nav.setOptions({ headerTitle: "Your Account" }); }, []); return ; diff --git a/packages/app-extension/src/components/Unlocked/Settings/index.tsx b/packages/app-extension/src/components/Unlocked/Settings/index.tsx index 8f29e610b..c723e3545 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/index.tsx @@ -1,32 +1,24 @@ -import { Suspense, useEffect } from "react"; +import { Suspense, useEffect, useMemo } from "react"; import { - BACKPACK_FEATURE_POP_MODE, BACKPACK_FEATURE_XNFT, MESSAGES_ENABLED, NOTIFICATIONS_ENABLED, - openPopupWindow, UI_RPC_METHOD_KEYRING_STORE_LOCK, } from "@coral-xyz/common"; import { ContactsIcon, GridIcon, - LaunchDetail, List, ListItem, PushDetail, } from "@coral-xyz/react-common"; import { useBackgroundClient, useFeatureGates } from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; -import { - AccountCircleOutlined, - Lock, - Settings, - Tab as WindowIcon, -} from "@mui/icons-material"; +import { AccountCircleOutlined, Lock, Settings } from "@mui/icons-material"; import AccountBalanceWalletIcon from "@mui/icons-material/AccountBalanceWallet"; import { Typography } from "@mui/material"; -import { useNavStack } from "../../common/Layout/NavStack"; +import { useNavigation } from "../../common/Layout/NavStack"; import { RecentActivityButton } from "../../Unlocked/Balances/RecentActivity"; import { NotificationButton } from "../Balances/Notifications"; @@ -47,11 +39,13 @@ export function SettingsButton() { } export function SettingsMenu() { - const { setTitle } = useNavStack(); + const nav = useNavigation(); + + const headerTitle = useMemo(() => , []); useEffect(() => { - setTitle(); - }, [setTitle]); + nav.setOptions({ headerTitle }); + }, [nav.setOptions]); return (
}> @@ -71,7 +65,7 @@ function _SettingsContent() { function SettingsList() { const theme = useCustomTheme(); - const nav = useNavStack(); + const nav = useNavigation(); const background = useBackgroundClient(); const featureGates = useFeatureGates(); From 86c31b067c0cdfac45c161870d664aae3e6712a7 Mon Sep 17 00:00:00 2001 From: mj221 Date: Sun, 12 Feb 2023 11:30:40 +1000 Subject: [PATCH 15/36] WIP resolve merge conflict with 'master' of https://github.com/coral-xyz/backpack into mj/domain-content-resolver --- .../YourAccount/EditWallets/RemoveWallet.tsx | 6 +- .../YourAccount/EditWallets/RenameWallet.tsx | 6 +- .../YourAccount/EditWallets/WalletDetail.tsx | 46 ++- .../YourAccount/EditWallets/index.tsx | 4 +- .../Settings/YourAccount/ShowPrivateKey.tsx | 16 +- .../YourAccount/ShowRecoveryPhrase.tsx | 14 +- .../src/hooks/useConflictQuery.tsx | 19 -- .../src/hooks/useSignMessageForWallet.tsx | 2 +- .../app-extension/src/options/Options.tsx | 5 + packages/app-mobile/app.config.js | 48 ++-- packages/app-mobile/eas.json | 11 +- packages/app-mobile/index.js | 4 + packages/app-mobile/package.json | 2 + packages/app-mobile/src/App.tsx | 11 +- .../app-mobile/src/components/CheckBox.tsx | 12 +- packages/app-mobile/src/components/Form.tsx | 4 +- .../Unlocked/Balances/TransferWidget.tsx | 31 +- .../src/navigation/OnboardingNavigator.tsx | 2 +- .../src/navigation/UnlockedNavigator.tsx | 12 +- .../src/screens/Unlocked/BalancesScreen.tsx | 17 +- .../src/screens/Unlocked/GlobalSwapScreen.tsx | 18 -- .../Unlocked/NftCollectiblesScreen.tsx | 13 - .../screens/Unlocked/RecentActivityScreen.tsx | 9 +- .../Settings/AddConnectWalletScreen.tsx | 8 +- .../src/screens/Unlocked/SwapTokenScreen.tsx | 60 ++++ .../screens/Unlocked/YourAccountScreen.tsx | 6 +- packages/background/src/backend/core.ts | 206 +++++++++---- .../background/src/backend/keyring/index.ts | 63 +++- .../src/backend/solana-connection.ts | 1 + .../background/src/backend/store/keyname.ts | 3 +- packages/background/src/frontend/common.ts | 100 ------- .../src/frontend/server-injected.ts | 271 +++++++++++------- packages/background/src/frontend/server-ui.ts | 64 ++++- packages/blockchains/common/src/index.ts | 19 ++ packages/blockchains/evm/src/index.ts | 1 + packages/blockchains/evm/src/keyring/index.ts | 39 ++- packages/blockchains/evm/src/util.ts | 10 +- .../blockchains/keyring/src/blockchain.ts | 8 + packages/blockchains/keyring/src/ledger.ts | 28 +- packages/blockchains/keyring/src/types.ts | 2 + 40 files changed, 759 insertions(+), 442 deletions(-) delete mode 100644 packages/app-extension/src/hooks/useConflictQuery.tsx delete mode 100644 packages/app-mobile/src/screens/Unlocked/GlobalSwapScreen.tsx create mode 100644 packages/app-mobile/src/screens/Unlocked/SwapTokenScreen.tsx delete mode 100644 packages/background/src/frontend/common.ts diff --git a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/EditWallets/RemoveWallet.tsx b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/EditWallets/RemoveWallet.tsx index b4ee442c9..0d9536eb9 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/EditWallets/RemoveWallet.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/EditWallets/RemoveWallet.tsx @@ -16,7 +16,7 @@ import { useCustomTheme } from "@coral-xyz/themes"; import { Typography } from "@mui/material"; import { WithMiniDrawer } from "../../../../common/Layout/Drawer"; -import { useNavStack } from "../../../../common/Layout/NavStack"; +import { useNavigation } from "../../../../common/Layout/NavStack"; export const RemoveWallet: React.FC<{ blockchain: Blockchain; @@ -24,13 +24,13 @@ export const RemoveWallet: React.FC<{ type: string; }> = ({ blockchain, publicKey, type }) => { const theme = useCustomTheme(); - const nav = useNavStack(); + const nav = useNavigation(); const background = useBackgroundClient(); const [showSuccess, setShowSuccess] = useState(false); const [loading, setLoading] = useState(false); useEffect(() => { - nav.setTitle("Remove Wallet"); + nav.setOptions({ headerTitle: "Remove Wallet" }); }, [nav]); const onRemove = async () => { diff --git a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/EditWallets/RenameWallet.tsx b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/EditWallets/RenameWallet.tsx index 03647e2db..579b34c2a 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/EditWallets/RenameWallet.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/EditWallets/RenameWallet.tsx @@ -9,19 +9,19 @@ import { useBackgroundClient } from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; import { Typography } from "@mui/material"; -import { useNavStack } from "../../../../common/Layout/NavStack"; +import { useNavigation } from "../../../../common/Layout/NavStack"; export const RenameWallet: React.FC<{ publicKey: string; name: string }> = ({ publicKey, name, }) => { const [walletName, setWalletName] = useState(name); - const nav = useNavStack(); + const nav = useNavigation(); const theme = useCustomTheme(); const background = useBackgroundClient(); useEffect(() => { - nav.setTitle("Rename Wallet"); + nav.setOptions({ headerTitle: "Rename Wallet" }); }, [nav]); const cancel = () => { diff --git a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/EditWallets/WalletDetail.tsx b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/EditWallets/WalletDetail.tsx index 4a7fec9e3..2f01bac96 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/EditWallets/WalletDetail.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/EditWallets/WalletDetail.tsx @@ -3,7 +3,9 @@ import type { Blockchain } from "@coral-xyz/common"; import { UI_RPC_METHOD_KEY_IS_COLD_UPDATE, UI_RPC_METHOD_KEYNAME_READ, + walletAddressDisplay, } from "@coral-xyz/common"; +import { SecondaryButton, WarningIcon } from "@coral-xyz/react-common"; import { isKeyCold, useBackgroundClient, @@ -14,7 +16,8 @@ import { ContentCopy } from "@mui/icons-material"; import { Typography } from "@mui/material"; import { useRecoilValue } from "recoil"; -import { useNavStack } from "../../../../common/Layout/NavStack"; +import { HeaderIcon } from "../../../../common"; +import { useNavigation } from "../../../../common/Layout/NavStack"; import { SettingsList } from "../../../../common/Settings/List"; import { WithCopyTooltip } from "../../../../common/WithCopyTooltip"; import { ModeSwitch } from "../../Preferences"; @@ -25,7 +28,7 @@ export const WalletDetail: React.FC<{ name: string; type: string; }> = ({ blockchain, publicKey, name, type }) => { - const nav = useNavStack(); + const nav = useNavigation(); const theme = useCustomTheme(); const background = useBackgroundClient(); const [tooltipOpen, setTooltipOpen] = useState(false); @@ -43,10 +46,10 @@ export const WalletDetail: React.FC<{ }); } catch { // No wallet name, might be dehydrated - return; + keyname = walletAddressDisplay(publicKey); } setWalletName(keyname); - nav.setTitle(keyname); + nav.setOptions({ headerTitle: keyname }); })(); }, []); @@ -148,6 +151,40 @@ export const WalletDetail: React.FC<{ return (
+ {type === "dehydrated" && ( +
+ } /> + + Some more steps are needed to recover this wallet + + { + nav.push("add-connect-wallet", { + blockchain, + publicKey, + isRecovery: true, + }); + }} + /> +
+ )}
@@ -157,7 +194,6 @@ export const WalletDetail: React.FC<{ {type !== "hardware" && type !== "dehydrated" && ( )} - {type === "dehydrated" && } {!isLastRecoverable && }
); diff --git a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/EditWallets/index.tsx b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/EditWallets/index.tsx index 0a19e1792..ca3a4674e 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/EditWallets/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/EditWallets/index.tsx @@ -4,7 +4,7 @@ import { useCustomTheme } from "@coral-xyz/themes"; import { MoreHoriz } from "@mui/icons-material"; import { WalletAddress } from "../../../../common"; -import { useNavStack } from "../../../../common/Layout/NavStack"; +import { useNavigation } from "../../../../common/Layout/NavStack"; import { ImportTypeBadge } from "../../../../common/WalletList"; export const WalletListItem: React.FC<{ @@ -27,7 +27,7 @@ export const WalletListItem: React.FC<{ onClick, }) => { const theme = useCustomTheme(); - const nav = useNavStack(); + const nav = useNavigation(); return ( ({ passwordField: { @@ -104,15 +106,15 @@ const useStyles = styles((theme: any) => ({ export function ShowPrivateKeyWarning({ publicKey }: { publicKey: string }) { const classes = useStyles(); const background = useBackgroundClient(); - const nav = useNavStack(); + const nav = useNavigation(); const [password, setPassword] = useState(""); const [error, setError] = useState(false); useEffect(() => { const navButton = nav.navButtonRight; - nav.setTitle("Show private key"); + nav.setOptions({ headerTitle: "Show private key" }); return () => { - nav.setNavButtonRight(navButton); + nav.setOptions({ headerRight: navButton }); }; }, []); @@ -221,10 +223,10 @@ export function ShowPrivateKey({ privateKey }: { privateKey: string }) { const theme = useCustomTheme(); const classes = useStyles(); const { close } = useDrawerContext(); - const nav = useNavStack(); + const nav = useNavigation(); useEffect(() => { - nav.setTitle("Private key"); + nav.setOptions({ headerTitle: "Private key" }); }, []); return ( diff --git a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/ShowRecoveryPhrase.tsx b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/ShowRecoveryPhrase.tsx index 2c179e2ce..93c1e3ccc 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/YourAccount/ShowRecoveryPhrase.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/YourAccount/ShowRecoveryPhrase.tsx @@ -5,7 +5,9 @@ import { DangerButton, EyeIcon, SecondaryButton, - TextInput, WarningIcon } from "@coral-xyz/react-common"; + TextInput, + WarningIcon, +} from "@coral-xyz/react-common"; import { useBackgroundClient } from "@coral-xyz/recoil"; import { styles, useCustomTheme } from "@coral-xyz/themes"; import ChatIcon from "@mui/icons-material/Chat"; @@ -20,7 +22,7 @@ import { MnemonicInputFields, } from "../../../common/Account/MnemonicInput"; import { useDrawerContext } from "../../../common/Layout/Drawer"; -import { useNavStack } from "../../../common/Layout/NavStack"; +import { useNavigation } from "../../../common/Layout/NavStack"; const useStyles = styles((theme: any) => ({ listRoot: { @@ -50,15 +52,17 @@ const useStyles = styles((theme: any) => ({ export function ShowRecoveryPhraseWarning() { const classes = useStyles(); const background = useBackgroundClient(); - const nav = useNavStack(); + const nav = useNavigation(); const [password, setPassword] = useState(""); const [error, setError] = useState(false); useEffect(() => { const navButton = nav.navButtonRight; - nav.setTitle("Secret recovery phrase"); + nav.setOptions({ + headerTitle: "Secret recovery phrase", + }); return () => { - nav.setNavButtonRight(navButton); + nav.setOptions({ headerRight: navButton }); }; }, []); diff --git a/packages/app-extension/src/hooks/useConflictQuery.tsx b/packages/app-extension/src/hooks/useConflictQuery.tsx deleted file mode 100644 index 29f34b7b1..000000000 --- a/packages/app-extension/src/hooks/useConflictQuery.tsx +++ /dev/null @@ -1,19 +0,0 @@ -import type { Blockchain } from "@coral-xyz/common"; -import { BACKEND_API_URL } from "@coral-xyz/common"; - -export const useConflictQuery = () => { - const checkConflicts = async ( - blockchainPublicKeys: Array<{ blockchain: Blockchain; publicKey: string }> - ) => { - const response = await fetch(`${BACKEND_API_URL}/publicKeys`, { - method: "POST", - body: JSON.stringify(blockchainPublicKeys), - headers: { - "Content-Type": "application/json", - }, - }); - return await response.json(); - }; - - return checkConflicts; -}; diff --git a/packages/app-extension/src/hooks/useSignMessageForWallet.tsx b/packages/app-extension/src/hooks/useSignMessageForWallet.tsx index 6dd92a65e..e80f7c193 100644 --- a/packages/app-extension/src/hooks/useSignMessageForWallet.tsx +++ b/packages/app-extension/src/hooks/useSignMessageForWallet.tsx @@ -6,7 +6,7 @@ import { import { useBackgroundClient } from "@coral-xyz/recoil"; import { ethers } from "ethers"; -export const useSignMessageForWallet = (mnemonic?: string) => { +export const useSignMessageForWallet = (mnemonic?: string | true) => { const background = useBackgroundClient(); const signMessageForWallet = async ( diff --git a/packages/app-extension/src/options/Options.tsx b/packages/app-extension/src/options/Options.tsx index 419eca8d6..934de20db 100644 --- a/packages/app-extension/src/options/Options.tsx +++ b/packages/app-extension/src/options/Options.tsx @@ -59,6 +59,10 @@ function Router() { const params = new URLSearchParams(window.location.search); const blockchain = params.get("blockchain") || Blockchain.SOLANA; + const action = (params.get("action") || "create") as + | "create" + | "import" + | "search"; const createKeyring = params.get("create") === "true"; const publicKey = params.get("publicKey") || undefined; @@ -68,6 +72,7 @@ function Router() { diff --git a/packages/app-mobile/package.json b/packages/app-mobile/package.json index 004988397..adba76089 100644 --- a/packages/app-mobile/package.json +++ b/packages/app-mobile/package.json @@ -28,6 +28,7 @@ "@react-navigation/native": "^6.0.11", "@react-navigation/native-stack": "^6.7.0", "@react-navigation/stack": "^6.3.2", + "big-integer": "^1.6.51", "buffer": "^6.0.3", "ethers": "^5.7.2", "expo": "^47.0.0", @@ -36,6 +37,7 @@ "expo-clipboard": "~4.0.1", "expo-constants": "~14.0.2", "expo-dev-client": "~2.0.1", + "expo-device": "~5.0.0", "expo-font": "~11.0.1", "expo-linking": "~3.3.0", "expo-secure-store": "~12.0.0", diff --git a/packages/app-mobile/src/App.tsx b/packages/app-mobile/src/App.tsx index 08c91d4e2..859d60c8d 100644 --- a/packages/app-mobile/src/App.tsx +++ b/packages/app-mobile/src/App.tsx @@ -1,9 +1,8 @@ -import type { Blockchain } from "@coral-xyz/common"; - import { Suspense, useCallback, useEffect, useRef } from "react"; import { Button, StyleSheet, Text, View } from "react-native"; import Constants from "expo-constants"; +import * as Device from "expo-device"; import * as SplashScreen from "expo-splash-screen"; import { StatusBar } from "expo-status-bar"; @@ -204,6 +203,10 @@ function BackgroundHiddenWebView(): JSX.Element { (state: any) => state.setInjectJavaScript ); const ref = useRef(null); + const { localWebViewUrl, remoteWebViewUrl } = + Constants?.expoConfig?.extra || {}; + + const webViewUrl = Device.isDevice ? remoteWebViewUrl : localWebViewUrl; return ( @@ -212,7 +215,9 @@ function BackgroundHiddenWebView(): JSX.Element { cacheMode="LOAD_CACHE_ELSE_NETWORK" cacheEnabled limitsNavigationsToAppBoundDomains - source={{ uri: Constants?.expoConfig?.extra?.webviewUrl }} + source={{ + uri: webViewUrl, + }} onMessage={(event) => { const msg = JSON.parse(event.nativeEvent.data); maybeParseLog(msg); diff --git a/packages/app-mobile/src/components/CheckBox.tsx b/packages/app-mobile/src/components/CheckBox.tsx index f3745857d..8a7b6864a 100644 --- a/packages/app-mobile/src/components/CheckBox.tsx +++ b/packages/app-mobile/src/components/CheckBox.tsx @@ -1,4 +1,4 @@ -import { StyleSheet, Text, View } from "react-native"; +import { StyleSheet, Text, View, Pressable } from "react-native"; import ExpoCheckBox from "expo-checkbox"; @@ -12,10 +12,14 @@ export const BaseCheckBoxLabel: React.FC<{ }> = ({ label, value, onPress }) => { const theme = useTheme(); return ( - + onPress(!value)} + > {} : onPress} color={theme.custom.colors.fontColor} /> {label ? ( @@ -30,7 +34,7 @@ export const BaseCheckBoxLabel: React.FC<{ {label} ) : null} - + ); }; diff --git a/packages/app-mobile/src/components/Form.tsx b/packages/app-mobile/src/components/Form.tsx index d9d469306..6f68a884a 100644 --- a/packages/app-mobile/src/components/Form.tsx +++ b/packages/app-mobile/src/components/Form.tsx @@ -202,10 +202,12 @@ export const InputFieldMaxLabel = ({ amount, onSetAmount, decimals, + label = "Max:", }: { amount: BigNumber | null; onSetAmount: (amount: BigNumber) => void; decimals: number; + label?: string; }) => { const theme = useTheme(); return ( @@ -219,7 +221,7 @@ export const InputFieldMaxLabel = ({ { color: theme.custom.colors.secondary }, ]} > - Max:{" "} + {label}{" "} ; const ENABLE_ONRAMP = false; -function SwapProvider({ children, blockchain, tokenAddress }) { - return children; -} +const getRouteFromAction = ( + action: NavTokenAction +): "DepositList" | "SendSelectTokenModal" | "SwapModal" => { + switch (action) { + case NavTokenAction.Receive: + return "DepositList"; + case NavTokenAction.Send: + return "SendSelectTokenModal"; + case NavTokenAction.Swap: + return "SwapModal"; + default: + return "DepositList"; + } +}; export function TransferWidget({ blockchain, @@ -38,8 +49,10 @@ export function TransferWidget({ blockchain !== Blockchain.ETHEREUM && enabledBlockchains.includes(Blockchain.SOLANA); - const onPress = (route: NavTokenAction, options: NavTokenOptions) => + const onPress = (action: NavTokenAction, options: NavTokenOptions) => { + const route = getRouteFromAction(action); onPressOption(route, options); + }; return ( - {renderSwap && ( + {renderSwap ? ( <> - )} + ) : null} ); } @@ -129,7 +142,7 @@ function SwapButton({ onPress: (route: NavTokenAction, options: NavTokenOptions) => void; }) { return ( - + diff --git a/packages/app-mobile/src/navigation/UnlockedNavigator.tsx b/packages/app-mobile/src/navigation/UnlockedNavigator.tsx index 9cac6bb55..1c66688e7 100644 --- a/packages/app-mobile/src/navigation/UnlockedNavigator.tsx +++ b/packages/app-mobile/src/navigation/UnlockedNavigator.tsx @@ -2,7 +2,6 @@ import type { Token } from "@@types/types"; import type { Blockchain } from "@coral-xyz/common"; import { useCallback } from "react"; -import { Text, View } from "react-native"; import { AccountSettingsNavigator } from "@navigation/AccountSettingsNavigator"; import { createBottomTabNavigator } from "@react-navigation/bottom-tabs"; @@ -20,6 +19,7 @@ import { SendTokenDetailScreen, SendTokenListScreen, } from "@screens/Unlocked/SendTokenScreen"; +import { SwapTokenScreen } from "@screens/Unlocked/SwapTokenScreen"; import { WalletListScreen } from "@screens/Unlocked/WalletListScreen"; import { @@ -101,7 +101,7 @@ export function UnlockedNavigator(): JSX.Element { - Recent Activity - - ); -} - type UnlockedTabNavigatorParamList = { Balances: undefined; Applications: undefined; diff --git a/packages/app-mobile/src/screens/Unlocked/BalancesScreen.tsx b/packages/app-mobile/src/screens/Unlocked/BalancesScreen.tsx index a1a6b5505..d0d53ebec 100644 --- a/packages/app-mobile/src/screens/Unlocked/BalancesScreen.tsx +++ b/packages/app-mobile/src/screens/Unlocked/BalancesScreen.tsx @@ -99,12 +99,8 @@ function BalanceDetailScreen({ { - const name = - route === NavTokenAction.Receive - ? "DepositSingle" - : "SendTokenModal"; - navigation.push(name, options); + onPressOption={(route: string, options: NavTokenOptions) => { + navigation.push(route, options); }} /> { - const name = - route === NavTokenAction.Receive - ? "DepositList" - : "SendSelectTokenModal"; - - navigation.push(name, options); + onPressOption={(route: string, options: NavTokenOptions) => { + navigation.push(route, options); }} /> diff --git a/packages/app-mobile/src/screens/Unlocked/GlobalSwapScreen.tsx b/packages/app-mobile/src/screens/Unlocked/GlobalSwapScreen.tsx deleted file mode 100644 index 704ce0c2a..000000000 --- a/packages/app-mobile/src/screens/Unlocked/GlobalSwapScreen.tsx +++ /dev/null @@ -1,18 +0,0 @@ -import { StyleSheet, Text, View } from "react-native"; - -import { Debug, Margin, PrimaryButton, Screen } from "@components"; - -export function GlobalSwapScreen({ navigation, route }) { - const handleSwap = () => {}; - const isDisabled = true; - - return ( - - handleSwap()} - /> - - ); -} diff --git a/packages/app-mobile/src/screens/Unlocked/NftCollectiblesScreen.tsx b/packages/app-mobile/src/screens/Unlocked/NftCollectiblesScreen.tsx index 76951e28a..16ad41701 100644 --- a/packages/app-mobile/src/screens/Unlocked/NftCollectiblesScreen.tsx +++ b/packages/app-mobile/src/screens/Unlocked/NftCollectiblesScreen.tsx @@ -39,7 +39,6 @@ import { Screen, EmptyState, Margin, CopyButtonIcon } from "@components/index"; import { useTheme } from "@hooks/useTheme"; import { NftDetailScreen, NftDetailSendScreen } from "./NftDetailScreen"; -const ONE_COLLECTION_ID = "3PMczHyeW2ds7ZWDZbDSF3d21HBqG6yR4tG7vP6qczfj"; type NftCollectionsWithId = { publicKey: string; @@ -73,18 +72,6 @@ function NftCollectionCard({ ); const onPressItem = () => { - if (collection.metadataCollectionId === ONE_COLLECTION_ID) { - onPress({ - type: "NFT_ONE_COLLECTION", - data: { - title: "ONE Holders Chat", - collectionId: collection.metadataCollectionId, - nftMint: collectionDisplayNft?.mint, - }, - }); - return; - } - if (collection.itemIds.length === 1) { if (!collectionDisplayNft.name || !collectionDisplayNft.id) { throw new Error("invalid NFT data"); diff --git a/packages/app-mobile/src/screens/Unlocked/RecentActivityScreen.tsx b/packages/app-mobile/src/screens/Unlocked/RecentActivityScreen.tsx index 66eba8ed2..ac07c3b9b 100644 --- a/packages/app-mobile/src/screens/Unlocked/RecentActivityScreen.tsx +++ b/packages/app-mobile/src/screens/Unlocked/RecentActivityScreen.tsx @@ -13,7 +13,12 @@ import { import * as Linking from "expo-linking"; -import { Blockchain, explorerUrl, RecentTransaction } from "@coral-xyz/common"; +import { + Blockchain, + explorerUrl, + RecentTransaction, + XNFT_GG_LINK, +} from "@coral-xyz/common"; import { useActiveWallet, useBlockchainConnectionUrl, @@ -289,7 +294,7 @@ function NoRecentActivityEmptyState({ subtitle="Get started by adding your first xNFT" buttonText="Browse the xNFT Library" onPress={() => { - Linking.openURL("https://xnft.gg"); + Linking.openURL(XNFT_GG_LINK); }} /> diff --git a/packages/app-mobile/src/screens/Unlocked/Settings/AddConnectWalletScreen.tsx b/packages/app-mobile/src/screens/Unlocked/Settings/AddConnectWalletScreen.tsx index 3b8262657..215bc370a 100644 --- a/packages/app-mobile/src/screens/Unlocked/Settings/AddConnectWalletScreen.tsx +++ b/packages/app-mobile/src/screens/Unlocked/Settings/AddConnectWalletScreen.tsx @@ -10,7 +10,7 @@ import { } from "@coral-xyz/common"; import { useBackgroundClient, - useKeyringType, + useKeyringHasMnemonic, useWalletName, } from "@coral-xyz/recoil"; import { MaterialIcons } from "@expo/vector-icons"; @@ -33,7 +33,7 @@ export function AddConnectWalletScreen({ route }) { const { blockchain } = route.params; const navigation = useNavigation(); const background = useBackgroundClient(); - const keyringType = useKeyringType(); + const hasMnemonic = useKeyringHasMnemonic(); const theme = useTheme(); const [newPublicKey, setNewPublicKey] = useState(null); @@ -68,7 +68,7 @@ export function AddConnectWalletScreen({ route }) { justifyContent: "space-between", }} > - {keyringType === "mnemonic" && ( + {hasMnemonic ? ( - )} + ) : null} {}; + const isDisabled = true; + const insets = useSafeAreaInsets(); + + return ( + + + + } + > + + + + + + + + handleSwap()} + /> + + ); +} diff --git a/packages/app-mobile/src/screens/Unlocked/YourAccountScreen.tsx b/packages/app-mobile/src/screens/Unlocked/YourAccountScreen.tsx index e64f34480..6897fcdeb 100644 --- a/packages/app-mobile/src/screens/Unlocked/YourAccountScreen.tsx +++ b/packages/app-mobile/src/screens/Unlocked/YourAccountScreen.tsx @@ -1,15 +1,15 @@ import { Screen } from "@components"; -import { useKeyringType } from "@coral-xyz/recoil"; +import { useKeyringHasMnemonic } from "@coral-xyz/recoil"; import { SettingsList } from "@screens/Unlocked/Settings/components/SettingsMenuList"; export function YourAccountScreen({ navigation }) { - const keyringType = useKeyringType(); + const hasMnemonic = useKeyringHasMnemonic(); const menuItems = { "Change Password": { onPress: () => navigation.push("change-password"), }, - ...(keyringType === "mnemonic" + ...(hasMnemonic ? { "Show Secret Recovery Phrase": { onPress: () => navigation.push("show-secret-phrase-warning"), diff --git a/packages/background/src/backend/core.ts b/packages/background/src/backend/core.ts index 45a847a68..085c76ccf 100644 --- a/packages/background/src/backend/core.ts +++ b/packages/background/src/backend/core.ts @@ -5,8 +5,8 @@ import type { EventEmitter, FEATURE_GATES_MAP, KeyringInit, - KeyringType, Preferences, + ServerPublicKey, SignedWalletDescriptor, WalletDescriptor, XnftPreference, @@ -23,9 +23,6 @@ import { EthereumExplorer, getAccountRecoveryPaths, getAddMessage, - getCreateMessage, - getRecoveryPaths, - LOAD_PUBLIC_KEY_AMOUNT, NOTIFICATION_ACTIVE_BLOCKCHAIN_UPDATED, NOTIFICATION_AGGREGATE_WALLETS_UPDATED, NOTIFICATION_APPROVED_ORIGINS_UPDATE, @@ -44,6 +41,7 @@ import { NOTIFICATION_KEYNAME_UPDATE, NOTIFICATION_KEYRING_DERIVED_WALLET, NOTIFICATION_KEYRING_IMPORTED_SECRET_KEY, + NOTIFICATION_KEYRING_IMPORTED_WALLET, NOTIFICATION_KEYRING_KEY_DELETE, NOTIFICATION_KEYRING_STORE_ACTIVE_USER_UPDATED, NOTIFICATION_KEYRING_STORE_CREATED, @@ -57,6 +55,7 @@ import { NOTIFICATION_SOLANA_COMMITMENT_UPDATED, NOTIFICATION_SOLANA_CONNECTION_URL_UPDATED, NOTIFICATION_SOLANA_EXPLORER_UPDATED, + NOTIFICATION_USER_ACCOUNT_AUTHENTICATED, NOTIFICATION_USER_ACCOUNT_PUBLIC_KEY_CREATED, NOTIFICATION_USER_ACCOUNT_PUBLIC_KEY_DELETED, NOTIFICATION_USER_ACCOUNT_PUBLIC_KEYS_UPDATED, @@ -109,6 +108,9 @@ export class Backend { private ethereumConnectionBackend: EthereumConnectionBackend; private events: EventEmitter; + // TODO: remove once beta is over. + private xnftWhitelist: Promise>; + constructor( events: EventEmitter, solanaB: SolanaConnectionBackend, @@ -118,6 +120,20 @@ export class Backend { this.solanaConnectionBackend = solanaB; this.ethereumConnectionBackend = ethereumB; this.events = events; + + // TODO: remove once beta is over. + this.xnftWhitelist = new Promise(async (resolve, reject) => { + try { + const resp = await fetch( + "https://app-store-api.backpack.workers.dev/api/curation/whitelist" + ); + const { whitelist } = await resp.json(); + resolve(whitelist); + } catch (err) { + console.error(err); + reject(err); + } + }); } /////////////////////////////////////////////////////////////////////////////// @@ -502,10 +518,18 @@ export class Backend { // Create an empty keyring to init blockchainKeyring = keyringForBlockchain(blockchain); if (keyringInit.length === 2) { - blockchainKeyring.initFromMnemonic(keyringInit[0], keyringInit[1]); + // If mnemonic wasn't actually passed retrieve it from the store. This + // is to avoid having to pass the mnemonic to the client to make this + // call + const mnemonic = + // @ts-ignore to allow passing true + keyringInit[0] === true + ? this.keyringStore.activeUserKeyring.exportMnemonic() + : keyringInit[0]; + await blockchainKeyring.initFromMnemonic(mnemonic, keyringInit[1]); } else { // Using a ledger - blockchainKeyring.initFromLedger(keyringInit[0]); + await blockchainKeyring.initFromLedger(keyringInit[0]); } } else { blockchainKeyring = @@ -813,6 +837,57 @@ export class Backend { ); } + async keyringReadNextDerivationPath( + blockchain: Blockchain, + keyring: "hd" | "ledger" + ): Promise { + return this.keyringStore.nextDerivationPath(blockchain, keyring); + } + + /** + * Add a new wallet to the keyring using the next derived wallet for the mnemonic. + * @param blockchain - Blockchain to add the wallet for + */ + async keyringImportWallet( + blockchain: Blockchain, + signedWalletDescriptor: SignedWalletDescriptor + ): Promise { + const { publicKey, name } = await this.keyringStore.addDerivationPath( + blockchain, + signedWalletDescriptor.derivationPath + ); + + try { + await this.userAccountPublicKeyCreate( + blockchain, + publicKey, + signedWalletDescriptor.signature + ); + } catch (error) { + // Something went wrong persisting to server, roll back changes to the + // keyring. This is not a complete rollback of state changes, because + // the next account index gets incremented. This is the correct behaviour + // because it should allow for sensible retries on conflicts. + await this.keyringKeyDelete(blockchain, publicKey); + throw error; + } + + this.events.emit(BACKEND_EVENT, { + name: NOTIFICATION_KEYRING_IMPORTED_WALLET, + data: { + blockchain, + publicKey, + name, + }, + }); + + // Set the active wallet to the newly added public key + await this.activeWalletUpdate(publicKey, blockchain); + + // Return the newly added public key + return publicKey.toString(); + } + /** * Add a new wallet to the keyring using the next derived wallet for the mnemonic. * @param blockchain - Blockchain to add the wallet for @@ -1096,8 +1171,8 @@ export class Backend { return SUCCESS_RESPONSE; } - keyringReset(): string { - this.keyringStore.reset(); + async keyringReset(): Promise { + await this.keyringStore.reset(); this.events.emit(BACKEND_EVENT, { name: NOTIFICATION_KEYRING_STORE_RESET, }); @@ -1132,10 +1207,8 @@ export class Backend { return this.keyringStore.createMnemonic(strength); } - keyringTypeRead(): KeyringType { - return this.keyringStore.activeUserKeyring.hasMnemonic() - ? "mnemonic" - : "ledger"; + keyringHasMnemonic(): boolean { + return this.keyringStore.activeUserKeyring.hasMnemonic(); } async previewPubkeys( @@ -1254,7 +1327,7 @@ export class Backend { */ async userAccountLogout(uuid: string): Promise { // Clear the jwt cookie if it exists. Don't block. - fetch(`${BACKEND_API_URL}/authenticate`, { + await fetch(`${BACKEND_API_URL}/authenticate`, { method: "DELETE", }); @@ -1263,7 +1336,7 @@ export class Backend { // const data = await store.getUserData(); if (data.users.length === 1) { - this.keyringReset(); + await this.keyringReset(); return SUCCESS_RESPONSE; } @@ -1327,6 +1400,17 @@ export class Backend { } const json = await response.json(); + + if (json.isAuthenticated) { + this.events.emit(BACKEND_EVENT, { + name: NOTIFICATION_USER_ACCOUNT_AUTHENTICATED, + data: { + username: json.username, + uuid: json.id, + }, + }); + } + this.events.emit(BACKEND_EVENT, { name: NOTIFICATION_USER_ACCOUNT_PUBLIC_KEYS_UPDATED, data: { @@ -1337,16 +1421,35 @@ export class Backend { } /** - * Find a `SignedWalletDescriptor` that can be used to create a new account. + * Query the Backpack API to check if a user has already used any of the + * blockchain/public key pairs from a list. + */ + async findServerPublicKeyConflicts( + serverPublicKeys: Array + ): Promise> { + const response = await fetch(`${BACKEND_API_URL}/publicKeys`, { + method: "POST", + body: JSON.stringify(serverPublicKeys), + headers: { + "Content-Type": "application/json", + }, + }); + return await response.json(); + } + + /** + * Find a `WalletDescriptor` that can be used to create a new account. * This requires that the sub wallets on the account index are not used by a * existing user account. This is checked by querying the Backpack API. + * + * This only works for mnemonics or a keyring store unlocked with a mnemoni + * because the background service worker can't use a Ledger. */ - async findSignedWalletDescriptor( + async findWalletDescriptor( blockchain: Blockchain, accountIndex = 0, - create = false, mnemonic?: string - ): Promise { + ): Promise { // If mnemonic is not passed as an argument, use the keyring store stored mnemonic. // Wallet must be unlocked. if (!mnemonic) @@ -1354,49 +1457,27 @@ export class Backend { const recoveryPaths = getAccountRecoveryPaths(blockchain, accountIndex); const publicKeys = await this.previewPubkeys( blockchain, - mnemonic, + mnemonic!, recoveryPaths ); - const response = await fetch(`${BACKEND_API_URL}/publicKeys`, { - method: "POST", - body: JSON.stringify( - publicKeys.map((publicKey) => ({ - blockchain, - publicKey, - })) - ), - headers: { - "Content-Type": "application/json", - }, - }); - const json = await response.json(); - if (json.length === 0) { + const users = await this.findServerPublicKeyConflicts( + publicKeys.map((publicKey) => ({ + blockchain, + publicKey, + })) + ); + if (users.length === 0) { // No users for any of the passed public keys, good to go // Take the root for the public key path const publicKey = publicKeys[0]; const derivationPath = recoveryPaths[0]; - // TODO remove this, signing different messages is just extra friction - const message = create - ? getCreateMessage(publicKey) - : getAddMessage(publicKey); return { - publicKey, derivationPath, - signature: await this.signMessageForPublicKey( - blockchain, - publicKey, - bs58.encode(Buffer.from(message, "utf-8")), - [mnemonic, [derivationPath]] - ), + publicKey, }; } else { // Iterate on account index - return this.findSignedWalletDescriptor( - blockchain, - accountIndex + 1, - create, - mnemonic - ); + return this.findWalletDescriptor(blockchain, accountIndex + 1, mnemonic!); } } @@ -1641,8 +1722,33 @@ export class Backend { if (!nav) { throw new Error("nav not found"); } + const targetTab = tab ?? nav.activeTab; + // This is a temporary measure for the duration of the private beta in order + // to control the xNFTs that can be opened from within Backpack AND + // externally using the injected provider's `openXnft` function. + // + // The whitelist is controlled internally and exposed through the xNFT + // library's worker API to check the address of the xNFT attempting to be + // opened by the user. + if (targetTab === TAB_XNFT) { + const pk = url.split("/")[1]; + const cachedWhitelist = await this.xnftWhitelist; + + if (!cachedWhitelist.includes(pk)) { + // Secondary lazy check to ensure there wasn't a whitelist update in-between cache updates + const resp = await fetch( + `https://app-store-api.backpack.workers.dev/api/curation/whitelist/check?address=${pk}` + ); + const { whitelisted } = await resp.json(); + + if (!whitelisted) { + throw new Error("opening an xnft that is not whitelisted"); + } + } + } + nav.data[targetTab] = nav.data[targetTab] ?? { id: targetTab, urls: [] }; const urls = nav.data[targetTab].urls; diff --git a/packages/background/src/backend/keyring/index.ts b/packages/background/src/backend/keyring/index.ts index 53c0b109d..82925ca5d 100644 --- a/packages/background/src/backend/keyring/index.ts +++ b/packages/background/src/backend/keyring/index.ts @@ -315,13 +315,21 @@ export class KeyringStore { // Preview public keys for a given mnemonic and derivation path without // importing the mnemonic. - public previewPubkeys( + public async previewPubkeys( blockchain: Blockchain, - mnemonic: string, + mnemonic: string | true, derivationPaths: Array - ): string[] { + ): Promise { const factory = hdFactoryForBlockchain(blockchain); - return factory.init(mnemonic, derivationPaths).publicKeys(); + if (mnemonic === true) { + // Read the mnemonic from the store + return await this.withUnlock(async () => { + mnemonic = this.activeUserKeyring.exportMnemonic(); + return factory.init(mnemonic, derivationPaths).publicKeys(); + }); + } else { + return factory.init(mnemonic, derivationPaths).publicKeys(); + } } public reset() { @@ -443,6 +451,27 @@ export class KeyringStore { }); } + public async nextDerivationPath( + blockchain: Blockchain, + keyring: "hd" | "ledger" + ): Promise { + return await this.withUnlock(async () => { + return this.activeUserKeyring.nextDerivationPath(blockchain, keyring); + }); + } + + public async addDerivationPath( + blockchain: Blockchain, + derivationPath: string + ): Promise<{ publicKey: string; name: string }> { + return await this.withUnlock(async () => { + return this.activeUserKeyring.addDerivationPath( + blockchain, + derivationPath + ); + }); + } + // Derive the next key for the given blockchain. public async deriveNextKey( blockchain: Blockchain @@ -779,6 +808,30 @@ class UserKeyring { this.activeBlockchain = blockchain; } + public nextDerivationPath( + blockchain: Blockchain, + keyring: "hd" | "ledger" + ): string { + let blockchainKeyring = this.blockchains.get(blockchain); + if (!blockchainKeyring) { + throw new Error("blockchain keyring not initialised"); + } else { + return blockchainKeyring.nextDerivationPath(keyring); + } + } + + public addDerivationPath( + blockchain: Blockchain, + derivationPath: string + ): Promise<{ publicKey: string; name: string }> { + let blockchainKeyring = this.blockchains.get(blockchain); + if (!blockchainKeyring) { + throw new Error("blockchain keyring not initialised"); + } else { + return blockchainKeyring.addDerivationPath(derivationPath); + } + } + /** * Get the next derived key for the mnemonic. */ @@ -799,7 +852,7 @@ class UserKeyring { } public exportMnemonic(): string { - if (!this.mnemonic) throw new Error("keyring uses a hardware wallet"); + if (!this.mnemonic) throw new Error("keyring does not have a mnemonic"); return this.mnemonic; } diff --git a/packages/background/src/backend/solana-connection.ts b/packages/background/src/backend/solana-connection.ts index 00588af20..54cd1075e 100644 --- a/packages/background/src/backend/solana-connection.ts +++ b/packages/background/src/backend/solana-connection.ts @@ -98,6 +98,7 @@ const logger = getLogger("solana-connection-backend"); export const LOAD_SPL_TOKENS_REFRESH_INTERVAL = 10 * 1000; export const RECENT_BLOCKHASH_REFRESH_INTERVAL = 10 * 1000; + // Time until cached values expire. This is arbitrary. const CACHE_EXPIRY = 15000; const NFT_CACHE_EXPIRY = 15 * 60000; diff --git a/packages/background/src/backend/store/keyname.ts b/packages/background/src/backend/store/keyname.ts index 9eeb99be1..2c0cd8ae1 100644 --- a/packages/background/src/backend/store/keyname.ts +++ b/packages/background/src/backend/store/keyname.ts @@ -22,8 +22,7 @@ export async function getKeyname(publicKey: string): Promise { const names = await LocalStorageDb.get(key()); const name = names[publicKey]; if (!name) { - console.error(`unable to find name for key: ${publicKey.toString()}`); - return ""; + throw Error(`unable to find name for key: ${publicKey.toString()}`); } return name; } diff --git a/packages/background/src/frontend/common.ts b/packages/background/src/frontend/common.ts deleted file mode 100644 index 21469735b..000000000 --- a/packages/background/src/frontend/common.ts +++ /dev/null @@ -1,100 +0,0 @@ -import type { Context, RpcResponse } from "@coral-xyz/common"; -import { getLogger } from "@coral-xyz/common"; - -import type { Backend } from "../backend/core"; -import { SUCCESS_RESPONSE } from "../backend/core"; -import type { Config, Handle } from "../types"; - -const logger = getLogger("server-injected-solana"); - -export class RequestManager { - static _requestId = 0; - static _responseResolvers: any = {}; - - // Initiate a request. The given popupFn should relay the given requestmanagerId to - // the UI, which will send it back with a response. - // - // Note that there are two ways we can receive a response. - // - // 1) The user can explicit perform a UI action via our components. - // 2) The user can close the window. - // - public static requestUiAction( - popupFn: (reqId: number) => Promise - ): Promise { - return new Promise(async (resolve, reject) => { - const requestId = RequestManager.nextRequestId(); - const window = await popupFn(requestId); - RequestManager.addResponseResolver( - requestId, - (input: any) => resolve({ ...input, window }), - reject - ); - chrome.windows.onRemoved.addListener((windowId) => { - if (windowId === window.id) { - RequestManager.removeResponseResolver(requestId); - resolve({ - // @ts-ignore - id: requestId, - result: undefined, - error: undefined, - windowClosed: true, - window, - }); - } - }); - }); - } - - // Resolve a response initiated via `requestUiAction`. - public static resolveResponse(id: number, result: any, error: any) { - const resolver = RequestManager.getResponseResolver(id); - if (!resolver) { - throw new Error(`unable to find response resolver for: ${id}`); - } - - const [resolve, _reject] = resolver; - - RequestManager.removeResponseResolver(id); - - resolve({ - id, - result, - error, - windowClosed: undefined, - }); - } - - private static addResponseResolver( - requestId: number, - resolve: Function, - reject: Function - ): number { - RequestManager._responseResolvers[requestId] = [resolve, reject]; - return requestId; - } - - private static nextRequestId(): number { - const r = RequestManager._requestId; - RequestManager._requestId += 1; - return r; - } - - private static getResponseResolver(requestId: number): [Function, Function] { - return RequestManager._responseResolvers[requestId]; - } - - private static removeResponseResolver(requestId: number) { - delete RequestManager._responseResolvers[requestId]; - } -} - -export async function handlePopupUiResponse( - ctx: Context, - msg: RpcResponse -): Promise { - const { id, result, error } = msg; - logger.debug("handle popup ui response", msg); - RequestManager.resolveResponse(id, result, error); - return SUCCESS_RESPONSE; -} diff --git a/packages/background/src/frontend/server-injected.ts b/packages/background/src/frontend/server-injected.ts index e3905f75e..43e8f3808 100644 --- a/packages/background/src/frontend/server-injected.ts +++ b/packages/background/src/frontend/server-injected.ts @@ -50,16 +50,16 @@ import { SOLANA_RPC_METHOD_SIGN_TX, SOLANA_RPC_METHOD_SIMULATE, TAB_XNFT, + UiActionRequestManager, withContext, withContextPort, } from "@coral-xyz/common"; import type { SendOptions } from "@solana/web3.js"; import type { Backend } from "../backend/core"; +import { SUCCESS_RESPONSE } from "../backend/core"; import type { Config, Handle } from "../types"; -import { handlePopupUiResponse, RequestManager } from "./common"; - const logger = getLogger("server-injected"); const whitelistedOrigins = [ @@ -156,6 +156,9 @@ async function handle( method !== SOLANA_RPC_METHOD_CONNECT ) { const origin = ctx.sender.origin; + if (origin === undefined) { + return [undefined, "origin is undefined"]; + } const isApproved = await ctx.backend.isApprovedOrigin(origin); if ( !isApproved && @@ -218,6 +221,10 @@ async function handleConnect( ): Promise> { const origin = ctx.sender.origin; + if (!origin) { + throw new Error("origin is undefined"); + } + if (locks.has(origin)) { throw new Error(`already handling a request from ${origin}`); } @@ -238,25 +245,29 @@ async function handleConnect( if (keyringStoreState === "locked") { if (await ctx.backend.isApprovedOrigin(origin)) { logger.debug("origin approved but need to unlock"); - resp = await RequestManager.requestUiAction((requestId: number) => { - return openLockedPopupWindow( - ctx.sender.origin, - getTabTitle(ctx), - requestId, - blockchain - ); - }); + resp = await UiActionRequestManager.requestUiAction( + (requestId: string) => { + return openLockedPopupWindow( + origin, + getTabTitle(ctx), + requestId, + blockchain + ); + } + ); didApprove = !resp.windowClosed && resp.result; } else { logger.debug("origin not apporved and needs to unlock"); - resp = await RequestManager.requestUiAction((requestId: number) => { - return openLockedApprovalPopupWindow( - ctx.sender.origin, - getTabTitle(ctx), - requestId, - blockchain - ); - }); + resp = await UiActionRequestManager.requestUiAction( + (requestId: string) => { + return openLockedApprovalPopupWindow( + origin, + getTabTitle(ctx), + requestId, + blockchain + ); + } + ); didApprove = !resp.windowClosed && resp.result.didApprove; } } else { @@ -266,14 +277,16 @@ async function handleConnect( } else { // Origin is not approved and wallet may or may not be locked logger.debug("requesting approval for origin"); - resp = await RequestManager.requestUiAction((requestId: number) => { - return openApprovalPopupWindow( - ctx.sender.origin, - getTabTitle(ctx), - requestId, - blockchain - ); - }); + resp = await UiActionRequestManager.requestUiAction( + (requestId: string) => { + return openApprovalPopupWindow( + origin, + getTabTitle(ctx), + requestId, + blockchain + ); + } + ); didApprove = !resp.windowClosed && resp.result.didApprove; } } @@ -319,14 +332,13 @@ async function handleConnect( throw new Error("user did not approve"); } -function getTabTitle(ctx) { - return ctx.sender.tab?.title ?? `Xnft from ${ctx.sender.origin}`; -} - async function handleDisconnect( ctx: Context, blockchain: Blockchain ): Promise> { + if (!ctx.sender.origin) { + throw new Error("origin is undefined"); + } const resp = await ctx.backend.disconnect(ctx.sender.origin); if (blockchain === Blockchain.SOLANA) { ctx.events.emit(BACKEND_EVENT, { @@ -346,17 +358,22 @@ async function handleSolanaSignAndSendTx( walletAddress: string, options?: SendOptions ): Promise> { + if (ctx.sender.origin === undefined) { + throw new Error("origin is undefined"); + } // Get user approval. - const uiResp = await RequestManager.requestUiAction((requestId: number) => { - return openApproveTransactionPopupWindow( - ctx.sender.origin, - getTabTitle(ctx), - requestId, - tx, - walletAddress, - Blockchain.SOLANA - ); - }); + const uiResp = await UiActionRequestManager.requestUiAction( + (requestId: string) => { + return openApproveTransactionPopupWindow( + ctx.sender.origin!, + getTabTitle(ctx), + requestId, + tx, + walletAddress, + Blockchain.SOLANA + ); + } + ); if (uiResp.error) { logger.debug("require ui action error", uiResp); @@ -365,7 +382,12 @@ async function handleSolanaSignAndSendTx( } let resp: RpcResponse; - const { didApprove, transaction } = uiResp.result; + const { didApprove, transaction } = uiResp.result + ? uiResp.result + : { + didApprove: false, + transaction: undefined, + }; try { // Only sign if the user clicked approve. @@ -387,7 +409,8 @@ async function handleSolanaSignAndSendTx( if (resp) { return resp; } - return [resp]; + + throw new Error("user denied transaction signature"); } async function handleSolanaSignTx( @@ -395,16 +418,21 @@ async function handleSolanaSignTx( tx: string, walletAddress: string ): Promise> { - const uiResp = await RequestManager.requestUiAction((requestId: number) => { - return openApproveTransactionPopupWindow( - ctx.sender.origin, - getTabTitle(ctx), - requestId, - tx, - walletAddress, - Blockchain.SOLANA - ); - }); + if (ctx.sender.origin === undefined) { + throw new Error("origin is undefined"); + } + const uiResp = await UiActionRequestManager.requestUiAction( + (requestId: string) => { + return openApproveTransactionPopupWindow( + ctx.sender.origin!, + getTabTitle(ctx), + requestId, + tx, + walletAddress, + Blockchain.SOLANA + ); + } + ); if (uiResp.error) { logger.debug("require ui action error", uiResp); @@ -443,16 +471,21 @@ async function handleSolanaSignAllTxs( txs: Array, walletAddress: string ): Promise>> { - const uiResp = await RequestManager.requestUiAction((requestId: number) => { - return openApproveAllTransactionsPopupWindow( - ctx.sender.origin, - getTabTitle(ctx), - requestId, - txs, - walletAddress, - Blockchain.SOLANA - ); - }); + if (ctx.sender.origin === undefined) { + throw new Error("origin is undefined"); + } + const uiResp = await UiActionRequestManager.requestUiAction( + (requestId: string) => { + return openApproveAllTransactionsPopupWindow( + ctx.sender.origin!, + getTabTitle(ctx), + requestId, + txs, + walletAddress, + Blockchain.SOLANA + ); + } + ); if (uiResp.error) { logger.debug("require ui action error", uiResp); @@ -491,16 +524,21 @@ async function handleSolanaSignMessage( msg: string, walletAddress: string ): Promise> { - const uiResp = await RequestManager.requestUiAction((requestId: number) => { - return openApproveMessagePopupWindow( - ctx.sender.origin, - getTabTitle(ctx), - requestId, - msg, - walletAddress, - Blockchain.SOLANA - ); - }); + if (ctx.sender.origin === undefined) { + throw new Error("origin is undefined"); + } + const uiResp = await UiActionRequestManager.requestUiAction( + (requestId: string) => { + return openApproveMessagePopupWindow( + ctx.sender.origin!, + getTabTitle(ctx), + requestId, + msg, + walletAddress, + Blockchain.SOLANA + ); + } + ); if (uiResp.error) { logger.debug("require ui action error", uiResp); @@ -554,17 +592,22 @@ async function handleEthereumSignAndSendTx( tx: string, walletAddress: string ): Promise> { + if (ctx.sender.origin === undefined) { + throw new Error("origin is undefined"); + } // Get user approval. - const uiResp = await RequestManager.requestUiAction((requestId: number) => { - return openApproveTransactionPopupWindow( - ctx.sender.origin, - getTabTitle(ctx), - requestId, - tx, - walletAddress, - Blockchain.ETHEREUM - ); - }); + const uiResp = await UiActionRequestManager.requestUiAction( + (requestId: string) => { + return openApproveTransactionPopupWindow( + ctx.sender.origin!, + getTabTitle(ctx), + requestId, + tx, + walletAddress, + Blockchain.ETHEREUM + ); + } + ); if (uiResp.error) { logger.debug("require ui action error", uiResp); @@ -604,16 +647,21 @@ async function handleEthereumSignTx( tx: string, walletAddress: string ): Promise> { - const uiResp = await RequestManager.requestUiAction((requestId: number) => { - return openApproveTransactionPopupWindow( - ctx.sender.origin, - getTabTitle(ctx), - requestId, - tx, - walletAddress, - Blockchain.ETHEREUM - ); - }); + if (ctx.sender.origin === undefined) { + throw new Error("origin is undefined"); + } + const uiResp = await UiActionRequestManager.requestUiAction( + (requestId: string) => { + return openApproveTransactionPopupWindow( + ctx.sender.origin!, + getTabTitle(ctx), + requestId, + tx, + walletAddress, + Blockchain.ETHEREUM + ); + } + ); if (uiResp.error) { logger.debug("require ui action error", uiResp); @@ -651,16 +699,21 @@ async function handleEthereumSignMessage( msg: string, walletAddress: string ): Promise> { - const uiResp = await RequestManager.requestUiAction((requestId: number) => { - return openApproveMessagePopupWindow( - ctx.sender.origin, - getTabTitle(ctx), - requestId, - msg, - walletAddress, - Blockchain.ETHEREUM - ); - }); + if (ctx.sender.origin === undefined) { + throw new Error("origin is undefined"); + } + const uiResp = await UiActionRequestManager.requestUiAction( + (requestId: string) => { + return openApproveMessagePopupWindow( + ctx.sender.origin!, + getTabTitle(ctx), + requestId, + msg, + walletAddress, + Blockchain.ETHEREUM + ); + } + ); if (uiResp.error) { logger.debug("require ui action error", uiResp); @@ -689,3 +742,17 @@ async function handleEthereumSignMessage( throw new Error("user denied ethereum message signature"); } + +async function handlePopupUiResponse( + ctx: Context, + msg: RpcResponse +): Promise { + const { id, result, error } = msg; + logger.debug("handle popup ui response", msg); + UiActionRequestManager.resolveResponse(id, result, error); + return SUCCESS_RESPONSE; +} + +function getTabTitle(ctx) { + return ctx.sender.tab?.title ?? `Xnft from ${ctx.sender.origin}`; +} diff --git a/packages/background/src/frontend/server-ui.ts b/packages/background/src/frontend/server-ui.ts index d0a7fea59..5346b6b3f 100644 --- a/packages/background/src/frontend/server-ui.ts +++ b/packages/background/src/frontend/server-ui.ts @@ -36,7 +36,8 @@ import { UI_RPC_METHOD_ETHEREUM_SIGN_AND_SEND_TRANSACTION, UI_RPC_METHOD_ETHEREUM_SIGN_MESSAGE, UI_RPC_METHOD_ETHEREUM_SIGN_TRANSACTION, - UI_RPC_METHOD_FIND_SIGNED_WALLET_DESCRIPTOR, + UI_RPC_METHOD_FIND_SERVER_PUBLIC_KEY_CONFLICTS, + UI_RPC_METHOD_FIND_WALLET_DESCRIPTOR, UI_RPC_METHOD_GET_FEATURE_GATES, UI_RPC_METHOD_GET_XNFT_PREFERENCES, UI_RPC_METHOD_KEY_IS_COLD_UPDATE, @@ -48,8 +49,11 @@ import { UI_RPC_METHOD_KEYRING_DERIVE_WALLET, UI_RPC_METHOD_KEYRING_EXPORT_MNEMONIC, UI_RPC_METHOD_KEYRING_EXPORT_SECRET_KEY, + UI_RPC_METHOD_KEYRING_HAS_MNEMONIC, UI_RPC_METHOD_KEYRING_IMPORT_SECRET_KEY, + UI_RPC_METHOD_KEYRING_IMPORT_WALLET, UI_RPC_METHOD_KEYRING_KEY_DELETE, + UI_RPC_METHOD_KEYRING_READ_NEXT_DERIVATION_PATH, UI_RPC_METHOD_KEYRING_RESET, UI_RPC_METHOD_KEYRING_STORE_CHECK_PASSWORD, UI_RPC_METHOD_KEYRING_STORE_CREATE, @@ -60,7 +64,6 @@ import { UI_RPC_METHOD_KEYRING_STORE_READ_ALL_PUBKEYS, UI_RPC_METHOD_KEYRING_STORE_STATE, UI_RPC_METHOD_KEYRING_STORE_UNLOCK, - UI_RPC_METHOD_KEYRING_TYPE_READ, UI_RPC_METHOD_KEYRING_VALIDATE_MNEMONIC, UI_RPC_METHOD_LEDGER_IMPORT, UI_RPC_METHOD_NAVIGATION_ACTIVE_TAB_UPDATE, @@ -188,6 +191,12 @@ async function handle( return handleKeyringStoreKeepAlive(ctx); case UI_RPC_METHOD_KEYRING_DERIVE_WALLET: return await handleKeyringDeriveWallet(ctx, params[0]); + case UI_RPC_METHOD_KEYRING_READ_NEXT_DERIVATION_PATH: + // @ts-ignore + return await handleKeyringReadNextDerivationPath(ctx, ...params); + case UI_RPC_METHOD_KEYRING_IMPORT_WALLET: + // @ts-ignore + return await handleKeyringImportWallet(ctx, ...params); case UI_RPC_METHOD_KEYRING_IMPORT_SECRET_KEY: return await handleKeyringImportSecretKey( ctx, @@ -197,6 +206,8 @@ async function handle( ); case UI_RPC_METHOD_KEYRING_EXPORT_SECRET_KEY: return handleKeyringExportSecretKey(ctx, params[0], params[1]); + case UI_RPC_METHOD_KEYRING_HAS_MNEMONIC: + return await handleKeyringHasMnemonic(ctx); case UI_RPC_METHOD_KEYRING_VALIDATE_MNEMONIC: return await handleValidateMnemonic(ctx, params[0]); case UI_RPC_METHOD_KEYRING_EXPORT_MNEMONIC: @@ -211,8 +222,6 @@ async function handle( ); case UI_RPC_METHOD_KEYRING_STORE_MNEMONIC_CREATE: return await handleMnemonicCreate(ctx, params[0]); - case UI_RPC_METHOD_KEYRING_TYPE_READ: - return await handleKeyringTypeRead(ctx); case UI_RPC_METHOD_PREVIEW_PUBKEYS: return await handlePreviewPubkeys( ctx, @@ -355,9 +364,12 @@ async function handle( case UI_RPC_METHOD_USER_ACCOUNT_READ: // @ts-ignore return await handleUserAccountRead(ctx, ...params); - case UI_RPC_METHOD_FIND_SIGNED_WALLET_DESCRIPTOR: + case UI_RPC_METHOD_FIND_SERVER_PUBLIC_KEY_CONFLICTS: + // @ts-ignore + return await handleFindServerPublicKeyConflicts(ctx, ...params); + case UI_RPC_METHOD_FIND_WALLET_DESCRIPTOR: // @ts-ignore - return await handleFindSignedWalletDescriptor(ctx, ...params); + return await handleFindWalletDescriptor(ctx, ...params); // // Password. // @@ -521,6 +533,22 @@ async function handleKeyringStoreReadAllPubkeys( return [resp]; } +async function handleKeyringReadNextDerivationPath( + ctx: Context, + ...args: Parameters +): Promise> { + const resp = await ctx.backend.keyringReadNextDerivationPath(...args); + return [resp]; +} + +async function handleKeyringImportWallet( + ctx: Context, + ...args: Parameters +): Promise> { + const resp = await ctx.backend.keyringImportWallet(...args); + return [resp]; +} + async function handleKeyringDeriveWallet( ctx: Context, blockchain: Blockchain @@ -642,11 +670,19 @@ async function handleUserAccountRead( return [resp]; } -async function handleFindSignedWalletDescriptor( +async function handleFindServerPublicKeyConflicts( + ctx: Context, + ...args: Parameters +): Promise> { + const resp = await ctx.backend.findServerPublicKeyConflicts(...args); + return [resp]; +} + +async function handleFindWalletDescriptor( ctx: Context, - ...args: Parameters + ...args: Parameters ): Promise> { - const resp = await ctx.backend.findSignedWalletDescriptor(...args); + const resp = await ctx.backend.findWalletDescriptor(...args); return [resp]; } @@ -682,6 +718,11 @@ function handleKeyringExportSecretKey( return [resp]; } +function handleKeyringHasMnemonic(ctx: Context): RpcResponse { + const resp = ctx.backend.keyringHasMnemonic(); + return [resp]; +} + function handleValidateMnemonic( ctx: Context, mnemonic: string @@ -730,11 +771,6 @@ async function handleMnemonicCreate( return [resp]; } -async function handleKeyringTypeRead(ctx: Context) { - const resp = ctx.backend.keyringTypeRead(); - return [resp]; -} - async function handleNavigationPush( ctx: Context, url: string, diff --git a/packages/blockchains/common/src/index.ts b/packages/blockchains/common/src/index.ts index be611bfa2..8481f5e77 100644 --- a/packages/blockchains/common/src/index.ts +++ b/packages/blockchains/common/src/index.ts @@ -1,15 +1,18 @@ import { + deriveEthereumPrivateKey, EthereumHdKeyringFactory, EthereumKeyringFactory, EthereumLedgerKeyringFactory, } from "@coral-xyz/blockchain-evm"; import { BlockchainKeyring } from "@coral-xyz/blockchain-keyring"; import { + deriveSolanaPrivateKey, SolanaHdKeyringFactory, SolanaKeyringFactory, SolanaLedgerKeyringFactory, } from "@coral-xyz/blockchain-solana"; import { Blockchain } from "@coral-xyz/common"; +import { mnemonicToSeedSync } from "bip39"; export function hdFactoryForBlockchain(blockchain: Blockchain) { return { @@ -34,3 +37,19 @@ export function keyringForBlockchain( ), }[blockchain]; } + +export function mnemonicPathToPrivateKey( + blockchain: Blockchain, + mnemonic: string, + derivationPath: string +) { + const seed = mnemonicToSeedSync(mnemonic); + if (blockchain === Blockchain.ETHEREUM) { + return deriveEthereumPrivateKey(seed, derivationPath); + } else if (blockchain === Blockchain.SOLANA) { + return Buffer.from(deriveSolanaPrivateKey(seed, derivationPath)).toString( + "hex" + ); + } + throw new Error("invalid blockchain"); +} diff --git a/packages/blockchains/evm/src/index.ts b/packages/blockchains/evm/src/index.ts index a82a3e401..8bd060cc8 100644 --- a/packages/blockchains/evm/src/index.ts +++ b/packages/blockchains/evm/src/index.ts @@ -1 +1,2 @@ export * from "./keyring"; +export * from "./util"; diff --git a/packages/blockchains/evm/src/keyring/index.ts b/packages/blockchains/evm/src/keyring/index.ts index fc2ea916d..92b802462 100644 --- a/packages/blockchains/evm/src/keyring/index.ts +++ b/packages/blockchains/evm/src/keyring/index.ts @@ -158,23 +158,39 @@ export class EthereumHdKeyring extends EthereumKeyring implements HdKeyring { this.walletIndex = walletIndex; } - deriveNextKey(): { - publicKey: string; - derivationPath: string; - } { + public deletePublicKey(publicKey: string) { + const index = this.wallets.findIndex((w) => w.address === publicKey); + if (index < 0) { + return; + } + this.derivationPaths = this.derivationPaths + .slice(0, index) + .concat(this.derivationPaths.slice(index + 1)); + super.deletePublicKey(publicKey); + } + + public nextDerivationPath(offset = 1) { this.ensureIndices(); - // Move to the next wallet index for the derivation - this.walletIndex! += 1; const derivationPath = getIndexedPath( Blockchain.ETHEREUM, this.accountIndex, - this.walletIndex + this.walletIndex! + offset ); if (this.derivationPaths.includes(derivationPath)) { // This key is already included for some reason, try again with // incremented walletIndex - return this.deriveNextKey(); + return this.nextDerivationPath(offset + 1); } + return { derivationPath, offset }; + } + + deriveNextKey(): { + publicKey: string; + derivationPath: string; + } { + const { derivationPath, offset } = this.nextDerivationPath(); + // Save the offset to the wallet index + this.walletIndex! += offset; const publicKey = this.addDerivationPath(derivationPath); return { publicKey, @@ -218,11 +234,14 @@ export class EthereumHdKeyring extends EthereumKeyring implements HdKeyring { export class EthereumLedgerKeyringFactory { public init(walletDescriptors: Array): LedgerKeyring { - return new EthereumLedgerKeyring(walletDescriptors); + return new EthereumLedgerKeyring(walletDescriptors, Blockchain.ETHEREUM); } public fromJson(obj: LedgerKeyringJson): LedgerKeyring { - return new EthereumLedgerKeyring(obj.walletDescriptors); + return new EthereumLedgerKeyring( + obj.walletDescriptors, + Blockchain.ETHEREUM + ); } } diff --git a/packages/blockchains/evm/src/util.ts b/packages/blockchains/evm/src/util.ts index a1ad3a358..6e9cfcb2d 100644 --- a/packages/blockchains/evm/src/util.ts +++ b/packages/blockchains/evm/src/util.ts @@ -5,7 +5,15 @@ export function deriveEthereumWallet( seed: Buffer, derivationPath: string ): Wallet { + const privateKey = deriveEthereumPrivateKey(seed, derivationPath); + return new ethers.Wallet(privateKey); +} + +export function deriveEthereumPrivateKey( + seed: Buffer, + derivationPath: string +): string { const hdNode = ethers.utils.HDNode.fromSeed(seed); const child = hdNode.derivePath(derivationPath); - return new ethers.Wallet(child.privateKey); + return child.privateKey; } diff --git a/packages/blockchains/keyring/src/blockchain.ts b/packages/blockchains/keyring/src/blockchain.ts index e6f2f71ff..c2fdf2549 100644 --- a/packages/blockchains/keyring/src/blockchain.ts +++ b/packages/blockchains/keyring/src/blockchain.ts @@ -118,6 +118,14 @@ export class BlockchainKeyring { return this.hdKeyring!.mnemonic; } + public nextDerivationPath(keyring: "hd" | "ledger") { + if (keyring === "hd") { + return this.hdKeyring!.nextDerivationPath(); + } else { + return this.ledgerKeyring!.nextDerivationPath(); + } + } + public async deriveNextKey(): Promise<{ publicKey: string; derivationPath: string; diff --git a/packages/blockchains/keyring/src/ledger.ts b/packages/blockchains/keyring/src/ledger.ts index 743ad3b29..1146de794 100644 --- a/packages/blockchains/keyring/src/ledger.ts +++ b/packages/blockchains/keyring/src/ledger.ts @@ -1,6 +1,8 @@ -import type { WalletDescriptor } from "@coral-xyz/common"; +import type { Blockchain, WalletDescriptor } from "@coral-xyz/common"; import { + derivationPathsToIndexes, generateUniqueId, + getIndexedPath, LEDGER_INJECTED_CHANNEL_REQUEST, LEDGER_INJECTED_CHANNEL_RESPONSE, } from "@coral-xyz/common"; @@ -9,9 +11,14 @@ import type { LedgerKeyringJson } from "./types"; export class LedgerKeyringBase { protected walletDescriptors: Array; + protected blockchain: Blockchain; - constructor(walletDescriptors: Array) { + constructor( + walletDescriptors: Array, + blockchain: Blockchain + ) { this.walletDescriptors = walletDescriptors; + this.blockchain = blockchain; } public deletePublicKey(publicKey: string) { @@ -42,6 +49,23 @@ export class LedgerKeyringBase { throw new Error("ledger keyring cannot import secret keys"); } + public nextDerivationPath(offset = 1) { + const derivationPaths = this.walletDescriptors.map((w) => w.derivationPath); + const { accountIndex, walletIndex } = + derivationPathsToIndexes(derivationPaths); + const derivationPath = getIndexedPath( + this.blockchain, + accountIndex, + walletIndex! + offset + ); + if (derivationPaths.includes(derivationPath)) { + // This key is already included for some reason, try again with + // incremented walletIndex + return this.nextDerivationPath(offset + 1); + } + return { derivationPath, offset }; + } + public toString(): string { return JSON.stringify({ walletDescriptors: this.walletDescriptors, diff --git a/packages/blockchains/keyring/src/types.ts b/packages/blockchains/keyring/src/types.ts index b059388ae..79a375a7c 100644 --- a/packages/blockchains/keyring/src/types.ts +++ b/packages/blockchains/keyring/src/types.ts @@ -39,6 +39,7 @@ export interface HdKeyringFactory { export interface HdKeyring extends Keyring { readonly mnemonic: string; addDerivationPath(derivationPath: string): string; + nextDerivationPath(): string; deriveNextKey(): { publicKey: string; derivationPath: string; @@ -54,6 +55,7 @@ export interface LedgerKeyringFactory { } export interface LedgerKeyring extends LedgerKeyringBase { + nextDerivationPath(): string; signTransaction(tx: Buffer, address: string): Promise; signMessage(tx: Buffer, address: string): Promise; add(walletDescriptor: WalletDescriptor): Promise; From f6850c040808bbc1f3539458246bd7a6adc8916b Mon Sep 17 00:00:00 2001 From: mj221 Date: Sun, 12 Feb 2023 11:32:30 +1000 Subject: [PATCH 16/36] WIP resolve merge conflict with 'master' of https://github.com/coral-xyz/backpack into mj/domain-content-resolver --- packages/blockchains/solana/src/index.ts | 1 + .../blockchains/solana/src/keyring/index.ts | 39 +++--- packages/blockchains/solana/src/util.ts | 11 +- .../{Attatchment.tsx => Attachment.tsx} | 2 +- .../src/components/FullScreenChat.tsx | 2 +- .../chat-sdk/src/components/MediaContent.tsx | 2 +- packages/chat-sdk/src/components/Message.tsx | 12 +- .../chat-sdk/src/components/ParsedMessage.tsx | 7 +- .../src/components/ReplyContainer.tsx | 1 + .../chat-sdk/src/components/SendMessage.tsx | 4 +- .../components/messageInput/MessageInput.tsx | 34 +++-- .../messageInput/MessageInputProvider.tsx | 5 +- packages/chat-sdk/src/config.ts | 2 +- packages/common/scripts/config.sh | 5 + packages/common/src/api/friendship.ts | 10 ++ packages/common/src/browser/extension.ts | 37 +++--- packages/common/src/browser/index.ts | 1 + .../src/browser/uiActionRequestManager.ts | 120 ++++++++++++++++++ packages/common/src/channel/app-ui.ts | 24 +++- packages/common/src/channel/content-script.ts | 44 ++++--- packages/common/src/channel/plugin.ts | 28 +++- packages/common/src/constants.ts | 32 ++++- packages/common/src/crypto.ts | 47 ++++++- packages/common/src/index.ts | 19 +-- packages/common/src/messages/db.ts | 6 + packages/common/src/notifications.ts | 1 + packages/common/src/plugin.ts | 15 ++- packages/common/src/solana/programs/xnft.ts | 36 ++++-- packages/common/src/types.ts | 45 ++++++- packages/db/src/api/RecoilSync.tsx | 5 + packages/db/src/api/friendships.ts | 9 ++ 31 files changed, 485 insertions(+), 121 deletions(-) rename packages/chat-sdk/src/components/{Attatchment.tsx => Attachment.tsx} (98%) create mode 100644 packages/common/src/browser/uiActionRequestManager.ts diff --git a/packages/blockchains/solana/src/index.ts b/packages/blockchains/solana/src/index.ts index a82a3e401..8bd060cc8 100644 --- a/packages/blockchains/solana/src/index.ts +++ b/packages/blockchains/solana/src/index.ts @@ -1 +1,2 @@ export * from "./keyring"; +export * from "./util"; diff --git a/packages/blockchains/solana/src/keyring/index.ts b/packages/blockchains/solana/src/keyring/index.ts index 5be0a78ed..deea01a64 100644 --- a/packages/blockchains/solana/src/keyring/index.ts +++ b/packages/blockchains/solana/src/keyring/index.ts @@ -19,11 +19,13 @@ import { } from "@coral-xyz/common"; import { Keypair, PublicKey } from "@solana/web3.js"; import { mnemonicToSeedSync, validateMnemonic } from "bip39"; -import * as bs58 from "bs58"; +import { ethers } from "ethers"; import nacl from "tweetnacl"; import { deriveSolanaKeypair } from "../util"; +const { base58 } = ethers.utils; + export class SolanaKeyringFactory implements KeyringFactory { public init(secretKeys: Array): SolanaKeyring { const keypairs = secretKeys.map((secret: string) => @@ -60,7 +62,7 @@ class SolanaKeyring implements Keyring { if (!kp) { throw new Error(`unable to find ${address.toString()}`); } - return bs58.encode(nacl.sign.detached(new Uint8Array(tx), kp.secretKey)); + return base58.encode(nacl.sign.detached(new Uint8Array(tx), kp.secretKey)); } public async signMessage(tx: Buffer, address: string): Promise { @@ -76,7 +78,7 @@ class SolanaKeyring implements Keyring { if (!kp) { return null; } - return bs58.encode(kp.secretKey); + return base58.encode(kp.secretKey); } public importSecretKey(secretKey: string): string { @@ -172,23 +174,28 @@ class SolanaHdKeyring extends SolanaKeyring implements HdKeyring { super.deletePublicKey(publicKey); } - public deriveNextKey(): { - publicKey: string; - derivationPath: string; - } { + public nextDerivationPath(offset = 1) { this.ensureIndices(); - // Move to the next wallet index for the derivation - this.walletIndex! += 1; const derivationPath = getIndexedPath( - Blockchain.SOLANA, + Blockchain.ETHEREUM, this.accountIndex, - this.walletIndex + this.walletIndex! + offset ); if (this.derivationPaths.includes(derivationPath)) { // This key is already included for some reason, try again with // incremented walletIndex - return this.deriveNextKey(); + return this.nextDerivationPath(offset + 1); } + return { derivationPath, offset }; + } + + public deriveNextKey(): { + publicKey: string; + derivationPath: string; + } { + const { derivationPath, offset } = this.nextDerivationPath(); + // Save the offset to the wallet index + this.walletIndex! += offset; const publicKey = this.addDerivationPath(derivationPath); return { publicKey, @@ -232,11 +239,11 @@ class SolanaHdKeyring extends SolanaKeyring implements HdKeyring { export class SolanaLedgerKeyringFactory { public init(walletDescriptors: Array): LedgerKeyring { - return new SolanaLedgerKeyring(walletDescriptors); + return new SolanaLedgerKeyring(walletDescriptors, Blockchain.SOLANA); } public fromJson(obj: LedgerKeyringJson): LedgerKeyring { - return new SolanaLedgerKeyring(obj.walletDescriptors); + return new SolanaLedgerKeyring(obj.walletDescriptors, Blockchain.SOLANA); } } @@ -254,7 +261,7 @@ export class SolanaLedgerKeyring return await this.request({ method: LEDGER_METHOD_SOLANA_SIGN_TRANSACTION, params: [ - bs58.encode(tx), + base58.encode(tx), walletDescriptor.derivationPath.replace("m/", ""), ], }); @@ -270,7 +277,7 @@ export class SolanaLedgerKeyring return await this.request({ method: LEDGER_METHOD_SOLANA_SIGN_MESSAGE, params: [ - bs58.encode(msg), + base58.encode(msg), walletDescriptor.derivationPath.replace("m/", ""), ], }); diff --git a/packages/blockchains/solana/src/util.ts b/packages/blockchains/solana/src/util.ts index c71c569f1..ef0e5f2a2 100644 --- a/packages/blockchains/solana/src/util.ts +++ b/packages/blockchains/solana/src/util.ts @@ -8,6 +8,14 @@ export function deriveSolanaKeypair( seed: Buffer, derivationPath: string ): Keypair { + const secret = deriveSolanaPrivateKey(seed, derivationPath); + return Keypair.fromSecretKey(secret); +} + +export function deriveSolanaPrivateKey( + seed: Buffer, + derivationPath: string +): Uint8Array { let derivedSeed: Buffer; if (derivationPath.startsWith("501'")) { // Sollet deprecated path @@ -15,6 +23,5 @@ export function deriveSolanaKeypair( } else { derivedSeed = derivePath(derivationPath, seed.toString("hex")).key; } - const secret = nacl.sign.keyPair.fromSeed(derivedSeed).secretKey; - return Keypair.fromSecretKey(secret); + return nacl.sign.keyPair.fromSeed(derivedSeed).secretKey; } diff --git a/packages/chat-sdk/src/components/Attatchment.tsx b/packages/chat-sdk/src/components/Attachment.tsx similarity index 98% rename from packages/chat-sdk/src/components/Attatchment.tsx rename to packages/chat-sdk/src/components/Attachment.tsx index a02b98969..5bc59aef9 100644 --- a/packages/chat-sdk/src/components/Attatchment.tsx +++ b/packages/chat-sdk/src/components/Attachment.tsx @@ -5,7 +5,7 @@ import AttachFileIcon from "@mui/icons-material/AttachFile"; import GifIcon from "@mui/icons-material/Gif"; import { IconButton } from "@mui/material"; -export const Attatchment = ({ +export const Attachment = ({ buttonStyle, onMediaSelect, }: { diff --git a/packages/chat-sdk/src/components/FullScreenChat.tsx b/packages/chat-sdk/src/components/FullScreenChat.tsx index 04b4d3f58..5f1605ec2 100644 --- a/packages/chat-sdk/src/components/FullScreenChat.tsx +++ b/packages/chat-sdk/src/components/FullScreenChat.tsx @@ -195,7 +195,7 @@ export const FullScreenChat = ({ style={{ position: "absolute", bottom: 70, - width: "100%", + right: 0, transition: "opacity 0.1s", opacity: jumpToBottom ? 1 : 0, }} diff --git a/packages/chat-sdk/src/components/MediaContent.tsx b/packages/chat-sdk/src/components/MediaContent.tsx index 5caba959f..feeb64a5a 100644 --- a/packages/chat-sdk/src/components/MediaContent.tsx +++ b/packages/chat-sdk/src/components/MediaContent.tsx @@ -92,7 +92,7 @@ export const MediaContent = ({ )} -
+
{mediaKind === "video" ? (
diff --git a/packages/chat-sdk/src/components/Message.tsx b/packages/chat-sdk/src/components/Message.tsx index 7530fa2da..a1f290445 100644 --- a/packages/chat-sdk/src/components/Message.tsx +++ b/packages/chat-sdk/src/components/Message.tsx @@ -233,18 +233,18 @@ export const MessageLine = (props) => {
{sameUserMessage ? (
{props.parent_message_author_uuid && ( -
+
{ <>
@@ -329,7 +330,7 @@ export const MessageLine = (props) => { className={classes.avatar} style={{ width: 32, height: 32 }} src={photoURL} - > + /> ) : ( { parent_username: `@${props.username}`, parent_message_author_uuid: props.userId, }); + document.getElementById("message-input")?.focus(); }} > diff --git a/packages/chat-sdk/src/components/ParsedMessage.tsx b/packages/chat-sdk/src/components/ParsedMessage.tsx index f871fadda..fe8bbaaab 100644 --- a/packages/chat-sdk/src/components/ParsedMessage.tsx +++ b/packages/chat-sdk/src/components/ParsedMessage.tsx @@ -1,5 +1,5 @@ import React from "react"; -import { NAV_COMPONENT_MESSAGE_PROFILE, parseMessage } from "@coral-xyz/common"; +import { NAV_COMPONENT_MESSAGE_CHAT, parseMessage } from "@coral-xyz/common"; import { useNavigation } from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; import { Skeleton } from "@mui/material"; @@ -29,10 +29,11 @@ export function ParsedMessage({ message }) {
{ push({ - title: handle, - componentId: NAV_COMPONENT_MESSAGE_PROFILE, + title: `@${user.username}`, + componentId: NAV_COMPONENT_MESSAGE_CHAT, componentProps: { userId: user.uuid, + username: user.username, }, }); }} diff --git a/packages/chat-sdk/src/components/ReplyContainer.tsx b/packages/chat-sdk/src/components/ReplyContainer.tsx index 24402f10b..1f52ab5c9 100644 --- a/packages/chat-sdk/src/components/ReplyContainer.tsx +++ b/packages/chat-sdk/src/components/ReplyContainer.tsx @@ -61,6 +61,7 @@ export const ReplyContainer = ({ fontWeight: 400, paddingLeft: 12, lineHeight: 1.4, + fontSize: 14, }} > diff --git a/packages/chat-sdk/src/components/SendMessage.tsx b/packages/chat-sdk/src/components/SendMessage.tsx index bf56f6c8d..0d59f246a 100644 --- a/packages/chat-sdk/src/components/SendMessage.tsx +++ b/packages/chat-sdk/src/components/SendMessage.tsx @@ -14,7 +14,7 @@ import { v4 as uuidv4 } from "uuid"; import { CustomAutoComplete, MessageInput } from "./messageInput/MessageInput"; import { MessageInputProvider } from "./messageInput/MessageInputProvider"; -import { Attatchment } from "./Attatchment"; +import { Attachment } from "./Attachment"; import { useChatContext } from "./ChatContext"; import { EmojiPickerComponent } from "./EmojiPicker"; import { GifPicker } from "./GifPicker"; @@ -384,7 +384,7 @@ export const SendMessage = ({ height: "28px", }} /> -
+ /> ); } @@ -144,8 +144,6 @@ function selectSplash( const heightSplash = splashUrls[bestFitHeight]; const widthSplash = splashUrls[bestFitWidth]; - console.log(heightSplash, widthSplash, height, width); - // if both are valid options -> return smaller one if (heightSplash.width > width && widthSplash.height > height) { if ( diff --git a/packages/app-extension/src/components/Unlocked/Apps/index.tsx b/packages/app-extension/src/components/Unlocked/Apps/index.tsx index a81d56365..298d7bc3d 100644 --- a/packages/app-extension/src/components/Unlocked/Apps/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Apps/index.tsx @@ -1,5 +1,9 @@ import { Blockchain, XNFT_GG_LINK } from "@coral-xyz/common"; -import { EmptyState, ProxyImage } from "@coral-xyz/react-common"; +import { + EmptyState, + ProxyImage, + useBreakpoints, +} from "@coral-xyz/react-common"; import { filteredPlugins, isAggregateWallets, @@ -15,7 +19,6 @@ import { Button, Grid, Skeleton, Typography } from "@mui/material"; import { getSvgPath } from "figma-squircle"; import { useRecoilValue, waitForAll } from "recoil"; -import { useBreakpoints } from "../../common/Layout/hooks"; import { _BalancesTableHead, BalancesTableHead, @@ -92,20 +95,20 @@ function PluginGrid() { return ( } - title={"Ethereum xNFTs not yet supported"} - subtitle={"Switch to Solana to use xNFTs"} - buttonText={""} + title="Ethereum xNFTs not yet supported" + subtitle="Switch to Solana to use xNFTs" + buttonText="" onClick={() => {}} header={ // Only show the wallet switcher if we are in single wallet mode. - !_isAggregateWallets && ( + !_isAggregateWallets ? ( <_BalancesTableHead blockchain={wallet.blockchain} wallet={wallet} - showContent={true} + showContent setShowContent={() => {}} /> - ) + ) : null } /> ); @@ -123,19 +126,19 @@ function PluginGrid() { return ( } - title={"No xNFTs"} - subtitle={"Get started with your first xNFT"} - buttonText={"Browse xNFTs"} + title="No xNFTs" + subtitle="Get started with your first xNFT" + buttonText="Browse xNFTs" onClick={() => window.open(XNFT_GG_LINK)} header={ - !_isAggregateWallets && ( + !_isAggregateWallets ? ( <_BalancesTableHead blockchain={activeWallet.blockchain} wallet={activeWallet} - showContent={true} + showContent setShowContent={() => {}} /> - ) + ) : null } /> ); @@ -210,9 +213,8 @@ function _WalletXnftGrid({ return ( <> - {showContent && ( -
- - {isLoading + + {isLoading ? Array.from(Array(iconsPerRow).keys()).map((_, idx) => { return ( ); })} - -
- )} + +
: null} ); } diff --git a/packages/app-extension/src/app/DbRecoilSync.tsx b/packages/app-extension/src/components/Unlocked/AuthenticatedSync.tsx similarity index 86% rename from packages/app-extension/src/app/DbRecoilSync.tsx rename to packages/app-extension/src/components/Unlocked/AuthenticatedSync.tsx index 45f62e6ef..fa5213b3f 100644 --- a/packages/app-extension/src/app/DbRecoilSync.tsx +++ b/packages/app-extension/src/components/Unlocked/AuthenticatedSync.tsx @@ -2,7 +2,11 @@ import { useEffect } from "react"; import type { EnrichedMessage, SubscriptionType } from "@coral-xyz/common"; import { BACKEND_API_URL } from "@coral-xyz/common"; import { RecoilSync } from "@coral-xyz/db"; -import { SignalingManager } from "@coral-xyz/react-common"; +import { + BackgroundChatsSync, + refreshGroupsAndFriendships, + SignalingManager, +} from "@coral-xyz/react-common"; import { friendships, groupCollections, @@ -15,17 +19,37 @@ import { useRecoilCallback, useSetRecoilState } from "recoil"; // Wrapper compoennt to ensure syncing only happens when there is an // authenticated user -export const DbRecoilSync = () => { +export const AuthenticatedSync = () => { const authenticatedUser = useAuthenticatedUser(); if (authenticatedUser) { - return ; - } else { - return <>; + return ( + <> + + + + ); } + + return null; +}; + +export const ChatSync = ({ uuid, jwt }: { uuid: string; jwt: string }) => { + useEffect(() => { + (async () => { + await Promise.all([ + refreshGroupsAndFriendships(uuid).then( + async () => await BackgroundChatsSync.getInstance().updateUuid(uuid) + ), + SignalingManager.getInstance().updateUuid(uuid, jwt), + ]); + })(); + }, [uuid, jwt]); + + return null; }; -export const AuthedDbRecoilSync = ({ uuid }: { uuid: string }) => { +export const DbRecoilSync = ({ uuid }: { uuid: string }) => { const updateChats = useUpdateChats(); const setFriendshipsValue = useSetRecoilState(friendships({ uuid })); @@ -147,7 +171,7 @@ export const AuthedDbRecoilSync = ({ uuid }: { uuid: string }) => { }; }, [uuid]); - return <>; + return null; }; export const useUpdateChats = () => diff --git a/packages/app-extension/src/components/Unlocked/Balances/Balances.tsx b/packages/app-extension/src/components/Unlocked/Balances/Balances.tsx index 139a5062f..085406221 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/Balances.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/Balances.tsx @@ -155,20 +155,18 @@ export function BalancesTableCell({ props }: any) { return (
- {!!icon && ( - - { + { event.currentTarget.src = UNKNOWN_ICON_SRC; }} /> - - )} + : null}
{title} @@ -177,29 +175,19 @@ export function BalancesTableCell({ props }: any) {
- {subtitle && ( - {subtitle} - )} - {percentChange !== undefined && positive && ( - - +{formatUSD(percentChange.toLocaleString())} - - )} - {percentChange !== undefined && negative && ( - - {formatUSD(percentChange.toLocaleString())} - - )} - {percentChange !== undefined && neutral && ( - - {formatUSD(percentChange.toLocaleString())} - - )} - {!usdValue && ( - - {"-"} - - )} + {subtitle ? {subtitle} : null} + {percentChange !== undefined && positive ? + +{formatUSD(percentChange.toLocaleString())} + : null} + {percentChange !== undefined && negative ? + {formatUSD(percentChange.toLocaleString())} + : null} + {percentChange !== undefined && neutral ? + {formatUSD(percentChange.toLocaleString())} + : null} + {!usdValue ? + - + : null}
@@ -324,24 +312,22 @@ export function _BalancesTableHead({
- {_isAggregateWallets && ( - !disableToggle && setShowContent(!showContent)} + onClick={() => !disableToggle && setShowContent(!showContent)} > - {showContent ? ( - + {showContent ? ( + ) : ( )} - - )} + : null}
} classes={{ diff --git a/packages/app-extension/src/components/Unlocked/Balances/Notifications.tsx b/packages/app-extension/src/components/Unlocked/Balances/Notifications.tsx index ad8b54399..1b59f9fa3 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/Notifications.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/Notifications.tsx @@ -7,16 +7,18 @@ import { } from "@coral-xyz/common"; import { updateFriendshipIfExists } from "@coral-xyz/db"; import { + BubbleTopLabel, DangerButton, EmptyState, isFirstLastListItemStyle, Loading, ProxyImage, SuccessButton, + useBreakpoints, UserAction, useUserMetadata, } from "@coral-xyz/react-common"; import { - unreadCount, + unreadCount, useAuthenticatedUser, useFriendship, useRecentNotifications, useUpdateFriendships, @@ -28,7 +30,6 @@ import { Badge, IconButton, List, ListItem, Typography } from "@mui/material"; import { useRecoilState } from "recoil"; import { CloseButton, WithDrawer } from "../../common/Layout/Drawer"; -import { useBreakpoints } from "../../common/Layout/hooks"; import { NavStackEphemeral, NavStackScreen, @@ -131,19 +132,19 @@ export function NotificationButton() { navButtonLeft={ setOpenDrawer(false)} />} > } /> } /> } /> } /> @@ -207,6 +208,7 @@ const getGroupedNotifications = (notifications: EnrichedNotification[]) => { export function Notifications() { const { isXs } = useBreakpoints(); const nav = isXs ? useNavigation() : null; + const authenticatedUser = useAuthenticatedUser(); const [openDrawer, setOpenDrawer] = isXs ? [false, () => {}] : useState(false); @@ -216,6 +218,7 @@ export function Notifications() { const notifications: EnrichedNotification[] = useRecentNotifications({ limit: 50, offset: 0, + uuid: authenticatedUser?.uuid ?? "", }); useEffect(() => { @@ -227,9 +230,16 @@ export function Notifications() { }, []); useEffect(() => { - const sortedNotifications = notifications - .slice() - .sort((a, b) => + const allNotifications = notifications + .slice(); + const uniqueNotifications = allNotifications.sort((a, b) => + new Date(a.timestamp).getTime() < new Date(b.timestamp).getTime() + ? -1 + : 1 + ).filter((x, index) => (x.xnft_id !== "friend_requests" || ( + allNotifications.map(y => y.body).indexOf(x.body) === index + ))) + const sortedNotifications = uniqueNotifications.sort((a, b) => new Date(a.timestamp).getTime() < new Date(b.timestamp).getTime() ? -1 : 1 @@ -271,32 +281,30 @@ export function Notifications() { groupedNotifications={groupedNotifications} /> - {!isXs && ( - -
- ({ title: "Notifications" })} - navButtonLeft={ - setOpenDrawer(false)} /> + {!isXs ? +
+ ({ title: "Notifications" })} + navButtonLeft={ + setOpenDrawer(false)} /> } > - } + } /> - } + } /> - } + } /> - -
- - )} + +
+ : null} ); } @@ -352,45 +360,43 @@ export function NotificationList({ const theme = useCustomTheme(); return groupedNotifications.length > 0 ? ( - <> -
- {groupedNotifications.map(({ date, notifications }) => ( -
( +
-
{date}
- + -
- {notifications.map((notification: any, idx: number) => ( - + {notifications.map((notification: any, idx: number) => ( + ))} -
- -
+
+ +
))} -
- +
) : ( ); @@ -404,9 +410,9 @@ const getTimeStr = (timestamp: number) => { if (elapsedTimeSeconds / 60 < 60) { const min = Math.floor(elapsedTimeSeconds / 60); if (min === 1) { - return "1 minute"; + return "1 min"; } else { - return `${min} minutes`; + return `${min} mins`; } } @@ -422,7 +428,7 @@ const getTimeStr = (timestamp: number) => { if (days === 1) { return `1 day`; } - return `${days} day`; + return `${days} days`; }; function NotificationListItem({ @@ -442,7 +448,7 @@ function NotificationListItem({ if (notification.xnft_id === "friend_requests") { return ( {getTimeStr(notification.timestamp)}
-
- {!notification.viewed && ( - - )} -
@@ -533,75 +530,57 @@ function AcceptRejectRequest({ userId }: { userId: string }) { const friendshipValue = useFriendship({ userId }); const { uuid } = useUser(); const setFriendshipValue = useUpdateFriendships(); + const theme = useCustomTheme(); const [inProgress, setInProgress] = useState(false); if (friendshipValue?.remoteRequested && !friendshipValue?.areFriends) { return (
- { - e.stopPropagation(); - setInProgress(true); - await sendFriendRequest({ to: userId, sendRequest: true }); - await updateFriendshipIfExists(uuid, userId, { - requested: 0, - areFriends: 1, - }); - setFriendshipValue({ - userId: userId, - friendshipValue: { - requested: false, - areFriends: true, - remoteRequested: false, - }, - }); - setInProgress(false); - }} - /> - { - e.stopPropagation(); - setInProgress(true); - await sendFriendRequest({ to: userId, sendRequest: false }); - await updateFriendshipIfExists(uuid, userId, { - requested: 0, - areFriends: 0, - remoteRequested: 0, - }); - setFriendshipValue({ - userId: userId, - friendshipValue: { - requested: false, - areFriends: false, - remoteRequested: false, - }, - }); - setInProgress(false); - }} + { + e.stopPropagation(); + setInProgress(true); + await sendFriendRequest({ to: userId, sendRequest: true }); + await updateFriendshipIfExists(uuid, userId, { + requested: 0, + areFriends: 1, + }); + await setFriendshipValue({ + userId: userId, + friendshipValue: { + requested: false, + areFriends: true, + remoteRequested: false, + }, + }); + setInProgress(false); + }} /> + { + e.stopPropagation(); + setInProgress(true); + await sendFriendRequest({ to: userId, sendRequest: false }); + await updateFriendshipIfExists(uuid, userId, { + requested: 0, + areFriends: 0, + remoteRequested: 0, + }); + await setFriendshipValue({ + userId: userId, + friendshipValue: { + requested: false, + areFriends: false, + remoteRequested: false, + }, + }); + setInProgress(false); + }} />
); } - return
; + return
; } function parseJson(body: string) { @@ -647,7 +626,9 @@ function FriendRequestListItem({ paddingTop: "10px", paddingBottom: "10px", display: "flex", - backgroundColor: theme.custom.colors.nav, + backgroundColor: !notification.viewed + ? theme.custom.colors.unreadBackground + : theme.custom.colors.nav, borderBottom: isLast ? undefined : `solid 1pt ${theme.custom.colors.border1}`, @@ -662,7 +643,7 @@ function FriendRequestListItem({ alignItems: "center", }} > -
+
-
- {friendshipValue?.remoteRequested && !friendshipValue?.areFriends && ( - - )} -
); @@ -729,9 +699,9 @@ function NoNotificationsLabel({ minimize }: { minimize: boolean }) { > } - title={"No Notifications"} + title="No Notifications" subtitle={"You don't have any notifications yet."} - buttonText={"Browse the xNFT Library"} + buttonText="Browse the xNFT Library" onClick={() => window.open(XNFT_GG_LINK)} innerStyle={{ marginBottom: minimize !== true ? "64px" : 0, // Tab height offset. diff --git a/packages/app-extension/src/components/Unlocked/Balances/RecentActivity.tsx b/packages/app-extension/src/components/Unlocked/Balances/RecentActivity.tsx index b59b72974..60c7d014c 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/RecentActivity.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/RecentActivity.tsx @@ -117,7 +117,7 @@ export function RecentActivityButton() { navButtonLeft={ setOpenDrawer(false)} />} > } /> @@ -378,10 +378,8 @@ function NoRecentActivityLabel({ minimize }: { minimize: boolean }) { > } - title={"No Recent Activity"} - subtitle={ - "Your transactions and app activity will show up here when you start using Backpack!" - } + title="No Recent Activity" + subtitle="Your transactions and app activity will show up here when you start using Backpack!" onClick={() => window.open(XNFT_GG_LINK)} contentStyle={{ color: minimize ? theme.custom.colors.secondary : "inherit", diff --git a/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/Icons.tsx b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/Icons.tsx index dc10dd2c2..724f5352a 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/Icons.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/Icons.tsx @@ -10,7 +10,7 @@ import { // TODO: move reused styles into classes export const ListItemIcons = { - SWAP: ({ + Swap: ({ tokenLogoOne, tokenLogoTwo, }: { @@ -43,7 +43,7 @@ export const ListItemIcons = {
); }, - TRANSFER: ({ tokenLogo }: { tokenLogo?: string }) => { + Transfer: ({ tokenLogo }: { tokenLogo?: string }) => { return ( ); }, - SOL: () => { + Sol: () => { return ( ); }, - NFT: ({ nftUrl }: { nftUrl?: string }) => { + Nft: ({ nftUrl }: { nftUrl?: string }) => { return ( ); }, - SENT: () => { + Sent: () => { return (
); }, - RECEIVED: () => { + Received: () => { return (
); }, - NFT_DEFAULT: () => { + NftDefault: () => { return ( ); }, - ERROR: () => { + Error: () => { return (
); }, - BURN: () => { + Burn: () => { return (
); }, - DEFAULT: () => { + Default: () => { return (
({ }, textSecondary: { fontSize: "16px", - color: theme.custom.colors.secondary, + color: theme.custom.colors.negative, lineHeight: "24px", textAlign: "end", }, @@ -71,11 +76,12 @@ export function SolanaTransactionListItem({ }: any) { const classes = useStyles(); const theme = useCustomTheme(); + const registry = useJupiterTokenMap(); const { contents, state } = useRecoilValueLoadable( metadataForRecentSolanaTransaction({ transaction }) ); const activeWallet = useActiveWallet(); - const tokenData = getTokenData(transaction); + const tokenData = getTokenData(registry, transaction); const metadata = (state === "hasValue" && contents) || undefined; const onClick = () => { @@ -89,6 +95,13 @@ export function SolanaTransactionListItem({ metadata ); + const transactionCaption = getTransactionCaption( + activeWallet, + transaction, + tokenData, + metadata + ); + return (
@@ -131,12 +142,7 @@ export function SolanaTransactionListItem({ {transactionTitle} - {getTransactionCaption( - activeWallet, - transaction, - tokenData, - metadata - )} + {transactionCaption}
@@ -161,12 +167,10 @@ function RecentActivityListItemIcon({ loading, transaction, tokenData, - metadata, }: { loading: boolean; transaction: HeliusParsedTransaction; tokenData: (TokenInfo | undefined)[]; - metadata?: any; }) { const activeWallet = useActiveWallet(); if (loading) { @@ -180,57 +184,56 @@ function RecentActivityListItemIcon({ ); } - if (transaction?.transactionError) return ; + if (transaction?.transactionError) return ; if (transaction.type === TransactionType.SWAP) { return ( - ); } // if NFT url available, display it. Check on-chain data first - const nftImage = undefined; - // TODO: metadata?.onChaindata?.data?.uri || metadata?.offChainData?.image; + const nftImage = undefined; // FIXME: metadata?.onChainMetadata?.metadata?.data?.uri; if (isNFTTransaction(transaction) && nftImage) { - return ; + return ; } if (transaction.type === TransactionType.TRANSFER) { //SOL transfer if (transaction.source === Source.SYSTEM_PROGRAM) { - return ; + return ; } // other SPL token Transfer. Check tokenRegistry first, then Helius metadata - const transferIcon = undefined; - // FIXME: tokenData[0]?.logoURI || - // metadata?.onChaindata?.data?.uri || - // metadata?.offChainData?.image; + const transferIcon = tokenData[0]?.logoURI; // FIXME: metadata offchain image - if (transferIcon) - return ; + if (transferIcon) { + return ; + } // if it is an NFT transfer and no NFT image was found above, show default Icon if (transaction?.tokenTransfers?.[0]?.tokenStandard === "NonFungible") { - return ; + return ; } // default - if (isUserTxnSender(transaction, activeWallet)) - return ; - return ; + if (isUserTxnSender(transaction, activeWallet)) { + return ; + } + + return ; } if ( transaction?.type === TransactionType.BURN || transaction?.type === TransactionType.BURN_NFT ) - return ; + return ; - return ; + return ; } // Controls data displayed on right side of 'Transactions' list @@ -255,22 +258,21 @@ function RecentActivityListItemData({ return ( <>
- {"+ " + - transaction?.tokenTransfers?.[1]?.tokenAmount.toFixed(5) + - " " + + {`+${transaction?.tokenTransfers?.[1]?.tokenAmount.toFixed(5)} ${ tokenData[1]?.symbol || - getTruncatedAddress(transaction?.tokenTransfers?.[1]?.mint)} + walletAddressDisplay(transaction?.tokenTransfers?.[1]?.mint) + }`}
- {"- " + - transaction?.tokenTransfers[0]?.tokenAmount.toFixed(5) + - " " + + {`-${transaction?.tokenTransfers[0]?.tokenAmount.toFixed(5)} ${ tokenData[0]?.symbol || - getTruncatedAddress(transaction?.tokenTransfers?.[0]?.mint)} + walletAddressDisplay(transaction?.tokenTransfers?.[0]?.mint) + }`}
); } + // BURN if ( transaction?.type === TransactionType.BURN || @@ -285,7 +287,7 @@ function RecentActivityListItemData({ // finish if (isNFTTransaction(transaction)) { - return
; + return
; } if ( @@ -298,20 +300,22 @@ function RecentActivityListItemData({ if (transaction.source === Source.SYSTEM_PROGRAM) { return (
- - {transaction?.nativeTransfers[0]?.amount / 10 ** 9 + " SOL"} + - + {reverseScientificNotation( + transaction?.nativeTransfers[0]?.amount / 10 ** 9 + ) + " SOL"}
); } return (
- -{" "} + - {new Number( transaction?.tokenTransfers?.[0]?.tokenAmount.toFixed(5) ) + " " + (tokenData[0]?.symbol || metadata?.onChainMetadata?.metadata?.data?.symbol || - metadata?.offChainData?.symbol || "")}
); @@ -322,20 +326,22 @@ function RecentActivityListItemData({ if (transaction.source === Source.SYSTEM_PROGRAM) { return (
- + {transaction?.nativeTransfers[0]?.amount / 10 ** 9 + " SOL"} + + + {reverseScientificNotation( + transaction?.nativeTransfers[0]?.amount / 10 ** 9 + ) + " SOL"}
); } return (
- +{" "} + + {new Number( transaction?.tokenTransfers?.[0]?.tokenAmount.toFixed(5) ) + " " + (tokenData[0]?.symbol || metadata?.onChainMetadata?.metadata?.data?.symbol || - metadata?.offChainData?.symbol || "")}
); @@ -343,5 +349,5 @@ function RecentActivityListItemData({ } // default - return
; + return
; } diff --git a/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/NoRecentActivity.tsx b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/NoRecentActivity.tsx index aa66a76de..312532fde 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/NoRecentActivity.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/NoRecentActivity.tsx @@ -15,10 +15,10 @@ export function NoRecentActivityLabel({ minimize }: { minimize: boolean }) { > } - title={"No Recent Activity"} - subtitle={"Get started by adding your first xNFT"} + title="No Recent Activity" + subtitle="Get started by adding your first xNFT" onClick={() => window.open(XNFT_GG_LINK)} - buttonText={"Browse the xNFT Library"} + buttonText="Browse the xNFT Library" contentStyle={{ color: minimize ? theme.custom.colors.secondary : "inherit", }} diff --git a/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/RecentSolanaActivityList.tsx b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/RecentSolanaActivityList.tsx index e086b6c23..3aef60b7b 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/RecentSolanaActivityList.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/RecentSolanaActivityList.tsx @@ -1,5 +1,6 @@ -import { Fragment, useState } from "react"; +import { useState } from "react"; import type { Blockchain } from "@coral-xyz/common"; +import { BubbleTopLabel } from "@coral-xyz/react-common"; import { useRecentTransactions } from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; import { List } from "@mui/material"; @@ -59,25 +60,22 @@ export function _RecentSolanaActivityList({ > {txnsGroupedByDate.map((group: HeliusParsedTransaction[], i: number) => { return ( - -
- {formatTimestampListView(group[0].timestamp)} -
+
+ ))} - +
); })}
diff --git a/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/TransactionDetail.tsx b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/TransactionDetail.tsx index 29c616ccb..b5d929c85 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/TransactionDetail.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/RecentSolanaActivity/TransactionDetail.tsx @@ -1,13 +1,19 @@ import type { Dispatch, SetStateAction } from "react"; import { useState } from "react"; import { useNavigate } from "react-router-dom"; -import { Blockchain, explorerUrl } from "@coral-xyz/common"; +import { + Blockchain, + exploreAddressUrl, + explorerUrl, + walletAddressDisplay, +} from "@coral-xyz/common"; import { PrimaryButton } from "@coral-xyz/react-common"; import { SOL_LOGO_URI, useActiveWallet, useBlockchainConnectionUrl, useBlockchainExplorer, + useJupiterTokenMap, } from "@coral-xyz/recoil"; import { styles, useCustomTheme } from "@coral-xyz/themes"; import { @@ -24,6 +30,7 @@ import { Card, List } from "@mui/material"; import type { TokenInfo } from "@solana/spl-token-registry"; import { Source, TransactionType } from "helius-sdk/dist/types"; +import { UNKNOWN_ICON_SRC } from "../../../common/Icon"; import { WithDrawer } from "../../../common/Layout/Drawer"; import { NavBackButton } from "../../../common/Layout/Nav"; import { @@ -36,7 +43,6 @@ import { getTokenData, getTransactionDetailTitle, getTransactionTitle, - getTruncatedAddress, isNFTTransaction, isUserTxnSender, } from "./detail-parser"; @@ -136,6 +142,11 @@ const useStyles = styles((theme) => ({ width: "56px", height: "56px", }, + addressExplorerRow: { + "&:hover": { + cursor: "pointer", + }, + }, })); export function TransactionDetail({ @@ -151,12 +162,13 @@ export function TransactionDetail({ }) { const theme = useCustomTheme(); const classes = useStyles(); + const registry = useJupiterTokenMap(); const activeWallet = useActiveWallet(); const navigate = useNavigate(); const [openDrawer, setOpenDrawer] = useState(true); // TODO - this is duplicated in ListItem.tsx, better to pass in setTransactionDetail state - const tokenData = getTokenData(transaction); + const tokenData = getTokenData(registry, transaction); return ( @@ -185,7 +197,7 @@ export function TransactionDetail({ } > (
{ navigate("/nfts"); }} - /> - )} + /> : null} @@ -267,7 +277,7 @@ function DetailCardHeader({ >
{transaction?.tokenTransfers[0]?.tokenAmount.toFixed(5) + " " + - tokenData[0]?.symbol || - getTruncatedAddress(transaction?.tokenTransfers?.[0]?.mint) || - "UNKWN"} + (tokenData[0]?.symbol || + walletAddressDisplay(transaction?.tokenTransfers?.[0]?.mint))}
@@ -303,7 +313,7 @@ function DetailCardHeader({ >
{transaction?.tokenTransfers[1]?.tokenAmount.toFixed(5) + " " + - tokenData[1]?.symbol || - getTruncatedAddress(transaction?.tokenTransfers?.[0]?.mint) || - "UNKWN"} + (tokenData[1]?.symbol || + walletAddressDisplay(transaction?.tokenTransfers?.[0]?.mint))}
@@ -325,8 +335,7 @@ function DetailCardHeader({ } // if NFT url available, display it. Check on-chain data first - const nftImage = undefined; - // FIXME: metadata?.onChainMetadata?.metadata?.data?.uri || metadata?.offChainData?.image; + const nftImage = undefined; // FIXME: metadata?.onChainMetadata?.metadata?.data?.uri; const nftPrice = transaction?.events?.nft?.amount ? transaction?.events?.nft?.amount / 10 ** 9 @@ -345,27 +354,25 @@ function DetailCardHeader({ > {getTransactionTitle(activeWallet, transaction)}
- {nftPrice && ( -
- + -
- {nftPrice + " SOL"} -
+ {nftPrice + " SOL"}
- )} +
: null} ); } @@ -389,14 +396,10 @@ function DetailCardHeader({ ); } // other SPL token Transfer. Check tokenRegistry first, then Helius metadata - const transferIcon = undefined; - // FIXME: tokenData[0]?.logoURI || - // metadata?.onChaindata?.data?.uri || - // metadata?.offChainData?.image; + const transferIcon = tokenData[0]?.logoURI || UNKNOWN_ICON_SRC; // FIXME: || metadata?.onChainMetadata?.metadata?.data?.uri; const transferSymbol = tokenData[0]?.symbol || metadata?.onChainMetadata?.metadata?.data?.symbol; - // FIXME: || metadata?.offChainData?.symbol; if (transferIcon) { return ( @@ -498,67 +501,82 @@ function DetailTable({ {(transaction?.type === TransactionType.UNKNOWN || transaction.type === TransactionType.TRANSFER) && - isUserTxnSender(transaction, activeWallet) && ( -
+ isUserTxnSender(transaction, activeWallet) ?
+
{ + window.open( + exploreAddressUrl( + explorer!, + transaction?.tokenTransfers?.[0]?.toUserAccount || + transaction?.nativeTransfers?.[0]?.toUserAccount, + connectionUrl! + ) + ); + }} + >
To
-
- {getTruncatedAddress( - transaction?.tokenTransfers?.[0]?.toUserAccount || - transaction?.nativeTransfers?.[0]?.toUserAccount - )} + {walletAddressDisplay( + transaction?.tokenTransfers?.[0]?.toUserAccount || + transaction?.nativeTransfers?.[0]?.toUserAccount + )} +
- )} +
: null} {(transaction?.type === TransactionType.UNKNOWN || transaction.type === TransactionType.TRANSFER) && - isUserTxnSender(transaction, activeWallet) === false && ( -
-
-
From
+ isUserTxnSender(transaction, activeWallet) === false ?
+
+
From
-
- {getTruncatedAddress( +
+ {walletAddressDisplay( transaction?.tokenTransfers?.[0]?.fromUserAccount || transaction?.nativeTransfers?.[0]?.fromUserAccount )} -
- )} +
: null} - {transaction?.type === TransactionType.SWAP && ( - <> -
-
-
You paid
+ {transaction?.type === TransactionType.SWAP ? <> +
+
+
You paid
-
- {transaction?.tokenTransfers[0]?.tokenAmount.toFixed(5) + +
+ {transaction?.tokenTransfers[0]?.tokenAmount.toFixed(5) + " " + - tokenData[0]?.symbol || - getTruncatedAddress(transaction?.tokenTransfers?.[0]?.mint) || - "UKNWN"} -
+ (tokenData[0]?.symbol || + walletAddressDisplay( + transaction?.tokenTransfers?.[0]?.mint + ))}
-
-
-
You Received
+
+
+
+
You Received
-
- {transaction?.tokenTransfers[1]?.tokenAmount.toFixed(5) + +
+ {transaction?.tokenTransfers[1]?.tokenAmount.toFixed(5) + " " + - tokenData[1]?.symbol || - getTruncatedAddress(transaction?.tokenTransfers?.[0]?.mint) || - "UNKWN"} -
+ (tokenData[1]?.symbol || + walletAddressDisplay( + transaction?.tokenTransfers?.[0]?.mint + ))}
- - )} +
+ : null} {/* ALL txn types have first row (Date) rest of data rows below (Network Fee, Status, Signature)*/}
@@ -593,7 +611,7 @@ function DetailTable({
Signature
- {getTruncatedAddress(transaction?.signature)} + {walletAddressDisplay(transaction?.signature)} ({ + address: mint, + chainId: 0, + decimals: 0, + logoURI: UNKNOWN_ICON_SRC, + name: "Unknown", + symbol: "UNK", +}); + export const isNFTTransaction = ( transaction: HeliusParsedTransaction ): boolean => { @@ -71,10 +81,6 @@ export const getSourceOrTypeFormatted = (sourceOrType: string): string => { .join(" "); }; -export const getTruncatedAddress = (address: string): string => { - return `${address?.slice(0, 5)}...${address?.slice(address?.length - 5)}`; -}; - export const isUserTxnSender = ( transaction: HeliusParsedTransaction, activeWallet: any @@ -106,7 +112,7 @@ export function getTransactionTitle( return "Burned"; case TransactionType.TRANSFER: // send/receive NFT's are returned as TransactionType.TRANSFER - const nftName = metadata?.onChainMetadata?.metadata?.data?.name; // FIXME: || metadata?.offChainData?.name; + const nftName = metadata?.onChainMetadata?.metadata?.data?.name; if (isNFTTransaction(transaction) && nftName) { return nftName; } else if (isUserTxnSender(transaction, activeWallet)) { @@ -119,7 +125,7 @@ export function getTransactionTitle( case TransactionType.SWAP: return "Token Swap"; case TransactionType.NFT_MINT: { - const nftName = metadata?.onChainMetadata?.metadata?.data?.name; // FIXME: || metadata?.offChainData?.name; + const nftName = metadata?.onChainMetadata?.metadata?.data?.name; return `Minted: ${nftName}`; } default: @@ -130,7 +136,6 @@ export function getTransactionTitle( // TODO: test this case to see if it is necessary const nonTransferNftName = metadata?.onChainMetadata?.metadata?.data?.name; - // FIXME: || metadata?.offChainData?.name; if (isNFTTransaction(transaction) && nonTransferNftName) { return nonTransferNftName; @@ -204,12 +209,12 @@ export const getTransactionCaption = ( // case TransactionType.UNKNOWN: case TransactionType.TRANSFER: if (isUserTxnSender(transaction, activeWallet)) { - return `To: ${getTruncatedAddress( + return `To: ${walletAddressDisplay( transaction?.tokenTransfers[0]?.toUserAccount || transaction?.nativeTransfers[0]?.toUserAccount )}`; } else if (isUserTxnSender(transaction, activeWallet) === false) { - return `From: ${getTruncatedAddress( + return `From: ${walletAddressDisplay( transaction?.tokenTransfers[0]?.fromUserAccount || transaction?.nativeTransfers[0]?.fromUserAccount )}`; @@ -223,11 +228,11 @@ export const getTransactionCaption = ( case TransactionType.SWAP: // fallback to truncated mint address if token metadata was not found return `${ - tokenData?.[0]?.symbol ?? - getTruncatedAddress(transaction?.tokenTransfers?.[0]?.mint) + tokenData?.[0]?.symbol || + walletAddressDisplay(transaction?.tokenTransfers?.[0]?.mint) } -> ${ - tokenData?.[1]?.symbol ?? - getTruncatedAddress(transaction?.tokenTransfers?.[1]?.mint) + tokenData?.[1]?.symbol || + walletAddressDisplay(transaction?.tokenTransfers?.[1]?.mint) }`; case TransactionType.NFT_LISTING: @@ -248,7 +253,7 @@ export const getTransactionCaption = ( // case TransactionType.BURN: // return transaction?. case TransactionType.NFT_MINT: - return getTruncatedAddress( + return walletAddressDisplay( metadata?.onChainMetadata?.metadata?.collection?.key ); @@ -264,42 +269,44 @@ export const getTransactionCaption = ( // transaction?.source !== TransactionType.UNKNOWN // ) // return getSourceOrTypeFormatted(transaction.source); - return getTruncatedAddress(transaction?.instructions[0].programId); + return walletAddressDisplay(transaction?.instructions[0].programId); } }; export const getTokenData = ( + registry: Map, transaction: HeliusParsedTransaction ): (TokenInfo | undefined)[] => { - const tokenRegistry = useSplTokenRegistry(); - let tokenData: (TokenInfo | undefined)[] = []; if (transaction.type === TransactionType.SWAP) { // if token is isNativeInput/isNativeOutput, token swap is to/from SOL - let tokenInput, tokenOutput; const isNativeInput = transaction.events?.swap?.nativeInput; const isNativeOutput = transaction.events?.swap?.nativeOutput; - tokenInput = isNativeInput - ? SOL_NATIVE_MINT - : transaction.events?.swap?.tokenInputs?.[0]?.mint; - tokenOutput = isNativeOutput - ? SOL_NATIVE_MINT - : transaction.events?.swap?.tokenOutputs?.[0]?.mint; - - if (tokenInput && tokenRegistry.get(tokenInput)) { - tokenData.push(tokenRegistry.get(tokenInput)); - } - if (tokenOutput && tokenRegistry.get(tokenOutput)) { - tokenData.push(tokenRegistry.get(tokenOutput)); + + const tokenInput = isNativeInput + ? WSOL_MINT + : transaction.events?.swap?.tokenInputs?.[0]?.mint || + transaction.tokenTransfers?.[0]?.mint; + + const tokenOutput = isNativeOutput + ? WSOL_MINT + : transaction.events?.swap?.tokenOutputs?.[0]?.mint || + transaction.tokenTransfers?.[1]?.mint; + + if (tokenInput && registry.get(tokenInput)) { + tokenData.push(registry.get(tokenInput) ?? unknownTokenInfo(tokenInput)); } - } - // add appropriate token metadata - if (transaction.type === TransactionType.TRANSFER) { + if (tokenOutput && registry.get(tokenOutput)) { + tokenData.push( + registry.get(tokenOutput) ?? unknownTokenInfo(tokenOutput) + ); + } + } else if (transaction.type === TransactionType.TRANSFER) { const transferredToken = transaction.tokenTransfers?.[0]?.mint; - if (transferredToken && tokenRegistry.get(transferredToken)) { - tokenData.push(tokenRegistry.get(transferredToken)); + if (transferredToken && registry.get(transferredToken)) { + tokenData.push(registry.get(transferredToken)); } } diff --git a/packages/app-extension/src/components/Unlocked/Balances/StripeRamp.tsx b/packages/app-extension/src/components/Unlocked/Balances/StripeRamp.tsx index 6633a2982..e563516d4 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/StripeRamp.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/StripeRamp.tsx @@ -81,22 +81,18 @@ export const StripeRamp = ({ return (
{" "} - {err && ( - <> -
- {err} -
-
-
- fetchToken()} /> -
- - )} - {!err && ( + {err ? <>
- {" "} + {err}
- )} +
+
+ fetchToken()} /> +
+ : null} + {!err ?
+ {" "} +
: null}
); }; diff --git a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/AddressSelector.tsx b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/AddressSelector.tsx index 81129f1ed..0077382d3 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/AddressSelector.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/AddressSelector.tsx @@ -1,13 +1,11 @@ import React, { useContext, useEffect, useState } from "react"; import type { RemoteUserData } from "@coral-xyz/common"; -import { - BACKEND_API_URL, - Blockchain, - walletAddressDisplay, -} from "@coral-xyz/common"; +import { BACKEND_API_URL, Blockchain } from "@coral-xyz/common"; import { useContacts } from "@coral-xyz/db"; import { ParentCommunicationManager } from "@coral-xyz/message-sdk"; import { + BubbleTopLabel, + DangerButton, isFirstLastListItemStyle, PrimaryButton, TextInput, @@ -28,15 +26,8 @@ import { } from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; import BlockIcon from "@mui/icons-material/Block"; -import ExpandMoreIcon from "@mui/icons-material/ExpandMore"; import SearchIcon from "@mui/icons-material/Search"; -import { - Accordion, - AccordionDetails, - AccordionSummary, - List, - ListItem, -} from "@mui/material"; +import { List, ListItem } from "@mui/material"; import InputAdornment from "@mui/material/InputAdornment"; import { createStyles, makeStyles } from "@mui/styles"; @@ -46,7 +37,6 @@ import { } from "../../../common/Layout/NavStack"; import { useIsValidAddress } from "./Send"; -import { TokenBadge } from "./TokenBadge"; let debouncedTimer = 0; @@ -135,7 +125,8 @@ export const AddressSelectorLoader = ({ }) => { // publicKey should only be undefined if the user is in single-wallet mode // (rather than aggregate mode). - const publicKeyStr = publicKey ?? useActiveWallet().publicKey; + const activePublicKey = useActiveWallet().publicKey; + const publicKeyStr = publicKey ?? activePublicKey; const [token] = useLoader( blockchainTokenData({ publicKey: publicKeyStr, @@ -144,7 +135,7 @@ export const AddressSelectorLoader = ({ }), null ); - if (!token) return <>; + if (!token) return null; return ; }; @@ -169,8 +160,6 @@ export const AddressSelector = ({ ethereumCtx.provider ); - const isSendDisabled = !isValidAddress; - useEffect(() => { const prev = nav.title; nav.setOptions({ headerTitle: `Send ${token.ticker}` }); @@ -183,42 +172,56 @@ export const AddressSelector = ({
- - {!inputContent && ( + {!inputContent ? ( - )} + ) : null} +
- { - push("send", { - blockchain, - token, - to: { - address: inputContent, - }, - }); - }} - disabled={isSendDisabled} - label="Next" - type="submit" - data-testid="Send" - /> + {!isValidAddress && inputContent.length > 15 ? ( + + ) : ( + { + const user = searchResults.find((x) => + x.public_keys.find( + (result) => result.publicKey === inputContent + ) + ); + push("send", { + blockchain, + token, + to: { + address: inputContent, + username: user?.username, + image: user?.image, + uuid: user?.id, + }, + }); + }} + disabled={!isValidAddress} + label="Next" + type="submit" + data-testid="Send" + /> + )}
@@ -226,11 +229,9 @@ export const AddressSelector = ({ }; function NotSelected({ - blockchain, searchFilter, searchResults, }: { - blockchain: Blockchain; searchFilter: string; searchResults: any[]; }) { @@ -259,14 +260,12 @@ function NotSelected({ ]; if (!allResults.length) { - return <>; + return null; } return (
-
- Users who haven't yet set a primary address -
+
({ image: x.remoteUserImage, username: x.remoteUsername, @@ -297,17 +295,15 @@ function NotSelected({ } function MembersList({ - count, members, }: { - count: number; members: { image: string; username: string }[]; }) { const theme = useCustomTheme(); - const MEMBER_TRHESHOLD = 3; + const MEMBER_THRESHOLD = 3; const classes = useStyles(); const renderMembersStr = () => { - if (members.length <= MEMBER_TRHESHOLD) { + if (members.length <= MEMBER_THRESHOLD) { return members.map( (member, index) => member.username + `${index === members.length - 1 ? "" : ", "}` @@ -365,7 +361,6 @@ const Contacts = ({ blockchain: Blockchain; searchFilter: string; }) => { - const classes = useStyles(); const { uuid } = useUser(); const contacts = useContacts(uuid); @@ -383,30 +378,26 @@ const Contacts = ({ return (
- {filteredContacts.length !== 0 && ( + {filteredContacts.length !== 0 ? (
-
- Contacts -
-
- ({ - username: c.remoteUsername, - addresses: c.public_keys - .filter( - (x) => - x.blockchain === blockchain && - (x.publicKey.includes(searchFilter) || - c.remoteUsername.includes(searchFilter)) - ) - .map((x) => x.publicKey), - image: c.remoteUserImage, - uuid: c.remoteUserId, - }))} - /> -
+ + ({ + username: c.remoteUsername, + addresses: c.public_keys + .filter( + (x) => + x.blockchain === blockchain && + (x.publicKey.includes(searchFilter) || + c.remoteUsername.includes(searchFilter)) + ) + .map((x) => x.publicKey), + image: c.remoteUserImage, + uuid: c.remoteUserId, + }))} + />
- )} + ) : null}
); }; @@ -418,7 +409,6 @@ const YourAddresses = ({ blockchain: Blockchain; searchFilter: string; }) => { - const classes = useStyles(); const wallets = useAllWallets().filter((x) => x.blockchain === blockchain); const { uuid } = useUser(); const avatarUrl = useAvatarUrl(); @@ -426,16 +416,15 @@ const YourAddresses = ({ const activeEthWallet = useActiveEthereumWallet(); if (wallets.length === 1) { // Only one wallet available - return <>; + return null; } return (
-
- Your addresses -
+ x.blockchain === blockchain) .filter( (x) => x.publicKey !== @@ -467,6 +456,8 @@ function AddressList({ }) { const theme = useCustomTheme(); + const walletsWithPrimary = wallets.filter((w) => w.addresses?.[0]); + return ( - {wallets - .filter((wallet) => wallet.addresses?.[0]) - .map((wallet, index) => ( - <> - - - ))} + {walletsWithPrimary.map((wallet, index) => ( + + ))} ); } @@ -567,49 +554,35 @@ const AddressListItem = ({
{user.username}
- {!address && ( + {!address ? ( - )} - {/*
{walletAddressDisplay(address)}
*/} + ) : null}
); }; -const SearchAddress = ({ +const SearchInput = ({ inputContent, setInputContent, - blockchain, - searchResults, setSearchResults, + searchResults, }: { inputContent: string; setInputContent: any; - blockchain: Blockchain; - searchResults: any[]; setSearchResults: any; + searchResults: any[]; }) => { - const { provider: solanaProvider } = useAnchorContext(); - const ethereumCtx = useEthereumCtx(); - const [loading, setLoading] = useState(false); const theme = useCustomTheme(); + const { blockchain } = useAddressSelectorContext(); - const { isErrorAddress } = useIsValidAddress( - blockchain, - inputContent, - solanaProvider.connection, - ethereumCtx.provider - ); - - const fetchUserDetails = async (address: string) => { - setLoading(true); + const fetchUserDetails = async (address: string, blockchain: Blockchain) => { try { const response = await ParentCommunicationManager.getInstance().fetch( - `${BACKEND_API_URL}/users?usernamePrefix=${address}&limit=6` + `${BACKEND_API_URL}/users?usernamePrefix=${address}&blockchain=${blockchain}limit=6` ); const json = await response.json(); - setLoading(false); setSearchResults( json.users.sort((a: any, b: any) => a.username.length < b.username.length ? -1 : 1 @@ -620,23 +593,34 @@ const SearchAddress = ({ } }; - const debouncedFetchUserDetails = (prefix: string) => { + const debouncedFetchUserDetails = ( + prefix: string, + blockchain: Blockchain + ) => { clearTimeout(debouncedTimer); - debouncedTimer = setTimeout(() => { - fetchUserDetails(prefix); + debouncedTimer = setTimeout(async () => { + await fetchUserDetails(prefix, blockchain); }, 250); }; useEffect(() => { if (inputContent.length >= 2) { - debouncedFetchUserDetails(inputContent); + debouncedFetchUserDetails(inputContent, blockchain); + } else { + clearTimeout(debouncedTimer); + } + }, [inputContent, blockchain]); + + useEffect(() => { + if (!inputContent && searchResults.length) { + setSearchResults([]); } - }, [inputContent]); + }, [searchResults, inputContent]); return (
@@ -651,29 +635,43 @@ const SearchAddress = ({ }} margin="none" /> - {!isErrorAddress && inputContent && ( -
- This is a valid {blockchain} address -
- )} - {isErrorAddress && inputContent && inputContent.length > 15 && ( -
- This is not a valid {blockchain} address -
- )} - {searchResults.length !== 0 && ( +
+ ); +}; + +const SearchResults = ({ + searchResults, + blockchain, +}: { + searchResults: any[]; + blockchain: Blockchain; +}) => { + // Don't show any friends because they will show up under contacts + // This would be better implemented on the server query because it messes + // with the limit, i.e. you could filter all the results from the limit + const filteredSearchResults = searchResults.filter( + (user) => !user.areFriends + ); + + return ( +
+ {filteredSearchResults.length !== 0 ? (
- {" "} + ({ - username: user.username, - image: user.image, - uuid: user.id, - addresses: user.public_keys?.map((x: any) => x.publicKey), - }))} + wallets={filteredSearchResults + .map((user) => ({ + username: user.username, + image: user.image, + uuid: user.id, + addresses: user.public_keys + .filter((x: any) => x.blockchain === blockchain) + ?.map((x: any) => x.publicKey), + })) + .filter((x) => x.addresses.length !== 0)} />
- )} + ) : null}
); }; diff --git a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Deposit.tsx b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Deposit.tsx index 5579a787e..1d67cce98 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Deposit.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Deposit.tsx @@ -456,12 +456,8 @@ export function _Deposit({
- {blockchain === Blockchain.SOLANA && ( - <>This address can only receive SOL and SPL tokens on Solana. - )} - {blockchain === Blockchain.ETHEREUM && ( - <>This address can only receive ETH and ERC20 tokens on Ethereum. - )} + {blockchain === Blockchain.SOLANA ? <>This address can only receive SOL and SPL tokens on Solana. : null} + {blockchain === Blockchain.ETHEREUM ? <>This address can only receive ETH and ERC20 tokens on Ethereum. : null}
diff --git a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Ethereum/index.tsx b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Ethereum/index.tsx index 9023a97a9..0f1ea6ec6 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Ethereum/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Ethereum/index.tsx @@ -146,7 +146,7 @@ export function SendEthereumConfirmationCard({ ) : cardType === "complete" ? ( {}, detail: (
- {destinationUser && ( - - )} + {destinationUser ? : null} {walletAddressDisplay(destinationAddress)}
), diff --git a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Ramp.tsx b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Ramp.tsx index 84a839719..36e3f86bf 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Ramp.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Ramp.tsx @@ -131,7 +131,7 @@ export function Ramp({ return ( <> - {!!icon && ( - - + (event.currentTarget.style.display = "none") } /> - - )} + : null}
{title}
- {subtitle && ( - {subtitle} - )} + {subtitle ? {subtitle} : null}
diff --git a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Send.tsx b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Send.tsx index 16e54874d..54b6adf1d 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Send.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Send.tsx @@ -1,5 +1,5 @@ -import React, { useEffect, useRef, useState } from "react"; -import { RichMentionsInput } from "react-rich-mentions"; +import React, { type ChangeEvent, useEffect, useState } from "react"; +import { StyleSheet, View } from "react-native"; import { getHashedName, getNameAccountKey, @@ -10,16 +10,11 @@ import { ETH_NATIVE_MINT, explorerUrl, NATIVE_ACCOUNT_RENT_EXEMPTION_LAMPORTS, - NAV_COMPONENT_MESSAGE_CHAT, - NAV_COMPONENT_MESSAGE_PROFILE, SOL_NATIVE_MINT, - TAB_MESSAGES, toDisplayBalance, toTitleCase, - UI_RPC_METHOD_NAVIGATION_ACTIVE_TAB_UPDATE, walletAddressDisplay, } from "@coral-xyz/common"; -import { createEmptyFriendship } from "@coral-xyz/db"; import { CheckIcon, CrossIcon, @@ -29,10 +24,8 @@ import { MaxLabel, PrimaryButton, SecondaryButton, - SignalingManager, TextFieldLabel, TextInput, - UserIcon, } from "@coral-xyz/react-common"; import type { TokenDataWithPrice } from "@coral-xyz/recoil"; import { @@ -40,7 +33,6 @@ import { useActiveWallet, useAnchorContext, useBackgroundClient, - useBlockchainActiveWallet, useBlockchainConnectionUrl, useBlockchainExplorer, useBlockchainTokenAccount, @@ -52,12 +44,11 @@ import { useUser, } from "@coral-xyz/recoil"; import { styles, useCustomTheme } from "@coral-xyz/themes"; -import { TextField, Typography } from "@mui/material"; +import { Typography } from "@mui/material"; import { TldParser } from "@onsol/tldparser"; import type { Connection } from "@solana/web3.js"; import { PublicKey, SystemProgram } from "@solana/web3.js"; import { BigNumber, ethers } from "ethers"; -import { v4 as uuidv4 } from "uuid"; import { ApproveTransactionDrawer } from "../../../common/ApproveTransactionDrawer"; import { useDrawerContext } from "../../../common/Layout/Drawer"; @@ -88,6 +79,7 @@ const useStyles = styles((theme) => ({ justifyContent: "center", }, container: { + alignItems: "center", display: "flex", flexDirection: "column", height: "100%", @@ -101,14 +93,6 @@ const useStyles = styles((theme) => ({ paddingRight: "12px", marginBottom: -10, }, - buttonContainer: { - display: "flex", - paddingLeft: "12px", - paddingRight: "12px", - paddingBottom: "16px", - paddingTop: "25px", - justifyContent: "space-between", - }, textRoot: { marginTop: "0 !important", marginBottom: "0 !important", @@ -157,15 +141,18 @@ export function SendButton({ }) { // publicKey should only be undefined if the user is in single-wallet mode // (rather than aggregate mode). - publicKey = publicKey ?? useActiveWallet().publicKey; + const activeWallet = useActiveWallet(); + publicKey = publicKey ?? activeWallet.publicKey; + const token = useBlockchainTokenAccount({ publicKey, blockchain, tokenAddress: address, }); + return ( ; + + if (!token) return null; return ; } @@ -228,7 +218,7 @@ export function Send({ const ethereumCtx = useEthereumCtx(); const [openDrawer, setOpenDrawer] = useState(false); const [address, setAddress] = useState(to?.address || ""); - const [amount, setAmount] = useState(undefined); + const [amount, setAmount] = useState(null); const [feeOffset, setFeeOffset] = useState(BigNumber.from(0)); const [message, setMessage] = useState(""); const friendship = useFriendship({ userId: to?.uuid || "" }); @@ -281,7 +271,8 @@ export function Send({ const amountSubFee = BigNumber.from(token!.nativeBalance).sub(feeOffset); const maxAmount = amountSubFee.gt(0) ? amountSubFee : BigNumber.from(0); const exceedsBalance = amount && amount.gt(maxAmount); - const isSendDisabled = !isValidAddress || amount === null || !!exceedsBalance; + const isSendDisabled = + !isValidAddress || amount === null || amount.eq(0) || !!exceedsBalance; const isAmountError = amount && exceedsBalance; // On click handler. @@ -294,9 +285,9 @@ export function Send({ let sendButton; if (isErrorAddress) { - sendButton = ; + sendButton = ; } else if (isAmountError) { - sendButton = ; + sendButton = ; } else { sendButton = ( - <> - {!to && ( - - )} - {to && ( - - )} - - { - if ( - to?.uuid && - to?.uuid !== uuid && - friendship?.id && - to?.uuid !== uuid && - blockchain === Blockchain.SOLANA - ) { - // const client_generated_uuid = uuidv4(); - // createEmptyFriendship(uuid, to?.uuid, { - // last_message_sender: uuid, - // last_message_timestamp: new Date().toISOString(), - // last_message: message, - // last_message_client_uuid: client_generated_uuid, - // }); - // - // SignalingManager.getInstance().send({ - // type: "CHAT_MESSAGES", - // payload: { - // room: friendship?.id?.toString(), - // type: "individual", - // messages: [ - // { - // client_generated_uuid: client_generated_uuid, - // message, - // message_kind: "transaction", - // message_metadata: { - // final_tx_signature: txSig, - // }, - // }, - // ], - // }, - // }); - // await navOuter.toRoot(); - // await background.request({ - // method: UI_RPC_METHOD_NAVIGATION_ACTIVE_TAB_UPDATE, - // params: [TAB_MESSAGES], - // }); - // push({ - // title: `@${to?.username}`, - // componentId: NAV_COMPONENT_MESSAGE_CHAT, - // componentProps: { - // userId: to?.uuid, - // id: to?.uuid, - // username: to?.username, - // }, - // }); - } - }} - token={token} - destinationAddress={destinationAddress} - destinationUser={ - to?.uuid && to?.username && to?.image - ? { - username: to.username, - image: to.image, - } - : undefined + {!to ? ( + + ) : null} + {to ? ( + + ) : null} + + { + if ( + to?.uuid && + to?.uuid !== uuid && + friendship?.id && + to?.uuid !== uuid && + blockchain === Blockchain.SOLANA + ) { + // const client_generated_uuid = uuidv4(); + // createEmptyFriendship(uuid, to?.uuid, { + // last_message_sender: uuid, + // last_message_timestamp: new Date().toISOString(), + // last_message: message, + // last_message_client_uuid: client_generated_uuid, + // }); + // + // SignalingManager.getInstance().send({ + // type: "CHAT_MESSAGES", + // payload: { + // room: friendship?.id?.toString(), + // type: "individual", + // messages: [ + // { + // client_generated_uuid: client_generated_uuid, + // message, + // message_kind: "transaction", + // message_metadata: { + // final_tx_signature: txSig, + // }, + // }, + // ], + // }, + // }); + // await navOuter.toRoot(); + // await background.request({ + // method: UI_RPC_METHOD_NAVIGATION_ACTIVE_TAB_UPDATE, + // params: [TAB_MESSAGES], + // }); + // push({ + // title: `@${to?.username}`, + // componentId: NAV_COMPONENT_MESSAGE_CHAT, + // componentProps: { + // userId: to?.uuid, + // id: to?.uuid, + // username: to?.username, + // }, + // }); } - amount={amount!} - /> - - + }} + token={token} + destinationAddress={destinationAddress} + destinationUser={ + to?.uuid && to?.username && to?.image + ? { + username: to.username, + image: to.image, + } + : undefined + } + amount={amount!} + /> + ); } @@ -443,8 +432,8 @@ function SendV1({
@@ -469,7 +458,7 @@ function SendV1({
-
{sendButton}
+ {sendButton} ); } +function ButtonContainer({ children }: { children: React.ReactNode }) { + return {children}; +} + +const buttonContainerStyles = StyleSheet.create({ + container: { + width: "100%", + paddingHorizontal: 12, + paddingBottom: 16, + paddingTop: 25, + }, +}); + function SendV2({ token, maxAmount, @@ -540,7 +542,7 @@ function SendV2({
- {to.username && ( + {to.username ? (
@{`${to.username}`}
- )} + ) : null}
@@ -570,40 +572,53 @@ function SendV2({
- { - try { - const num = - e.target.value !== "" ? parseFloat(e.target.value) : 0.0; - if (num >= 0) { - _setAmount(e.target.value); - setAmount( - ethers.utils.parseUnits(num.toString(), token.decimals) - ); +
+ ) => { + try { + const parsedVal = + value.length === 1 && value[0] === "." ? "0." : value; + + _setAmount(parsedVal); + + const num = + parsedVal === "" || parsedVal === "0." + ? 0.0 + : parseFloat(parsedVal); + + if (num >= 0) { + setAmount( + ethers.utils.parseUnits(num.toString(), token.decimals) + ); + } + } catch (err) { + // Do nothing. } - } catch (err) { - // Do nothing. - } - }} - /> + }} + /> +
@@ -654,9 +669,7 @@ function SendV2({
-
-
{sendButton}
-
+ {sendButton} ); } @@ -729,7 +742,6 @@ export function Sending({ marginLeft: "auto", marginRight: "auto", }} - thickness={6} /> )}
@@ -740,7 +752,7 @@ export function Sending({ marginRight: "16px", }} > - {explorer && connectionUrl && ( + {explorer && connectionUrl ? ( { if (isComplete) { @@ -752,7 +764,7 @@ export function Sending({ }} label={isComplete ? "View Balances" : "View Explorer"} /> - )} + ) : null}
); @@ -815,7 +827,7 @@ export function Error({ > {error} - {explorer && connectionUrl && signature && ( + {explorer && connectionUrl && signature ? ( window.open( explorerUrl(explorer, signature, connectionUrl), @@ -832,9 +844,9 @@ export function Error({ ) } /> - )} + ) : null}
- onRetry()} /> + onRetry()} />
); } @@ -921,7 +933,6 @@ export function useIsValidAddress( } const account = await solanaConnection?.getAccountInfo(pubkey); - console.log("ext:account", account); // Null data means the account has no lamports. This is valid. if (!account) { diff --git a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Solana/index.tsx b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Solana/index.tsx index 288fca466..a7fdd675d 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Solana/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Solana/index.tsx @@ -202,7 +202,7 @@ export function SendSolanaConfirmationCard({ ) : cardType === "complete" ? ( {}, detail: (
- {destinationUser && ( - - )} + {destinationUser ? : null} {walletAddressDisplay(destinationAddress)}
), diff --git a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Token.tsx b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Token.tsx index eea26595f..32e12bcab 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Token.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/TokensWidget/Token.tsx @@ -84,7 +84,7 @@ export function Token({ blockchain={blockchain} address={activityAddress} contractAddresses={contractAddresses} - minimize={true} + minimize style={{ marginTop: 0 }} />
diff --git a/packages/app-extension/src/components/Unlocked/Balances/TransferWidget.tsx b/packages/app-extension/src/components/Unlocked/Balances/TransferWidget.tsx index 11644ee18..ec52a5e80 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/TransferWidget.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/TransferWidget.tsx @@ -1,3 +1,4 @@ +import React from "react"; import type { Blockchain } from "@coral-xyz/common"; import { ETH_NATIVE_MINT, @@ -5,11 +6,7 @@ import { STRIPE_ENABLED, } from "@coral-xyz/common"; import { Dollar } from "@coral-xyz/react-common"; -import { - SwapProvider, - useActiveSolanaWallet, - useFeatureGates, -} from "@coral-xyz/recoil"; +import { SwapProvider, useFeatureGates } from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; import { ArrowDownward, ArrowUpward, SwapHoriz } from "@mui/icons-material"; import { Typography } from "@mui/material"; @@ -50,39 +47,24 @@ export function TransferWidget({
- {enableOnramp && ( - <> - -
- - )} + {enableOnramp ? ( + + ) : null} -
- {swapEnabled && ( - <> -
- - - )} + {swapEnabled ? ( + + ) : null}
); } @@ -90,47 +72,57 @@ export function TransferWidget({ function SwapButton({ blockchain, address, - publicKey, }: { blockchain?: Blockchain; address?: string; - publicKey?: string; }) { const theme = useCustomTheme(); - // Aggregate view swapper can just default to the current (global) active key. - publicKey = publicKey ?? useActiveSolanaWallet()?.publicKey; + const SwapButtonComponent = ({ + routes = [], + }: { + routes?: React.ComponentProps["routes"]; + }) => ( + + } + routes={routes} + disabled={routes.length === 0} + /> + ); + + // Wrap in Suspense so it doesn't block if Jupiter is slow or down. return ( - - - } - routes={[ - { - name: "swap", - component: (props: any) => , - title: `Swap`, - props: { - blockchain, + }> + + , + title: `Swap`, + props: { + blockchain, + }, }, - }, - { - title: `Select Token`, - name: "select-token", - component: (props: any) => , - }, - ]} - /> - + { + title: `Select Token`, + name: "select-token", + component: (props: any) => , + }, + ]} + /> + + ); } @@ -146,7 +138,7 @@ function SendButton({ const theme = useCustomTheme(); return ( ; + routes?: Array<{ props?: any; component: any; title: string; name: string }>; + disabled?: boolean; }) { const theme = useCustomTheme(); return ( @@ -304,6 +298,9 @@ function TransferButton({ style={{ width: "52px", height: "70px", + // semi-transparent and unclickable when disabled=true + opacity: disabled ? 0.5 : 1, + pointerEvents: disabled ? "none" : "auto", }} > diff --git a/packages/app-extension/src/components/Unlocked/Balances/index.tsx b/packages/app-extension/src/components/Unlocked/Balances/index.tsx index 06f6e2c50..767174c79 100644 --- a/packages/app-extension/src/components/Unlocked/Balances/index.tsx +++ b/packages/app-extension/src/components/Unlocked/Balances/index.tsx @@ -46,7 +46,7 @@ export function Balances() { marginBottom: "32px", }} > - +
- styles((theme) => ({ +const useStyles = makeStyles((theme: any) => + createStyles({ container: { padding: 0, color: theme.custom.colors.fontColor2, }, - icon: { - color: theme.custom.colors.icon, - marginRight: 10, - height: "24px", - width: "24px", - }, horizontalCenter: { justifyContent: "center", display: "flex", @@ -42,24 +36,12 @@ export const useStyles = (isDark: boolean) => padding: 10, height: "80vh", }, - drawer: { - "& .MuiDrawer-paper": { - background: isDark - ? theme.custom.colors.background - : theme.custom.colors.nav, - height: "90vh", - borderTopLeftRadius: "15px", - borderTopRightRadius: "15px", - "&::-webkit-scrollbar": { - display: "none", - }, - }, - }, - })); + }) +); export const ChatDrawer = ({ setOpenDrawer }: { setOpenDrawer: any }) => { const isDark = useDarkMode(); - const classes = useStyles(isDark)(); + const classes = useStyles({ isDark }); const { props, title }: any = useDecodedSearchParams(); const [members, setMembers] = useState([]); const [searchFilter, setSearchFilter] = useState(""); @@ -67,6 +49,7 @@ export const ChatDrawer = ({ setOpenDrawer }: { setOpenDrawer: any }) => { const [count, setCount] = useState(0); const [loading, setLoading] = useState(true); const [staticMembers, setStaticMembers] = useState([]); + const { username } = useUser(); const theme = useCustomTheme(); const pathname = useLocation().pathname; @@ -93,7 +76,7 @@ export const ChatDrawer = ({ setOpenDrawer }: { setOpenDrawer: any }) => { setLoading(false); setStaticMembers((members) => { if (members.length === 0) { - return json.members.slice(0, 4); + return json.members.slice(0, 3); } return members; }); @@ -106,19 +89,45 @@ export const ChatDrawer = ({ setOpenDrawer }: { setOpenDrawer: any }) => { return ( setOpenDrawer(false)} >
- + {props.title || title}
- {count !== 0 && } + {count !== 0 ? ( + ({ + image: x.image, + })), + { + image: `https://swr.xnfts.dev/avatars/${username}`, + }, + ]} + /> + ) : null} { setSearchFilter(prefix); @@ -148,7 +157,7 @@ export const ChatDrawer = ({ setOpenDrawer }: { setOpenDrawer: any }) => { {offset !== 0 ? "Prev" : ""}
{/* TODO: clean up this logic */} - {members.length === LIMIT && ( + {members.length === LIMIT ? (
{ > Next
- )} + ) : null}
- {loading && } - {!loading && ( - <> -
- {members.filter((x) => - x.username - ?.toLocaleLowerCase() - .includes(searchFilter?.toLocaleLowerCase()) - ).length !== 0 ? ( - - x.username - ?.toLocaleLowerCase() - .includes(searchFilter?.toLocaleLowerCase()) - )} - /> - ) : ( - <> - )} -
- - )} + {loading ? : null} + {!loading ? ( +
+ {members.filter((x) => + x.username + ?.toLocaleLowerCase() + .includes(searchFilter?.toLocaleLowerCase()) + ).length !== 0 ? ( + + x.username + ?.toLocaleLowerCase() + .includes(searchFilter?.toLocaleLowerCase()) + )} + /> + ) : ( +
+ )} +
+ ) : null}
); @@ -208,7 +215,7 @@ function MembersList({ members, }: { count: number; - members: RemoteUserData[]; + members: { image: string }[]; }) { const theme = useCustomTheme(); const countText = count >= 1000 ? `${(count / 1000).toFixed(1)}k` : count; @@ -222,9 +229,14 @@ function MembersList({ }} > {members.map((member, idx) => ( - { }, []); useEffect(() => { - nav.setOptions({ headerTitle: "Contacts" }); + nav.setOptions({ headerTitle: "Friends" }); }, [nav]); return ( @@ -84,17 +84,16 @@ export const ContactRequests = ({ {description}
- {!isSent && requests.sent.length > 0 && ( - + {!isSent && requests.sent.length > 0 ? nav.push("contact-requests-sent", { description: ( <> - People you added as contacts. + People you added as friends.
Click someone to view their profile. ), @@ -103,9 +102,8 @@ export const ContactRequests = ({ }) } > - Sent ({requests.sent.length}) - - )} + Sent ({requests.sent.length}) + : null} { }, }); toast.success( - "Contact removed", - `We've removed @${remoteUsername} from your contacts.` + "Friend removed", + `We've removed @${remoteUsername} from your friends.` ); } else { if (friendshipValue?.requested) { @@ -99,12 +99,12 @@ export const MessageOptions = () => { }} > {friendshipValue?.areFriends - ? "Remove from contacts" + ? "Remove from Friends" : friendshipValue?.requested ? "Cancel Pending Request" : friendshipValue?.remoteRequested - ? "Accept Contact Request" - : "Add to contacts"} + ? "Accept Friend Request" + : "Add to Friends"} diff --git a/packages/app-extension/src/components/Unlocked/Messages/Requests.tsx b/packages/app-extension/src/components/Unlocked/Messages/Requests.tsx index f32f9677d..f642b2a91 100644 --- a/packages/app-extension/src/components/Unlocked/Messages/Requests.tsx +++ b/packages/app-extension/src/components/Unlocked/Messages/Requests.tsx @@ -51,19 +51,15 @@ export const Requests = ({ searchFilter }: { searchFilter: string }) => { return (
- {filteredRequests.length !== 0 && ( - - )} - {filteredRequests.length === 0 && ( -
-
- You have no pending requests -
+ {filteredRequests.length !== 0 ? : null} + {filteredRequests.length === 0 ?
+
+ You have no pending requests
- )} +
: null}
); }; @@ -71,10 +67,10 @@ export const Requests = ({ searchFilter }: { searchFilter: string }) => { export function SkeletonContainer() { return ( <> - + - + ); } diff --git a/packages/app-extension/src/components/Unlocked/Messages/SearchUsers.tsx b/packages/app-extension/src/components/Unlocked/Messages/SearchUsers.tsx index 4a57e7bb1..53de5174f 100644 --- a/packages/app-extension/src/components/Unlocked/Messages/SearchUsers.tsx +++ b/packages/app-extension/src/components/Unlocked/Messages/SearchUsers.tsx @@ -1,7 +1,12 @@ import { useState } from "react"; import type { EnrichedInboxDb, RemoteUserData } from "@coral-xyz/common"; import { UserList } from "@coral-xyz/message-sdk"; -import { ContactsIcon, EmptyState, TextInput } from "@coral-xyz/react-common"; +import { + BubbleTopLabel, + ContactsIcon, + EmptyState, + TextInput, +} from "@coral-xyz/react-common"; import { useCustomTheme } from "@coral-xyz/themes"; import SearchIcon from "@mui/icons-material/Search"; import { Typography } from "@mui/material"; @@ -38,7 +43,7 @@ export const SearchUsers = ({
} @@ -55,54 +60,50 @@ export const SearchUsers = ({ /> {filteredFriends.length > 0 ? (
-
- - Your contacts - - {requests.received.length > 0 && ( +
+ + {requests.received.length > 0 ? ( - )} + ) : null} +
+
+
-
) : ( <> - {requests.received.length > 0 && ( + {requests.received.length > 0 ? (
-
- )} + ) : null} ( )} title={ searchFilter === "" - ? "No contacts" + ? "No friends" : `No results for '${searchFilter}'` } - subtitle={searchFilter === "" ? "Search for people to add." : ""} + subtitle={ + searchFilter === "" + ? "Request users to become friends in the messaging tab" + : "" + } + style={{ paddingLeft: 0, paddingRight: 0, marginTop: "24px" }} /> )} - {/*
-
Requests
- */}
); }; @@ -115,23 +116,32 @@ const RequestHeader = ({ const theme = useCustomTheme(); const nav = useNavigation(); return ( - - nav.push("contact-requests", { - description: ( - <> - These people wanted to add you as a contact. -
Click someone to view their profile. - - ), - requests, - }) - } +
- Requests ({requests.received.length}) - + + nav.push("contact-requests", { + description: ( + <> + These people wanted to add you as a friend. +
Click someone to view their profile. + + ), + requests, + }) + } + > + Request{requests.received.length > 1 ? "s" : ""} ( + {requests.received.length}) + +
); }; diff --git a/packages/app-extension/src/components/Unlocked/Nfts/Cards.tsx b/packages/app-extension/src/components/Unlocked/Nfts/Cards.tsx new file mode 100644 index 000000000..b69a49421 --- /dev/null +++ b/packages/app-extension/src/components/Unlocked/Nfts/Cards.tsx @@ -0,0 +1,506 @@ +import type { MouseEvent } from "react"; +import { useState } from "react"; +import type { Nft, NftCollection } from "@coral-xyz/common"; +import { + NAV_COMPONENT_MESSAGE_GROUP_CHAT, + NAV_COMPONENT_NFT_CHAT, + NAV_COMPONENT_NFT_COLLECTION, + NAV_COMPONENT_NFT_DETAIL, + TAB_MESSAGES, + UI_RPC_METHOD_NAVIGATION_ACTIVE_TAB_UPDATE, + UNKNOWN_NFT_ICON_SRC, +} from "@coral-xyz/common"; +import { + AppsColorIcon, + MessageBubbleUnreadIcon, + ProxyImage, +} from "@coral-xyz/react-common"; +import { + chatByCollectionId, + chatByNftId, + collectibleXnft, + nftsByIds, + useActiveWallet, + useBackgroundClient, + useBlockchainConnectionUrl, + useNavigation, + useOpenPlugin, +} from "@coral-xyz/recoil"; +import { HOVER_OPACITY, styles, useCustomTheme } from "@coral-xyz/themes"; +import { Sms } from "@mui/icons-material"; +import RocketLaunchIcon from "@mui/icons-material/RocketLaunch"; +import { + Button, + CircularProgress, + IconButton, + Typography, +} from "@mui/material"; +import { useRecoilValue, useRecoilValueLoadable } from "recoil"; + +import { useOpenChat } from "./Detail"; +const useStyles = styles((theme) => ({ + button: { + "&:hover": { + opacity: HOVER_OPACITY, + }, + }, +})); + +export function NFTCard({ + nft, + subtitle, + showCollectionChat, +}: { + nft: Nft; + subtitle?: { + length: number; + name: string; + }; + showCollectionChat?: boolean; +}) { + const activeWallet = useActiveWallet(); + const connectionUrl = useBlockchainConnectionUrl(activeWallet.blockchain); + const classes = useStyles(); + const theme = useCustomTheme(); + const { push } = useNavigation(); + const openPlugin = useOpenPlugin(); + const whitelistedNftChat = useRecoilValue( + chatByNftId({ + publicKey: activeWallet.publicKey, + nftId: nft.id, + connectionUrl, + }) + ); + const whitelistedCollectionChat = useRecoilValue( + chatByCollectionId(nft.metadataCollectionId) + ); + const openChat = useOpenChat(); + const [joiningChat, setJoiningChat] = useState(false); + + const { contents, state } = useRecoilValueLoadable( + collectibleXnft( + nft ? { collection: nft.metadataCollectionId, mint: nft.mint } : null + ) + ); + + if (!nft) { + return null; + } + + const chat = + whitelistedNftChat ?? showCollectionChat ? whitelistedCollectionChat : null; + + const xnft = (state === "hasValue" && contents) || null; + + const onOpenXnft = (e: MouseEvent) => { + e.stopPropagation(); + if (xnft) { + openPlugin(xnft + "/" + nft.mint); + } + }; + + const openDetails = () => { + push({ + title: subtitle?.name ?? nft.name, + componentId: NAV_COMPONENT_NFT_DETAIL, + componentProps: { + nftId: nft.id, + publicKey: activeWallet.publicKey, + connectionUrl, + }, + }); + }; + + return ( +
+ +
+ +
+ {subtitle?.name ?? nft.name} +
+ {subtitle?.length ?? 0 > 1 ? ( + + {subtitle?.length ?? ""} + + ) : null} + + {chat && nft.mint ? ( +
{ + setJoiningChat(true); + await openChat(chat, nft.mint!); + setJoiningChat(false); + e.stopPropagation(); + }} + > + {joiningChat ? ( + + ) : ( + + )} +
+ ) : null} +
+
+ ); +} + +export function CollectionCard({ collection }: { collection: NftCollection }) { + const activeWallet = useActiveWallet(); + const connectionUrl = useBlockchainConnectionUrl(activeWallet.blockchain); + const classes = useStyles(); + const { push } = useNavigation(); + const whitelistedChatCollection = useRecoilValue( + chatByCollectionId(collection.metadataCollectionId) + ); + const theme = useCustomTheme(); + const openChat = useOpenChat(); + const [joiningChat, setJoiningChat] = useState(false); + const collectionDisplayNftIds: { + publicKey: string; + nftId: string; + }[] = collection.itemIds.map((nftId) => ({ + publicKey: activeWallet.publicKey, + nftId, + })); + + collectionDisplayNftIds.length = Math.min(collectionDisplayNftIds.length, 4); + + const collectionDisplayNfts = useRecoilValue( + nftsByIds({ + nftIds: collectionDisplayNftIds, + blockchain: activeWallet.blockchain, + }) + ); + + const paddedCollectionDisplayNfts = [ + ...collectionDisplayNfts, + null, + null, + null, + null, + ]; + paddedCollectionDisplayNfts.length = 4; + + if (!collectionDisplayNfts) { + return null; + } + + const nft = collectionDisplayNfts[0]; + + const openCollection = () => { + push({ + title: nft.collectionName, + componentId: NAV_COMPONENT_NFT_COLLECTION, + componentProps: { + id: collection.id, + publicKey: activeWallet.publicKey, + connectionUrl, + }, + }); + }; + + return ( +
+ +
+ +
+ {nft.collectionName} +
+ {collection.itemIds.length > 0 ? ( + + {collection.itemIds.length} + + ) : null} + + {whitelistedChatCollection ? ( +
{ + setJoiningChat(true); + await openChat(whitelistedChatCollection, nft.mint!); + setJoiningChat(false); + e.stopPropagation(); + }} + > + {joiningChat ? ( + + ) : ( + + )} +
+ ) : null} +
+
+ ); +} diff --git a/packages/app-extension/src/components/Unlocked/Nfts/Collection.tsx b/packages/app-extension/src/components/Unlocked/Nfts/Collection.tsx index f2e26197f..ecb7bf99e 100644 --- a/packages/app-extension/src/components/Unlocked/Nfts/Collection.tsx +++ b/packages/app-extension/src/components/Unlocked/Nfts/Collection.tsx @@ -1,14 +1,19 @@ +import { useState } from "react"; import { NAV_COMPONENT_NFT_DETAIL } from "@coral-xyz/common"; import { + chatByCollectionId, nftById, nftCollectionsWithIds, useNavigation, } from "@coral-xyz/recoil"; -import { Grid } from "@mui/material"; +import { useCustomTheme } from "@coral-xyz/themes"; +import { Sms } from "@mui/icons-material"; +import { CircularProgress, Grid, Typography } from "@mui/material"; import type { UnwrapRecoilValue } from "recoil"; -import { useRecoilValueLoadable } from "recoil"; +import { useRecoilValue, useRecoilValueLoadable } from "recoil"; -import { GridCard } from "./Common"; +import { NFTCard } from "./Cards"; +import { useOpenChat } from "./Detail"; export function NftsCollection({ publicKey, @@ -40,6 +45,9 @@ function _Grid({ connectionUrl: string; id: string; }) { + const theme = useCustomTheme(); + const openChat = useOpenChat(); + const [joiningChat, setJoiningChat] = useState(false); const { contents, state } = useRecoilValueLoadable< UnwrapRecoilValue >(nftCollectionsWithIds); @@ -51,6 +59,12 @@ function _Grid({ .flat() .find((c: any) => c.id === id); + const whitelistedCollectionChat = useRecoilValueLoadable( + chatByCollectionId(collection?.metadataCollectionId) + ); + + const chat = whitelistedCollectionChat.contents; + // Hack: id can be undefined due to framer-motion animation, and // collection can be undefined when looking at a collection not in current // wallet. @@ -58,18 +72,90 @@ function _Grid({ return null; } + const countText = + chat?.memberCount >= 1000 + ? `${(chat?.memberCount / 1000).toFixed(1)}k` + : chat?.memberCount ?? "0"; + return ( - - {collection.itemIds.map((collectionId: string) => ( - - - - ))} - + <> + {chat ? ( + { + setJoiningChat(true); + await openChat(chat, collection.itemIds[0]); + setJoiningChat(false); + e.stopPropagation(); + }} + > +
+ {joiningChat ? ( + // eslint-disable-next-line react/jsx-no-undef + + ) : ( + + )} +
+
+ {`${chat.name} ⸱ ${countText} members`} +
+
+ Join +
+ + ) : null} + + {collection.itemIds.map((nftId: string) => ( + + + + ))} + + ); } @@ -90,18 +176,8 @@ function NftCard({ }) ); const nft = (state === "hasValue" && contents) || null; - - const { push } = useNavigation(); - const onClick = () => { - push({ - title: nft?.name || "", - componentId: NAV_COMPONENT_NFT_DETAIL, - componentProps: { - nftId, - publicKey, - connectionUrl, - }, - }); - }; - return ; + if (!nft) { + return null; + } + return ; } diff --git a/packages/app-extension/src/components/Unlocked/Nfts/Common.tsx b/packages/app-extension/src/components/Unlocked/Nfts/Common.tsx deleted file mode 100644 index f1f3922f5..000000000 --- a/packages/app-extension/src/components/Unlocked/Nfts/Common.tsx +++ /dev/null @@ -1,205 +0,0 @@ -import type { MouseEvent } from "react"; -import { UNKNOWN_NFT_ICON_SRC } from "@coral-xyz/common"; -import { NAV_COMPONENT_NFT_CHAT } from "@coral-xyz/common/dist/esm/constants"; -import { MessageBubbleUnreadIcon, ProxyImage } from "@coral-xyz/react-common"; -import { - collectibleXnft, - useNavigation, - useOpenPlugin, -} from "@coral-xyz/recoil"; -import { HOVER_OPACITY, styles, useCustomTheme } from "@coral-xyz/themes"; -import CircleIcon from "@mui/icons-material/Circle"; -import RocketLaunchIcon from "@mui/icons-material/RocketLaunch"; -import { Button, IconButton, Typography } from "@mui/material"; -import { useRecoilValueLoadable } from "recoil"; - -const useStyles = styles(() => ({ - button: { - "&:hover": { - opacity: HOVER_OPACITY, - }, - }, -})); - -export function GridCard({ - onClick, - nft, - subtitle, - metadataCollectionId, - showNotificationBubble, -}: any) { - const classes = useStyles(); - const theme = useCustomTheme(); - const { push } = useNavigation(); - const openPlugin = useOpenPlugin(); - - const { contents, state } = subtitle - ? useRecoilValueLoadable( - collectibleXnft( - nft ? { collection: nft.metadataCollectionId, mint: nft.mint } : null - ) - ) - : { contents: undefined, state: "hasValue" }; - - const xnft = (state === "hasValue" && contents) || null; - - const onClickAction = (e: MouseEvent) => { - e.stopPropagation(); - if (xnft) { - openPlugin(xnft); - } - }; - - if (!nft) { - return null; - } - - return ( - <> - - - ); -} diff --git a/packages/app-extension/src/components/Unlocked/Nfts/Detail.tsx b/packages/app-extension/src/components/Unlocked/Nfts/Detail.tsx index 97a94171b..5290676c4 100644 --- a/packages/app-extension/src/components/Unlocked/Nfts/Detail.tsx +++ b/packages/app-extension/src/components/Unlocked/Nfts/Detail.tsx @@ -1,4 +1,5 @@ import { type CSSProperties, useEffect, useState } from "react"; +import type { Nft } from "@coral-xyz/common"; import { AVATAR_BASE_URL, BACKEND_API_URL, @@ -6,13 +7,15 @@ import { confirmTransaction, explorerNftUrl, getLogger, + isMadLads, + NAV_COMPONENT_MESSAGE_GROUP_CHAT, Solana, TAB_MESSAGES, toTitleCase, UI_RPC_METHOD_NAVIGATION_ACTIVE_TAB_UPDATE, UI_RPC_METHOD_NAVIGATION_TO_ROOT, - WHITELISTED_CHAT_COLLECTIONS, } from "@coral-xyz/common"; +import { LocalImageManager, refreshGroups } from "@coral-xyz/db"; import { NegativeButton, PrimaryButton, @@ -22,14 +25,17 @@ import { } from "@coral-xyz/react-common"; import { appStoreMetaTags, + chatByNftId, collectibleXnft, newAvatarAtom, nftById, + useActiveWallet, useAnchorContext, useBackgroundClient, useDecodedSearchParams, useEthereumCtx, useEthereumExplorer, + useNavigation, useOpenPlugin, useSolanaCtx, useSolanaExplorer, @@ -41,7 +47,11 @@ import MoreHorizIcon from "@mui/icons-material/MoreHoriz"; import { Button, IconButton, Typography } from "@mui/material"; import { PublicKey } from "@solana/web3.js"; import { BigNumber } from "ethers"; -import { useRecoilValueLoadable, useSetRecoilState } from "recoil"; +import { + useRecoilValue, + useRecoilValueLoadable, + useSetRecoilState, +} from "recoil"; import { ApproveTransactionDrawer } from "../../common/ApproveTransactionDrawer"; import { @@ -64,6 +74,45 @@ import { SendSolanaConfirmationCard } from "../Balances/TokensWidget/Solana"; const logger = getLogger("app-extension/nft-detail"); +export function useOpenChat() { + const { uuid } = useUser(); + const activeWallet = useActiveWallet(); + const background = useBackgroundClient(); + const { push } = useNavigation(); + + return async (whitelistedChatCollection: any, mint: string) => { + await fetch(`${BACKEND_API_URL}/nft/bulk`, { + method: "POST", + headers: { "Content-Type": "application/json" }, + body: JSON.stringify({ + publicKey: activeWallet.publicKey, + nfts: [ + { + collectionId: whitelistedChatCollection?.collectionId, + nftId: mint, + centralizedGroup: whitelistedChatCollection?.id, + }, + ], + }), + }); + await refreshGroups(uuid); + + await background.request({ + method: UI_RPC_METHOD_NAVIGATION_ACTIVE_TAB_UPDATE, + params: [TAB_MESSAGES], + }); + push({ + title: whitelistedChatCollection?.name, + componentId: NAV_COMPONENT_MESSAGE_GROUP_CHAT, + componentProps: { + fromInbox: true, + id: whitelistedChatCollection?.id, + title: whitelistedChatCollection?.name, + }, + }); + }; +} + export function NftsDetail({ publicKey, connectionUrl, @@ -74,7 +123,11 @@ export function NftsDetail({ nftId: string; }) { const theme = useCustomTheme(); - const background = useBackgroundClient(); + const whitelistedChatCollection = useRecoilValue( + chatByNftId({ publicKey, connectionUrl, nftId }) + ); + const openChat = useOpenChat(); + const { contents, state } = useRecoilValueLoadable( nftById({ publicKey, connectionUrl, nftId }) ); @@ -85,30 +138,10 @@ export function NftsDetail({ ) ); const xnft = (xnftState === "hasValue" && xnftContents) || null; - //@ts-ignore - const whitelistedChatCollection = WHITELISTED_CHAT_COLLECTIONS.find( - (x) => x.collectionId === nft?.metadataCollectionId - ); const [chatJoined, setChatJoined] = useState(false); const [joiningChat, setJoiningChat] = useState(false); - let whitelistedChatCollectionId = whitelistedChatCollection?.collectionId; - - if (whitelistedChatCollection) { - Object.keys(whitelistedChatCollection.attributeMapping || {}).forEach( - (attrName) => { - if ( - !nft?.attributes?.find( - (x) => - x.traitType === attrName && - x.value === - whitelistedChatCollection?.attributeMapping?.[attrName] - ) - ) { - whitelistedChatCollectionId = ""; - } - } - ); - } + + const whitelistedChatCollectionId = whitelistedChatCollection?.collectionId; // Hack: needed because this is undefined due to framer-motion animation. if (!nftId) { @@ -141,7 +174,7 @@ export function NftsDetail({ marginTop: "16px", }} > - {whitelistedChatCollectionId && ( + {whitelistedChatCollectionId ? ( { setJoiningChat(true); - await fetch(`${BACKEND_API_URL}/nft/bulk`, { - method: "POST", - headers: { "Content-Type": "application/json" }, - body: JSON.stringify({ - publicKey: publicKey, - nfts: [ - { - collectionId: whitelistedChatCollection?.collectionId, - nftId: nft?.mint, - centralizedGroup: whitelistedChatCollection?.id, - }, - ], - }), - }); - setJoiningChat(false); - background.request({ - method: UI_RPC_METHOD_NAVIGATION_ACTIVE_TAB_UPDATE, - params: [TAB_MESSAGES], - }); + await openChat(whitelistedChatCollection, nft.mint!); setChatJoined(true); }} /> - )} + ) : null}
- {xnft && } + {xnft ? : null} - {nft.attributes && nft.attributes.length > 0 && } + {nft.attributes && nft.attributes.length > 0 ? ( + + ) : null}
); } function Image({ nft }: { nft: any }) { + const src = isMadLads(nft) ? nft.lockScreenImageUrl : nft.imageUrl; return (
); } -function ApplicationButton({ xnft }: { xnft: string }) { +function ApplicationButton({ + xnft, + mintAddress, +}: { + xnft: string; + mintAddress?: string; +}) { const theme = useCustomTheme(); const openPlugin = useOpenPlugin(); const { contents, state } = useRecoilValueLoadable(appStoreMetaTags(xnft)); @@ -225,7 +250,7 @@ function ApplicationButton({ xnft }: { xnft: string }) { const data = (state === "hasValue" && contents) || null; const handleClick = () => { - openPlugin(xnft); + openPlugin(xnft + "/" + mintAddress); }; return ( @@ -332,14 +357,27 @@ function Description({ nft }: { nft: any }) { ); } -function SendButton({ nft, style }: { nft: any; style?: CSSProperties }) { +function SendButton({ + invert, + nft, + style, +}: { + invert: boolean; + nft: any; + style?: CSSProperties; +}) { const [openDrawer, setOpenDrawer] = useState(false); const send = () => { setOpenDrawer(true); }; return ( <> - send()} label={"Send"} /> + send()} + label="Send" + />
setOpenDrawer(false)} />} > } /> @@ -432,12 +470,12 @@ function SendScreen({ nft }: { nft: any }) { marginRight: "8px", }} onClick={close} - label={"Cancel"} + label="Cancel" /> setOpenConfirm(true)} - label={"Next"} + label="Next" />
@@ -446,7 +484,7 @@ function SendScreen({ nft }: { nft: any }) { openDrawer={openConfirm} setOpenDrawer={setOpenConfirm} > - {nft.blockchain === Blockchain.SOLANA && ( + {nft.blockchain === Blockchain.SOLANA ? ( setWasSent(true)} /> - )} - {nft.blockchain === Blockchain.ETHEREUM && ( + ) : null} + {nft.blockchain === Blockchain.ETHEREUM ? ( setWasSent(true)} /> - )} + ) : null} ); @@ -550,7 +588,7 @@ function Attributes({ nft }: { nft: any }) { export function NftOptionsButton() { const theme = useCustomTheme(); const background = useBackgroundClient(); - const { username } = useUser(); + const { uuid, username } = useUser(); const setNewAvatar = useSetRecoilState(newAvatarAtom(username)); const [anchorEl, setAnchorEl] = useState(null); const [openDrawer, setOpenDrawer] = useState(false); @@ -586,7 +624,9 @@ export function NftOptionsButton() { // @ts-ignore const isEthereum: boolean = nft && nft.contractAddress; - const explorer = isEthereum ? useEthereumExplorer() : useSolanaExplorer(); + const ethExpl = useEthereumExplorer(); + const solExpl = useSolanaExplorer(); + const explorer = isEthereum ? ethExpl : solExpl; const onClick = (event: React.MouseEvent) => { setAnchorEl(event.currentTarget); @@ -603,6 +643,14 @@ export function NftOptionsButton() { const onSetPfp = async () => { if (nft) { + // + // Cleanup component state. + // + setAnchorEl(null); + + // + // Store on server. + // const id = `${nft.blockchain}/${ nft.blockchain === "solana" ? nft.mint : nft.id }`; @@ -615,6 +663,11 @@ export function NftOptionsButton() { body: JSON.stringify({ avatar: id }), }); await fetch(`${AVATAR_BASE_URL}/${username}?bust_cache=1`); + + // + // Store locally. + // + await updateLocalNftPfp(uuid, username, nft); setNewAvatar({ id, url: nft.imageUrl }); } }; @@ -701,13 +754,14 @@ function BurnConfirmationCard({ ) ).value.amount ); + setState("sending"); + const _signature = await Solana.burnAndCloseNft(solanaCtx, { solDestination: solanaCtx.walletPublicKey, mint: new PublicKey(nft.mint.toString()), amount, }); setSignature(_signature); - setState("sending"); // // Confirm the tx. @@ -744,16 +798,16 @@ function BurnConfirmationCard({ amount={BigNumber.from(1)} token={token} signature={signature!} - titleOverride={"Burning"} + titleOverride="Burning" /> ) : state === "confirmed" ? ( ) : ( void }) {
); } + +export async function updateLocalNftPfp( + uuid: string, + username: string, + nft: Nft +) { + // + // Only show mad lads on the lock screen in full screen view. + // + let lockScreenImageUrl; + if (isMadLads(nft)) { + window.localStorage.setItem( + lockScreenKey(uuid), + JSON.stringify({ + uuid, + nft, + }) + ); + lockScreenImageUrl = nft.lockScreenImageUrl!; + } else { + window.localStorage.removeItem(lockScreenKey(uuid)); + lockScreenImageUrl = nft.imageUrl; + } + await LocalImageManager.getInstance().storeImageInLocalStorage( + lockScreenKeyImage(username), + true, + lockScreenImageUrl + ); +} + +export function lockScreenKey(uuid: string) { + return `${uuid}:lock-screen-nft:1`; +} + +export function lockScreenKeyImage(username: string) { + return `https://swr.xnfts.dev/avatars/${username}`; +} diff --git a/packages/app-extension/src/components/Unlocked/Nfts/EntryONE.tsx b/packages/app-extension/src/components/Unlocked/Nfts/EntryONE.tsx index 749ed3e42..ccd32f145 100644 --- a/packages/app-extension/src/components/Unlocked/Nfts/EntryONE.tsx +++ b/packages/app-extension/src/components/Unlocked/Nfts/EntryONE.tsx @@ -1,10 +1,13 @@ import { useLayoutEffect, useRef, useState } from "react"; import { isOneLive, useOpenPlugin } from "@coral-xyz/recoil"; import { styles } from "@coral-xyz/themes"; +import { CollectionsTwoTone } from "@mui/icons-material"; import { Skeleton } from "@mui/material"; import Card from "@mui/material/Card"; import { useRecoilValue } from "recoil"; +import type { AllWalletCollections } from "./NftTable"; + const useStyles = styles((theme) => ({ blockchainCard: { position: "relative", @@ -21,6 +24,7 @@ const useStyles = styles((theme) => ({ }, }, imageBackground: { + zIndex: 2, position: "relative", height: "100%", display: "flex", @@ -30,7 +34,8 @@ const useStyles = styles((theme) => ({ backgroundColor: "#000", }, image: { - zIndex: "1", + zIndex: 1, + position: "relative", height: "117px", width: "547px", backgroundSize: "547px 234px", @@ -57,16 +62,22 @@ const useStyles = styles((theme) => ({ display: "none", }, visuallyHidden: { + zIndex: -1, + pointerEvents: "none", visibility: "hidden", position: "absolute", - top: "0px", + top: "1000px", }, })); -export default function EntryONE() { +export default function EntryONE({ + allWalletCollections, +}: { + allWalletCollections: AllWalletCollections | null; +}) { const [imageLoaded, setImageLoaded] = useState(false); const ref = useRef(null); - const isONELive = useRecoilValue(isOneLive); + const oneLive = useRecoilValue(isOneLive); const classes = useStyles(); const openPlugin = useOpenPlugin(); @@ -90,8 +101,20 @@ export default function EntryONE() { const isLoading = false || !imageLoaded; + const hasNft = !!allWalletCollections?.find((wallet) => { + return !!wallet.collections?.find((collection) => { + return ( + collection.metadataCollectionId === oneLive.madCollection && + collection.itemIds.length > 0 + ); + }); + }); + + const banner = + hasNft && oneLive.byeBanner ? oneLive.byeBanner : oneLive.banner; + const openXNFT = () => { - if (isONELive.isLive) { + if (oneLive.isLive) { openPlugin("CkqWjTWzRMAtYN3CSs8Gp4K9H891htmaN1ysNXqcULc8"); } }; @@ -100,7 +123,7 @@ export default function EntryONE() { + />
- + ); } diff --git a/packages/app-extension/src/components/Unlocked/Nfts/Experience.tsx b/packages/app-extension/src/components/Unlocked/Nfts/Experience.tsx index a3b68303c..718f65681 100644 --- a/packages/app-extension/src/components/Unlocked/Nfts/Experience.tsx +++ b/packages/app-extension/src/components/Unlocked/Nfts/Experience.tsx @@ -53,7 +53,7 @@ export function NftChat({ collectionId, nftMint }: any) { return (
diff --git a/packages/app-extension/src/components/Unlocked/Nfts/NftTable.tsx b/packages/app-extension/src/components/Unlocked/Nfts/NftTable.tsx index aa1b509a8..fca6d5212 100644 --- a/packages/app-extension/src/components/Unlocked/Nfts/NftTable.tsx +++ b/packages/app-extension/src/components/Unlocked/Nfts/NftTable.tsx @@ -1,13 +1,8 @@ -import { Suspense, useCallback, useEffect, useRef, useState } from "react"; +import { Suspense, useCallback, useRef, useState } from "react"; import Autosizer from "react-virtualized-auto-sizer"; import { VariableSizeList } from "react-window"; -import type { - Blockchain, - CollectionChatData, - NftCollection, -} from "@coral-xyz/common"; +import type { Blockchain, NftCollection } from "@coral-xyz/common"; import { - BACKEND_API_URL, NAV_COMPONENT_NFT_COLLECTION, NAV_COMPONENT_NFT_DETAIL, } from "@coral-xyz/common"; @@ -16,10 +11,10 @@ import { nftById, useAllWallets, useBlockchainConnectionUrl, - useGroupCollections, useNavigation, useUser, } from "@coral-xyz/recoil"; +import type { CustomTheme } from "@coral-xyz/themes"; import { styled } from "@coral-xyz/themes"; import { Skeleton } from "@mui/material"; import { useRecoilValue } from "recoil"; @@ -27,9 +22,9 @@ import { useRecoilValue } from "recoil"; import { Scrollbar } from "../../common/Layout/Scrollbar"; import { _BalancesTableHead } from "../Balances/Balances"; -import { GridCard } from "./Common"; +import { CollectionCard, NFTCard } from "./Cards"; -type AllWalletCollections = Array<{ +export type AllWalletCollections = Array<{ publicKey: string; collections: null | Array; }>; @@ -165,23 +160,21 @@ const HeaderRow = function HeaderRow({ const wallet = wallets.find((wallet) => wallet.publicKey === c.publicKey); const blockchain = wallet?.blockchain; return ( - <> - - <_BalancesTableHead - blockchain={blockchain as Blockchain} - wallet={wallet!} - showContent={!isCollapsed} - setShowContent={(isCollapsed) => { - collapseSingleCollection(listIndex, blockchainIndex, !isCollapsed); - }} - /> - - + + <_BalancesTableHead + blockchain={blockchain as Blockchain} + wallet={wallet!} + showContent={!isCollapsed} + setShowContent={(isCollapsed) => { + collapseSingleCollection(listIndex, blockchainIndex, !isCollapsed); + }} + /> + ); }; const FooterRow = function () { - return ; + return ; }; const LoadingRow = function ({ itemsPerRow }: { itemsPerRow: number }) { @@ -192,7 +185,7 @@ const LoadingRow = function ({ itemsPerRow }: { itemsPerRow: number }) {
- {collection && ( + {collection ? ( }> - )} + ) : null}
); })} @@ -295,7 +288,7 @@ const ItemRow = function ({ }; const CustomCard = styled("div")( - ({ theme }) => + ({ theme }: { theme: CustomTheme }) => ({ top, bottom }: { top: boolean; bottom: boolean }) => ({ position: "relative", backgroundColor: "inherit", @@ -349,44 +342,18 @@ function NftCollectionCard({ return null; } - const onClick = () => { - if (collection.itemIds.length === 1) { - if (!collectionDisplayNft.name || !collectionDisplayNft.id) { - throw new Error("invalid NFT data"); - } - // If there is only one item in the collection, link straight to its detail page - push({ - title: collectionDisplayNft.name || "", - componentId: NAV_COMPONENT_NFT_DETAIL, - componentProps: { - nftId: collectionDisplayNft.id, - publicKey, - connectionUrl, - }, - }); - } else { - // Multiple items in connection, display a grid - push({ - title: collectionDisplayNft.collectionName, - componentId: NAV_COMPONENT_NFT_COLLECTION, - componentProps: { - id: collection.id, - publicKey, - connectionUrl, - }, - }); - } - }; + if (collection.itemIds.length > 1) { + return ; + } return ( - ); } @@ -490,14 +457,14 @@ const getItemForIndex = ( if (!collectionItems) { return { - height: 165.5, + height: 165.5 + 26, key: `loading${blockchainIndex}${itemsPerRow}`, component: , }; } return { - height: 165.5, + height: 165.5 + 26, key: `items${blockchainIndex}${startIndex}${itemsPerRow}`, component: ( }] + oneLive.isLive + ? [ + { + height: 129, + key: "oneEntry", + component: ( + + ), + }, + ] : [] } blockchainCollections={ @@ -38,7 +46,7 @@ export function Nfts() { } /> ); - }, [isONELive, allWalletCollections]); + }, [oneLive, allWalletCollections]); const nftCount = allWalletCollections ? allWalletCollections @@ -55,30 +63,33 @@ export function Nfts() { display: "flex", flexDirection: "column", height: "100%", + zIndex: 0, }} > {isEmpty ? ( <> - {isONELive.isLive && } + {oneLive.isLive ? ( + + ) : null} } - title={"No NFTs"} - subtitle={"Get started with your first NFT"} - buttonText={"Browse Magic Eden"} + title="No NFTs" + subtitle="Get started with your first NFT" + buttonText="Browse Magic Eden" onClick={() => window.open("https://magiceden.io")} - verticallyCentered={!isONELive} + verticallyCentered={!oneLive} header={ - !_isAggregateWallets && ( + !_isAggregateWallets ? ( <_BalancesTableHead blockchain={activeWallet.blockchain} wallet={activeWallet} - showContent={true} + showContent setShowContent={() => {}} /> - ) + ) : null } style={{ - height: !isONELive.isLive ? "100%" : undefined, + height: !oneLive.isLive ? "100%" : undefined, }} /> diff --git a/packages/app-extension/src/components/Unlocked/PrimaryPubkeySelector.tsx b/packages/app-extension/src/components/Unlocked/PrimaryPubkeySelector.tsx index 005a2f40f..106445670 100644 --- a/packages/app-extension/src/components/Unlocked/PrimaryPubkeySelector.tsx +++ b/packages/app-extension/src/components/Unlocked/PrimaryPubkeySelector.tsx @@ -32,6 +32,7 @@ export const PrimaryPubkeySelector = () => { [Blockchain.SOLANA]: "", }); const setServerPublicKeys = useSetRecoilState(serverPublicKeys); + const [migrationDone, setMigrationDone] = useState(false); blockchains.forEach((blockchain) => { const allBlockchainWallets = wallets.filter( @@ -48,7 +49,7 @@ export const PrimaryPubkeySelector = () => { }); if (!gates["PRIMARY_PUBKEY_ENABLED"]) { - return <>; + return null; } return ( @@ -58,7 +59,7 @@ export const PrimaryPubkeySelector = () => { borderTopRightRadius: "12px", height: "80%", }} - openDrawer={needsMigration.length > 0} + openDrawer={needsMigration.length > 0 ? !migrationDone : false} setOpenDrawer={() => {}} >
{ } onClick={() => { needsMigration.forEach(async (blockchain) => { - await fetch(`${BACKEND_API_URL}/users/activePubkey`, { + fetch(`${BACKEND_API_URL}/users/activePubkey`, { method: "POST", body: JSON.stringify({ publicKey: selectedAddresses[blockchain], @@ -144,6 +145,7 @@ export const PrimaryPubkeySelector = () => { }) ); }); + setMigrationDone(true); }} /> diff --git a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ConnectHardware/ConnectHardwareSearching.tsx b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ConnectHardware/ConnectHardwareSearching.tsx index 0dd9de763..5b92d6d4c 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ConnectHardware/ConnectHardwareSearching.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ConnectHardware/ConnectHardwareSearching.tsx @@ -124,7 +124,7 @@ export function ConnectHardwareSearching({ This is just a placeholder next button so its always disabled. Screen will auto advance when transport is set. */} - + ); diff --git a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportMenu.tsx b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportMenu.tsx index b99fb240a..2dae10a54 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportMenu.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportMenu.tsx @@ -5,6 +5,7 @@ import { UI_RPC_METHOD_BLOCKCHAIN_KEYRINGS_READ, } from "@coral-xyz/common"; import { + BackpackMnemonicIcon, HardwareIcon, MnemonicIcon, PushDetail, @@ -54,21 +55,21 @@ export function ImportMenu({ blockchain }: { blockchain: Blockchain }) { const importMenu = { ...(allowOwnPhrase ? { - "My secret recovery phrase": { + "Backpack recovery phrase": { onClick: () => navigation.push("import-from-mnemonic", { blockchain, keyringExists, inputMnemonic: false, }), - icon: (props: any) => , + icon: (props: any) => , detailIcon: , }, } : {}), ...(allowOtherPhrase ? { - "Other secret recovery phrase": { + "Other recovery phrase": { onClick: () => navigation.push("import-from-mnemonic", { blockchain, diff --git a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportMnemonic.tsx b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportMnemonic.tsx index e4bdb6f76..937b79dca 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportMnemonic.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportMnemonic.tsx @@ -12,11 +12,13 @@ import { UI_RPC_METHOD_KEYRING_IMPORT_WALLET, } from "@coral-xyz/common"; import { PrimaryButton, TextInput } from "@coral-xyz/react-common"; -import { useBackgroundClient } from "@coral-xyz/recoil"; +import { + useBackgroundClient, + useSignMessageForWallet, +} from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; import { Box } from "@mui/material"; -import { useSignMessageForWallet } from "../../../../hooks/useSignMessageForWallet"; import { useSteps } from "../../../../hooks/useSteps"; import { Header } from "../../../common"; import { ImportWallets } from "../../../common/Account/ImportWallets"; @@ -98,17 +100,17 @@ export function ImportMnemonic({ // Show the seed phrase if we are creating based on a mnemonic ...(inputMnemonic ? [ - { + { setMnemonic(mnemonic); nextStep(); }} />, // Must prompt for a name if using an input mnemonic, because we can't // easily generate one - { + { setName(name); nextStep(); }} @@ -177,7 +179,7 @@ export function InputName({ onNext }: { onNext: (name: string) => void }) { setName(e.target.value)} diff --git a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportSecretKey.tsx b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportSecretKey.tsx index e3d209cdb..501bdfda8 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportSecretKey.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/AddConnectWallet/ImportSecretKey.tsx @@ -125,7 +125,7 @@ export function ImportSecretKey({ setName(e.target.value)} @@ -164,7 +164,16 @@ export function ImportSecretKey({ /> - + This connection will be public, so if you'd prefer to create a - separate wallet, create a new account. + separate identity, create a new account.
nav.push("edit-wallets-blockchain-selector")} /> { onClose(); }} diff --git a/packages/app-extension/src/components/Unlocked/Settings/AvatarHeader/AvatarHeader.tsx b/packages/app-extension/src/components/Unlocked/Settings/AvatarHeader/AvatarHeader.tsx index bdf44b97a..7e2bbd6af 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/AvatarHeader/AvatarHeader.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/AvatarHeader/AvatarHeader.tsx @@ -1,8 +1,10 @@ import { useState } from "react"; import { ProxyImage } from "@coral-xyz/react-common"; -import { useAvatarUrl } from "@coral-xyz/recoil"; -import { styled } from "@coral-xyz/themes"; +import { useAvatarUrl, useUser } from "@coral-xyz/recoil"; +import type { CustomTheme } from "@coral-xyz/themes"; +import { styled, useCustomTheme } from "@coral-xyz/themes"; import { Edit } from "@mui/icons-material"; +import { Typography } from "@mui/material"; import { CloseButton, WithDrawer } from "../../../common/Layout/Drawer"; import { @@ -15,6 +17,8 @@ import { UpdateProfilePicture } from "./UpdateProfilePicture"; const title = "Change Profile Picture"; export function AvatarHeader() { + const user = useUser(); + const theme = useCustomTheme(); const [openDrawer, setOpenDrawer] = useState(false); const avatarUrl = useAvatarUrl(64); @@ -23,25 +27,34 @@ export function AvatarHeader() { }; return ( -
+
- + + + @{user.username} +
setOpenDrawer(false)} />} > ( )} @@ -68,13 +81,13 @@ export function AvatarHeader() { ); } -const AvatarWrapper = styled("div")(({ theme }) => ({ +const AvatarWrapper = styled("div")(({ theme }: { theme: CustomTheme }) => ({ position: "relative", background: theme.custom.colors.avatarIconBackground, borderRadius: "40px", padding: "3px", - width: "70px", - height: "70px", + width: "80px", + height: "80px", marginLeft: "auto", marginRight: "auto", overflow: "hidden", diff --git a/packages/app-extension/src/components/Unlocked/Settings/AvatarHeader/UpdateProfilePicture.tsx b/packages/app-extension/src/components/Unlocked/Settings/AvatarHeader/UpdateProfilePicture.tsx index 089b38459..2b23efbe4 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/AvatarHeader/UpdateProfilePicture.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/AvatarHeader/UpdateProfilePicture.tsx @@ -1,5 +1,5 @@ import React, { useEffect, useMemo, useState } from "react"; -import type { NftCollection } from "@coral-xyz/common"; +import type { Nft, NftCollection } from "@coral-xyz/common"; import { AVATAR_BASE_URL, BACKEND_API_URL, @@ -25,6 +25,7 @@ import { useSolanaConnectionUrl, useUser, } from "@coral-xyz/recoil"; +import type { CustomTheme } from "@coral-xyz/themes"; import { styled, useCustomTheme } from "@coral-xyz/themes"; import DeleteIcon from "@mui/icons-material/Delete"; import { CircularProgress, Grid, IconButton } from "@mui/material"; @@ -38,8 +39,10 @@ import { import { Scrollbar } from "../../../common/Layout/Scrollbar"; import { _BalancesTableHead } from "../../Balances/Balances"; +import { updateLocalNftPfp } from "../../Nfts/Detail"; type tempAvatar = { + nft?: Nft; url: string; id: string; }; @@ -53,7 +56,7 @@ export function UpdateProfilePicture({ const [loading, setLoading] = useState(false); const _isAggregateWallets = useRecoilValue(isAggregateWallets); const avatarUrl = useAvatarUrl(); - const { username } = useUser(); + const { uuid, username } = useUser(); const activeWallet = useActiveWallet(); const setNewAvatar = useSetRecoilState(newAvatarAtom(username)); const theme = useCustomTheme(); @@ -96,25 +99,23 @@ export function UpdateProfilePicture({ - {!isDefaultAvatar && ( - + onClick={() => setTempAvatar({ id: "", url: `https://avatars.xnfts.dev/v1/${username}`, }) } > - - - )} + + : null}
) : numberOfNFTs === 0 ? ( <> - {!_isAggregateWallets && ( -
- <_BalancesTableHead - blockchain={activeWallet.blockchain} - wallet={activeWallet} - showContent={true} - setShowContent={() => {}} + <_BalancesTableHead + blockchain={activeWallet.blockchain} + wallet={activeWallet} + showContent + setShowContent={() => {}} /> -
- )} +
: null} } - title={"No NFTs to use"} - subtitle={"Get started with your first NFT"} + title="No NFTs to use" + subtitle="Get started with your first NFT" onClick={() => window.open("https://magiceden.io/")} contentStyle={{ marginBottom: 0, @@ -165,7 +164,7 @@ export function UpdateProfilePicture({ innerStyle={{ border: "none", }} - buttonText={"Browse Magic Eden"} + buttonText="Browse Magic Eden" /> ) : ( @@ -201,7 +200,7 @@ export function UpdateProfilePicture({ }} > { setTempAvatar(null); }} @@ -222,6 +221,9 @@ export function UpdateProfilePicture({ } onClick={async () => { if (tempAvatar) { + if (!tempAvatar.nft) { + throw new Error("invariant violation"); + } setLoading(true); await fetch(BACKEND_API_URL + "/users/avatar", { headers: { @@ -233,6 +235,7 @@ export function UpdateProfilePicture({ }), }); await fetch(AVATAR_BASE_URL + "/" + username + "?bust_cache=1"); // bust edge cache + await updateLocalNftPfp(uuid, username, tempAvatar.nft!); setLoading(false); setNewAvatar(tempAvatar); setTempAvatar(null); @@ -270,9 +273,9 @@ const BlockchainNFTs = React.memo(function BlockchainNFTs({ const wallet = wallets.find((wallet) => wallet.publicKey === publicKey)!; const blockchain = wallet.blockchain; const connectionUrl = - blockchain === Blockchain.SOLANA - ? useSolanaConnectionUrl() - : useEthereumConnectionUrl(); + blockchain === Blockchain.SOLANA + ? useSolanaConnectionUrl() + : useEthereumConnectionUrl(); const nftsIds = collections.reduce((flat, collection) => { flat.push(...collection.itemIds); @@ -344,6 +347,7 @@ function RenderNFT({ : nft.id; setTempAvatar({ + nft, url: nft.imageUrl, id: `${nft.blockchain}/${avatarId}`, }); @@ -356,7 +360,7 @@ function RenderNFT({ border: tempAvatar?.url === nft.imageUrl ? "3px solid black" : "", }} src={nft.imageUrl} - removeOnError={true} + removeOnError /> ), [nft, nftId, tempAvatar] @@ -371,14 +375,16 @@ const Container = styled("div")(() => ({ overflow: "hidden", })); -const StyledProxyImage = styled(ProxyImage)(({ theme }) => ({ - "&:hover": { - border: `3px solid ${theme.custom.colors.avatarIconBackground}`, - cursor: "pointer", - }, -})); +const StyledProxyImage = styled(ProxyImage)( + ({ theme }: { theme: CustomTheme }) => ({ + "&:hover": { + border: `3px solid ${theme.custom.colors.avatarIconBackground}`, + cursor: "pointer", + }, + }) +); -const FakeDrawer = styled("div")(({ theme }) => ({ +const FakeDrawer = styled("div")(({ theme }: { theme: CustomTheme }) => ({ position: "relative", display: "flex", flexDirection: "column", @@ -394,7 +400,7 @@ const FakeDrawer = styled("div")(({ theme }) => ({ zIndex: "0", overflow: "hidden", })); -const ButtonsOverlay = styled("div")(({ theme }) => ({ +const ButtonsOverlay = styled("div")(({ theme }: { theme: CustomTheme }) => ({ position: "absolute", bottom: "0px", display: "flex", @@ -415,7 +421,7 @@ const Avatar = styled(ProxyImage)(() => ({ zIndex: 0, })); -const AvatarWrapper = styled("div")(({ theme }) => ({ +const AvatarWrapper = styled("div")(({ theme }: { theme: CustomTheme }) => ({ boxSizing: "border-box", position: "relative", borderRadius: "50px", diff --git a/packages/app-extension/src/components/Unlocked/Settings/AvatarPopover.tsx b/packages/app-extension/src/components/Unlocked/Settings/AvatarPopover.tsx index 54da82948..b6b668a25 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/AvatarPopover.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/AvatarPopover.tsx @@ -5,7 +5,7 @@ import { UI_RPC_METHOD_ACTIVE_USER_UPDATE, UI_RPC_METHOD_KEYRING_STORE_LOCK, } from "@coral-xyz/common"; -import { ProxyImage } from "@coral-xyz/react-common"; +import { ProxyImage, useBreakpoints } from "@coral-xyz/react-common"; import { useAllUsers, useAvatarUrl, @@ -16,8 +16,6 @@ import { HOVER_OPACITY, styles, useCustomTheme } from "@coral-xyz/themes"; import { Add, Check } from "@mui/icons-material"; import { Button, IconButton, Popover, Typography } from "@mui/material"; -import { useBreakpoints } from "../../../components/common/Layout/hooks"; - import { SettingsNavStackDrawer } from "./SettingsNavStackDrawer"; const useStyles = styles((theme) => ({ @@ -33,7 +31,6 @@ const useStyles = styles((theme) => ({ popoverRoot: { zIndex: 1, }, - popoverPaper: {}, })); export function AvatarPopoverButton({ @@ -45,7 +42,7 @@ export function AvatarPopoverButton({ }) { const classes = useStyles(); const theme = useCustomTheme(); - const [anchorEl, setAnchorEl] = useState(null); + const [anchorEl, setAnchorEl] = useState(undefined); const avatarUrl = useAvatarUrl(32); const [settingsOpen, setSettingsOpen] = useState(false); const { isXs } = useBreakpoints(); @@ -81,7 +78,7 @@ export function AvatarPopoverButton({ setAnchorEl(false)} + onClose={() => setAnchorEl(undefined)} anchorOrigin={{ vertical: isXs ? "bottom" : "top", horizontal: "left", @@ -98,9 +95,13 @@ export function AvatarPopoverButton({ horizontal: "left", }} classes={{ root: classes.popoverRoot }} + // Required duration of 0 because the rerender on a user change causes + // the transition component in mui to not complete and so the popover + // never disappears + transitionDuration={0} > setAnchorEl(null)} + close={() => setAnchorEl(undefined)} openSettings={() => setSettingsOpen(true)} > @@ -348,7 +349,7 @@ function UserMenuItem({ user, onClick }: { user: any; onClick: () => void }) { @{user.username}
- {isCurrentUser && ( + {isCurrentUser ? (
void }) { }} />
- )} + ) : null}
); diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/AutoLock.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/AutoLock.tsx index a5e3a8f5a..50f04340e 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/AutoLock.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/AutoLock.tsx @@ -98,8 +98,8 @@ export function PreferencesAutoLock() { >
{ setOption(id); }} - detail={option === id && } + detail={option === id ? : null} > {text} @@ -154,7 +154,7 @@ export function PreferencesAutoLock() {
diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Ethereum/CustomRpcUrl.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Ethereum/CustomRpcUrl.tsx index 59686b71e..8e1a5739f 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Ethereum/CustomRpcUrl.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Ethereum/CustomRpcUrl.tsx @@ -50,21 +50,21 @@ export function PreferenceEthereumCustomRpcUrl() { { setRpcUrl(e.target.value); }} /> setChainId(e.target.value)} /> diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/ConnectionSwitch.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/ConnectionSwitch.tsx index a80d567f3..5761ffe6f 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/ConnectionSwitch.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/ConnectionSwitch.tsx @@ -8,12 +8,10 @@ import { useBackgroundClient, useSolanaConnectionUrl } from "@coral-xyz/recoil"; import { useCustomTheme } from "@coral-xyz/themes"; import { Check } from "@mui/icons-material"; -import { useDrawerContext } from "../../../../common/Layout/Drawer"; import { useNavigation } from "../../../../common/Layout/NavStack"; import { SettingsList } from "../../../../common/Settings/List"; export function PreferencesSolanaConnection() { - const { close } = useDrawerContext(); const background = useBackgroundClient(); const currentUrl = useSolanaConnectionUrl(); const nav = useNavigation(); @@ -25,15 +23,15 @@ export function PreferencesSolanaConnection() { const menuItems = { "Mainnet (Beta)": { onClick: () => changeNetwork(SolanaCluster.MAINNET), - detail: currentUrl === SolanaCluster.MAINNET ? : <>, + detail: currentUrl === SolanaCluster.MAINNET ? : null, }, Devnet: { onClick: () => changeNetwork(SolanaCluster.DEVNET), - detail: currentUrl === SolanaCluster.DEVNET ? : <>, + detail: currentUrl === SolanaCluster.DEVNET ? : null, }, Localnet: { onClick: () => changeNetwork(SolanaCluster.LOCALNET), - detail: currentUrl === SolanaCluster.LOCALNET ? : <>, + detail: currentUrl === SolanaCluster.LOCALNET ? : null, }, Custom: { onClick: () => { @@ -60,7 +58,6 @@ export function PreferencesSolanaConnection() { method: UI_RPC_METHOD_SOLANA_CONNECTION_URL_UPDATE, params: [url], }) - .then(close) .catch(console.error); } catch (err) { console.error(err); diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/CustomRpcUrl.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/CustomRpcUrl.tsx index 6e602c546..397534fa4 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/CustomRpcUrl.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/Solana/CustomRpcUrl.tsx @@ -58,11 +58,11 @@ export function PreferenceSolanaCustomRpcUrl() {
{ setRpcUrl(e.target.value); diff --git a/packages/app-extension/src/components/Unlocked/Settings/Preferences/TrustedSites.tsx b/packages/app-extension/src/components/Unlocked/Settings/Preferences/TrustedSites.tsx index 4b02d05f4..68c6961cb 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Preferences/TrustedSites.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Preferences/TrustedSites.tsx @@ -25,8 +25,8 @@ export function PreferencesTrustedSites() { return approvedOrigins.length === 0 ? ( } - title={"No trusted sites"} - subtitle={"Trusted sites will be listed here"} + title="No trusted sites" + subtitle="Trusted sites will be listed here" contentStyle={{ marginBottom: "64px", // Tab height offset. }} diff --git a/packages/app-extension/src/components/Unlocked/Settings/SettingsNavStackDrawer.tsx b/packages/app-extension/src/components/Unlocked/Settings/SettingsNavStackDrawer.tsx index 0b1fbafe7..edcf41f29 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/SettingsNavStackDrawer.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/SettingsNavStackDrawer.tsx @@ -65,185 +65,185 @@ export function SettingsNavStackDrawer({ navButtonLeft={ setSettingsOpen(false)} />} > } /> } /> } /> } /> } /> } /> } /> } /> } /> } /> } /> } /> ( )} /> } /> } /> ( )} /> ( )} /> ( )} /> } /> ( )} /> ( )} /> } /> } /> } /> } /> } /> } /> } /> ( )} /> } /> } /> } /> } /> } /> } /> } /> } /> } /> } /> } /> } /> } /> diff --git a/packages/app-extension/src/components/Unlocked/Settings/UsernamesMenu.tsx b/packages/app-extension/src/components/Unlocked/Settings/UsernamesMenu.tsx index 2331c84ee..b62a16f82 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/UsernamesMenu.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/UsernamesMenu.tsx @@ -186,22 +186,20 @@ function UserAccountListItem({ @{username}
- {isActive && ( -
- -
- )} +
: null}
); diff --git a/packages/app-extension/src/components/Unlocked/Settings/Xnfts/Detail.tsx b/packages/app-extension/src/components/Unlocked/Settings/Xnfts/Detail.tsx index 2033a1342..a97739c42 100644 --- a/packages/app-extension/src/components/Unlocked/Settings/Xnfts/Detail.tsx +++ b/packages/app-extension/src/components/Unlocked/Settings/Xnfts/Detail.tsx @@ -232,7 +232,7 @@ export const XnftDetail: React.FC<{ xnft: any }> = ({ xnft }) => { setOpenConfirm(true)} />
@@ -301,7 +301,7 @@ const UninstallConfirmationCard = ({ xnft }: { xnft: any }) => { ) : cardType === "sending" ? ( ) : cardType === "complete" ? ( - + ) : (

7PK!2;*^ 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 diff --git a/examples/xnft/explorer/published/Screen Shot 2022-11-16 at 7.05.55 PM.png b/examples/xnft/explorer/published/Screen Shot 2022-11-16 at 7.05.55 PM.png deleted file mode 100644 index d6f071c128ba1bbe192f50d41e208f8160b7fdfa..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 392462 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¬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